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