x86: cpu: clean up check for cpuid instruction support
[libav.git] / cmdutils.c
1 /*
2 * Various utilities for command line tools
3 * Copyright (c) 2000-2003 Fabrice Bellard
4 *
5 * This file is part of Libav.
6 *
7 * Libav is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * Libav is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with Libav; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22 #include <string.h>
23 #include <stdlib.h>
24 #include <errno.h>
25 #include <math.h>
26
27 /* Include only the enabled headers since some compilers (namely, Sun
28 Studio) will not omit unused inline functions and create undefined
29 references to libraries that are not being built. */
30
31 #include "config.h"
32 #include "libavformat/avformat.h"
33 #include "libavfilter/avfilter.h"
34 #include "libavdevice/avdevice.h"
35 #include "libavresample/avresample.h"
36 #include "libswscale/swscale.h"
37 #include "libavutil/avassert.h"
38 #include "libavutil/avstring.h"
39 #include "libavutil/mathematics.h"
40 #include "libavutil/imgutils.h"
41 #include "libavutil/parseutils.h"
42 #include "libavutil/pixdesc.h"
43 #include "libavutil/eval.h"
44 #include "libavutil/dict.h"
45 #include "libavutil/opt.h"
46 #include "cmdutils.h"
47 #include "version.h"
48 #if CONFIG_NETWORK
49 #include "libavformat/network.h"
50 #endif
51 #if HAVE_SYS_RESOURCE_H
52 #include <sys/resource.h>
53 #endif
54
55 struct SwsContext *sws_opts;
56 AVDictionary *format_opts, *codec_opts;
57
58 static const int this_year = 2012;
59
60 void init_opts(void)
61 {
62 #if CONFIG_SWSCALE
63 sws_opts = sws_getContext(16, 16, 0, 16, 16, 0, SWS_BICUBIC,
64 NULL, NULL, NULL);
65 #endif
66 }
67
68 void uninit_opts(void)
69 {
70 #if CONFIG_SWSCALE
71 sws_freeContext(sws_opts);
72 sws_opts = NULL;
73 #endif
74 av_dict_free(&format_opts);
75 av_dict_free(&codec_opts);
76 }
77
78 void log_callback_help(void *ptr, int level, const char *fmt, va_list vl)
79 {
80 vfprintf(stdout, fmt, vl);
81 }
82
83 double parse_number_or_die(const char *context, const char *numstr, int type,
84 double min, double max)
85 {
86 char *tail;
87 const char *error;
88 double d = av_strtod(numstr, &tail);
89 if (*tail)
90 error = "Expected number for %s but found: %s\n";
91 else if (d < min || d > max)
92 error = "The value for %s was %s which is not within %f - %f\n";
93 else if (type == OPT_INT64 && (int64_t)d != d)
94 error = "Expected int64 for %s but found %s\n";
95 else if (type == OPT_INT && (int)d != d)
96 error = "Expected int for %s but found %s\n";
97 else
98 return d;
99 av_log(NULL, AV_LOG_FATAL, error, context, numstr, min, max);
100 exit_program(1);
101 return 0;
102 }
103
104 int64_t parse_time_or_die(const char *context, const char *timestr,
105 int is_duration)
106 {
107 int64_t us;
108 if (av_parse_time(&us, timestr, is_duration) < 0) {
109 av_log(NULL, AV_LOG_FATAL, "Invalid %s specification for %s: %s\n",
110 is_duration ? "duration" : "date", context, timestr);
111 exit_program(1);
112 }
113 return us;
114 }
115
116 void show_help_options(const OptionDef *options, const char *msg, int mask,
117 int value)
118 {
119 const OptionDef *po;
120 int first;
121
122 first = 1;
123 for (po = options; po->name != NULL; po++) {
124 char buf[64];
125 if ((po->flags & mask) == value) {
126 if (first) {
127 printf("%s", msg);
128 first = 0;
129 }
130 av_strlcpy(buf, po->name, sizeof(buf));
131 if (po->flags & HAS_ARG) {
132 av_strlcat(buf, " ", sizeof(buf));
133 av_strlcat(buf, po->argname, sizeof(buf));
134 }
135 printf("-%-17s %s\n", buf, po->help);
136 }
137 }
138 }
139
140 void show_help_children(const AVClass *class, int flags)
141 {
142 const AVClass *child = NULL;
143 av_opt_show2(&class, NULL, flags, 0);
144 printf("\n");
145
146 while (child = av_opt_child_class_next(class, child))
147 show_help_children(child, flags);
148 }
149
150 static const OptionDef *find_option(const OptionDef *po, const char *name)
151 {
152 const char *p = strchr(name, ':');
153 int len = p ? p - name : strlen(name);
154
155 while (po->name != NULL) {
156 if (!strncmp(name, po->name, len) && strlen(po->name) == len)
157 break;
158 po++;
159 }
160 return po;
161 }
162
163 #if defined(_WIN32) && !defined(__MINGW32CE__)
164 #include <windows.h>
165 /* Will be leaked on exit */
166 static char** win32_argv_utf8 = NULL;
167 static int win32_argc = 0;
168
169 /**
170 * Prepare command line arguments for executable.
171 * For Windows - perform wide-char to UTF-8 conversion.
172 * Input arguments should be main() function arguments.
173 * @param argc_ptr Arguments number (including executable)
174 * @param argv_ptr Arguments list.
175 */
176 static void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
177 {
178 char *argstr_flat;
179 wchar_t **argv_w;
180 int i, buffsize = 0, offset = 0;
181
182 if (win32_argv_utf8) {
183 *argc_ptr = win32_argc;
184 *argv_ptr = win32_argv_utf8;
185 return;
186 }
187
188 win32_argc = 0;
189 argv_w = CommandLineToArgvW(GetCommandLineW(), &win32_argc);
190 if (win32_argc <= 0 || !argv_w)
191 return;
192
193 /* determine the UTF-8 buffer size (including NULL-termination symbols) */
194 for (i = 0; i < win32_argc; i++)
195 buffsize += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
196 NULL, 0, NULL, NULL);
197
198 win32_argv_utf8 = av_mallocz(sizeof(char *) * (win32_argc + 1) + buffsize);
199 argstr_flat = (char *)win32_argv_utf8 + sizeof(char *) * (win32_argc + 1);
200 if (win32_argv_utf8 == NULL) {
201 LocalFree(argv_w);
202 return;
203 }
204
205 for (i = 0; i < win32_argc; i++) {
206 win32_argv_utf8[i] = &argstr_flat[offset];
207 offset += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
208 &argstr_flat[offset],
209 buffsize - offset, NULL, NULL);
210 }
211 win32_argv_utf8[i] = NULL;
212 LocalFree(argv_w);
213
214 *argc_ptr = win32_argc;
215 *argv_ptr = win32_argv_utf8;
216 }
217 #else
218 static inline void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
219 {
220 /* nothing to do */
221 }
222 #endif /* WIN32 && !__MINGW32CE__ */
223
224 int parse_option(void *optctx, const char *opt, const char *arg,
225 const OptionDef *options)
226 {
227 const OptionDef *po;
228 int bool_val = 1;
229 int *dstcount;
230 void *dst;
231
232 po = find_option(options, opt);
233 if (!po->name && opt[0] == 'n' && opt[1] == 'o') {
234 /* handle 'no' bool option */
235 po = find_option(options, opt + 2);
236 if ((po->name && (po->flags & OPT_BOOL)))
237 bool_val = 0;
238 }
239 if (!po->name)
240 po = find_option(options, "default");
241 if (!po->name) {
242 av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);
243 return AVERROR(EINVAL);
244 }
245 if (po->flags & HAS_ARG && !arg) {
246 av_log(NULL, AV_LOG_ERROR, "Missing argument for option '%s'\n", opt);
247 return AVERROR(EINVAL);
248 }
249
250 /* new-style options contain an offset into optctx, old-style address of
251 * a global var*/
252 dst = po->flags & (OPT_OFFSET | OPT_SPEC) ? (uint8_t *)optctx + po->u.off
253 : po->u.dst_ptr;
254
255 if (po->flags & OPT_SPEC) {
256 SpecifierOpt **so = dst;
257 char *p = strchr(opt, ':');
258
259 dstcount = (int *)(so + 1);
260 *so = grow_array(*so, sizeof(**so), dstcount, *dstcount + 1);
261 (*so)[*dstcount - 1].specifier = av_strdup(p ? p + 1 : "");
262 dst = &(*so)[*dstcount - 1].u;
263 }
264
265 if (po->flags & OPT_STRING) {
266 char *str;
267 str = av_strdup(arg);
268 *(char **)dst = str;
269 } else if (po->flags & OPT_BOOL) {
270 *(int *)dst = bool_val;
271 } else if (po->flags & OPT_INT) {
272 *(int *)dst = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
273 } else if (po->flags & OPT_INT64) {
274 *(int64_t *)dst = parse_number_or_die(opt, arg, OPT_INT64, INT64_MIN, INT64_MAX);
275 } else if (po->flags & OPT_TIME) {
276 *(int64_t *)dst = parse_time_or_die(opt, arg, 1);
277 } else if (po->flags & OPT_FLOAT) {
278 *(float *)dst = parse_number_or_die(opt, arg, OPT_FLOAT, -INFINITY, INFINITY);
279 } else if (po->flags & OPT_DOUBLE) {
280 *(double *)dst = parse_number_or_die(opt, arg, OPT_DOUBLE, -INFINITY, INFINITY);
281 } else if (po->u.func_arg) {
282 int ret = po->flags & OPT_FUNC2 ? po->u.func2_arg(optctx, opt, arg)
283 : po->u.func_arg(opt, arg);
284 if (ret < 0) {
285 av_log(NULL, AV_LOG_ERROR,
286 "Failed to set value '%s' for option '%s'\n", arg, opt);
287 return ret;
288 }
289 }
290 if (po->flags & OPT_EXIT)
291 exit_program(0);
292 return !!(po->flags & HAS_ARG);
293 }
294
295 void parse_options(void *optctx, int argc, char **argv, const OptionDef *options,
296 void (*parse_arg_function)(void *, const char*))
297 {
298 const char *opt;
299 int optindex, handleoptions = 1, ret;
300
301 /* perform system-dependent conversions for arguments list */
302 prepare_app_arguments(&argc, &argv);
303
304 /* parse options */
305 optindex = 1;
306 while (optindex < argc) {
307 opt = argv[optindex++];
308
309 if (handleoptions && opt[0] == '-' && opt[1] != '\0') {
310 if (opt[1] == '-' && opt[2] == '\0') {
311 handleoptions = 0;
312 continue;
313 }
314 opt++;
315
316 if ((ret = parse_option(optctx, opt, argv[optindex], options)) < 0)
317 exit_program(1);
318 optindex += ret;
319 } else {
320 if (parse_arg_function)
321 parse_arg_function(optctx, opt);
322 }
323 }
324 }
325
326 int locate_option(int argc, char **argv, const OptionDef *options,
327 const char *optname)
328 {
329 const OptionDef *po;
330 int i;
331
332 for (i = 1; i < argc; i++) {
333 const char *cur_opt = argv[i];
334
335 if (*cur_opt++ != '-')
336 continue;
337
338 po = find_option(options, cur_opt);
339 if (!po->name && cur_opt[0] == 'n' && cur_opt[1] == 'o')
340 po = find_option(options, cur_opt + 2);
341
342 if ((!po->name && !strcmp(cur_opt, optname)) ||
343 (po->name && !strcmp(optname, po->name)))
344 return i;
345
346 if (!po || po->flags & HAS_ARG)
347 i++;
348 }
349 return 0;
350 }
351
352 void parse_loglevel(int argc, char **argv, const OptionDef *options)
353 {
354 int idx = locate_option(argc, argv, options, "loglevel");
355 if (!idx)
356 idx = locate_option(argc, argv, options, "v");
357 if (idx && argv[idx + 1])
358 opt_loglevel("loglevel", argv[idx + 1]);
359 }
360
361 #define FLAGS (o->type == AV_OPT_TYPE_FLAGS) ? AV_DICT_APPEND : 0
362 int opt_default(const char *opt, const char *arg)
363 {
364 const AVOption *o;
365 char opt_stripped[128];
366 const char *p;
367 const AVClass *cc = avcodec_get_class(), *fc = avformat_get_class(), *sc = sws_get_class();
368
369 if (!(p = strchr(opt, ':')))
370 p = opt + strlen(opt);
371 av_strlcpy(opt_stripped, opt, FFMIN(sizeof(opt_stripped), p - opt + 1));
372
373 if ((o = av_opt_find(&cc, opt_stripped, NULL, 0,
374 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)) ||
375 ((opt[0] == 'v' || opt[0] == 'a' || opt[0] == 's') &&
376 (o = av_opt_find(&cc, opt + 1, NULL, 0, AV_OPT_SEARCH_FAKE_OBJ))))
377 av_dict_set(&codec_opts, opt, arg, FLAGS);
378 else if ((o = av_opt_find(&fc, opt, NULL, 0,
379 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)))
380 av_dict_set(&format_opts, opt, arg, FLAGS);
381 else if ((o = av_opt_find(&sc, opt, NULL, 0,
382 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) {
383 // XXX we only support sws_flags, not arbitrary sws options
384 int ret = av_opt_set(sws_opts, opt, arg, 0);
385 if (ret < 0) {
386 av_log(NULL, AV_LOG_ERROR, "Error setting option %s.\n", opt);
387 return ret;
388 }
389 }
390
391 if (o)
392 return 0;
393 av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);
394 return AVERROR_OPTION_NOT_FOUND;
395 }
396
397 int opt_loglevel(const char *opt, const char *arg)
398 {
399 const struct { const char *name; int level; } log_levels[] = {
400 { "quiet" , AV_LOG_QUIET },
401 { "panic" , AV_LOG_PANIC },
402 { "fatal" , AV_LOG_FATAL },
403 { "error" , AV_LOG_ERROR },
404 { "warning", AV_LOG_WARNING },
405 { "info" , AV_LOG_INFO },
406 { "verbose", AV_LOG_VERBOSE },
407 { "debug" , AV_LOG_DEBUG },
408 };
409 char *tail;
410 int level;
411 int i;
412
413 for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
414 if (!strcmp(log_levels[i].name, arg)) {
415 av_log_set_level(log_levels[i].level);
416 return 0;
417 }
418 }
419
420 level = strtol(arg, &tail, 10);
421 if (*tail) {
422 av_log(NULL, AV_LOG_FATAL, "Invalid loglevel \"%s\". "
423 "Possible levels are numbers or:\n", arg);
424 for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
425 av_log(NULL, AV_LOG_FATAL, "\"%s\"\n", log_levels[i].name);
426 exit_program(1);
427 }
428 av_log_set_level(level);
429 return 0;
430 }
431
432 int opt_timelimit(const char *opt, const char *arg)
433 {
434 #if HAVE_SETRLIMIT
435 int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
436 struct rlimit rl = { lim, lim + 1 };
437 if (setrlimit(RLIMIT_CPU, &rl))
438 perror("setrlimit");
439 #else
440 av_log(NULL, AV_LOG_WARNING, "-%s not implemented on this OS\n", opt);
441 #endif
442 return 0;
443 }
444
445 void print_error(const char *filename, int err)
446 {
447 char errbuf[128];
448 const char *errbuf_ptr = errbuf;
449
450 if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
451 errbuf_ptr = strerror(AVUNERROR(err));
452 av_log(NULL, AV_LOG_ERROR, "%s: %s\n", filename, errbuf_ptr);
453 }
454
455 static int warned_cfg = 0;
456
457 #define INDENT 1
458 #define SHOW_VERSION 2
459 #define SHOW_CONFIG 4
460
461 #define PRINT_LIB_INFO(libname, LIBNAME, flags, level) \
462 if (CONFIG_##LIBNAME) { \
463 const char *indent = flags & INDENT? " " : ""; \
464 if (flags & SHOW_VERSION) { \
465 unsigned int version = libname##_version(); \
466 av_log(NULL, level, \
467 "%slib%-10s %2d.%3d.%2d / %2d.%3d.%2d\n", \
468 indent, #libname, \
469 LIB##LIBNAME##_VERSION_MAJOR, \
470 LIB##LIBNAME##_VERSION_MINOR, \
471 LIB##LIBNAME##_VERSION_MICRO, \
472 version >> 16, version >> 8 & 0xff, version & 0xff); \
473 } \
474 if (flags & SHOW_CONFIG) { \
475 const char *cfg = libname##_configuration(); \
476 if (strcmp(LIBAV_CONFIGURATION, cfg)) { \
477 if (!warned_cfg) { \
478 av_log(NULL, level, \
479 "%sWARNING: library configuration mismatch\n", \
480 indent); \
481 warned_cfg = 1; \
482 } \
483 av_log(NULL, level, "%s%-11s configuration: %s\n", \
484 indent, #libname, cfg); \
485 } \
486 } \
487 } \
488
489 static void print_all_libs_info(int flags, int level)
490 {
491 PRINT_LIB_INFO(avutil, AVUTIL, flags, level);
492 PRINT_LIB_INFO(avcodec, AVCODEC, flags, level);
493 PRINT_LIB_INFO(avformat, AVFORMAT, flags, level);
494 PRINT_LIB_INFO(avdevice, AVDEVICE, flags, level);
495 PRINT_LIB_INFO(avfilter, AVFILTER, flags, level);
496 PRINT_LIB_INFO(avresample, AVRESAMPLE, flags, level);
497 PRINT_LIB_INFO(swscale, SWSCALE, flags, level);
498 }
499
500 void show_banner(void)
501 {
502 av_log(NULL, AV_LOG_INFO,
503 "%s version " LIBAV_VERSION ", Copyright (c) %d-%d the Libav developers\n",
504 program_name, program_birth_year, this_year);
505 av_log(NULL, AV_LOG_INFO, " built on %s %s with %s %s\n",
506 __DATE__, __TIME__, CC_TYPE, CC_VERSION);
507 av_log(NULL, AV_LOG_VERBOSE, " configuration: " LIBAV_CONFIGURATION "\n");
508 print_all_libs_info(INDENT|SHOW_CONFIG, AV_LOG_VERBOSE);
509 print_all_libs_info(INDENT|SHOW_VERSION, AV_LOG_VERBOSE);
510 }
511
512 void show_version(void) {
513 av_log_set_callback(log_callback_help);
514 printf("%s " LIBAV_VERSION "\n", program_name);
515 print_all_libs_info(SHOW_VERSION, AV_LOG_INFO);
516 }
517
518 void show_license(void)
519 {
520 printf(
521 #if CONFIG_NONFREE
522 "This version of %s has nonfree parts compiled in.\n"
523 "Therefore it is not legally redistributable.\n",
524 program_name
525 #elif CONFIG_GPLV3
526 "%s is free software; you can redistribute it and/or modify\n"
527 "it under the terms of the GNU General Public License as published by\n"
528 "the Free Software Foundation; either version 3 of the License, or\n"
529 "(at your option) any later version.\n"
530 "\n"
531 "%s is distributed in the hope that it will be useful,\n"
532 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
533 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
534 "GNU General Public License for more details.\n"
535 "\n"
536 "You should have received a copy of the GNU General Public License\n"
537 "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
538 program_name, program_name, program_name
539 #elif CONFIG_GPL
540 "%s is free software; you can redistribute it and/or modify\n"
541 "it under the terms of the GNU General Public License as published by\n"
542 "the Free Software Foundation; either version 2 of the License, or\n"
543 "(at your option) any later version.\n"
544 "\n"
545 "%s is distributed in the hope that it will be useful,\n"
546 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
547 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
548 "GNU General Public License for more details.\n"
549 "\n"
550 "You should have received a copy of the GNU General Public License\n"
551 "along with %s; if not, write to the Free Software\n"
552 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
553 program_name, program_name, program_name
554 #elif CONFIG_LGPLV3
555 "%s is free software; you can redistribute it and/or modify\n"
556 "it under the terms of the GNU Lesser General Public License as published by\n"
557 "the Free Software Foundation; either version 3 of the License, or\n"
558 "(at your option) any later version.\n"
559 "\n"
560 "%s is distributed in the hope that it will be useful,\n"
561 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
562 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
563 "GNU Lesser General Public License for more details.\n"
564 "\n"
565 "You should have received a copy of the GNU Lesser General Public License\n"
566 "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
567 program_name, program_name, program_name
568 #else
569 "%s is free software; you can redistribute it and/or\n"
570 "modify it under the terms of the GNU Lesser General Public\n"
571 "License as published by the Free Software Foundation; either\n"
572 "version 2.1 of the License, or (at your option) any later version.\n"
573 "\n"
574 "%s is distributed in the hope that it will be useful,\n"
575 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
576 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
577 "Lesser General Public License for more details.\n"
578 "\n"
579 "You should have received a copy of the GNU Lesser General Public\n"
580 "License along with %s; if not, write to the Free Software\n"
581 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
582 program_name, program_name, program_name
583 #endif
584 );
585 }
586
587 void show_formats(void)
588 {
589 AVInputFormat *ifmt = NULL;
590 AVOutputFormat *ofmt = NULL;
591 const char *last_name;
592
593 printf("File formats:\n"
594 " D. = Demuxing supported\n"
595 " .E = Muxing supported\n"
596 " --\n");
597 last_name = "000";
598 for (;;) {
599 int decode = 0;
600 int encode = 0;
601 const char *name = NULL;
602 const char *long_name = NULL;
603
604 while ((ofmt = av_oformat_next(ofmt))) {
605 if ((name == NULL || strcmp(ofmt->name, name) < 0) &&
606 strcmp(ofmt->name, last_name) > 0) {
607 name = ofmt->name;
608 long_name = ofmt->long_name;
609 encode = 1;
610 }
611 }
612 while ((ifmt = av_iformat_next(ifmt))) {
613 if ((name == NULL || strcmp(ifmt->name, name) < 0) &&
614 strcmp(ifmt->name, last_name) > 0) {
615 name = ifmt->name;
616 long_name = ifmt->long_name;
617 encode = 0;
618 }
619 if (name && strcmp(ifmt->name, name) == 0)
620 decode = 1;
621 }
622 if (name == NULL)
623 break;
624 last_name = name;
625
626 printf(" %s%s %-15s %s\n",
627 decode ? "D" : " ",
628 encode ? "E" : " ",
629 name,
630 long_name ? long_name:" ");
631 }
632 }
633
634 void show_codecs(void)
635 {
636 AVCodec *p = NULL, *p2;
637 const char *last_name;
638 printf("Codecs:\n"
639 " D..... = Decoding supported\n"
640 " .E.... = Encoding supported\n"
641 " ..V... = Video codec\n"
642 " ..A... = Audio codec\n"
643 " ..S... = Subtitle codec\n"
644 " ...S.. = Supports draw_horiz_band\n"
645 " ....D. = Supports direct rendering method 1\n"
646 " .....T = Supports weird frame truncation\n"
647 " ------\n");
648 last_name= "000";
649 for (;;) {
650 int decode = 0;
651 int encode = 0;
652 int cap = 0;
653 const char *type_str;
654
655 p2 = NULL;
656 while ((p = av_codec_next(p))) {
657 if ((p2 == NULL || strcmp(p->name, p2->name) < 0) &&
658 strcmp(p->name, last_name) > 0) {
659 p2 = p;
660 decode = encode = cap = 0;
661 }
662 if (p2 && strcmp(p->name, p2->name) == 0) {
663 if (av_codec_is_decoder(p))
664 decode = 1;
665 if (av_codec_is_encoder(p))
666 encode = 1;
667 cap |= p->capabilities;
668 }
669 }
670 if (p2 == NULL)
671 break;
672 last_name = p2->name;
673
674 switch (p2->type) {
675 case AVMEDIA_TYPE_VIDEO:
676 type_str = "V";
677 break;
678 case AVMEDIA_TYPE_AUDIO:
679 type_str = "A";
680 break;
681 case AVMEDIA_TYPE_SUBTITLE:
682 type_str = "S";
683 break;
684 default:
685 type_str = "?";
686 break;
687 }
688 printf(" %s%s%s%s%s%s %-15s %s",
689 decode ? "D" : (/* p2->decoder ? "d" : */ " "),
690 encode ? "E" : " ",
691 type_str,
692 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S" : " ",
693 cap & CODEC_CAP_DR1 ? "D" : " ",
694 cap & CODEC_CAP_TRUNCATED ? "T" : " ",
695 p2->name,
696 p2->long_name ? p2->long_name : "");
697 #if 0
698 if (p2->decoder && decode == 0)
699 printf(" use %s for decoding", p2->decoder->name);
700 #endif
701 printf("\n");
702 }
703 printf("\n");
704 printf("Note, the names of encoders and decoders do not always match, so there are\n"
705 "several cases where the above table shows encoder only or decoder only entries\n"
706 "even though both encoding and decoding are supported. For example, the h263\n"
707 "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
708 "worse.\n");
709 }
710
711 void show_bsfs(void)
712 {
713 AVBitStreamFilter *bsf = NULL;
714
715 printf("Bitstream filters:\n");
716 while ((bsf = av_bitstream_filter_next(bsf)))
717 printf("%s\n", bsf->name);
718 printf("\n");
719 }
720
721 void show_protocols(void)
722 {
723 void *opaque = NULL;
724 const char *name;
725
726 printf("Supported file protocols:\n"
727 "Input:\n");
728 while ((name = avio_enum_protocols(&opaque, 0)))
729 printf("%s\n", name);
730 printf("Output:\n");
731 while ((name = avio_enum_protocols(&opaque, 1)))
732 printf("%s\n", name);
733 }
734
735 void show_filters(void)
736 {
737 AVFilter av_unused(**filter) = NULL;
738
739 printf("Filters:\n");
740 #if CONFIG_AVFILTER
741 while ((filter = av_filter_next(filter)) && *filter)
742 printf("%-16s %s\n", (*filter)->name, (*filter)->description);
743 #endif
744 }
745
746 void show_pix_fmts(void)
747 {
748 enum PixelFormat pix_fmt;
749
750 printf("Pixel formats:\n"
751 "I.... = Supported Input format for conversion\n"
752 ".O... = Supported Output format for conversion\n"
753 "..H.. = Hardware accelerated format\n"
754 "...P. = Paletted format\n"
755 "....B = Bitstream format\n"
756 "FLAGS NAME NB_COMPONENTS BITS_PER_PIXEL\n"
757 "-----\n");
758
759 #if !CONFIG_SWSCALE
760 # define sws_isSupportedInput(x) 0
761 # define sws_isSupportedOutput(x) 0
762 #endif
763
764 for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {
765 const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[pix_fmt];
766 printf("%c%c%c%c%c %-16s %d %2d\n",
767 sws_isSupportedInput (pix_fmt) ? 'I' : '.',
768 sws_isSupportedOutput(pix_fmt) ? 'O' : '.',
769 pix_desc->flags & PIX_FMT_HWACCEL ? 'H' : '.',
770 pix_desc->flags & PIX_FMT_PAL ? 'P' : '.',
771 pix_desc->flags & PIX_FMT_BITSTREAM ? 'B' : '.',
772 pix_desc->name,
773 pix_desc->nb_components,
774 av_get_bits_per_pixel(pix_desc));
775 }
776 }
777
778 int show_sample_fmts(const char *opt, const char *arg)
779 {
780 int i;
781 char fmt_str[128];
782 for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
783 printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
784 return 0;
785 }
786
787 int read_yesno(void)
788 {
789 int c = getchar();
790 int yesno = (toupper(c) == 'Y');
791
792 while (c != '\n' && c != EOF)
793 c = getchar();
794
795 return yesno;
796 }
797
798 int cmdutils_read_file(const char *filename, char **bufptr, size_t *size)
799 {
800 int ret;
801 FILE *f = fopen(filename, "rb");
802
803 if (!f) {
804 av_log(NULL, AV_LOG_ERROR, "Cannot read file '%s': %s\n", filename,
805 strerror(errno));
806 return AVERROR(errno);
807 }
808 fseek(f, 0, SEEK_END);
809 *size = ftell(f);
810 fseek(f, 0, SEEK_SET);
811 *bufptr = av_malloc(*size + 1);
812 if (!*bufptr) {
813 av_log(NULL, AV_LOG_ERROR, "Could not allocate file buffer\n");
814 fclose(f);
815 return AVERROR(ENOMEM);
816 }
817 ret = fread(*bufptr, 1, *size, f);
818 if (ret < *size) {
819 av_free(*bufptr);
820 if (ferror(f)) {
821 av_log(NULL, AV_LOG_ERROR, "Error while reading file '%s': %s\n",
822 filename, strerror(errno));
823 ret = AVERROR(errno);
824 } else
825 ret = AVERROR_EOF;
826 } else {
827 ret = 0;
828 (*bufptr)[*size++] = '\0';
829 }
830
831 fclose(f);
832 return ret;
833 }
834
835 void init_pts_correction(PtsCorrectionContext *ctx)
836 {
837 ctx->num_faulty_pts = ctx->num_faulty_dts = 0;
838 ctx->last_pts = ctx->last_dts = INT64_MIN;
839 }
840
841 int64_t guess_correct_pts(PtsCorrectionContext *ctx, int64_t reordered_pts,
842 int64_t dts)
843 {
844 int64_t pts = AV_NOPTS_VALUE;
845
846 if (dts != AV_NOPTS_VALUE) {
847 ctx->num_faulty_dts += dts <= ctx->last_dts;
848 ctx->last_dts = dts;
849 }
850 if (reordered_pts != AV_NOPTS_VALUE) {
851 ctx->num_faulty_pts += reordered_pts <= ctx->last_pts;
852 ctx->last_pts = reordered_pts;
853 }
854 if ((ctx->num_faulty_pts<=ctx->num_faulty_dts || dts == AV_NOPTS_VALUE)
855 && reordered_pts != AV_NOPTS_VALUE)
856 pts = reordered_pts;
857 else
858 pts = dts;
859
860 return pts;
861 }
862
863 FILE *get_preset_file(char *filename, size_t filename_size,
864 const char *preset_name, int is_path,
865 const char *codec_name)
866 {
867 FILE *f = NULL;
868 int i;
869 const char *base[3] = { getenv("AVCONV_DATADIR"),
870 getenv("HOME"),
871 AVCONV_DATADIR, };
872
873 if (is_path) {
874 av_strlcpy(filename, preset_name, filename_size);
875 f = fopen(filename, "r");
876 } else {
877 for (i = 0; i < 3 && !f; i++) {
878 if (!base[i])
879 continue;
880 snprintf(filename, filename_size, "%s%s/%s.avpreset", base[i],
881 i != 1 ? "" : "/.avconv", preset_name);
882 f = fopen(filename, "r");
883 if (!f && codec_name) {
884 snprintf(filename, filename_size,
885 "%s%s/%s-%s.avpreset",
886 base[i], i != 1 ? "" : "/.avconv", codec_name,
887 preset_name);
888 f = fopen(filename, "r");
889 }
890 }
891 }
892
893 return f;
894 }
895
896 int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
897 {
898 if (*spec <= '9' && *spec >= '0') /* opt:index */
899 return strtol(spec, NULL, 0) == st->index;
900 else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
901 *spec == 't') { /* opt:[vasdt] */
902 enum AVMediaType type;
903
904 switch (*spec++) {
905 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
906 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
907 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
908 case 'd': type = AVMEDIA_TYPE_DATA; break;
909 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
910 default: av_assert0(0);
911 }
912 if (type != st->codec->codec_type)
913 return 0;
914 if (*spec++ == ':') { /* possibly followed by :index */
915 int i, index = strtol(spec, NULL, 0);
916 for (i = 0; i < s->nb_streams; i++)
917 if (s->streams[i]->codec->codec_type == type && index-- == 0)
918 return i == st->index;
919 return 0;
920 }
921 return 1;
922 } else if (*spec == 'p' && *(spec + 1) == ':') {
923 int prog_id, i, j;
924 char *endptr;
925 spec += 2;
926 prog_id = strtol(spec, &endptr, 0);
927 for (i = 0; i < s->nb_programs; i++) {
928 if (s->programs[i]->id != prog_id)
929 continue;
930
931 if (*endptr++ == ':') {
932 int stream_idx = strtol(endptr, NULL, 0);
933 return stream_idx >= 0 &&
934 stream_idx < s->programs[i]->nb_stream_indexes &&
935 st->index == s->programs[i]->stream_index[stream_idx];
936 }
937
938 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
939 if (st->index == s->programs[i]->stream_index[j])
940 return 1;
941 }
942 return 0;
943 } else if (!*spec) /* empty specifier, matches everything */
944 return 1;
945
946 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
947 return AVERROR(EINVAL);
948 }
949
950 AVDictionary *filter_codec_opts(AVDictionary *opts, enum CodecID codec_id,
951 AVFormatContext *s, AVStream *st, AVCodec *codec)
952 {
953 AVDictionary *ret = NULL;
954 AVDictionaryEntry *t = NULL;
955 int flags = s->oformat ? AV_OPT_FLAG_ENCODING_PARAM
956 : AV_OPT_FLAG_DECODING_PARAM;
957 char prefix = 0;
958 const AVClass *cc = avcodec_get_class();
959
960 if (!codec)
961 codec = s->oformat ? avcodec_find_encoder(codec_id)
962 : avcodec_find_decoder(codec_id);
963 if (!codec)
964 return NULL;
965
966 switch (codec->type) {
967 case AVMEDIA_TYPE_VIDEO:
968 prefix = 'v';
969 flags |= AV_OPT_FLAG_VIDEO_PARAM;
970 break;
971 case AVMEDIA_TYPE_AUDIO:
972 prefix = 'a';
973 flags |= AV_OPT_FLAG_AUDIO_PARAM;
974 break;
975 case AVMEDIA_TYPE_SUBTITLE:
976 prefix = 's';
977 flags |= AV_OPT_FLAG_SUBTITLE_PARAM;
978 break;
979 }
980
981 while (t = av_dict_get(opts, "", t, AV_DICT_IGNORE_SUFFIX)) {
982 char *p = strchr(t->key, ':');
983
984 /* check stream specification in opt name */
985 if (p)
986 switch (check_stream_specifier(s, st, p + 1)) {
987 case 1: *p = 0; break;
988 case 0: continue;
989 default: return NULL;
990 }
991
992 if (av_opt_find(&cc, t->key, NULL, flags, AV_OPT_SEARCH_FAKE_OBJ) ||
993 (codec && codec->priv_class &&
994 av_opt_find(&codec->priv_class, t->key, NULL, flags,
995 AV_OPT_SEARCH_FAKE_OBJ)))
996 av_dict_set(&ret, t->key, t->value, 0);
997 else if (t->key[0] == prefix &&
998 av_opt_find(&cc, t->key + 1, NULL, flags,
999 AV_OPT_SEARCH_FAKE_OBJ))
1000 av_dict_set(&ret, t->key + 1, t->value, 0);
1001
1002 if (p)
1003 *p = ':';
1004 }
1005 return ret;
1006 }
1007
1008 AVDictionary **setup_find_stream_info_opts(AVFormatContext *s,
1009 AVDictionary *codec_opts)
1010 {
1011 int i;
1012 AVDictionary **opts;
1013
1014 if (!s->nb_streams)
1015 return NULL;
1016 opts = av_mallocz(s->nb_streams * sizeof(*opts));
1017 if (!opts) {
1018 av_log(NULL, AV_LOG_ERROR,
1019 "Could not alloc memory for stream options.\n");
1020 return NULL;
1021 }
1022 for (i = 0; i < s->nb_streams; i++)
1023 opts[i] = filter_codec_opts(codec_opts, s->streams[i]->codec->codec_id,
1024 s, s->streams[i], NULL);
1025 return opts;
1026 }
1027
1028 void *grow_array(void *array, int elem_size, int *size, int new_size)
1029 {
1030 if (new_size >= INT_MAX / elem_size) {
1031 av_log(NULL, AV_LOG_ERROR, "Array too big.\n");
1032 exit_program(1);
1033 }
1034 if (*size < new_size) {
1035 uint8_t *tmp = av_realloc(array, new_size*elem_size);
1036 if (!tmp) {
1037 av_log(NULL, AV_LOG_ERROR, "Could not alloc buffer.\n");
1038 exit_program(1);
1039 }
1040 memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
1041 *size = new_size;
1042 return tmp;
1043 }
1044 return array;
1045 }
1046
1047 static int alloc_buffer(FrameBuffer **pool, AVCodecContext *s, FrameBuffer **pbuf)
1048 {
1049 FrameBuffer *buf = av_mallocz(sizeof(*buf));
1050 int i, ret;
1051 const int pixel_size = av_pix_fmt_descriptors[s->pix_fmt].comp[0].step_minus1+1;
1052 int h_chroma_shift, v_chroma_shift;
1053 int edge = 32; // XXX should be avcodec_get_edge_width(), but that fails on svq1
1054 int w = s->width, h = s->height;
1055
1056 if (!buf)
1057 return AVERROR(ENOMEM);
1058
1059 if (!(s->flags & CODEC_FLAG_EMU_EDGE)) {
1060 w += 2*edge;
1061 h += 2*edge;
1062 }
1063
1064 avcodec_align_dimensions(s, &w, &h);
1065 if ((ret = av_image_alloc(buf->base, buf->linesize, w, h,
1066 s->pix_fmt, 32)) < 0) {
1067 av_freep(&buf);
1068 return ret;
1069 }
1070 /* XXX this shouldn't be needed, but some tests break without this line
1071 * those decoders are buggy and need to be fixed.
1072 * the following tests fail:
1073 * cdgraphics, ansi, aasc, fraps-v1, qtrle-1bit
1074 */
1075 memset(buf->base[0], 128, ret);
1076
1077 avcodec_get_chroma_sub_sample(s->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1078 for (i = 0; i < FF_ARRAY_ELEMS(buf->data); i++) {
1079 const int h_shift = i==0 ? 0 : h_chroma_shift;
1080 const int v_shift = i==0 ? 0 : v_chroma_shift;
1081 if (s->flags & CODEC_FLAG_EMU_EDGE)
1082 buf->data[i] = buf->base[i];
1083 else
1084 buf->data[i] = buf->base[i] +
1085 FFALIGN((buf->linesize[i]*edge >> v_shift) +
1086 (pixel_size*edge >> h_shift), 32);
1087 }
1088 buf->w = s->width;
1089 buf->h = s->height;
1090 buf->pix_fmt = s->pix_fmt;
1091 buf->pool = pool;
1092
1093 *pbuf = buf;
1094 return 0;
1095 }
1096
1097 int codec_get_buffer(AVCodecContext *s, AVFrame *frame)
1098 {
1099 FrameBuffer **pool = s->opaque;
1100 FrameBuffer *buf;
1101 int ret, i;
1102
1103 if (!*pool && (ret = alloc_buffer(pool, s, pool)) < 0)
1104 return ret;
1105
1106 buf = *pool;
1107 *pool = buf->next;
1108 buf->next = NULL;
1109 if (buf->w != s->width || buf->h != s->height || buf->pix_fmt != s->pix_fmt) {
1110 av_freep(&buf->base[0]);
1111 av_free(buf);
1112 if ((ret = alloc_buffer(pool, s, &buf)) < 0)
1113 return ret;
1114 }
1115 buf->refcount++;
1116
1117 frame->opaque = buf;
1118 frame->type = FF_BUFFER_TYPE_USER;
1119 frame->extended_data = frame->data;
1120 frame->pkt_pts = s->pkt ? s->pkt->pts : AV_NOPTS_VALUE;
1121 frame->width = buf->w;
1122 frame->height = buf->h;
1123 frame->format = buf->pix_fmt;
1124 frame->sample_aspect_ratio = s->sample_aspect_ratio;
1125
1126 for (i = 0; i < FF_ARRAY_ELEMS(buf->data); i++) {
1127 frame->base[i] = buf->base[i]; // XXX h264.c uses base though it shouldn't
1128 frame->data[i] = buf->data[i];
1129 frame->linesize[i] = buf->linesize[i];
1130 }
1131
1132 return 0;
1133 }
1134
1135 static void unref_buffer(FrameBuffer *buf)
1136 {
1137 FrameBuffer **pool = buf->pool;
1138
1139 av_assert0(buf->refcount);
1140 buf->refcount--;
1141 if (!buf->refcount) {
1142 buf->next = *pool;
1143 *pool = buf;
1144 }
1145 }
1146
1147 void codec_release_buffer(AVCodecContext *s, AVFrame *frame)
1148 {
1149 FrameBuffer *buf = frame->opaque;
1150 int i;
1151
1152 for (i = 0; i < FF_ARRAY_ELEMS(frame->data); i++)
1153 frame->data[i] = NULL;
1154
1155 unref_buffer(buf);
1156 }
1157
1158 void filter_release_buffer(AVFilterBuffer *fb)
1159 {
1160 FrameBuffer *buf = fb->priv;
1161 av_free(fb);
1162 unref_buffer(buf);
1163 }
1164
1165 void free_buffer_pool(FrameBuffer **pool)
1166 {
1167 FrameBuffer *buf = *pool;
1168 while (buf) {
1169 *pool = buf->next;
1170 av_freep(&buf->base[0]);
1171 av_free(buf);
1172 buf = *pool;
1173 }
1174 }