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