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