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