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