pthreads: Generic progress lubrication support.
[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             goto unknown_opt;
255         bool_val = 0;
256     }
257     if (!po->name)
258         po = find_option(options, "default");
259     if (!po->name) {
260 unknown_opt:
261         av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);
262         return AVERROR(EINVAL);
263     }
264     if (po->flags & HAS_ARG && !arg) {
265         av_log(NULL, AV_LOG_ERROR, "Missing argument for option '%s'\n", opt);
266         return AVERROR(EINVAL);
267     }
268
269     /* new-style options contain an offset into optctx, old-style address of
270      * a global var*/
271     dst = po->flags & (OPT_OFFSET | OPT_SPEC) ? (uint8_t *)optctx + po->u.off
272                                               : po->u.dst_ptr;
273
274     if (po->flags & OPT_SPEC) {
275         SpecifierOpt **so = dst;
276         char *p = strchr(opt, ':');
277
278         dstcount = (int *)(so + 1);
279         *so = grow_array(*so, sizeof(**so), dstcount, *dstcount + 1);
280         (*so)[*dstcount - 1].specifier = av_strdup(p ? p + 1 : "");
281         dst = &(*so)[*dstcount - 1].u;
282     }
283
284     if (po->flags & OPT_STRING) {
285         char *str;
286         str = av_strdup(arg);
287         *(char **)dst = str;
288     } else if (po->flags & OPT_BOOL) {
289         *(int *)dst = bool_val;
290     } else if (po->flags & OPT_INT) {
291         *(int *)dst = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
292     } else if (po->flags & OPT_INT64) {
293         *(int64_t *)dst = parse_number_or_die(opt, arg, OPT_INT64, INT64_MIN, INT64_MAX);
294     } else if (po->flags & OPT_TIME) {
295         *(int64_t *)dst = parse_time_or_die(opt, arg, 1);
296     } else if (po->flags & OPT_FLOAT) {
297         *(float *)dst = parse_number_or_die(opt, arg, OPT_FLOAT, -INFINITY, INFINITY);
298     } else if (po->flags & OPT_DOUBLE) {
299         *(double *)dst = parse_number_or_die(opt, arg, OPT_DOUBLE, -INFINITY, INFINITY);
300     } else if (po->u.func_arg) {
301         int ret = po->flags & OPT_FUNC2 ? po->u.func2_arg(optctx, opt, arg)
302                                         : po->u.func_arg(opt, arg);
303         if (ret < 0) {
304             av_log(NULL, AV_LOG_ERROR,
305                    "Failed to set value '%s' for option '%s'\n", arg, opt);
306             return ret;
307         }
308     }
309     if (po->flags & OPT_EXIT)
310         exit_program(0);
311     return !!(po->flags & HAS_ARG);
312 }
313
314 void parse_options(void *optctx, int argc, char **argv, const OptionDef *options,
315                    void (*parse_arg_function)(void *, const char*))
316 {
317     const char *opt;
318     int optindex, handleoptions = 1, ret;
319
320     /* perform system-dependent conversions for arguments list */
321     prepare_app_arguments(&argc, &argv);
322
323     /* parse options */
324     optindex = 1;
325     while (optindex < argc) {
326         opt = argv[optindex++];
327
328         if (handleoptions && opt[0] == '-' && opt[1] != '\0') {
329             if (opt[1] == '-' && opt[2] == '\0') {
330                 handleoptions = 0;
331                 continue;
332             }
333             opt++;
334
335             if ((ret = parse_option(optctx, opt, argv[optindex], options)) < 0)
336                 exit_program(1);
337             optindex += ret;
338         } else {
339             if (parse_arg_function)
340                 parse_arg_function(optctx, opt);
341         }
342     }
343 }
344
345 /*
346  * Return index of option opt in argv or 0 if not found.
347  */
348 static 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;
424     char opt_stripped[128];
425     const char *p;
426     const AVClass *cc = avcodec_get_class(), *fc = avformat_get_class(), *sc;
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
453     if (oc || of || os)
454         return 0;
455     av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);
456     return AVERROR_OPTION_NOT_FOUND;
457 }
458
459 int opt_loglevel(const char *opt, const char *arg)
460 {
461     const struct { const char *name; int level; } log_levels[] = {
462         { "quiet"  , AV_LOG_QUIET   },
463         { "panic"  , AV_LOG_PANIC   },
464         { "fatal"  , AV_LOG_FATAL   },
465         { "error"  , AV_LOG_ERROR   },
466         { "warning", AV_LOG_WARNING },
467         { "info"   , AV_LOG_INFO    },
468         { "verbose", AV_LOG_VERBOSE },
469         { "debug"  , AV_LOG_DEBUG   },
470     };
471     char *tail;
472     int level;
473     int i;
474
475     for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
476         if (!strcmp(log_levels[i].name, arg)) {
477             av_log_set_level(log_levels[i].level);
478             return 0;
479         }
480     }
481
482     level = strtol(arg, &tail, 10);
483     if (*tail) {
484         av_log(NULL, AV_LOG_FATAL, "Invalid loglevel \"%s\". "
485                "Possible levels are numbers or:\n", arg);
486         for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
487             av_log(NULL, AV_LOG_FATAL, "\"%s\"\n", log_levels[i].name);
488         exit_program(1);
489     }
490     av_log_set_level(level);
491     return 0;
492 }
493
494 int opt_report(const char *opt)
495 {
496     char filename[64];
497     time_t now;
498     struct tm *tm;
499
500     if (report_file) /* already opened */
501         return 0;
502     time(&now);
503     tm = localtime(&now);
504     snprintf(filename, sizeof(filename), "%s-%04d%02d%02d-%02d%02d%02d.log",
505              program_name,
506              tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
507              tm->tm_hour, tm->tm_min, tm->tm_sec);
508     report_file = fopen(filename, "w");
509     if (!report_file) {
510         av_log(NULL, AV_LOG_ERROR, "Failed to open report \"%s\": %s\n",
511                filename, strerror(errno));
512         return AVERROR(errno);
513     }
514     av_log_set_callback(log_callback_report);
515     av_log(NULL, AV_LOG_INFO,
516            "%s started on %04d-%02d-%02d at %02d:%02d:%02d\n"
517            "Report written to \"%s\"\n",
518            program_name,
519            tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
520            tm->tm_hour, tm->tm_min, tm->tm_sec,
521            filename);
522     av_log_set_level(FFMAX(av_log_get_level(), AV_LOG_VERBOSE));
523     return 0;
524 }
525
526 int opt_max_alloc(const char *opt, const char *arg)
527 {
528     char *tail;
529     size_t max;
530
531     max = strtol(arg, &tail, 10);
532     if (*tail) {
533         av_log(NULL, AV_LOG_FATAL, "Invalid max_alloc \"%s\".\n", arg);
534         exit_program(1);
535     }
536     av_max_alloc(max);
537     return 0;
538 }
539
540 int opt_codec_debug(const char *opt, const char *arg)
541 {
542     av_log_set_level(AV_LOG_DEBUG);
543     return opt_default(opt, arg);
544 }
545
546 int opt_timelimit(const char *opt, const char *arg)
547 {
548 #if HAVE_SETRLIMIT
549     int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
550     struct rlimit rl = { lim, lim + 1 };
551     if (setrlimit(RLIMIT_CPU, &rl))
552         perror("setrlimit");
553 #else
554     av_log(NULL, AV_LOG_WARNING, "-%s not implemented on this OS\n", opt);
555 #endif
556     return 0;
557 }
558
559 void print_error(const char *filename, int err)
560 {
561     char errbuf[128];
562     const char *errbuf_ptr = errbuf;
563
564     if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
565         errbuf_ptr = strerror(AVUNERROR(err));
566     av_log(NULL, AV_LOG_ERROR, "%s: %s\n", filename, errbuf_ptr);
567 }
568
569 static int warned_cfg = 0;
570
571 #define INDENT        1
572 #define SHOW_VERSION  2
573 #define SHOW_CONFIG   4
574 #define SHOW_COPYRIGHT 8
575
576 #define PRINT_LIB_INFO(libname, LIBNAME, flags, level)                  \
577     if (CONFIG_##LIBNAME) {                                             \
578         const char *indent = flags & INDENT? "  " : "";                 \
579         if (flags & SHOW_VERSION) {                                     \
580             unsigned int version = libname##_version();                 \
581             av_log(NULL, level, "%slib%-11s %2d.%3d.%3d / %2d.%3d.%3d\n",\
582                    indent, #libname,                                    \
583                    LIB##LIBNAME##_VERSION_MAJOR,                        \
584                    LIB##LIBNAME##_VERSION_MINOR,                        \
585                    LIB##LIBNAME##_VERSION_MICRO,                        \
586                    version >> 16, version >> 8 & 0xff, version & 0xff); \
587         }                                                               \
588         if (flags & SHOW_CONFIG) {                                      \
589             const char *cfg = libname##_configuration();                \
590             if (strcmp(FFMPEG_CONFIGURATION, cfg)) {                    \
591                 if (!warned_cfg) {                                      \
592                     av_log(NULL, level,                                 \
593                             "%sWARNING: library configuration mismatch\n", \
594                             indent);                                    \
595                     warned_cfg = 1;                                     \
596                 }                                                       \
597                 av_log(NULL, level, "%s%-11s configuration: %s\n",      \
598                         indent, #libname, cfg);                         \
599             }                                                           \
600         }                                                               \
601     }                                                                   \
602
603 static void print_all_libs_info(int flags, int level)
604 {
605     PRINT_LIB_INFO(avutil,   AVUTIL,   flags, level);
606     PRINT_LIB_INFO(avcodec,  AVCODEC,  flags, level);
607     PRINT_LIB_INFO(avformat, AVFORMAT, flags, level);
608     PRINT_LIB_INFO(avdevice, AVDEVICE, flags, level);
609     PRINT_LIB_INFO(avfilter, AVFILTER, flags, level);
610     PRINT_LIB_INFO(swscale,  SWSCALE,  flags, level);
611     PRINT_LIB_INFO(swresample,SWRESAMPLE,  flags, level);
612 #if CONFIG_POSTPROC
613     PRINT_LIB_INFO(postproc, POSTPROC, flags, level);
614 #endif
615 }
616
617 static void print_program_info(int flags, int level)
618 {
619     const char *indent = flags & INDENT? "  " : "";
620
621     av_log(NULL, level, "%s version " FFMPEG_VERSION, program_name);
622     if (flags & SHOW_COPYRIGHT)
623         av_log(NULL, level, " Copyright (c) %d-%d the FFmpeg developers",
624                program_birth_year, this_year);
625     av_log(NULL, level, "\n");
626     av_log(NULL, level, "%sbuilt on %s %s with %s %s\n",
627            indent, __DATE__, __TIME__, CC_TYPE, CC_VERSION);
628     av_log(NULL, level, "%sconfiguration: " FFMPEG_CONFIGURATION "\n", indent);
629 }
630
631 void show_banner(int argc, char **argv, const OptionDef *options)
632 {
633     int idx = locate_option(argc, argv, options, "version");
634     if (idx)
635         return;
636
637     print_program_info (INDENT|SHOW_COPYRIGHT, AV_LOG_INFO);
638     print_all_libs_info(INDENT|SHOW_CONFIG,  AV_LOG_INFO);
639     print_all_libs_info(INDENT|SHOW_VERSION, AV_LOG_INFO);
640 }
641
642 int opt_version(const char *opt, const char *arg) {
643     av_log_set_callback(log_callback_help);
644     print_program_info (0           , AV_LOG_INFO);
645     print_all_libs_info(SHOW_VERSION, AV_LOG_INFO);
646     return 0;
647 }
648
649 int opt_license(const char *opt, const char *arg)
650 {
651     printf(
652 #if CONFIG_NONFREE
653     "This version of %s has nonfree parts compiled in.\n"
654     "Therefore it is not legally redistributable.\n",
655     program_name
656 #elif CONFIG_GPLV3
657     "%s is free software; you can redistribute it and/or modify\n"
658     "it under the terms of the GNU General Public License as published by\n"
659     "the Free Software Foundation; either version 3 of the License, or\n"
660     "(at your option) any later version.\n"
661     "\n"
662     "%s is distributed in the hope that it will be useful,\n"
663     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
664     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
665     "GNU General Public License for more details.\n"
666     "\n"
667     "You should have received a copy of the GNU General Public License\n"
668     "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
669     program_name, program_name, program_name
670 #elif CONFIG_GPL
671     "%s is free software; you can redistribute it and/or modify\n"
672     "it under the terms of the GNU General Public License as published by\n"
673     "the Free Software Foundation; either version 2 of the License, or\n"
674     "(at your option) any later version.\n"
675     "\n"
676     "%s is distributed in the hope that it will be useful,\n"
677     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
678     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
679     "GNU General Public License for more details.\n"
680     "\n"
681     "You should have received a copy of the GNU General Public License\n"
682     "along with %s; if not, write to the Free Software\n"
683     "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
684     program_name, program_name, program_name
685 #elif CONFIG_LGPLV3
686     "%s is free software; you can redistribute it and/or modify\n"
687     "it under the terms of the GNU Lesser General Public License as published by\n"
688     "the Free Software Foundation; either version 3 of the License, or\n"
689     "(at your option) any later version.\n"
690     "\n"
691     "%s is distributed in the hope that it will be useful,\n"
692     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
693     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
694     "GNU Lesser General Public License for more details.\n"
695     "\n"
696     "You should have received a copy of the GNU Lesser General Public License\n"
697     "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
698     program_name, program_name, program_name
699 #else
700     "%s is free software; you can redistribute it and/or\n"
701     "modify it under the terms of the GNU Lesser General Public\n"
702     "License as published by the Free Software Foundation; either\n"
703     "version 2.1 of the License, or (at your option) any later version.\n"
704     "\n"
705     "%s is distributed in the hope that it will be useful,\n"
706     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
707     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
708     "Lesser General Public License for more details.\n"
709     "\n"
710     "You should have received a copy of the GNU Lesser General Public\n"
711     "License along with %s; if not, write to the Free Software\n"
712     "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
713     program_name, program_name, program_name
714 #endif
715     );
716     return 0;
717 }
718
719 int opt_formats(const char *opt, const char *arg)
720 {
721     AVInputFormat *ifmt  = NULL;
722     AVOutputFormat *ofmt = NULL;
723     const char *last_name;
724
725     printf("File formats:\n"
726            " D. = Demuxing supported\n"
727            " .E = Muxing supported\n"
728            " --\n");
729     last_name = "000";
730     for (;;) {
731         int decode = 0;
732         int encode = 0;
733         const char *name      = NULL;
734         const char *long_name = NULL;
735
736         while ((ofmt = av_oformat_next(ofmt))) {
737             if ((name == NULL || strcmp(ofmt->name, name) < 0) &&
738                 strcmp(ofmt->name, last_name) > 0) {
739                 name      = ofmt->name;
740                 long_name = ofmt->long_name;
741                 encode    = 1;
742             }
743         }
744         while ((ifmt = av_iformat_next(ifmt))) {
745             if ((name == NULL || strcmp(ifmt->name, name) < 0) &&
746                 strcmp(ifmt->name, last_name) > 0) {
747                 name      = ifmt->name;
748                 long_name = ifmt->long_name;
749                 encode    = 0;
750             }
751             if (name && strcmp(ifmt->name, name) == 0)
752                 decode = 1;
753         }
754         if (name == NULL)
755             break;
756         last_name = name;
757
758         printf(" %s%s %-15s %s\n",
759                decode ? "D" : " ",
760                encode ? "E" : " ",
761                name,
762             long_name ? long_name:" ");
763     }
764     return 0;
765 }
766
767 static char get_media_type_char(enum AVMediaType type)
768 {
769     static const char map[AVMEDIA_TYPE_NB] = {
770         [AVMEDIA_TYPE_VIDEO]      = 'V',
771         [AVMEDIA_TYPE_AUDIO]      = 'A',
772         [AVMEDIA_TYPE_DATA]       = 'D',
773         [AVMEDIA_TYPE_SUBTITLE]   = 'S',
774         [AVMEDIA_TYPE_ATTACHMENT] = 'T',
775     };
776     return type >= 0 && type < AVMEDIA_TYPE_NB && map[type] ? map[type] : '?';
777 }
778
779 int opt_codecs(const char *opt, const char *arg)
780 {
781     AVCodec *p = NULL, *p2;
782     const char *last_name;
783     printf("Codecs:\n"
784            " D..... = Decoding supported\n"
785            " .E.... = Encoding supported\n"
786            " ..V... = Video codec\n"
787            " ..A... = Audio codec\n"
788            " ..S... = Subtitle codec\n"
789            " ...S.. = Supports draw_horiz_band\n"
790            " ....D. = Supports direct rendering method 1\n"
791            " .....T = Supports weird frame truncation\n"
792            " ------\n");
793     last_name= "000";
794     for (;;) {
795         int decode = 0;
796         int encode = 0;
797         int cap    = 0;
798
799         p2 = NULL;
800         while ((p = av_codec_next(p))) {
801             if ((p2 == NULL || strcmp(p->name, p2->name) < 0) &&
802                 strcmp(p->name, last_name) > 0) {
803                 p2 = p;
804                 decode = encode = cap = 0;
805             }
806             if (p2 && strcmp(p->name, p2->name) == 0) {
807                 if (p->decode)
808                     decode = 1;
809                 if (p->encode)
810                     encode = 1;
811                 cap |= p->capabilities;
812             }
813         }
814         if (p2 == NULL)
815             break;
816         last_name = p2->name;
817
818         printf(" %s%s%c%s%s%s %-15s %s",
819                decode ? "D" : (/* p2->decoder ? "d" : */ " "),
820                encode ? "E" : " ",
821                get_media_type_char(p2->type),
822                cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S" : " ",
823                cap & CODEC_CAP_DR1 ? "D" : " ",
824                cap & CODEC_CAP_TRUNCATED ? "T" : " ",
825                p2->name,
826                p2->long_name ? p2->long_name : "");
827 #if 0
828             if (p2->decoder && decode == 0)
829                 printf(" use %s for decoding", p2->decoder->name);
830 #endif
831         printf("\n");
832     }
833     printf("\n");
834     printf("Note, the names of encoders and decoders do not always match, so there are\n"
835            "several cases where the above table shows encoder only or decoder only entries\n"
836            "even though both encoding and decoding are supported. For example, the h263\n"
837            "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
838            "worse.\n");
839     return 0;
840 }
841
842 int opt_bsfs(const char *opt, const char *arg)
843 {
844     AVBitStreamFilter *bsf = NULL;
845
846     printf("Bitstream filters:\n");
847     while ((bsf = av_bitstream_filter_next(bsf)))
848         printf("%s\n", bsf->name);
849     printf("\n");
850     return 0;
851 }
852
853 int opt_protocols(const char *opt, const char *arg)
854 {
855     URLProtocol *up=NULL;
856
857     printf("Supported file protocols:\n"
858            "I.. = Input  supported\n"
859            ".O. = Output supported\n"
860            "..S = Seek   supported\n"
861            "FLAGS NAME\n"
862            "----- \n");
863     while((up = av_protocol_next(up)))
864         printf("%c%c%c   %s\n",
865                up->url_read  ? 'I' : '.',
866                up->url_write ? 'O' : '.',
867                up->url_seek  ? 'S' : '.',
868                up->name);
869     return 0;
870 }
871
872 int opt_filters(const char *opt, const char *arg)
873 {
874     AVFilter av_unused(**filter) = NULL;
875     char descr[64], *descr_cur;
876     int i, j;
877     const AVFilterPad *pad;
878
879     printf("Filters:\n");
880 #if CONFIG_AVFILTER
881     while ((filter = av_filter_next(filter)) && *filter) {
882         descr_cur = descr;
883         for (i = 0; i < 2; i++) {
884             if (i) {
885                 *(descr_cur++) = '-';
886                 *(descr_cur++) = '>';
887             }
888             pad = i ? (*filter)->outputs : (*filter)->inputs;
889             for (j = 0; pad[j].name; j++) {
890                 if (descr_cur >= descr + sizeof(descr) - 4)
891                     break;
892                 *(descr_cur++) = get_media_type_char(pad[j].type);
893             }
894             if (!j)
895                 *(descr_cur++) = '|';
896         }
897         *descr_cur = 0;
898         printf("%-16s %-10s %s\n", (*filter)->name, descr, (*filter)->description);
899     }
900 #endif
901     return 0;
902 }
903
904 int opt_pix_fmts(const char *opt, const char *arg)
905 {
906     enum PixelFormat pix_fmt;
907
908     printf("Pixel formats:\n"
909            "I.... = Supported Input  format for conversion\n"
910            ".O... = Supported Output format for conversion\n"
911            "..H.. = Hardware accelerated format\n"
912            "...P. = Paletted format\n"
913            "....B = Bitstream format\n"
914            "FLAGS NAME            NB_COMPONENTS BITS_PER_PIXEL\n"
915            "-----\n");
916
917 #if !CONFIG_SWSCALE
918 #   define sws_isSupportedInput(x)  0
919 #   define sws_isSupportedOutput(x) 0
920 #endif
921
922     for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {
923         const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[pix_fmt];
924         if(!pix_desc->name)
925             continue;
926         printf("%c%c%c%c%c %-16s       %d            %2d\n",
927                sws_isSupportedInput (pix_fmt)      ? 'I' : '.',
928                sws_isSupportedOutput(pix_fmt)      ? 'O' : '.',
929                pix_desc->flags & PIX_FMT_HWACCEL   ? 'H' : '.',
930                pix_desc->flags & PIX_FMT_PAL       ? 'P' : '.',
931                pix_desc->flags & PIX_FMT_BITSTREAM ? 'B' : '.',
932                pix_desc->name,
933                pix_desc->nb_components,
934                av_get_bits_per_pixel(pix_desc));
935     }
936     return 0;
937 }
938
939 int show_sample_fmts(const char *opt, const char *arg)
940 {
941     int i;
942     char fmt_str[128];
943     for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
944         printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
945     return 0;
946 }
947
948 int read_yesno(void)
949 {
950     int c = getchar();
951     int yesno = (toupper(c) == 'Y');
952
953     while (c != '\n' && c != EOF)
954         c = getchar();
955
956     return yesno;
957 }
958
959 int cmdutils_read_file(const char *filename, char **bufptr, size_t *size)
960 {
961     int ret;
962     FILE *f = fopen(filename, "rb");
963
964     if (!f) {
965         av_log(NULL, AV_LOG_ERROR, "Cannot read file '%s': %s\n", filename,
966                strerror(errno));
967         return AVERROR(errno);
968     }
969     fseek(f, 0, SEEK_END);
970     *size = ftell(f);
971     fseek(f, 0, SEEK_SET);
972     *bufptr = av_malloc(*size + 1);
973     if (!*bufptr) {
974         av_log(NULL, AV_LOG_ERROR, "Could not allocate file buffer\n");
975         fclose(f);
976         return AVERROR(ENOMEM);
977     }
978     ret = fread(*bufptr, 1, *size, f);
979     if (ret < *size) {
980         av_free(*bufptr);
981         if (ferror(f)) {
982             av_log(NULL, AV_LOG_ERROR, "Error while reading file '%s': %s\n",
983                    filename, strerror(errno));
984             ret = AVERROR(errno);
985         } else
986             ret = AVERROR_EOF;
987     } else {
988         ret = 0;
989         (*bufptr)[*size++] = '\0';
990     }
991
992     fclose(f);
993     return ret;
994 }
995
996 FILE *get_preset_file(char *filename, size_t filename_size,
997                       const char *preset_name, int is_path,
998                       const char *codec_name)
999 {
1000     FILE *f = NULL;
1001     int i;
1002     const char *base[3] = { getenv("FFMPEG_DATADIR"),
1003                             getenv("HOME"),
1004                             FFMPEG_DATADIR, };
1005
1006     if (is_path) {
1007         av_strlcpy(filename, preset_name, filename_size);
1008         f = fopen(filename, "r");
1009     } else {
1010 #ifdef _WIN32
1011         char datadir[MAX_PATH], *ls;
1012         base[2] = NULL;
1013
1014         if (GetModuleFileNameA(GetModuleHandleA(NULL), datadir, sizeof(datadir) - 1))
1015         {
1016             for (ls = datadir; ls < datadir + strlen(datadir); ls++)
1017                 if (*ls == '\\') *ls = '/';
1018
1019             if (ls = strrchr(datadir, '/'))
1020             {
1021                 *ls = 0;
1022                 strncat(datadir, "/ffpresets",  sizeof(datadir) - 1 - strlen(datadir));
1023                 base[2] = datadir;
1024             }
1025         }
1026 #endif
1027         for (i = 0; i < 3 && !f; i++) {
1028             if (!base[i])
1029                 continue;
1030             snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i],
1031                      i != 1 ? "" : "/.ffmpeg", preset_name);
1032             f = fopen(filename, "r");
1033             if (!f && codec_name) {
1034                 snprintf(filename, filename_size,
1035                          "%s%s/%s-%s.ffpreset",
1036                          base[i],  i != 1 ? "" : "/.ffmpeg", codec_name,
1037                          preset_name);
1038                 f = fopen(filename, "r");
1039             }
1040         }
1041     }
1042
1043     return f;
1044 }
1045
1046 int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
1047 {
1048     if (*spec <= '9' && *spec >= '0') /* opt:index */
1049         return strtol(spec, NULL, 0) == st->index;
1050     else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
1051              *spec == 't') { /* opt:[vasdt] */
1052         enum AVMediaType type;
1053
1054         switch (*spec++) {
1055         case 'v': type = AVMEDIA_TYPE_VIDEO;      break;
1056         case 'a': type = AVMEDIA_TYPE_AUDIO;      break;
1057         case 's': type = AVMEDIA_TYPE_SUBTITLE;   break;
1058         case 'd': type = AVMEDIA_TYPE_DATA;       break;
1059         case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
1060         default: abort(); // never reached, silence warning
1061         }
1062         if (type != st->codec->codec_type)
1063             return 0;
1064         if (*spec++ == ':') { /* possibly followed by :index */
1065             int i, index = strtol(spec, NULL, 0);
1066             for (i = 0; i < s->nb_streams; i++)
1067                 if (s->streams[i]->codec->codec_type == type && index-- == 0)
1068                    return i == st->index;
1069             return 0;
1070         }
1071         return 1;
1072     } else if (*spec == 'p' && *(spec + 1) == ':') {
1073         int prog_id, i, j;
1074         char *endptr;
1075         spec += 2;
1076         prog_id = strtol(spec, &endptr, 0);
1077         for (i = 0; i < s->nb_programs; i++) {
1078             if (s->programs[i]->id != prog_id)
1079                 continue;
1080
1081             if (*endptr++ == ':') {
1082                 int stream_idx = strtol(endptr, NULL, 0);
1083                 return stream_idx >= 0 &&
1084                     stream_idx < s->programs[i]->nb_stream_indexes &&
1085                     st->index == s->programs[i]->stream_index[stream_idx];
1086             }
1087
1088             for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
1089                 if (st->index == s->programs[i]->stream_index[j])
1090                     return 1;
1091         }
1092         return 0;
1093     } else if (!*spec) /* empty specifier, matches everything */
1094         return 1;
1095
1096     av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
1097     return AVERROR(EINVAL);
1098 }
1099
1100 AVDictionary *filter_codec_opts(AVDictionary *opts, AVCodec *codec,
1101                                 AVFormatContext *s, AVStream *st)
1102 {
1103     AVDictionary    *ret = NULL;
1104     AVDictionaryEntry *t = NULL;
1105     int            flags = s->oformat ? AV_OPT_FLAG_ENCODING_PARAM
1106                                       : AV_OPT_FLAG_DECODING_PARAM;
1107     char          prefix = 0;
1108     const AVClass    *cc = avcodec_get_class();
1109
1110     if (!codec)
1111         return NULL;
1112
1113     switch (codec->type) {
1114     case AVMEDIA_TYPE_VIDEO:
1115         prefix  = 'v';
1116         flags  |= AV_OPT_FLAG_VIDEO_PARAM;
1117         break;
1118     case AVMEDIA_TYPE_AUDIO:
1119         prefix  = 'a';
1120         flags  |= AV_OPT_FLAG_AUDIO_PARAM;
1121         break;
1122     case AVMEDIA_TYPE_SUBTITLE:
1123         prefix  = 's';
1124         flags  |= AV_OPT_FLAG_SUBTITLE_PARAM;
1125         break;
1126     }
1127
1128     while (t = av_dict_get(opts, "", t, AV_DICT_IGNORE_SUFFIX)) {
1129         char *p = strchr(t->key, ':');
1130
1131         /* check stream specification in opt name */
1132         if (p)
1133             switch (check_stream_specifier(s, st, p + 1)) {
1134             case  1: *p = 0; break;
1135             case  0:         continue;
1136             default:         return NULL;
1137             }
1138
1139         if (av_opt_find(&cc, t->key, NULL, flags, AV_OPT_SEARCH_FAKE_OBJ) ||
1140             (codec && codec->priv_class &&
1141              av_opt_find(&codec->priv_class, t->key, NULL, flags,
1142                          AV_OPT_SEARCH_FAKE_OBJ)))
1143             av_dict_set(&ret, t->key, t->value, 0);
1144         else if (t->key[0] == prefix &&
1145                  av_opt_find(&cc, t->key + 1, NULL, flags,
1146                              AV_OPT_SEARCH_FAKE_OBJ))
1147             av_dict_set(&ret, t->key + 1, t->value, 0);
1148
1149         if (p)
1150             *p = ':';
1151     }
1152     return ret;
1153 }
1154
1155 AVDictionary **setup_find_stream_info_opts(AVFormatContext *s,
1156                                            AVDictionary *codec_opts)
1157 {
1158     int i;
1159     AVDictionary **opts;
1160
1161     if (!s->nb_streams)
1162         return NULL;
1163     opts = av_mallocz(s->nb_streams * sizeof(*opts));
1164     if (!opts) {
1165         av_log(NULL, AV_LOG_ERROR,
1166                "Could not alloc memory for stream options.\n");
1167         return NULL;
1168     }
1169     for (i = 0; i < s->nb_streams; i++)
1170         opts[i] = filter_codec_opts(codec_opts, avcodec_find_decoder(s->streams[i]->codec->codec_id),
1171                                     s, s->streams[i]);
1172     return opts;
1173 }
1174
1175 void *grow_array(void *array, int elem_size, int *size, int new_size)
1176 {
1177     if (new_size >= INT_MAX / elem_size) {
1178         av_log(NULL, AV_LOG_ERROR, "Array too big.\n");
1179         exit_program(1);
1180     }
1181     if (*size < new_size) {
1182         uint8_t *tmp = av_realloc(array, new_size*elem_size);
1183         if (!tmp) {
1184             av_log(NULL, AV_LOG_ERROR, "Could not alloc buffer.\n");
1185             exit_program(1);
1186         }
1187         memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
1188         *size = new_size;
1189         return tmp;
1190     }
1191     return array;
1192 }