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