d6eb981205b0650be4d9317e9b5b2a2e0d67e516
[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 Libav.
6  *
7  * Libav is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * Libav is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with Libav; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21
22 #include <string.h>
23 #include <stdlib.h>
24 #include <errno.h>
25 #include <math.h>
26
27 /* Include only the enabled headers since some compilers (namely, Sun
28    Studio) will not omit unused inline functions and create undefined
29    references to libraries that are not being built. */
30
31 #include "config.h"
32 #include "libavformat/avformat.h"
33 #include "libavfilter/avfilter.h"
34 #include "libavdevice/avdevice.h"
35 #include "libavresample/avresample.h"
36 #include "libswscale/swscale.h"
37 #include "libavutil/avassert.h"
38 #include "libavutil/avstring.h"
39 #include "libavutil/mathematics.h"
40 #include "libavutil/imgutils.h"
41 #include "libavutil/parseutils.h"
42 #include "libavutil/pixdesc.h"
43 #include "libavutil/eval.h"
44 #include "libavutil/dict.h"
45 #include "libavutil/opt.h"
46 #include "libavutil/cpu.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/time.h>
54 #include <sys/resource.h>
55 #endif
56
57 struct SwsContext *sws_opts;
58 AVDictionary *format_opts, *codec_opts, *resample_opts;
59
60 static const int this_year = 2013;
61
62 void init_opts(void)
63 {
64 #if CONFIG_SWSCALE
65     sws_opts = sws_getContext(16, 16, 0, 16, 16, 0, SWS_BICUBIC,
66                               NULL, NULL, NULL);
67 #endif
68 }
69
70 void uninit_opts(void)
71 {
72 #if CONFIG_SWSCALE
73     sws_freeContext(sws_opts);
74     sws_opts = NULL;
75 #endif
76     av_dict_free(&format_opts);
77     av_dict_free(&codec_opts);
78     av_dict_free(&resample_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 (*program_exit)(int ret);
87
88 void register_exit(void (*cb)(int ret))
89 {
90     program_exit = cb;
91 }
92
93 void exit_program(int ret)
94 {
95     if (program_exit)
96         program_exit(ret);
97
98     exit(ret);
99 }
100
101 double parse_number_or_die(const char *context, const char *numstr, int type,
102                            double min, double max)
103 {
104     char *tail;
105     const char *error;
106     double d = av_strtod(numstr, &tail);
107     if (*tail)
108         error = "Expected number for %s but found: %s\n";
109     else if (d < min || d > max)
110         error = "The value for %s was %s which is not within %f - %f\n";
111     else if (type == OPT_INT64 && (int64_t)d != d)
112         error = "Expected int64 for %s but found %s\n";
113     else if (type == OPT_INT && (int)d != d)
114         error = "Expected int for %s but found %s\n";
115     else
116         return d;
117     av_log(NULL, AV_LOG_FATAL, error, context, numstr, min, max);
118     exit_program(1);
119     return 0;
120 }
121
122 int64_t parse_time_or_die(const char *context, const char *timestr,
123                           int is_duration)
124 {
125     int64_t us;
126     if (av_parse_time(&us, timestr, is_duration) < 0) {
127         av_log(NULL, AV_LOG_FATAL, "Invalid %s specification for %s: %s\n",
128                is_duration ? "duration" : "date", context, timestr);
129         exit_program(1);
130     }
131     return us;
132 }
133
134 void show_help_options(const OptionDef *options, const char *msg, int req_flags,
135                        int rej_flags, int alt_flags)
136 {
137     const OptionDef *po;
138     int first;
139
140     first = 1;
141     for (po = options; po->name != NULL; po++) {
142         char buf[64];
143
144         if (((po->flags & req_flags) != req_flags) ||
145             (alt_flags && !(po->flags & alt_flags)) ||
146             (po->flags & rej_flags))
147             continue;
148
149         if (first) {
150             printf("%s\n", msg);
151             first = 0;
152         }
153         av_strlcpy(buf, po->name, sizeof(buf));
154         if (po->argname) {
155             av_strlcat(buf, " ", sizeof(buf));
156             av_strlcat(buf, po->argname, sizeof(buf));
157         }
158         printf("-%-17s  %s\n", buf, po->help);
159     }
160     printf("\n");
161 }
162
163 void show_help_children(const AVClass *class, int flags)
164 {
165     const AVClass *child = NULL;
166     av_opt_show2(&class, NULL, flags, 0);
167     printf("\n");
168
169     while (child = av_opt_child_class_next(class, child))
170         show_help_children(child, flags);
171 }
172
173 static const OptionDef *find_option(const OptionDef *po, const char *name)
174 {
175     const char *p = strchr(name, ':');
176     int len = p ? p - name : strlen(name);
177
178     while (po->name != NULL) {
179         if (!strncmp(name, po->name, len) && strlen(po->name) == len)
180             break;
181         po++;
182     }
183     return po;
184 }
185
186 /* _WIN32 means using the windows libc - cygwin doesn't define that
187  * by default. HAVE_COMMANDLINETOARGVW is true on cygwin, while
188  * it doesn't provide the actual command line via GetCommandLineW(). */
189 #if HAVE_COMMANDLINETOARGVW && defined(_WIN32)
190 #include <windows.h>
191 #include <shellapi.h>
192 /* Will be leaked on exit */
193 static char** win32_argv_utf8 = NULL;
194 static int win32_argc = 0;
195
196 /**
197  * Prepare command line arguments for executable.
198  * For Windows - perform wide-char to UTF-8 conversion.
199  * Input arguments should be main() function arguments.
200  * @param argc_ptr Arguments number (including executable)
201  * @param argv_ptr Arguments list.
202  */
203 static void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
204 {
205     char *argstr_flat;
206     wchar_t **argv_w;
207     int i, buffsize = 0, offset = 0;
208
209     if (win32_argv_utf8) {
210         *argc_ptr = win32_argc;
211         *argv_ptr = win32_argv_utf8;
212         return;
213     }
214
215     win32_argc = 0;
216     argv_w = CommandLineToArgvW(GetCommandLineW(), &win32_argc);
217     if (win32_argc <= 0 || !argv_w)
218         return;
219
220     /* determine the UTF-8 buffer size (including NULL-termination symbols) */
221     for (i = 0; i < win32_argc; i++)
222         buffsize += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
223                                         NULL, 0, NULL, NULL);
224
225     win32_argv_utf8 = av_mallocz(sizeof(char *) * (win32_argc + 1) + buffsize);
226     argstr_flat     = (char *)win32_argv_utf8 + sizeof(char *) * (win32_argc + 1);
227     if (win32_argv_utf8 == NULL) {
228         LocalFree(argv_w);
229         return;
230     }
231
232     for (i = 0; i < win32_argc; i++) {
233         win32_argv_utf8[i] = &argstr_flat[offset];
234         offset += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
235                                       &argstr_flat[offset],
236                                       buffsize - offset, NULL, NULL);
237     }
238     win32_argv_utf8[i] = NULL;
239     LocalFree(argv_w);
240
241     *argc_ptr = win32_argc;
242     *argv_ptr = win32_argv_utf8;
243 }
244 #else
245 static inline void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
246 {
247     /* nothing to do */
248 }
249 #endif /* HAVE_COMMANDLINETOARGVW */
250
251 static int write_option(void *optctx, const OptionDef *po, const char *opt,
252                         const char *arg)
253 {
254     /* new-style options contain an offset into optctx, old-style address of
255      * a global var*/
256     void *dst = po->flags & (OPT_OFFSET | OPT_SPEC) ?
257                 (uint8_t *)optctx + po->u.off : po->u.dst_ptr;
258     int *dstcount;
259
260     if (po->flags & OPT_SPEC) {
261         SpecifierOpt **so = dst;
262         char *p = strchr(opt, ':');
263
264         dstcount = (int *)(so + 1);
265         *so = grow_array(*so, sizeof(**so), dstcount, *dstcount + 1);
266         (*so)[*dstcount - 1].specifier = av_strdup(p ? p + 1 : "");
267         dst = &(*so)[*dstcount - 1].u;
268     }
269
270     if (po->flags & OPT_STRING) {
271         char *str;
272         str = av_strdup(arg);
273         av_freep(dst);
274         *(char **)dst = str;
275     } else if (po->flags & OPT_BOOL || po->flags & OPT_INT) {
276         *(int *)dst = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
277     } else if (po->flags & OPT_INT64) {
278         *(int64_t *)dst = parse_number_or_die(opt, arg, OPT_INT64, INT64_MIN, INT64_MAX);
279     } else if (po->flags & OPT_TIME) {
280         *(int64_t *)dst = parse_time_or_die(opt, arg, 1);
281     } else if (po->flags & OPT_FLOAT) {
282         *(float *)dst = parse_number_or_die(opt, arg, OPT_FLOAT, -INFINITY, INFINITY);
283     } else if (po->flags & OPT_DOUBLE) {
284         *(double *)dst = parse_number_or_die(opt, arg, OPT_DOUBLE, -INFINITY, INFINITY);
285     } else if (po->u.func_arg) {
286         int ret = po->u.func_arg(optctx, opt, arg);
287         if (ret < 0) {
288             av_log(NULL, AV_LOG_ERROR,
289                    "Failed to set value '%s' for option '%s'\n", arg, opt);
290             return ret;
291         }
292     }
293     if (po->flags & OPT_EXIT)
294         exit_program(0);
295
296     return 0;
297 }
298
299 int parse_option(void *optctx, const char *opt, const char *arg,
300                  const OptionDef *options)
301 {
302     const OptionDef *po;
303     int ret;
304
305     po = find_option(options, opt);
306     if (!po->name && opt[0] == 'n' && opt[1] == 'o') {
307         /* handle 'no' bool option */
308         po = find_option(options, opt + 2);
309         if ((po->name && (po->flags & OPT_BOOL)))
310             arg = "0";
311     } else if (po->flags & OPT_BOOL)
312         arg = "1";
313
314     if (!po->name)
315         po = find_option(options, "default");
316     if (!po->name) {
317         av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);
318         return AVERROR(EINVAL);
319     }
320     if (po->flags & HAS_ARG && !arg) {
321         av_log(NULL, AV_LOG_ERROR, "Missing argument for option '%s'\n", opt);
322         return AVERROR(EINVAL);
323     }
324
325     ret = write_option(optctx, po, opt, arg);
326     if (ret < 0)
327         return ret;
328
329     return !!(po->flags & HAS_ARG);
330 }
331
332 void parse_options(void *optctx, int argc, char **argv, const OptionDef *options,
333                    void (*parse_arg_function)(void *, const char*))
334 {
335     const char *opt;
336     int optindex, handleoptions = 1, ret;
337
338     /* perform system-dependent conversions for arguments list */
339     prepare_app_arguments(&argc, &argv);
340
341     /* parse options */
342     optindex = 1;
343     while (optindex < argc) {
344         opt = argv[optindex++];
345
346         if (handleoptions && opt[0] == '-' && opt[1] != '\0') {
347             if (opt[1] == '-' && opt[2] == '\0') {
348                 handleoptions = 0;
349                 continue;
350             }
351             opt++;
352
353             if ((ret = parse_option(optctx, opt, argv[optindex], options)) < 0)
354                 exit_program(1);
355             optindex += ret;
356         } else {
357             if (parse_arg_function)
358                 parse_arg_function(optctx, opt);
359         }
360     }
361 }
362
363 int parse_optgroup(void *optctx, OptionGroup *g)
364 {
365     int i, ret;
366
367     av_log(NULL, AV_LOG_DEBUG, "Parsing a group of options: %s %s.\n",
368            g->group_def->name, g->arg);
369
370     for (i = 0; i < g->nb_opts; i++) {
371         Option *o = &g->opts[i];
372
373         if (g->group_def->flags &&
374             !(g->group_def->flags & o->opt->flags)) {
375             av_log(NULL, AV_LOG_ERROR, "Option %s (%s) cannot be applied to "
376                    "%s %s -- you are trying to apply an input option to an "
377                    "output file or vice versa. Move this option before the "
378                    "file it belongs to.\n", o->key, o->opt->help,
379                    g->group_def->name, g->arg);
380             return AVERROR(EINVAL);
381         }
382
383         av_log(NULL, AV_LOG_DEBUG, "Applying option %s (%s) with argument %s.\n",
384                o->key, o->opt->help, o->val);
385
386         ret = write_option(optctx, o->opt, o->key, o->val);
387         if (ret < 0)
388             return ret;
389     }
390
391     av_log(NULL, AV_LOG_DEBUG, "Successfully parsed a group of options.\n");
392
393     return 0;
394 }
395
396 int locate_option(int argc, char **argv, const OptionDef *options,
397                   const char *optname)
398 {
399     const OptionDef *po;
400     int i;
401
402     for (i = 1; i < argc; i++) {
403         const char *cur_opt = argv[i];
404
405         if (*cur_opt++ != '-')
406             continue;
407
408         po = find_option(options, cur_opt);
409         if (!po->name && cur_opt[0] == 'n' && cur_opt[1] == 'o')
410             po = find_option(options, cur_opt + 2);
411
412         if ((!po->name && !strcmp(cur_opt, optname)) ||
413              (po->name && !strcmp(optname, po->name)))
414             return i;
415
416         if (!po || po->flags & HAS_ARG)
417             i++;
418     }
419     return 0;
420 }
421
422 void parse_loglevel(int argc, char **argv, const OptionDef *options)
423 {
424     int idx = locate_option(argc, argv, options, "loglevel");
425     if (!idx)
426         idx = locate_option(argc, argv, options, "v");
427     if (idx && argv[idx + 1])
428         opt_loglevel(NULL, "loglevel", argv[idx + 1]);
429 }
430
431 #define FLAGS (o->type == AV_OPT_TYPE_FLAGS) ? AV_DICT_APPEND : 0
432 int opt_default(void *optctx, const char *opt, const char *arg)
433 {
434     const AVOption *o;
435     char opt_stripped[128];
436     const char *p;
437     const AVClass *cc = avcodec_get_class(), *fc = avformat_get_class();
438 #if CONFIG_AVRESAMPLE
439     const AVClass *rc = avresample_get_class();
440 #endif
441 #if CONFIG_SWSCALE
442     const AVClass *sc = sws_get_class();
443 #endif
444
445     if (!(p = strchr(opt, ':')))
446         p = opt + strlen(opt);
447     av_strlcpy(opt_stripped, opt, FFMIN(sizeof(opt_stripped), p - opt + 1));
448
449     if ((o = av_opt_find(&cc, opt_stripped, NULL, 0,
450                          AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)) ||
451         ((opt[0] == 'v' || opt[0] == 'a' || opt[0] == 's') &&
452          (o = av_opt_find(&cc, opt + 1, NULL, 0, AV_OPT_SEARCH_FAKE_OBJ))))
453         av_dict_set(&codec_opts, opt, arg, FLAGS);
454     else if ((o = av_opt_find(&fc, opt, NULL, 0,
455                               AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)))
456         av_dict_set(&format_opts, opt, arg, FLAGS);
457 #if CONFIG_AVRESAMPLE
458     else if ((o = av_opt_find(&rc, opt, NULL, 0,
459                               AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)))
460         av_dict_set(&resample_opts, opt, arg, FLAGS);
461 #endif
462 #if CONFIG_SWSCALE
463     else if ((o = av_opt_find(&sc, opt, NULL, 0,
464                               AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) {
465         // XXX we only support sws_flags, not arbitrary sws options
466         int ret = av_opt_set(sws_opts, opt, arg, 0);
467         if (ret < 0) {
468             av_log(NULL, AV_LOG_ERROR, "Error setting option %s.\n", opt);
469             return ret;
470         }
471     }
472 #endif
473
474     if (o)
475         return 0;
476     return AVERROR_OPTION_NOT_FOUND;
477 }
478
479 /*
480  * Check whether given option is a group separator.
481  *
482  * @return index of the group definition that matched or -1 if none
483  */
484 static int match_group_separator(const OptionGroupDef *groups, int nb_groups,
485                                  const char *opt)
486 {
487     int i;
488
489     for (i = 0; i < nb_groups; i++) {
490         const OptionGroupDef *p = &groups[i];
491         if (p->sep && !strcmp(p->sep, opt))
492             return i;
493     }
494
495     return -1;
496 }
497
498 /*
499  * Finish parsing an option group.
500  *
501  * @param group_idx which group definition should this group belong to
502  * @param arg argument of the group delimiting option
503  */
504 static void finish_group(OptionParseContext *octx, int group_idx,
505                          const char *arg)
506 {
507     OptionGroupList *l = &octx->groups[group_idx];
508     OptionGroup *g;
509
510     GROW_ARRAY(l->groups, l->nb_groups);
511     g = &l->groups[l->nb_groups - 1];
512
513     *g             = octx->cur_group;
514     g->arg         = arg;
515     g->group_def   = l->group_def;
516 #if CONFIG_SWSCALE
517     g->sws_opts    = sws_opts;
518 #endif
519     g->codec_opts  = codec_opts;
520     g->format_opts = format_opts;
521     g->resample_opts = resample_opts;
522
523     codec_opts  = NULL;
524     format_opts = NULL;
525     resample_opts = NULL;
526 #if CONFIG_SWSCALE
527     sws_opts    = NULL;
528 #endif
529     init_opts();
530
531     memset(&octx->cur_group, 0, sizeof(octx->cur_group));
532 }
533
534 /*
535  * Add an option instance to currently parsed group.
536  */
537 static void add_opt(OptionParseContext *octx, const OptionDef *opt,
538                     const char *key, const char *val)
539 {
540     int global = !(opt->flags & (OPT_PERFILE | OPT_SPEC | OPT_OFFSET));
541     OptionGroup *g = global ? &octx->global_opts : &octx->cur_group;
542
543     GROW_ARRAY(g->opts, g->nb_opts);
544     g->opts[g->nb_opts - 1].opt = opt;
545     g->opts[g->nb_opts - 1].key = key;
546     g->opts[g->nb_opts - 1].val = val;
547 }
548
549 static void init_parse_context(OptionParseContext *octx,
550                                const OptionGroupDef *groups, int nb_groups)
551 {
552     static const OptionGroupDef global_group = { "global" };
553     int i;
554
555     memset(octx, 0, sizeof(*octx));
556
557     octx->nb_groups = nb_groups;
558     octx->groups    = av_mallocz(sizeof(*octx->groups) * octx->nb_groups);
559     if (!octx->groups)
560         exit_program(1);
561
562     for (i = 0; i < octx->nb_groups; i++)
563         octx->groups[i].group_def = &groups[i];
564
565     octx->global_opts.group_def = &global_group;
566     octx->global_opts.arg       = "";
567
568     init_opts();
569 }
570
571 void uninit_parse_context(OptionParseContext *octx)
572 {
573     int i, j;
574
575     for (i = 0; i < octx->nb_groups; i++) {
576         OptionGroupList *l = &octx->groups[i];
577
578         for (j = 0; j < l->nb_groups; j++) {
579             av_freep(&l->groups[j].opts);
580             av_dict_free(&l->groups[j].codec_opts);
581             av_dict_free(&l->groups[j].format_opts);
582             av_dict_free(&l->groups[j].resample_opts);
583 #if CONFIG_SWSCALE
584             sws_freeContext(l->groups[j].sws_opts);
585 #endif
586         }
587         av_freep(&l->groups);
588     }
589     av_freep(&octx->groups);
590
591     av_freep(&octx->cur_group.opts);
592     av_freep(&octx->global_opts.opts);
593
594     uninit_opts();
595 }
596
597 int split_commandline(OptionParseContext *octx, int argc, char *argv[],
598                       const OptionDef *options,
599                       const OptionGroupDef *groups, int nb_groups)
600 {
601     int optindex = 1;
602
603     /* perform system-dependent conversions for arguments list */
604     prepare_app_arguments(&argc, &argv);
605
606     init_parse_context(octx, groups, nb_groups);
607     av_log(NULL, AV_LOG_DEBUG, "Splitting the commandline.\n");
608
609     while (optindex < argc) {
610         const char *opt = argv[optindex++], *arg;
611         const OptionDef *po;
612         int ret;
613
614         av_log(NULL, AV_LOG_DEBUG, "Reading option '%s' ...", opt);
615
616         /* unnamed group separators, e.g. output filename */
617         if (opt[0] != '-' || !opt[1]) {
618             finish_group(octx, 0, opt);
619             av_log(NULL, AV_LOG_DEBUG, " matched as %s.\n", groups[0].name);
620             continue;
621         }
622         opt++;
623
624 #define GET_ARG(arg)                                                           \
625 do {                                                                           \
626     arg = argv[optindex++];                                                    \
627     if (!arg) {                                                                \
628         av_log(NULL, AV_LOG_ERROR, "Missing argument for option '%s'.\n", opt);\
629         return AVERROR(EINVAL);                                                \
630     }                                                                          \
631 } while (0)
632
633         /* named group separators, e.g. -i */
634         if ((ret = match_group_separator(groups, nb_groups, opt)) >= 0) {
635             GET_ARG(arg);
636             finish_group(octx, ret, arg);
637             av_log(NULL, AV_LOG_DEBUG, " matched as %s with argument '%s'.\n",
638                    groups[ret].name, arg);
639             continue;
640         }
641
642         /* normal options */
643         po = find_option(options, opt);
644         if (po->name) {
645             if (po->flags & OPT_EXIT) {
646                 /* optional argument, e.g. -h */
647                 arg = argv[optindex++];
648             } else if (po->flags & HAS_ARG) {
649                 GET_ARG(arg);
650             } else {
651                 arg = "1";
652             }
653
654             add_opt(octx, po, opt, arg);
655             av_log(NULL, AV_LOG_DEBUG, " matched as option '%s' (%s) with "
656                    "argument '%s'.\n", po->name, po->help, arg);
657             continue;
658         }
659
660         /* AVOptions */
661         if (argv[optindex]) {
662             ret = opt_default(NULL, opt, argv[optindex]);
663             if (ret >= 0) {
664                 av_log(NULL, AV_LOG_DEBUG, " matched as AVOption '%s' with "
665                        "argument '%s'.\n", opt, argv[optindex]);
666                 optindex++;
667                 continue;
668             } else if (ret != AVERROR_OPTION_NOT_FOUND) {
669                 av_log(NULL, AV_LOG_ERROR, "Error parsing option '%s' "
670                        "with argument '%s'.\n", opt, argv[optindex]);
671                 return ret;
672             }
673         }
674
675         /* boolean -nofoo options */
676         if (opt[0] == 'n' && opt[1] == 'o' &&
677             (po = find_option(options, opt + 2)) &&
678             po->name && po->flags & OPT_BOOL) {
679             add_opt(octx, po, opt, "0");
680             av_log(NULL, AV_LOG_DEBUG, " matched as option '%s' (%s) with "
681                    "argument 0.\n", po->name, po->help);
682             continue;
683         }
684
685         av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'.\n", opt);
686         return AVERROR_OPTION_NOT_FOUND;
687     }
688
689     if (octx->cur_group.nb_opts || codec_opts || format_opts || resample_opts)
690         av_log(NULL, AV_LOG_WARNING, "Trailing options were found on the "
691                "commandline.\n");
692
693     av_log(NULL, AV_LOG_DEBUG, "Finished splitting the commandline.\n");
694
695     return 0;
696 }
697
698 int opt_cpuflags(void *optctx, const char *opt, const char *arg)
699 {
700     int flags = av_parse_cpu_flags(arg);
701
702     if (flags < 0)
703         return flags;
704
705     av_set_cpu_flags_mask(flags);
706     return 0;
707 }
708
709 int opt_loglevel(void *optctx, const char *opt, const char *arg)
710 {
711     const struct { const char *name; int level; } log_levels[] = {
712         { "quiet"  , AV_LOG_QUIET   },
713         { "panic"  , AV_LOG_PANIC   },
714         { "fatal"  , AV_LOG_FATAL   },
715         { "error"  , AV_LOG_ERROR   },
716         { "warning", AV_LOG_WARNING },
717         { "info"   , AV_LOG_INFO    },
718         { "verbose", AV_LOG_VERBOSE },
719         { "debug"  , AV_LOG_DEBUG   },
720     };
721     char *tail;
722     int level;
723     int i;
724
725     for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
726         if (!strcmp(log_levels[i].name, arg)) {
727             av_log_set_level(log_levels[i].level);
728             return 0;
729         }
730     }
731
732     level = strtol(arg, &tail, 10);
733     if (*tail) {
734         av_log(NULL, AV_LOG_FATAL, "Invalid loglevel \"%s\". "
735                "Possible levels are numbers or:\n", arg);
736         for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
737             av_log(NULL, AV_LOG_FATAL, "\"%s\"\n", log_levels[i].name);
738         exit_program(1);
739     }
740     av_log_set_level(level);
741     return 0;
742 }
743
744 int opt_timelimit(void *optctx, const char *opt, const char *arg)
745 {
746 #if HAVE_SETRLIMIT
747     int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
748     struct rlimit rl = { lim, lim + 1 };
749     if (setrlimit(RLIMIT_CPU, &rl))
750         perror("setrlimit");
751 #else
752     av_log(NULL, AV_LOG_WARNING, "-%s not implemented on this OS\n", opt);
753 #endif
754     return 0;
755 }
756
757 void print_error(const char *filename, int err)
758 {
759     char errbuf[128];
760     const char *errbuf_ptr = errbuf;
761
762     if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
763         errbuf_ptr = strerror(AVUNERROR(err));
764     av_log(NULL, AV_LOG_ERROR, "%s: %s\n", filename, errbuf_ptr);
765 }
766
767 static int warned_cfg = 0;
768
769 #define INDENT        1
770 #define SHOW_VERSION  2
771 #define SHOW_CONFIG   4
772
773 #define PRINT_LIB_INFO(libname, LIBNAME, flags, level)                  \
774     if (CONFIG_##LIBNAME) {                                             \
775         const char *indent = flags & INDENT? "  " : "";                 \
776         if (flags & SHOW_VERSION) {                                     \
777             unsigned int version = libname##_version();                 \
778             av_log(NULL, level,                                         \
779                    "%slib%-10s %2d.%3d.%2d / %2d.%3d.%2d\n",            \
780                    indent, #libname,                                    \
781                    LIB##LIBNAME##_VERSION_MAJOR,                        \
782                    LIB##LIBNAME##_VERSION_MINOR,                        \
783                    LIB##LIBNAME##_VERSION_MICRO,                        \
784                    version >> 16, version >> 8 & 0xff, version & 0xff); \
785         }                                                               \
786         if (flags & SHOW_CONFIG) {                                      \
787             const char *cfg = libname##_configuration();                \
788             if (strcmp(LIBAV_CONFIGURATION, cfg)) {                     \
789                 if (!warned_cfg) {                                      \
790                     av_log(NULL, level,                                 \
791                             "%sWARNING: library configuration mismatch\n", \
792                             indent);                                    \
793                     warned_cfg = 1;                                     \
794                 }                                                       \
795                 av_log(NULL, level, "%s%-11s configuration: %s\n",      \
796                         indent, #libname, cfg);                         \
797             }                                                           \
798         }                                                               \
799     }                                                                   \
800
801 static void print_all_libs_info(int flags, int level)
802 {
803     PRINT_LIB_INFO(avutil,   AVUTIL,   flags, level);
804     PRINT_LIB_INFO(avcodec,  AVCODEC,  flags, level);
805     PRINT_LIB_INFO(avformat, AVFORMAT, flags, level);
806     PRINT_LIB_INFO(avdevice, AVDEVICE, flags, level);
807     PRINT_LIB_INFO(avfilter, AVFILTER, flags, level);
808     PRINT_LIB_INFO(avresample, AVRESAMPLE, flags, level);
809     PRINT_LIB_INFO(swscale,  SWSCALE,  flags, level);
810 }
811
812 void show_banner(void)
813 {
814     av_log(NULL, AV_LOG_INFO,
815            "%s version " LIBAV_VERSION ", Copyright (c) %d-%d the Libav developers\n",
816            program_name, program_birth_year, this_year);
817     av_log(NULL, AV_LOG_INFO, "  built on %s %s with %s\n",
818            __DATE__, __TIME__, CC_IDENT);
819     av_log(NULL, AV_LOG_VERBOSE, "  configuration: " LIBAV_CONFIGURATION "\n");
820     print_all_libs_info(INDENT|SHOW_CONFIG,  AV_LOG_VERBOSE);
821     print_all_libs_info(INDENT|SHOW_VERSION, AV_LOG_VERBOSE);
822 }
823
824 int show_version(void *optctx, const char *opt, const char *arg)
825 {
826     av_log_set_callback(log_callback_help);
827     printf("%s " LIBAV_VERSION "\n", program_name);
828     print_all_libs_info(SHOW_VERSION, AV_LOG_INFO);
829
830     return 0;
831 }
832
833 int show_license(void *optctx, const char *opt, const char *arg)
834 {
835     printf(
836 #if CONFIG_NONFREE
837     "This version of %s has nonfree parts compiled in.\n"
838     "Therefore it is not legally redistributable.\n",
839     program_name
840 #elif CONFIG_GPLV3
841     "%s is free software; you can redistribute it and/or modify\n"
842     "it under the terms of the GNU General Public License as published by\n"
843     "the Free Software Foundation; either version 3 of the License, or\n"
844     "(at your option) any later version.\n"
845     "\n"
846     "%s is distributed in the hope that it will be useful,\n"
847     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
848     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
849     "GNU General Public License for more details.\n"
850     "\n"
851     "You should have received a copy of the GNU General Public License\n"
852     "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
853     program_name, program_name, program_name
854 #elif CONFIG_GPL
855     "%s is free software; you can redistribute it and/or modify\n"
856     "it under the terms of the GNU General Public License as published by\n"
857     "the Free Software Foundation; either version 2 of the License, or\n"
858     "(at your option) any later version.\n"
859     "\n"
860     "%s is distributed in the hope that it will be useful,\n"
861     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
862     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
863     "GNU General Public License for more details.\n"
864     "\n"
865     "You should have received a copy of the GNU General Public License\n"
866     "along with %s; if not, write to the Free Software\n"
867     "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
868     program_name, program_name, program_name
869 #elif CONFIG_LGPLV3
870     "%s is free software; you can redistribute it and/or modify\n"
871     "it under the terms of the GNU Lesser General Public License as published by\n"
872     "the Free Software Foundation; either version 3 of the License, or\n"
873     "(at your option) any later version.\n"
874     "\n"
875     "%s is distributed in the hope that it will be useful,\n"
876     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
877     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
878     "GNU Lesser General Public License for more details.\n"
879     "\n"
880     "You should have received a copy of the GNU Lesser General Public License\n"
881     "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
882     program_name, program_name, program_name
883 #else
884     "%s is free software; you can redistribute it and/or\n"
885     "modify it under the terms of the GNU Lesser General Public\n"
886     "License as published by the Free Software Foundation; either\n"
887     "version 2.1 of the License, or (at your option) any later version.\n"
888     "\n"
889     "%s is distributed in the hope that it will be useful,\n"
890     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
891     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
892     "Lesser General Public License for more details.\n"
893     "\n"
894     "You should have received a copy of the GNU Lesser General Public\n"
895     "License along with %s; if not, write to the Free Software\n"
896     "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
897     program_name, program_name, program_name
898 #endif
899     );
900
901     return 0;
902 }
903
904 int show_formats(void *optctx, const char *opt, const char *arg)
905 {
906     AVInputFormat *ifmt  = NULL;
907     AVOutputFormat *ofmt = NULL;
908     const char *last_name;
909
910     printf("File formats:\n"
911            " D. = Demuxing supported\n"
912            " .E = Muxing supported\n"
913            " --\n");
914     last_name = "000";
915     for (;;) {
916         int decode = 0;
917         int encode = 0;
918         const char *name      = NULL;
919         const char *long_name = NULL;
920
921         while ((ofmt = av_oformat_next(ofmt))) {
922             if ((name == NULL || strcmp(ofmt->name, name) < 0) &&
923                 strcmp(ofmt->name, last_name) > 0) {
924                 name      = ofmt->name;
925                 long_name = ofmt->long_name;
926                 encode    = 1;
927             }
928         }
929         while ((ifmt = av_iformat_next(ifmt))) {
930             if ((name == NULL || strcmp(ifmt->name, name) < 0) &&
931                 strcmp(ifmt->name, last_name) > 0) {
932                 name      = ifmt->name;
933                 long_name = ifmt->long_name;
934                 encode    = 0;
935             }
936             if (name && strcmp(ifmt->name, name) == 0)
937                 decode = 1;
938         }
939         if (name == NULL)
940             break;
941         last_name = name;
942
943         printf(" %s%s %-15s %s\n",
944                decode ? "D" : " ",
945                encode ? "E" : " ",
946                name,
947             long_name ? long_name:" ");
948     }
949     return 0;
950 }
951
952 #define PRINT_CODEC_SUPPORTED(codec, field, type, list_name, term, get_name) \
953     if (codec->field) {                                                      \
954         const type *p = c->field;                                            \
955                                                                              \
956         printf("    Supported " list_name ":");                              \
957         while (*p != term) {                                                 \
958             get_name(*p);                                                    \
959             printf(" %s", name);                                             \
960             p++;                                                             \
961         }                                                                    \
962         printf("\n");                                                        \
963     }                                                                        \
964
965 static void print_codec(const AVCodec *c)
966 {
967     int encoder = av_codec_is_encoder(c);
968
969     printf("%s %s [%s]:\n", encoder ? "Encoder" : "Decoder", c->name,
970            c->long_name ? c->long_name : "");
971
972     if (c->type == AVMEDIA_TYPE_VIDEO) {
973         printf("    Threading capabilities: ");
974         switch (c->capabilities & (CODEC_CAP_FRAME_THREADS |
975                                    CODEC_CAP_SLICE_THREADS)) {
976         case CODEC_CAP_FRAME_THREADS |
977              CODEC_CAP_SLICE_THREADS: printf("frame and slice"); break;
978         case CODEC_CAP_FRAME_THREADS: printf("frame");           break;
979         case CODEC_CAP_SLICE_THREADS: printf("slice");           break;
980         default:                      printf("no");              break;
981         }
982         printf("\n");
983     }
984
985     if (c->supported_framerates) {
986         const AVRational *fps = c->supported_framerates;
987
988         printf("    Supported framerates:");
989         while (fps->num) {
990             printf(" %d/%d", fps->num, fps->den);
991             fps++;
992         }
993         printf("\n");
994     }
995     PRINT_CODEC_SUPPORTED(c, pix_fmts, enum AVPixelFormat, "pixel formats",
996                           AV_PIX_FMT_NONE, GET_PIX_FMT_NAME);
997     PRINT_CODEC_SUPPORTED(c, supported_samplerates, int, "sample rates", 0,
998                           GET_SAMPLE_RATE_NAME);
999     PRINT_CODEC_SUPPORTED(c, sample_fmts, enum AVSampleFormat, "sample formats",
1000                           AV_SAMPLE_FMT_NONE, GET_SAMPLE_FMT_NAME);
1001     PRINT_CODEC_SUPPORTED(c, channel_layouts, uint64_t, "channel layouts",
1002                           0, GET_CH_LAYOUT_DESC);
1003
1004     if (c->priv_class) {
1005         show_help_children(c->priv_class,
1006                            AV_OPT_FLAG_ENCODING_PARAM |
1007                            AV_OPT_FLAG_DECODING_PARAM);
1008     }
1009 }
1010
1011 static char get_media_type_char(enum AVMediaType type)
1012 {
1013     switch (type) {
1014         case AVMEDIA_TYPE_VIDEO:    return 'V';
1015         case AVMEDIA_TYPE_AUDIO:    return 'A';
1016         case AVMEDIA_TYPE_SUBTITLE: return 'S';
1017         default:                    return '?';
1018     }
1019 }
1020
1021 static const AVCodec *next_codec_for_id(enum AVCodecID id, const AVCodec *prev,
1022                                         int encoder)
1023 {
1024     while ((prev = av_codec_next(prev))) {
1025         if (prev->id == id &&
1026             (encoder ? av_codec_is_encoder(prev) : av_codec_is_decoder(prev)))
1027             return prev;
1028     }
1029     return NULL;
1030 }
1031
1032 static void print_codecs_for_id(enum AVCodecID id, int encoder)
1033 {
1034     const AVCodec *codec = NULL;
1035
1036     printf(" (%s: ", encoder ? "encoders" : "decoders");
1037
1038     while ((codec = next_codec_for_id(id, codec, encoder)))
1039         printf("%s ", codec->name);
1040
1041     printf(")");
1042 }
1043
1044 int show_codecs(void *optctx, const char *opt, const char *arg)
1045 {
1046     const AVCodecDescriptor *desc = NULL;
1047
1048     printf("Codecs:\n"
1049            " D..... = Decoding supported\n"
1050            " .E.... = Encoding supported\n"
1051            " ..V... = Video codec\n"
1052            " ..A... = Audio codec\n"
1053            " ..S... = Subtitle codec\n"
1054            " ...I.. = Intra frame-only codec\n"
1055            " ....L. = Lossy compression\n"
1056            " .....S = Lossless compression\n"
1057            " -------\n");
1058     while ((desc = avcodec_descriptor_next(desc))) {
1059         const AVCodec *codec = NULL;
1060
1061         printf(avcodec_find_decoder(desc->id) ? "D" : ".");
1062         printf(avcodec_find_encoder(desc->id) ? "E" : ".");
1063
1064         printf("%c", get_media_type_char(desc->type));
1065         printf((desc->props & AV_CODEC_PROP_INTRA_ONLY) ? "I" : ".");
1066         printf((desc->props & AV_CODEC_PROP_LOSSY)      ? "L" : ".");
1067         printf((desc->props & AV_CODEC_PROP_LOSSLESS)   ? "S" : ".");
1068
1069         printf(" %-20s %s", desc->name, desc->long_name ? desc->long_name : "");
1070
1071         /* print decoders/encoders when there's more than one or their
1072          * names are different from codec name */
1073         while ((codec = next_codec_for_id(desc->id, codec, 0))) {
1074             if (strcmp(codec->name, desc->name)) {
1075                 print_codecs_for_id(desc->id, 0);
1076                 break;
1077             }
1078         }
1079         codec = NULL;
1080         while ((codec = next_codec_for_id(desc->id, codec, 1))) {
1081             if (strcmp(codec->name, desc->name)) {
1082                 print_codecs_for_id(desc->id, 1);
1083                 break;
1084             }
1085         }
1086
1087         printf("\n");
1088     }
1089     return 0;
1090 }
1091
1092 static void print_codecs(int encoder)
1093 {
1094     const AVCodecDescriptor *desc = NULL;
1095
1096     printf("%s:\n"
1097            " V... = Video\n"
1098            " A... = Audio\n"
1099            " S... = Subtitle\n"
1100            " .F.. = Frame-level multithreading\n"
1101            " ..S. = Slice-level multithreading\n"
1102            " ...X = Codec is experimental\n"
1103            " ---\n",
1104            encoder ? "Encoders" : "Decoders");
1105     while ((desc = avcodec_descriptor_next(desc))) {
1106         const AVCodec *codec = NULL;
1107
1108         while ((codec = next_codec_for_id(desc->id, codec, encoder))) {
1109             printf("%c", get_media_type_char(desc->type));
1110             printf((codec->capabilities & CODEC_CAP_FRAME_THREADS) ? "F" : ".");
1111             printf((codec->capabilities & CODEC_CAP_SLICE_THREADS) ? "S" : ".");
1112             printf((codec->capabilities & CODEC_CAP_EXPERIMENTAL)  ? "X" : ".");
1113
1114             printf(" %-20s %s", codec->name, codec->long_name ? codec->long_name : "");
1115             if (strcmp(codec->name, desc->name))
1116                 printf(" (codec %s)", desc->name);
1117
1118             printf("\n");
1119         }
1120     }
1121 }
1122
1123 int show_decoders(void *optctx, const char *opt, const char *arg)
1124 {
1125     print_codecs(0);
1126     return 0;
1127 }
1128
1129 int show_encoders(void *optctx, const char *opt, const char *arg)
1130 {
1131     print_codecs(1);
1132     return 0;
1133 }
1134
1135 int show_bsfs(void *optctx, const char *opt, const char *arg)
1136 {
1137     AVBitStreamFilter *bsf = NULL;
1138
1139     printf("Bitstream filters:\n");
1140     while ((bsf = av_bitstream_filter_next(bsf)))
1141         printf("%s\n", bsf->name);
1142     printf("\n");
1143     return 0;
1144 }
1145
1146 int show_protocols(void *optctx, const char *opt, const char *arg)
1147 {
1148     void *opaque = NULL;
1149     const char *name;
1150
1151     printf("Supported file protocols:\n"
1152            "Input:\n");
1153     while ((name = avio_enum_protocols(&opaque, 0)))
1154         printf("%s\n", name);
1155     printf("Output:\n");
1156     while ((name = avio_enum_protocols(&opaque, 1)))
1157         printf("%s\n", name);
1158     return 0;
1159 }
1160
1161 int show_filters(void *optctx, const char *opt, const char *arg)
1162 {
1163     const AVFilter av_unused(*filter) = NULL;
1164
1165     printf("Filters:\n");
1166 #if CONFIG_AVFILTER
1167     while ((filter = avfilter_next(filter)))
1168         printf("%-16s %s\n", filter->name, filter->description);
1169 #endif
1170     return 0;
1171 }
1172
1173 int show_pix_fmts(void *optctx, const char *opt, const char *arg)
1174 {
1175     const AVPixFmtDescriptor *pix_desc = NULL;
1176
1177     printf("Pixel formats:\n"
1178            "I.... = Supported Input  format for conversion\n"
1179            ".O... = Supported Output format for conversion\n"
1180            "..H.. = Hardware accelerated format\n"
1181            "...P. = Paletted format\n"
1182            "....B = Bitstream format\n"
1183            "FLAGS NAME            NB_COMPONENTS BITS_PER_PIXEL\n"
1184            "-----\n");
1185
1186 #if !CONFIG_SWSCALE
1187 #   define sws_isSupportedInput(x)  0
1188 #   define sws_isSupportedOutput(x) 0
1189 #endif
1190
1191     while ((pix_desc = av_pix_fmt_desc_next(pix_desc))) {
1192         enum AVPixelFormat pix_fmt = av_pix_fmt_desc_get_id(pix_desc);
1193         printf("%c%c%c%c%c %-16s       %d            %2d\n",
1194                sws_isSupportedInput (pix_fmt)              ? 'I' : '.',
1195                sws_isSupportedOutput(pix_fmt)              ? 'O' : '.',
1196                pix_desc->flags & AV_PIX_FMT_FLAG_HWACCEL   ? 'H' : '.',
1197                pix_desc->flags & AV_PIX_FMT_FLAG_PAL       ? 'P' : '.',
1198                pix_desc->flags & AV_PIX_FMT_FLAG_BITSTREAM ? 'B' : '.',
1199                pix_desc->name,
1200                pix_desc->nb_components,
1201                av_get_bits_per_pixel(pix_desc));
1202     }
1203     return 0;
1204 }
1205
1206 int show_sample_fmts(void *optctx, const char *opt, const char *arg)
1207 {
1208     int i;
1209     char fmt_str[128];
1210     for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
1211         printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
1212     return 0;
1213 }
1214
1215 static void show_help_codec(const char *name, int encoder)
1216 {
1217     const AVCodecDescriptor *desc;
1218     const AVCodec *codec;
1219
1220     if (!name) {
1221         av_log(NULL, AV_LOG_ERROR, "No codec name specified.\n");
1222         return;
1223     }
1224
1225     codec = encoder ? avcodec_find_encoder_by_name(name) :
1226                       avcodec_find_decoder_by_name(name);
1227
1228     if (codec)
1229         print_codec(codec);
1230     else if ((desc = avcodec_descriptor_get_by_name(name))) {
1231         int printed = 0;
1232
1233         while ((codec = next_codec_for_id(desc->id, codec, encoder))) {
1234             printed = 1;
1235             print_codec(codec);
1236         }
1237
1238         if (!printed) {
1239             av_log(NULL, AV_LOG_ERROR, "Codec '%s' is known to Libav, "
1240                    "but no %s for it are available. Libav might need to be "
1241                    "recompiled with additional external libraries.\n",
1242                    name, encoder ? "encoders" : "decoders");
1243         }
1244     } else {
1245         av_log(NULL, AV_LOG_ERROR, "Codec '%s' is not recognized by Libav.\n",
1246                name);
1247     }
1248 }
1249
1250 static void show_help_demuxer(const char *name)
1251 {
1252     const AVInputFormat *fmt = av_find_input_format(name);
1253
1254     if (!fmt) {
1255         av_log(NULL, AV_LOG_ERROR, "Unknown format '%s'.\n", name);
1256         return;
1257     }
1258
1259     printf("Demuxer %s [%s]:\n", fmt->name, fmt->long_name);
1260
1261     if (fmt->extensions)
1262         printf("    Common extensions: %s.\n", fmt->extensions);
1263
1264     if (fmt->priv_class)
1265         show_help_children(fmt->priv_class, AV_OPT_FLAG_DECODING_PARAM);
1266 }
1267
1268 static void show_help_muxer(const char *name)
1269 {
1270     const AVCodecDescriptor *desc;
1271     const AVOutputFormat *fmt = av_guess_format(name, NULL, NULL);
1272
1273     if (!fmt) {
1274         av_log(NULL, AV_LOG_ERROR, "Unknown format '%s'.\n", name);
1275         return;
1276     }
1277
1278     printf("Muxer %s [%s]:\n", fmt->name, fmt->long_name);
1279
1280     if (fmt->extensions)
1281         printf("    Common extensions: %s.\n", fmt->extensions);
1282     if (fmt->mime_type)
1283         printf("    Mime type: %s.\n", fmt->mime_type);
1284     if (fmt->video_codec != AV_CODEC_ID_NONE &&
1285         (desc = avcodec_descriptor_get(fmt->video_codec))) {
1286         printf("    Default video codec: %s.\n", desc->name);
1287     }
1288     if (fmt->audio_codec != AV_CODEC_ID_NONE &&
1289         (desc = avcodec_descriptor_get(fmt->audio_codec))) {
1290         printf("    Default audio codec: %s.\n", desc->name);
1291     }
1292     if (fmt->subtitle_codec != AV_CODEC_ID_NONE &&
1293         (desc = avcodec_descriptor_get(fmt->subtitle_codec))) {
1294         printf("    Default subtitle codec: %s.\n", desc->name);
1295     }
1296
1297     if (fmt->priv_class)
1298         show_help_children(fmt->priv_class, AV_OPT_FLAG_ENCODING_PARAM);
1299 }
1300
1301 #if CONFIG_AVFILTER
1302 static void show_help_filter(const char *name)
1303 {
1304     const AVFilter *f = avfilter_get_by_name(name);
1305     int i, count;
1306
1307     if (!name) {
1308         av_log(NULL, AV_LOG_ERROR, "No filter name specified.\n");
1309         return;
1310     } else if (!f) {
1311         av_log(NULL, AV_LOG_ERROR, "Unknown filter '%s'.\n", name);
1312         return;
1313     }
1314
1315     printf("Filter %s [%s]:\n", f->name, f->description);
1316
1317     if (f->flags & AVFILTER_FLAG_SLICE_THREADS)
1318         printf("    slice threading supported\n");
1319
1320     printf("    Inputs:\n");
1321     count = avfilter_pad_count(f->inputs);
1322     for (i = 0; i < count; i++) {
1323         printf("        %d %s (%s)\n", i, avfilter_pad_get_name(f->inputs, i),
1324                media_type_string(avfilter_pad_get_type(f->inputs, i)));
1325     }
1326     if (f->flags & AVFILTER_FLAG_DYNAMIC_INPUTS)
1327         printf("        dynamic (depending on the options)\n");
1328
1329     printf("    Outputs:\n");
1330     count = avfilter_pad_count(f->outputs);
1331     for (i = 0; i < count; i++) {
1332         printf("        %d %s (%s)\n", i, avfilter_pad_get_name(f->outputs, i),
1333                media_type_string(avfilter_pad_get_type(f->outputs, i)));
1334     }
1335     if (f->flags & AVFILTER_FLAG_DYNAMIC_OUTPUTS)
1336         printf("        dynamic (depending on the options)\n");
1337
1338     if (f->priv_class)
1339         show_help_children(f->priv_class, AV_OPT_FLAG_VIDEO_PARAM |
1340                                           AV_OPT_FLAG_AUDIO_PARAM);
1341 }
1342 #endif
1343
1344 int show_help(void *optctx, const char *opt, const char *arg)
1345 {
1346     char *topic, *par;
1347     av_log_set_callback(log_callback_help);
1348
1349     topic = av_strdup(arg ? arg : "");
1350     par = strchr(topic, '=');
1351     if (par)
1352         *par++ = 0;
1353
1354     if (!*topic) {
1355         show_help_default(topic, par);
1356     } else if (!strcmp(topic, "decoder")) {
1357         show_help_codec(par, 0);
1358     } else if (!strcmp(topic, "encoder")) {
1359         show_help_codec(par, 1);
1360     } else if (!strcmp(topic, "demuxer")) {
1361         show_help_demuxer(par);
1362     } else if (!strcmp(topic, "muxer")) {
1363         show_help_muxer(par);
1364 #if CONFIG_AVFILTER
1365     } else if (!strcmp(topic, "filter")) {
1366         show_help_filter(par);
1367 #endif
1368     } else {
1369         show_help_default(topic, par);
1370     }
1371
1372     av_freep(&topic);
1373     return 0;
1374 }
1375
1376 int read_yesno(void)
1377 {
1378     int c = getchar();
1379     int yesno = (av_toupper(c) == 'Y');
1380
1381     while (c != '\n' && c != EOF)
1382         c = getchar();
1383
1384     return yesno;
1385 }
1386
1387 int cmdutils_read_file(const char *filename, char **bufptr, size_t *size)
1388 {
1389     int ret;
1390     FILE *f = fopen(filename, "rb");
1391
1392     if (!f) {
1393         av_log(NULL, AV_LOG_ERROR, "Cannot read file '%s': %s\n", filename,
1394                strerror(errno));
1395         return AVERROR(errno);
1396     }
1397     fseek(f, 0, SEEK_END);
1398     *size = ftell(f);
1399     fseek(f, 0, SEEK_SET);
1400     *bufptr = av_malloc(*size + 1);
1401     if (!*bufptr) {
1402         av_log(NULL, AV_LOG_ERROR, "Could not allocate file buffer\n");
1403         fclose(f);
1404         return AVERROR(ENOMEM);
1405     }
1406     ret = fread(*bufptr, 1, *size, f);
1407     if (ret < *size) {
1408         av_free(*bufptr);
1409         if (ferror(f)) {
1410             av_log(NULL, AV_LOG_ERROR, "Error while reading file '%s': %s\n",
1411                    filename, strerror(errno));
1412             ret = AVERROR(errno);
1413         } else
1414             ret = AVERROR_EOF;
1415     } else {
1416         ret = 0;
1417         (*bufptr)[(*size)++] = '\0';
1418     }
1419
1420     fclose(f);
1421     return ret;
1422 }
1423
1424 void init_pts_correction(PtsCorrectionContext *ctx)
1425 {
1426     ctx->num_faulty_pts = ctx->num_faulty_dts = 0;
1427     ctx->last_pts = ctx->last_dts = INT64_MIN;
1428 }
1429
1430 int64_t guess_correct_pts(PtsCorrectionContext *ctx, int64_t reordered_pts,
1431                           int64_t dts)
1432 {
1433     int64_t pts = AV_NOPTS_VALUE;
1434
1435     if (dts != AV_NOPTS_VALUE) {
1436         ctx->num_faulty_dts += dts <= ctx->last_dts;
1437         ctx->last_dts = dts;
1438     }
1439     if (reordered_pts != AV_NOPTS_VALUE) {
1440         ctx->num_faulty_pts += reordered_pts <= ctx->last_pts;
1441         ctx->last_pts = reordered_pts;
1442     }
1443     if ((ctx->num_faulty_pts<=ctx->num_faulty_dts || dts == AV_NOPTS_VALUE)
1444         && reordered_pts != AV_NOPTS_VALUE)
1445         pts = reordered_pts;
1446     else
1447         pts = dts;
1448
1449     return pts;
1450 }
1451
1452 FILE *get_preset_file(char *filename, size_t filename_size,
1453                       const char *preset_name, int is_path,
1454                       const char *codec_name)
1455 {
1456     FILE *f = NULL;
1457     int i;
1458     const char *base[3] = { getenv("AVCONV_DATADIR"),
1459                             getenv("HOME"),
1460                             AVCONV_DATADIR, };
1461
1462     if (is_path) {
1463         av_strlcpy(filename, preset_name, filename_size);
1464         f = fopen(filename, "r");
1465     } else {
1466         for (i = 0; i < 3 && !f; i++) {
1467             if (!base[i])
1468                 continue;
1469             snprintf(filename, filename_size, "%s%s/%s.avpreset", base[i],
1470                      i != 1 ? "" : "/.avconv", preset_name);
1471             f = fopen(filename, "r");
1472             if (!f && codec_name) {
1473                 snprintf(filename, filename_size,
1474                          "%s%s/%s-%s.avpreset",
1475                          base[i], i != 1 ? "" : "/.avconv", codec_name,
1476                          preset_name);
1477                 f = fopen(filename, "r");
1478             }
1479         }
1480     }
1481
1482     return f;
1483 }
1484
1485 int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
1486 {
1487     if (*spec <= '9' && *spec >= '0') /* opt:index */
1488         return strtol(spec, NULL, 0) == st->index;
1489     else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
1490              *spec == 't') { /* opt:[vasdt] */
1491         enum AVMediaType type;
1492
1493         switch (*spec++) {
1494         case 'v': type = AVMEDIA_TYPE_VIDEO;      break;
1495         case 'a': type = AVMEDIA_TYPE_AUDIO;      break;
1496         case 's': type = AVMEDIA_TYPE_SUBTITLE;   break;
1497         case 'd': type = AVMEDIA_TYPE_DATA;       break;
1498         case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
1499         default:  av_assert0(0);
1500         }
1501         if (type != st->codec->codec_type)
1502             return 0;
1503         if (*spec++ == ':') { /* possibly followed by :index */
1504             int i, index = strtol(spec, NULL, 0);
1505             for (i = 0; i < s->nb_streams; i++)
1506                 if (s->streams[i]->codec->codec_type == type && index-- == 0)
1507                    return i == st->index;
1508             return 0;
1509         }
1510         return 1;
1511     } else if (*spec == 'p' && *(spec + 1) == ':') {
1512         int prog_id, i, j;
1513         char *endptr;
1514         spec += 2;
1515         prog_id = strtol(spec, &endptr, 0);
1516         for (i = 0; i < s->nb_programs; i++) {
1517             if (s->programs[i]->id != prog_id)
1518                 continue;
1519
1520             if (*endptr++ == ':') {
1521                 int stream_idx = strtol(endptr, NULL, 0);
1522                 return stream_idx >= 0 &&
1523                     stream_idx < s->programs[i]->nb_stream_indexes &&
1524                     st->index == s->programs[i]->stream_index[stream_idx];
1525             }
1526
1527             for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
1528                 if (st->index == s->programs[i]->stream_index[j])
1529                     return 1;
1530         }
1531         return 0;
1532     } else if (!*spec) /* empty specifier, matches everything */
1533         return 1;
1534
1535     av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
1536     return AVERROR(EINVAL);
1537 }
1538
1539 AVDictionary *filter_codec_opts(AVDictionary *opts, enum AVCodecID codec_id,
1540                                 AVFormatContext *s, AVStream *st, AVCodec *codec)
1541 {
1542     AVDictionary    *ret = NULL;
1543     AVDictionaryEntry *t = NULL;
1544     int            flags = s->oformat ? AV_OPT_FLAG_ENCODING_PARAM
1545                                       : AV_OPT_FLAG_DECODING_PARAM;
1546     char          prefix = 0;
1547     const AVClass    *cc = avcodec_get_class();
1548
1549     if (!codec)
1550         codec            = s->oformat ? avcodec_find_encoder(codec_id)
1551                                       : avcodec_find_decoder(codec_id);
1552
1553     switch (st->codec->codec_type) {
1554     case AVMEDIA_TYPE_VIDEO:
1555         prefix  = 'v';
1556         flags  |= AV_OPT_FLAG_VIDEO_PARAM;
1557         break;
1558     case AVMEDIA_TYPE_AUDIO:
1559         prefix  = 'a';
1560         flags  |= AV_OPT_FLAG_AUDIO_PARAM;
1561         break;
1562     case AVMEDIA_TYPE_SUBTITLE:
1563         prefix  = 's';
1564         flags  |= AV_OPT_FLAG_SUBTITLE_PARAM;
1565         break;
1566     }
1567
1568     while (t = av_dict_get(opts, "", t, AV_DICT_IGNORE_SUFFIX)) {
1569         char *p = strchr(t->key, ':');
1570
1571         /* check stream specification in opt name */
1572         if (p)
1573             switch (check_stream_specifier(s, st, p + 1)) {
1574             case  1: *p = 0; break;
1575             case  0:         continue;
1576             default:         return NULL;
1577             }
1578
1579         if (av_opt_find(&cc, t->key, NULL, flags, AV_OPT_SEARCH_FAKE_OBJ) ||
1580             (codec && codec->priv_class &&
1581              av_opt_find(&codec->priv_class, t->key, NULL, flags,
1582                          AV_OPT_SEARCH_FAKE_OBJ)))
1583             av_dict_set(&ret, t->key, t->value, 0);
1584         else if (t->key[0] == prefix &&
1585                  av_opt_find(&cc, t->key + 1, NULL, flags,
1586                              AV_OPT_SEARCH_FAKE_OBJ))
1587             av_dict_set(&ret, t->key + 1, t->value, 0);
1588
1589         if (p)
1590             *p = ':';
1591     }
1592     return ret;
1593 }
1594
1595 AVDictionary **setup_find_stream_info_opts(AVFormatContext *s,
1596                                            AVDictionary *codec_opts)
1597 {
1598     int i;
1599     AVDictionary **opts;
1600
1601     if (!s->nb_streams)
1602         return NULL;
1603     opts = av_mallocz(s->nb_streams * sizeof(*opts));
1604     if (!opts) {
1605         av_log(NULL, AV_LOG_ERROR,
1606                "Could not alloc memory for stream options.\n");
1607         return NULL;
1608     }
1609     for (i = 0; i < s->nb_streams; i++)
1610         opts[i] = filter_codec_opts(codec_opts, s->streams[i]->codec->codec_id,
1611                                     s, s->streams[i], NULL);
1612     return opts;
1613 }
1614
1615 void *grow_array(void *array, int elem_size, int *size, int new_size)
1616 {
1617     if (new_size >= INT_MAX / elem_size) {
1618         av_log(NULL, AV_LOG_ERROR, "Array too big.\n");
1619         exit_program(1);
1620     }
1621     if (*size < new_size) {
1622         uint8_t *tmp = av_realloc(array, new_size*elem_size);
1623         if (!tmp) {
1624             av_log(NULL, AV_LOG_ERROR, "Could not alloc buffer.\n");
1625             exit_program(1);
1626         }
1627         memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
1628         *size = new_size;
1629         return tmp;
1630     }
1631     return array;
1632 }
1633
1634 const char *media_type_string(enum AVMediaType media_type)
1635 {
1636     switch (media_type) {
1637     case AVMEDIA_TYPE_VIDEO:      return "video";
1638     case AVMEDIA_TYPE_AUDIO:      return "audio";
1639     case AVMEDIA_TYPE_DATA:       return "data";
1640     case AVMEDIA_TYPE_SUBTITLE:   return "subtitle";
1641     case AVMEDIA_TYPE_ATTACHMENT: return "attachment";
1642     default:                      return "unknown";
1643     }
1644 }