LCOV - code coverage report
Current view: top level - fftools - cmdutils.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 427 1158 36.9 %
Date: 2017-12-14 19:11:59 Functions: 36 84 42.9 %

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

Generated by: LCOV version 1.13