LCOV - code coverage report
Current view: top level - fftools - cmdutils.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 439 1195 36.7 %
Date: 2018-05-20 11:54:08 Functions: 36 85 42.4 %

          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       16949 : void init_opts(void)
      86             : {
      87       16949 :     av_dict_set(&sws_dict, "flags", "bicubic", 0);
      88       16949 : }
      89             : 
      90       11298 : void uninit_opts(void)
      91             : {
      92       11298 :     av_dict_free(&swr_opts);
      93       11298 :     av_dict_free(&sws_dict);
      94       11298 :     av_dict_free(&format_opts);
      95       11298 :     av_dict_free(&codec_opts);
      96       11298 :     av_dict_free(&resample_opts);
      97       11298 : }
      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        5681 : 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        5681 : }
     128             : 
     129             : static void (*program_exit)(int ret);
     130             : 
     131        5681 : void register_exit(void (*cb)(int ret))
     132             : {
     133        5681 :     program_exit = cb;
     134        5681 : }
     135             : 
     136        5618 : void exit_program(int ret)
     137             : {
     138        5618 :     if (program_exit)
     139        5618 :         program_exit(ret);
     140             : 
     141        5618 :     exit(ret);
     142             : }
     143             : 
     144       19385 : 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       19385 :     double d = av_strtod(numstr, &tail);
     150       19385 :     if (*tail)
     151           0 :         error = "Expected number for %s but found: %s\n";
     152       19385 :     else if (d < min || d > max)
     153           0 :         error = "The value for %s was %s which is not within %f - %f\n";
     154       19385 :     else if (type == OPT_INT64 && (int64_t)d != d)
     155           0 :         error = "Expected int64 for %s but found %s\n";
     156       19385 :     else if (type == OPT_INT && (int)d != d)
     157           0 :         error = "Expected int for %s but found %s\n";
     158             :     else
     159       19385 :         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         136 : int64_t parse_time_or_die(const char *context, const char *timestr,
     166             :                           int is_duration)
     167             : {
     168             :     int64_t us;
     169         136 :     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         136 :     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      706911 : static const OptionDef *find_option(const OptionDef *po, const char *name)
     219             : {
     220      706911 :     const char *p = strchr(name, ':');
     221      706911 :     int len = p ? p - name : strlen(name);
     222             : 
     223    93155171 :     while (po->name) {
     224    92061293 :         if (!strncmp(name, po->name, len) && strlen(po->name) == len)
     225      319944 :             break;
     226    91741349 :         po++;
     227             :     }
     228      706911 :     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        5681 : static inline void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
     290             : {
     291             :     /* nothing to do */
     292        5681 : }
     293             : #endif /* HAVE_COMMANDLINETOARGVW */
     294             : 
     295       58885 : 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      117770 :     void *dst = po->flags & (OPT_OFFSET | OPT_SPEC) ?
     301       58885 :                 (uint8_t *)optctx + po->u.off : po->u.dst_ptr;
     302             :     int *dstcount;
     303             : 
     304       58885 :     if (po->flags & OPT_SPEC) {
     305       22381 :         SpecifierOpt **so = dst;
     306       22381 :         char *p = strchr(opt, ':');
     307             :         char *str;
     308             : 
     309       22381 :         dstcount = (int *)(so + 1);
     310       22381 :         *so = grow_array(*so, sizeof(**so), dstcount, *dstcount + 1);
     311       22381 :         str = av_strdup(p ? p + 1 : "");
     312       22381 :         if (!str)
     313           0 :             return AVERROR(ENOMEM);
     314       22381 :         (*so)[*dstcount - 1].specifier = str;
     315       22381 :         dst = &(*so)[*dstcount - 1].u;
     316             :     }
     317             : 
     318       58885 :     if (po->flags & OPT_STRING) {
     319             :         char *str;
     320       26284 :         str = av_strdup(arg);
     321       26284 :         av_freep(dst);
     322       26284 :         if (!str)
     323           0 :             return AVERROR(ENOMEM);
     324       26284 :         *(char **)dst = str;
     325       32601 :     } else if (po->flags & OPT_BOOL || po->flags & OPT_INT) {
     326       14778 :         *(int *)dst = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
     327       17823 :     } else if (po->flags & OPT_INT64) {
     328        3913 :         *(int64_t *)dst = parse_number_or_die(opt, arg, OPT_INT64, INT64_MIN, INT64_MAX);
     329       13910 :     } else if (po->flags & OPT_TIME) {
     330         134 :         *(int64_t *)dst = parse_time_or_die(opt, arg, 1);
     331       13776 :     } else if (po->flags & OPT_FLOAT) {
     332           1 :         *(float *)dst = parse_number_or_die(opt, arg, OPT_FLOAT, -INFINITY, INFINITY);
     333       13775 :     } else if (po->flags & OPT_DOUBLE) {
     334         246 :         *(double *)dst = parse_number_or_die(opt, arg, OPT_DOUBLE, -INFINITY, INFINITY);
     335       13529 :     } else if (po->u.func_arg) {
     336       13529 :         int ret = po->u.func_arg(optctx, opt, arg);
     337       13529 :         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       58885 :     if (po->flags & OPT_EXIT)
     345           1 :         exit_program(0);
     346             : 
     347       58884 :     return 0;
     348             : }
     349             : 
     350        6932 : 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        6932 :     po = find_option(options, opt);
     357        6932 :     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        6932 :     } else if (po->flags & OPT_BOOL)
     363          48 :         arg = "1";
     364             : 
     365        6932 :     if (!po->name)
     366          11 :         po = find_option(options, "default");
     367        6932 :     if (!po->name) {
     368           0 :         av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);
     369           0 :         return AVERROR(EINVAL);
     370             :     }
     371        6932 :     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        6932 :     ret = write_option(optctx, po, opt, arg);
     377        6932 :     if (ret < 0)
     378           0 :         return ret;
     379             : 
     380        6932 :     return !!(po->flags & HAS_ARG);
     381             : }
     382             : 
     383          63 : 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          63 :     int optindex, handleoptions = 1, ret;
     388             : 
     389             :     /* perform system-dependent conversions for arguments list */
     390          63 :     prepare_app_arguments(&argc, &argv);
     391             : 
     392             :     /* parse options */
     393          63 :     optindex = 1;
     394         455 :     while (optindex < argc) {
     395         329 :         opt = argv[optindex++];
     396             : 
     397         329 :         if (handleoptions && opt[0] == '-' && opt[1] != '\0') {
     398         272 :             if (opt[1] == '-' && opt[2] == '\0') {
     399           0 :                 handleoptions = 0;
     400           0 :                 continue;
     401             :             }
     402         272 :             opt++;
     403             : 
     404         272 :             if ((ret = parse_option(optctx, opt, argv[optindex], options)) < 0)
     405           0 :                 exit_program(1);
     406         272 :             optindex += ret;
     407             :         } else {
     408          57 :             if (parse_arg_function)
     409          57 :                 parse_arg_function(optctx, opt);
     410             :         }
     411             :     }
     412          63 : }
     413             : 
     414       16886 : int parse_optgroup(void *optctx, OptionGroup *g)
     415             : {
     416             :     int i, ret;
     417             : 
     418       33772 :     av_log(NULL, AV_LOG_DEBUG, "Parsing a group of options: %s %s.\n",
     419       16886 :            g->group_def->name, g->arg);
     420             : 
     421       68838 :     for (i = 0; i < g->nb_opts; i++) {
     422       51953 :         Option *o = &g->opts[i];
     423             : 
     424       84813 :         if (g->group_def->flags &&
     425       32860 :             !(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      103906 :         av_log(NULL, AV_LOG_DEBUG, "Applying option %s (%s) with argument %s.\n",
     435       51953 :                o->key, o->opt->help, o->val);
     436             : 
     437       51953 :         ret = write_option(optctx, o->opt, o->key, o->val);
     438       51952 :         if (ret < 0)
     439           0 :             return ret;
     440             :     }
     441             : 
     442       16885 :     av_log(NULL, AV_LOG_DEBUG, "Successfully parsed a group of options.\n");
     443             : 
     444       16885 :     return 0;
     445             : }
     446             : 
     447       28405 : int locate_option(int argc, char **argv, const OptionDef *options,
     448             :                   const char *optname)
     449             : {
     450             :     const OptionDef *po;
     451             :     int i;
     452             : 
     453      579969 :     for (i = 1; i < argc; i++) {
     454      551604 :         const char *cur_opt = argv[i];
     455             : 
     456      551604 :         if (*cur_opt++ != '-')
     457       17571 :             continue;
     458             : 
     459      534033 :         po = find_option(options, cur_opt);
     460      534033 :         if (!po->name && cur_opt[0] == 'n' && cur_opt[1] == 'o')
     461       56005 :             po = find_option(options, cur_opt + 2);
     462             : 
     463     1068066 :         if ((!po->name && !strcmp(cur_opt, optname)) ||
     464      795092 :              (po->name && !strcmp(optname, po->name)))
     465          40 :             return i;
     466             : 
     467      533993 :         if (!po->name || po->flags & HAS_ARG)
     468      460448 :             i++;
     469             :     }
     470       28365 :     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        5681 : static void check_options(const OptionDef *po)
     498             : {
     499     1004162 :     while (po->name) {
     500      992800 :         if (po->flags & OPT_PERFILE)
     501      179776 :             av_assert0(po->flags & (OPT_INPUT | OPT_OUTPUT));
     502      992800 :         po++;
     503             :     }
     504        5681 : }
     505             : 
     506        5681 : void parse_loglevel(int argc, char **argv, const OptionDef *options)
     507             : {
     508        5681 :     int idx = locate_option(argc, argv, options, "loglevel");
     509             :     const char *env;
     510             : 
     511        5681 :     check_options(options);
     512             : 
     513        5681 :     if (!idx)
     514        5681 :         idx = locate_option(argc, argv, options, "v");
     515        5681 :     if (idx && argv[idx + 1])
     516          40 :         opt_loglevel(NULL, "loglevel", argv[idx + 1]);
     517        5681 :     idx = locate_option(argc, argv, options, "report");
     518        5681 :     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        5681 :     idx = locate_option(argc, argv, options, "hide_banner");
     531        5681 :     if (idx)
     532           0 :         hide_banner = 1;
     533        5681 : }
     534             : 
     535      209542 : static const AVOption *opt_find(void *obj, const char *name, const char *unit,
     536             :                             int opt_flags, int search_flags)
     537             : {
     538      209542 :     const AVOption *o = av_opt_find(obj, name, unit, opt_flags, search_flags);
     539      209542 :     if(o && !o->flags)
     540           2 :         return NULL;
     541      209540 :     return o;
     542             : }
     543             : 
     544             : #define FLAGS (o->type == AV_OPT_TYPE_FLAGS && (arg[0]=='-' || arg[0]=='+')) ? AV_DICT_APPEND : 0
     545       57990 : int opt_default(void *optctx, const char *opt, const char *arg)
     546             : {
     547             :     const AVOption *o;
     548       57990 :     int consumed = 0;
     549             :     char opt_stripped[128];
     550             :     const char *p;
     551       57990 :     const AVClass *cc = avcodec_get_class(), *fc = avformat_get_class();
     552             : #if CONFIG_AVRESAMPLE
     553       57990 :     const AVClass *rc = avresample_get_class();
     554             : #endif
     555             : #if CONFIG_SWSCALE
     556       57990 :     const AVClass *sc = sws_get_class();
     557             : #endif
     558             : #if CONFIG_SWRESAMPLE
     559       57990 :     const AVClass *swr_class = swr_get_class();
     560             : #endif
     561             : 
     562       57990 :     if (!strcmp(opt, "debug") || !strcmp(opt, "fdebug"))
     563           0 :         av_log_set_level(AV_LOG_DEBUG);
     564             : 
     565       57990 :     if (!(p = strchr(opt, ':')))
     566       57990 :         p = opt + strlen(opt);
     567       57990 :     av_strlcpy(opt_stripped, opt, FFMIN(sizeof(opt_stripped), p - opt + 1));
     568             : 
     569       57990 :     if ((o = opt_find(&cc, opt_stripped, NULL, 0,
     570       24240 :                          AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)) ||
     571       55082 :         ((opt[0] == 'v' || opt[0] == 'a' || opt[0] == 's') &&
     572        6605 :          (o = opt_find(&cc, opt + 1, NULL, 0, AV_OPT_SEARCH_FAKE_OBJ)))) {
     573       33751 :         av_dict_set(&codec_opts, opt, arg, FLAGS);
     574       33751 :         consumed = 1;
     575             :     }
     576       57990 :     if ((o = opt_find(&fc, opt, NULL, 0,
     577             :                          AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) {
     578        6532 :         av_dict_set(&format_opts, opt, arg, FLAGS);
     579        6532 :         if (consumed)
     580          64 :             av_log(NULL, AV_LOG_VERBOSE, "Routing option %s to both codec and muxer layer\n", opt);
     581        6532 :         consumed = 1;
     582             :     }
     583             : #if CONFIG_SWSCALE
     584       57990 :     if (!consumed && (o = opt_find(&sc, opt, NULL, 0,
     585             :                          AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) {
     586        6575 :         struct SwsContext *sws = sws_alloc_context();
     587        6575 :         int ret = av_opt_set(sws, opt, arg, 0);
     588        6575 :         sws_freeContext(sws);
     589       13150 :         if (!strcmp(opt, "srcw") || !strcmp(opt, "srch") ||
     590       19725 :             !strcmp(opt, "dstw") || !strcmp(opt, "dsth") ||
     591       13150 :             !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        6575 :         if (ret < 0) {
     596           0 :             av_log(NULL, AV_LOG_ERROR, "Error setting option %s.\n", opt);
     597           0 :             return ret;
     598             :         }
     599             : 
     600        6575 :         av_dict_set(&sws_dict, opt, arg, FLAGS);
     601             : 
     602        6575 :         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       57990 :     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       57990 :     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       57990 :     if (consumed)
     633       46794 :         return 0;
     634       11196 :     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      104384 : static int match_group_separator(const OptionGroupDef *groups, int nb_groups,
     643             :                                  const char *opt)
     644             : {
     645             :     int i;
     646             : 
     647      307502 :     for (i = 0; i < nb_groups; i++) {
     648      208768 :         const OptionGroupDef *p = &groups[i];
     649      208768 :         if (p->sep && !strcmp(p->sep, opt))
     650        5650 :             return i;
     651             :     }
     652             : 
     653       98734 :     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       11268 : static void finish_group(OptionParseContext *octx, int group_idx,
     663             :                          const char *arg)
     664             : {
     665       11268 :     OptionGroupList *l = &octx->groups[group_idx];
     666             :     OptionGroup *g;
     667             : 
     668       11268 :     GROW_ARRAY(l->groups, l->nb_groups);
     669       11268 :     g = &l->groups[l->nb_groups - 1];
     670             : 
     671       11268 :     *g             = octx->cur_group;
     672       11268 :     g->arg         = arg;
     673       11268 :     g->group_def   = l->group_def;
     674       11268 :     g->sws_dict    = sws_dict;
     675       11268 :     g->swr_opts    = swr_opts;
     676       11268 :     g->codec_opts  = codec_opts;
     677       11268 :     g->format_opts = format_opts;
     678       11268 :     g->resample_opts = resample_opts;
     679             : 
     680       11268 :     codec_opts  = NULL;
     681       11268 :     format_opts = NULL;
     682       11268 :     resample_opts = NULL;
     683       11268 :     sws_dict    = NULL;
     684       11268 :     swr_opts    = NULL;
     685       11268 :     init_opts();
     686             : 
     687       11268 :     memset(&octx->cur_group, 0, sizeof(octx->cur_group));
     688       11268 : }
     689             : 
     690             : /*
     691             :  * Add an option instance to currently parsed group.
     692             :  */
     693       51953 : static void add_opt(OptionParseContext *octx, const OptionDef *opt,
     694             :                     const char *key, const char *val)
     695             : {
     696       51953 :     int global = !(opt->flags & (OPT_PERFILE | OPT_SPEC | OPT_OFFSET));
     697       51953 :     OptionGroup *g = global ? &octx->global_opts : &octx->cur_group;
     698             : 
     699       51953 :     GROW_ARRAY(g->opts, g->nb_opts);
     700       51953 :     g->opts[g->nb_opts - 1].opt = opt;
     701       51953 :     g->opts[g->nb_opts - 1].key = key;
     702       51953 :     g->opts[g->nb_opts - 1].val = val;
     703       51953 : }
     704             : 
     705        5618 : 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        5618 :     memset(octx, 0, sizeof(*octx));
     712             : 
     713        5618 :     octx->nb_groups = nb_groups;
     714        5618 :     octx->groups    = av_mallocz_array(octx->nb_groups, sizeof(*octx->groups));
     715        5618 :     if (!octx->groups)
     716           0 :         exit_program(1);
     717             : 
     718       16854 :     for (i = 0; i < octx->nb_groups; i++)
     719       11236 :         octx->groups[i].group_def = &groups[i];
     720             : 
     721        5618 :     octx->global_opts.group_def = &global_group;
     722        5618 :     octx->global_opts.arg       = "";
     723             : 
     724        5618 :     init_opts();
     725        5618 : }
     726             : 
     727        5617 : void uninit_parse_context(OptionParseContext *octx)
     728             : {
     729             :     int i, j;
     730             : 
     731       16851 :     for (i = 0; i < octx->nb_groups; i++) {
     732       11234 :         OptionGroupList *l = &octx->groups[i];
     733             : 
     734       22502 :         for (j = 0; j < l->nb_groups; j++) {
     735       11268 :             av_freep(&l->groups[j].opts);
     736       11268 :             av_dict_free(&l->groups[j].codec_opts);
     737       11268 :             av_dict_free(&l->groups[j].format_opts);
     738       11268 :             av_dict_free(&l->groups[j].resample_opts);
     739             : 
     740       11268 :             av_dict_free(&l->groups[j].sws_dict);
     741       11268 :             av_dict_free(&l->groups[j].swr_opts);
     742             :         }
     743       11234 :         av_freep(&l->groups);
     744             :     }
     745        5617 :     av_freep(&octx->groups);
     746             : 
     747        5617 :     av_freep(&octx->cur_group.opts);
     748        5617 :     av_freep(&octx->global_opts.opts);
     749             : 
     750        5617 :     uninit_opts();
     751        5617 : }
     752             : 
     753        5618 : int split_commandline(OptionParseContext *octx, int argc, char *argv[],
     754             :                       const OptionDef *options,
     755             :                       const OptionGroupDef *groups, int nb_groups)
     756             : {
     757        5618 :     int optindex = 1;
     758        5618 :     int dashdash = -2;
     759             : 
     760             :     /* perform system-dependent conversions for arguments list */
     761        5618 :     prepare_app_arguments(&argc, &argv);
     762             : 
     763        5618 :     init_parse_context(octx, groups, nb_groups);
     764        5618 :     av_log(NULL, AV_LOG_DEBUG, "Splitting the commandline.\n");
     765             : 
     766        5618 :     while (optindex < argc) {
     767      110002 :         const char *opt = argv[optindex++], *arg;
     768             :         const OptionDef *po;
     769             :         int ret;
     770             : 
     771      110002 :         av_log(NULL, AV_LOG_DEBUG, "Reading option '%s' ...", opt);
     772             : 
     773      110002 :         if (opt[0] == '-' && opt[1] == '-' && !opt[2]) {
     774           0 :             dashdash = optindex;
     775           0 :             continue;
     776             :         }
     777             :         /* unnamed group separators, e.g. output filename */
     778      110002 :         if (opt[0] != '-' || !opt[1] || dashdash+1 == optindex) {
     779        5618 :             finish_group(octx, 0, opt);
     780        5618 :             av_log(NULL, AV_LOG_DEBUG, " matched as %s.\n", groups[0].name);
     781        5618 :             continue;
     782             :         }
     783      104384 :         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      104384 :         if ((ret = match_group_separator(groups, nb_groups, opt)) >= 0) {
     796        5650 :             GET_ARG(arg);
     797        5650 :             finish_group(octx, ret, arg);
     798        5650 :             av_log(NULL, AV_LOG_DEBUG, " matched as %s with argument '%s'.\n",
     799        5650 :                    groups[ret].name, arg);
     800        5650 :             continue;
     801             :         }
     802             : 
     803             :         /* normal options */
     804       98734 :         po = find_option(options, opt);
     805       98734 :         if (po->name) {
     806       40757 :             if (po->flags & OPT_EXIT) {
     807             :                 /* optional argument, e.g. -h */
     808           1 :                 arg = argv[optindex++];
     809       40756 :             } else if (po->flags & HAS_ARG) {
     810       37348 :                 GET_ARG(arg);
     811             :             } else {
     812        3408 :                 arg = "1";
     813             :             }
     814             : 
     815       40757 :             add_opt(octx, po, opt, arg);
     816       40757 :             av_log(NULL, AV_LOG_DEBUG, " matched as option '%s' (%s) with "
     817             :                    "argument '%s'.\n", po->name, po->help, arg);
     818       40757 :             continue;
     819             :         }
     820             : 
     821             :         /* AVOptions */
     822       57977 :         if (argv[optindex]) {
     823       57977 :             ret = opt_default(NULL, opt, argv[optindex]);
     824       57977 :             if (ret >= 0) {
     825       46781 :                 av_log(NULL, AV_LOG_DEBUG, " matched as AVOption '%s' with "
     826       46781 :                        "argument '%s'.\n", opt, argv[optindex]);
     827       46781 :                 optindex++;
     828       46781 :                 continue;
     829       11196 :             } 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       22392 :         if (opt[0] == 'n' && opt[1] == 'o' &&
     838       22392 :             (po = find_option(options, opt + 2)) &&
     839       22392 :             po->name && po->flags & OPT_BOOL) {
     840       11196 :             add_opt(octx, po, opt, "0");
     841       11196 :             av_log(NULL, AV_LOG_DEBUG, " matched as option '%s' (%s) with "
     842             :                    "argument 0.\n", po->name, po->help);
     843       11196 :             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        5618 :     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        5618 :     av_log(NULL, AV_LOG_DEBUG, "Finished splitting the commandline.\n");
     855             : 
     856        5618 :     return 0;
     857             : }
     858             : 
     859        5595 : int opt_cpuflags(void *optctx, const char *opt, const char *arg)
     860             : {
     861             :     int ret;
     862        5595 :     unsigned flags = av_get_cpu_flags();
     863             : 
     864        5595 :     if ((ret = av_parse_cpu_caps(&flags, arg)) < 0)
     865           0 :         return ret;
     866             : 
     867        5595 :     av_force_cpu_flags(flags);
     868        5595 :     return 0;
     869             : }
     870             : 
     871          80 : int opt_loglevel(void *optctx, const char *opt, const char *arg)
     872             : {
     873          80 :     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             :     const char *token;
     885             :     char *tail;
     886          80 :     int flags = av_log_get_flags();
     887          80 :     int level = av_log_get_level();
     888          80 :     int cmd, i = 0;
     889             : 
     890          80 :     av_assert0(arg);
     891         160 :     while (*arg) {
     892          80 :         token = arg;
     893          80 :         if (*token == '+' || *token == '-') {
     894           0 :             cmd = *token++;
     895             :         } else {
     896          80 :             cmd = 0;
     897             :         }
     898          80 :         if (!i && !cmd) {
     899          80 :             flags = 0;  /* missing relative prefix, build absolute value */
     900             :         }
     901          80 :         if (!strncmp(token, "repeat", 6)) {
     902           0 :             if (cmd == '-') {
     903           0 :                 flags |= AV_LOG_SKIP_REPEATED;
     904             :             } else {
     905           0 :                 flags &= ~AV_LOG_SKIP_REPEATED;
     906             :             }
     907           0 :             arg = token + 6;
     908          80 :         } else if (!strncmp(token, "level", 5)) {
     909           0 :             if (cmd == '-') {
     910           0 :                 flags &= ~AV_LOG_PRINT_LEVEL;
     911             :             } else {
     912           0 :                 flags |= AV_LOG_PRINT_LEVEL;
     913             :             }
     914           0 :             arg = token + 5;
     915             :         } else {
     916          80 :             break;
     917             :         }
     918           0 :         i++;
     919             :     }
     920          80 :     if (!*arg) {
     921           0 :         goto end;
     922          80 :     } else if (*arg == '+') {
     923           0 :         arg++;
     924          80 :     } else if (!i) {
     925          80 :         flags = av_log_get_flags();  /* level value without prefix, reset flags */
     926             :     }
     927             : 
     928         800 :     for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
     929         720 :         if (!strcmp(log_levels[i].name, arg)) {
     930           0 :             level = log_levels[i].level;
     931           0 :             goto end;
     932             :         }
     933             :     }
     934             : 
     935          80 :     level = strtol(arg, &tail, 10);
     936          80 :     if (*tail) {
     937           0 :         av_log(NULL, AV_LOG_FATAL, "Invalid loglevel \"%s\". "
     938             :                "Possible levels are numbers or:\n", arg);
     939           0 :         for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
     940           0 :             av_log(NULL, AV_LOG_FATAL, "\"%s\"\n", log_levels[i].name);
     941           0 :         exit_program(1);
     942             :     }
     943             : 
     944          80 : end:
     945          80 :     av_log_set_flags(flags);
     946          80 :     av_log_set_level(level);
     947          80 :     return 0;
     948             : }
     949             : 
     950           0 : static void expand_filename_template(AVBPrint *bp, const char *template,
     951             :                                      struct tm *tm)
     952             : {
     953             :     int c;
     954             : 
     955           0 :     while ((c = *(template++))) {
     956           0 :         if (c == '%') {
     957           0 :             if (!(c = *(template++)))
     958           0 :                 break;
     959           0 :             switch (c) {
     960           0 :             case 'p':
     961           0 :                 av_bprintf(bp, "%s", program_name);
     962           0 :                 break;
     963           0 :             case 't':
     964           0 :                 av_bprintf(bp, "%04d%02d%02d-%02d%02d%02d",
     965           0 :                            tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
     966             :                            tm->tm_hour, tm->tm_min, tm->tm_sec);
     967           0 :                 break;
     968           0 :             case '%':
     969           0 :                 av_bprint_chars(bp, c, 1);
     970           0 :                 break;
     971             :             }
     972             :         } else {
     973           0 :             av_bprint_chars(bp, c, 1);
     974             :         }
     975             :     }
     976           0 : }
     977             : 
     978           0 : static int init_report(const char *env)
     979             : {
     980           0 :     char *filename_template = NULL;
     981             :     char *key, *val;
     982           0 :     int ret, count = 0;
     983             :     time_t now;
     984             :     struct tm *tm;
     985             :     AVBPrint filename;
     986             : 
     987           0 :     if (report_file) /* already opened */
     988           0 :         return 0;
     989           0 :     time(&now);
     990           0 :     tm = localtime(&now);
     991             : 
     992           0 :     while (env && *env) {
     993           0 :         if ((ret = av_opt_get_key_value(&env, "=", ":", 0, &key, &val)) < 0) {
     994           0 :             if (count)
     995           0 :                 av_log(NULL, AV_LOG_ERROR,
     996             :                        "Failed to parse FFREPORT environment variable: %s\n",
     997           0 :                        av_err2str(ret));
     998           0 :             break;
     999             :         }
    1000           0 :         if (*env)
    1001           0 :             env++;
    1002           0 :         count++;
    1003           0 :         if (!strcmp(key, "file")) {
    1004           0 :             av_free(filename_template);
    1005           0 :             filename_template = val;
    1006           0 :             val = NULL;
    1007           0 :         } else if (!strcmp(key, "level")) {
    1008             :             char *tail;
    1009           0 :             report_file_level = strtol(val, &tail, 10);
    1010           0 :             if (*tail) {
    1011           0 :                 av_log(NULL, AV_LOG_FATAL, "Invalid report file level\n");
    1012           0 :                 exit_program(1);
    1013             :             }
    1014             :         } else {
    1015           0 :             av_log(NULL, AV_LOG_ERROR, "Unknown key '%s' in FFREPORT\n", key);
    1016             :         }
    1017           0 :         av_free(val);
    1018           0 :         av_free(key);
    1019             :     }
    1020             : 
    1021           0 :     av_bprint_init(&filename, 0, 1);
    1022           0 :     expand_filename_template(&filename,
    1023           0 :                              av_x_if_null(filename_template, "%p-%t.log"), tm);
    1024           0 :     av_free(filename_template);
    1025           0 :     if (!av_bprint_is_complete(&filename)) {
    1026           0 :         av_log(NULL, AV_LOG_ERROR, "Out of memory building report file name\n");
    1027           0 :         return AVERROR(ENOMEM);
    1028             :     }
    1029             : 
    1030           0 :     report_file = fopen(filename.str, "w");
    1031           0 :     if (!report_file) {
    1032           0 :         int ret = AVERROR(errno);
    1033           0 :         av_log(NULL, AV_LOG_ERROR, "Failed to open report \"%s\": %s\n",
    1034           0 :                filename.str, strerror(errno));
    1035           0 :         return ret;
    1036             :     }
    1037           0 :     av_log_set_callback(log_callback_report);
    1038           0 :     av_log(NULL, AV_LOG_INFO,
    1039             :            "%s started on %04d-%02d-%02d at %02d:%02d:%02d\n"
    1040             :            "Report written to \"%s\"\n",
    1041             :            program_name,
    1042           0 :            tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
    1043             :            tm->tm_hour, tm->tm_min, tm->tm_sec,
    1044             :            filename.str);
    1045           0 :     av_bprint_finalize(&filename, NULL);
    1046           0 :     return 0;
    1047             : }
    1048             : 
    1049           0 : int opt_report(const char *opt)
    1050             : {
    1051           0 :     return init_report(NULL);
    1052             : }
    1053             : 
    1054           0 : int opt_max_alloc(void *optctx, const char *opt, const char *arg)
    1055             : {
    1056             :     char *tail;
    1057             :     size_t max;
    1058             : 
    1059           0 :     max = strtol(arg, &tail, 10);
    1060           0 :     if (*tail) {
    1061           0 :         av_log(NULL, AV_LOG_FATAL, "Invalid max_alloc \"%s\".\n", arg);
    1062           0 :         exit_program(1);
    1063             :     }
    1064           0 :     av_max_alloc(max);
    1065           0 :     return 0;
    1066             : }
    1067             : 
    1068           0 : int opt_timelimit(void *optctx, const char *opt, const char *arg)
    1069             : {
    1070             : #if HAVE_SETRLIMIT
    1071           0 :     int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
    1072           0 :     struct rlimit rl = { lim, lim + 1 };
    1073           0 :     if (setrlimit(RLIMIT_CPU, &rl))
    1074           0 :         perror("setrlimit");
    1075             : #else
    1076             :     av_log(NULL, AV_LOG_WARNING, "-%s not implemented on this OS\n", opt);
    1077             : #endif
    1078           0 :     return 0;
    1079             : }
    1080             : 
    1081          75 : void print_error(const char *filename, int err)
    1082             : {
    1083             :     char errbuf[128];
    1084          75 :     const char *errbuf_ptr = errbuf;
    1085             : 
    1086          75 :     if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
    1087           0 :         errbuf_ptr = strerror(AVUNERROR(err));
    1088          75 :     av_log(NULL, AV_LOG_ERROR, "%s: %s\n", filename, errbuf_ptr);
    1089          75 : }
    1090             : 
    1091             : static int warned_cfg = 0;
    1092             : 
    1093             : #define INDENT        1
    1094             : #define SHOW_VERSION  2
    1095             : #define SHOW_CONFIG   4
    1096             : #define SHOW_COPYRIGHT 8
    1097             : 
    1098             : #define PRINT_LIB_INFO(libname, LIBNAME, flags, level)                  \
    1099             :     if (CONFIG_##LIBNAME) {                                             \
    1100             :         const char *indent = flags & INDENT? "  " : "";                 \
    1101             :         if (flags & SHOW_VERSION) {                                     \
    1102             :             unsigned int version = libname##_version();                 \
    1103             :             av_log(NULL, level,                                         \
    1104             :                    "%slib%-11s %2d.%3d.%3d / %2d.%3d.%3d\n",            \
    1105             :                    indent, #libname,                                    \
    1106             :                    LIB##LIBNAME##_VERSION_MAJOR,                        \
    1107             :                    LIB##LIBNAME##_VERSION_MINOR,                        \
    1108             :                    LIB##LIBNAME##_VERSION_MICRO,                        \
    1109             :                    AV_VERSION_MAJOR(version), AV_VERSION_MINOR(version),\
    1110             :                    AV_VERSION_MICRO(version));                          \
    1111             :         }                                                               \
    1112             :         if (flags & SHOW_CONFIG) {                                      \
    1113             :             const char *cfg = libname##_configuration();                \
    1114             :             if (strcmp(FFMPEG_CONFIGURATION, cfg)) {                    \
    1115             :                 if (!warned_cfg) {                                      \
    1116             :                     av_log(NULL, level,                                 \
    1117             :                             "%sWARNING: library configuration mismatch\n", \
    1118             :                             indent);                                    \
    1119             :                     warned_cfg = 1;                                     \
    1120             :                 }                                                       \
    1121             :                 av_log(NULL, level, "%s%-11s configuration: %s\n",      \
    1122             :                         indent, #libname, cfg);                         \
    1123             :             }                                                           \
    1124             :         }                                                               \
    1125             :     }                                                                   \
    1126             : 
    1127       11362 : static void print_all_libs_info(int flags, int level)
    1128             : {
    1129       11362 :     PRINT_LIB_INFO(avutil,     AVUTIL,     flags, level);
    1130       11362 :     PRINT_LIB_INFO(avcodec,    AVCODEC,    flags, level);
    1131       11362 :     PRINT_LIB_INFO(avformat,   AVFORMAT,   flags, level);
    1132       11362 :     PRINT_LIB_INFO(avdevice,   AVDEVICE,   flags, level);
    1133       11362 :     PRINT_LIB_INFO(avfilter,   AVFILTER,   flags, level);
    1134       11362 :     PRINT_LIB_INFO(avresample, AVRESAMPLE, flags, level);
    1135       11362 :     PRINT_LIB_INFO(swscale,    SWSCALE,    flags, level);
    1136       11362 :     PRINT_LIB_INFO(swresample, SWRESAMPLE, flags, level);
    1137       11362 :     PRINT_LIB_INFO(postproc,   POSTPROC,   flags, level);
    1138       11362 : }
    1139             : 
    1140        5681 : static void print_program_info(int flags, int level)
    1141             : {
    1142        5681 :     const char *indent = flags & INDENT? "  " : "";
    1143             : 
    1144        5681 :     av_log(NULL, level, "%s version " FFMPEG_VERSION, program_name);
    1145        5681 :     if (flags & SHOW_COPYRIGHT)
    1146        5681 :         av_log(NULL, level, " Copyright (c) %d-%d the FFmpeg developers",
    1147             :                program_birth_year, CONFIG_THIS_YEAR);
    1148        5681 :     av_log(NULL, level, "\n");
    1149        5681 :     av_log(NULL, level, "%sbuilt with %s\n", indent, CC_IDENT);
    1150             : 
    1151        5681 :     av_log(NULL, level, "%sconfiguration: " FFMPEG_CONFIGURATION "\n", indent);
    1152        5681 : }
    1153             : 
    1154           0 : static void print_buildconf(int flags, int level)
    1155             : {
    1156           0 :     const char *indent = flags & INDENT ? "  " : "";
    1157           0 :     char str[] = { FFMPEG_CONFIGURATION };
    1158             :     char *conflist, *remove_tilde, *splitconf;
    1159             : 
    1160             :     // Change all the ' --' strings to '~--' so that
    1161             :     // they can be identified as tokens.
    1162           0 :     while ((conflist = strstr(str, " --")) != NULL) {
    1163           0 :         strncpy(conflist, "~--", 3);
    1164             :     }
    1165             : 
    1166             :     // Compensate for the weirdness this would cause
    1167             :     // when passing 'pkg-config --static'.
    1168           0 :     while ((remove_tilde = strstr(str, "pkg-config~")) != NULL) {
    1169           0 :         strncpy(remove_tilde, "pkg-config ", 11);
    1170             :     }
    1171             : 
    1172           0 :     splitconf = strtok(str, "~");
    1173           0 :     av_log(NULL, level, "\n%sconfiguration:\n", indent);
    1174           0 :     while (splitconf != NULL) {
    1175           0 :         av_log(NULL, level, "%s%s%s\n", indent, indent, splitconf);
    1176           0 :         splitconf = strtok(NULL, "~");
    1177             :     }
    1178           0 : }
    1179             : 
    1180        5681 : void show_banner(int argc, char **argv, const OptionDef *options)
    1181             : {
    1182        5681 :     int idx = locate_option(argc, argv, options, "version");
    1183        5681 :     if (hide_banner || idx)
    1184           0 :         return;
    1185             : 
    1186        5681 :     print_program_info (INDENT|SHOW_COPYRIGHT, AV_LOG_INFO);
    1187        5681 :     print_all_libs_info(INDENT|SHOW_CONFIG,  AV_LOG_INFO);
    1188        5681 :     print_all_libs_info(INDENT|SHOW_VERSION, AV_LOG_INFO);
    1189             : }
    1190             : 
    1191           0 : int show_version(void *optctx, const char *opt, const char *arg)
    1192             : {
    1193           0 :     av_log_set_callback(log_callback_help);
    1194           0 :     print_program_info (SHOW_COPYRIGHT, AV_LOG_INFO);
    1195           0 :     print_all_libs_info(SHOW_VERSION, AV_LOG_INFO);
    1196             : 
    1197           0 :     return 0;
    1198             : }
    1199             : 
    1200           0 : int show_buildconf(void *optctx, const char *opt, const char *arg)
    1201             : {
    1202           0 :     av_log_set_callback(log_callback_help);
    1203           0 :     print_buildconf      (INDENT|0, AV_LOG_INFO);
    1204             : 
    1205           0 :     return 0;
    1206             : }
    1207             : 
    1208           0 : int show_license(void *optctx, const char *opt, const char *arg)
    1209             : {
    1210             : #if CONFIG_NONFREE
    1211             :     printf(
    1212             :     "This version of %s has nonfree parts compiled in.\n"
    1213             :     "Therefore it is not legally redistributable.\n",
    1214             :     program_name );
    1215             : #elif CONFIG_GPLV3
    1216             :     printf(
    1217             :     "%s is free software; you can redistribute it and/or modify\n"
    1218             :     "it under the terms of the GNU General Public License as published by\n"
    1219             :     "the Free Software Foundation; either version 3 of the License, or\n"
    1220             :     "(at your option) any later version.\n"
    1221             :     "\n"
    1222             :     "%s is distributed in the hope that it will be useful,\n"
    1223             :     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
    1224             :     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
    1225             :     "GNU General Public License for more details.\n"
    1226             :     "\n"
    1227             :     "You should have received a copy of the GNU General Public License\n"
    1228             :     "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
    1229             :     program_name, program_name, program_name );
    1230             : #elif CONFIG_GPL
    1231           0 :     printf(
    1232             :     "%s is free software; you can redistribute it and/or modify\n"
    1233             :     "it under the terms of the GNU General Public License as published by\n"
    1234             :     "the Free Software Foundation; either version 2 of the License, or\n"
    1235             :     "(at your option) any later version.\n"
    1236             :     "\n"
    1237             :     "%s is distributed in the hope that it will be useful,\n"
    1238             :     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
    1239             :     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
    1240             :     "GNU General Public License for more details.\n"
    1241             :     "\n"
    1242             :     "You should have received a copy of the GNU General Public License\n"
    1243             :     "along with %s; if not, write to the Free Software\n"
    1244             :     "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
    1245             :     program_name, program_name, program_name );
    1246             : #elif CONFIG_LGPLV3
    1247             :     printf(
    1248             :     "%s is free software; you can redistribute it and/or modify\n"
    1249             :     "it under the terms of the GNU Lesser General Public License as published by\n"
    1250             :     "the Free Software Foundation; either version 3 of the License, or\n"
    1251             :     "(at your option) any later version.\n"
    1252             :     "\n"
    1253             :     "%s is distributed in the hope that it will be useful,\n"
    1254             :     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
    1255             :     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
    1256             :     "GNU Lesser General Public License for more details.\n"
    1257             :     "\n"
    1258             :     "You should have received a copy of the GNU Lesser General Public License\n"
    1259             :     "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
    1260             :     program_name, program_name, program_name );
    1261             : #else
    1262             :     printf(
    1263             :     "%s is free software; you can redistribute it and/or\n"
    1264             :     "modify it under the terms of the GNU Lesser General Public\n"
    1265             :     "License as published by the Free Software Foundation; either\n"
    1266             :     "version 2.1 of the License, or (at your option) any later version.\n"
    1267             :     "\n"
    1268             :     "%s is distributed in the hope that it will be useful,\n"
    1269             :     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
    1270             :     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
    1271             :     "Lesser General Public License for more details.\n"
    1272             :     "\n"
    1273             :     "You should have received a copy of the GNU Lesser General Public\n"
    1274             :     "License along with %s; if not, write to the Free Software\n"
    1275             :     "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
    1276             :     program_name, program_name, program_name );
    1277             : #endif
    1278             : 
    1279           0 :     return 0;
    1280             : }
    1281             : 
    1282           0 : static int is_device(const AVClass *avclass)
    1283             : {
    1284           0 :     if (!avclass)
    1285           0 :         return 0;
    1286           0 :     return AV_IS_INPUT_DEVICE(avclass->category) || AV_IS_OUTPUT_DEVICE(avclass->category);
    1287             : }
    1288             : 
    1289           0 : static int show_formats_devices(void *optctx, const char *opt, const char *arg, int device_only, int muxdemuxers)
    1290             : {
    1291           0 :     void *ifmt_opaque = NULL;
    1292           0 :     const AVInputFormat *ifmt  = NULL;
    1293           0 :     void *ofmt_opaque = NULL;
    1294           0 :     const AVOutputFormat *ofmt = NULL;
    1295             :     const char *last_name;
    1296             :     int is_dev;
    1297             : 
    1298           0 :     printf("%s\n"
    1299             :            " D. = Demuxing supported\n"
    1300             :            " .E = Muxing supported\n"
    1301             :            " --\n", device_only ? "Devices:" : "File formats:");
    1302           0 :     last_name = "000";
    1303           0 :     for (;;) {
    1304           0 :         int decode = 0;
    1305           0 :         int encode = 0;
    1306           0 :         const char *name      = NULL;
    1307           0 :         const char *long_name = NULL;
    1308             : 
    1309           0 :         if (muxdemuxers !=SHOW_DEMUXERS) {
    1310           0 :             ofmt_opaque = NULL;
    1311           0 :             while ((ofmt = av_muxer_iterate(&ofmt_opaque))) {
    1312           0 :                 is_dev = is_device(ofmt->priv_class);
    1313           0 :                 if (!is_dev && device_only)
    1314           0 :                     continue;
    1315           0 :                 if ((!name || strcmp(ofmt->name, name) < 0) &&
    1316           0 :                     strcmp(ofmt->name, last_name) > 0) {
    1317           0 :                     name      = ofmt->name;
    1318           0 :                     long_name = ofmt->long_name;
    1319           0 :                     encode    = 1;
    1320             :                 }
    1321             :             }
    1322             :         }
    1323           0 :         if (muxdemuxers != SHOW_MUXERS) {
    1324           0 :             ifmt_opaque = NULL;
    1325           0 :             while ((ifmt = av_demuxer_iterate(&ifmt_opaque))) {
    1326           0 :                 is_dev = is_device(ifmt->priv_class);
    1327           0 :                 if (!is_dev && device_only)
    1328           0 :                     continue;
    1329           0 :                 if ((!name || strcmp(ifmt->name, name) < 0) &&
    1330           0 :                     strcmp(ifmt->name, last_name) > 0) {
    1331           0 :                     name      = ifmt->name;
    1332           0 :                     long_name = ifmt->long_name;
    1333           0 :                     encode    = 0;
    1334             :                 }
    1335           0 :                 if (name && strcmp(ifmt->name, name) == 0)
    1336           0 :                     decode = 1;
    1337             :             }
    1338             :         }
    1339           0 :         if (!name)
    1340           0 :             break;
    1341           0 :         last_name = name;
    1342             : 
    1343           0 :         printf(" %s%s %-15s %s\n",
    1344             :                decode ? "D" : " ",
    1345             :                encode ? "E" : " ",
    1346             :                name,
    1347             :             long_name ? long_name:" ");
    1348             :     }
    1349           0 :     return 0;
    1350             : }
    1351             : 
    1352           0 : int show_formats(void *optctx, const char *opt, const char *arg)
    1353             : {
    1354           0 :     return show_formats_devices(optctx, opt, arg, 0, SHOW_DEFAULT);
    1355             : }
    1356             : 
    1357           0 : int show_muxers(void *optctx, const char *opt, const char *arg)
    1358             : {
    1359           0 :     return show_formats_devices(optctx, opt, arg, 0, SHOW_MUXERS);
    1360             : }
    1361             : 
    1362           0 : int show_demuxers(void *optctx, const char *opt, const char *arg)
    1363             : {
    1364           0 :     return show_formats_devices(optctx, opt, arg, 0, SHOW_DEMUXERS);
    1365             : }
    1366             : 
    1367           0 : int show_devices(void *optctx, const char *opt, const char *arg)
    1368             : {
    1369           0 :     return show_formats_devices(optctx, opt, arg, 1, SHOW_DEFAULT);
    1370             : }
    1371             : 
    1372             : #define PRINT_CODEC_SUPPORTED(codec, field, type, list_name, term, get_name) \
    1373             :     if (codec->field) {                                                      \
    1374             :         const type *p = codec->field;                                        \
    1375             :                                                                              \
    1376             :         printf("    Supported " list_name ":");                              \
    1377             :         while (*p != term) {                                                 \
    1378             :             get_name(*p);                                                    \
    1379             :             printf(" %s", name);                                             \
    1380             :             p++;                                                             \
    1381             :         }                                                                    \
    1382             :         printf("\n");                                                        \
    1383             :     }                                                                        \
    1384             : 
    1385           0 : static void print_codec(const AVCodec *c)
    1386             : {
    1387           0 :     int encoder = av_codec_is_encoder(c);
    1388             : 
    1389           0 :     printf("%s %s [%s]:\n", encoder ? "Encoder" : "Decoder", c->name,
    1390           0 :            c->long_name ? c->long_name : "");
    1391             : 
    1392           0 :     printf("    General capabilities: ");
    1393           0 :     if (c->capabilities & AV_CODEC_CAP_DRAW_HORIZ_BAND)
    1394           0 :         printf("horizband ");
    1395           0 :     if (c->capabilities & AV_CODEC_CAP_DR1)
    1396           0 :         printf("dr1 ");
    1397           0 :     if (c->capabilities & AV_CODEC_CAP_TRUNCATED)
    1398           0 :         printf("trunc ");
    1399           0 :     if (c->capabilities & AV_CODEC_CAP_DELAY)
    1400           0 :         printf("delay ");
    1401           0 :     if (c->capabilities & AV_CODEC_CAP_SMALL_LAST_FRAME)
    1402           0 :         printf("small ");
    1403           0 :     if (c->capabilities & AV_CODEC_CAP_SUBFRAMES)
    1404           0 :         printf("subframes ");
    1405           0 :     if (c->capabilities & AV_CODEC_CAP_EXPERIMENTAL)
    1406           0 :         printf("exp ");
    1407           0 :     if (c->capabilities & AV_CODEC_CAP_CHANNEL_CONF)
    1408           0 :         printf("chconf ");
    1409           0 :     if (c->capabilities & AV_CODEC_CAP_PARAM_CHANGE)
    1410           0 :         printf("paramchange ");
    1411           0 :     if (c->capabilities & AV_CODEC_CAP_VARIABLE_FRAME_SIZE)
    1412           0 :         printf("variable ");
    1413           0 :     if (c->capabilities & (AV_CODEC_CAP_FRAME_THREADS |
    1414             :                            AV_CODEC_CAP_SLICE_THREADS |
    1415             :                            AV_CODEC_CAP_AUTO_THREADS))
    1416           0 :         printf("threads ");
    1417           0 :     if (!c->capabilities)
    1418           0 :         printf("none");
    1419           0 :     printf("\n");
    1420             : 
    1421           0 :     if (c->type == AVMEDIA_TYPE_VIDEO ||
    1422           0 :         c->type == AVMEDIA_TYPE_AUDIO) {
    1423           0 :         printf("    Threading capabilities: ");
    1424           0 :         switch (c->capabilities & (AV_CODEC_CAP_FRAME_THREADS |
    1425             :                                    AV_CODEC_CAP_SLICE_THREADS |
    1426             :                                    AV_CODEC_CAP_AUTO_THREADS)) {
    1427           0 :         case AV_CODEC_CAP_FRAME_THREADS |
    1428           0 :              AV_CODEC_CAP_SLICE_THREADS: printf("frame and slice"); break;
    1429           0 :         case AV_CODEC_CAP_FRAME_THREADS: printf("frame");           break;
    1430           0 :         case AV_CODEC_CAP_SLICE_THREADS: printf("slice");           break;
    1431           0 :         case AV_CODEC_CAP_AUTO_THREADS : printf("auto");            break;
    1432           0 :         default:                         printf("none");            break;
    1433             :         }
    1434           0 :         printf("\n");
    1435             :     }
    1436             : 
    1437           0 :     if (c->supported_framerates) {
    1438           0 :         const AVRational *fps = c->supported_framerates;
    1439             : 
    1440           0 :         printf("    Supported framerates:");
    1441           0 :         while (fps->num) {
    1442           0 :             printf(" %d/%d", fps->num, fps->den);
    1443           0 :             fps++;
    1444             :         }
    1445           0 :         printf("\n");
    1446             :     }
    1447           0 :     PRINT_CODEC_SUPPORTED(c, pix_fmts, enum AVPixelFormat, "pixel formats",
    1448             :                           AV_PIX_FMT_NONE, GET_PIX_FMT_NAME);
    1449           0 :     PRINT_CODEC_SUPPORTED(c, supported_samplerates, int, "sample rates", 0,
    1450             :                           GET_SAMPLE_RATE_NAME);
    1451           0 :     PRINT_CODEC_SUPPORTED(c, sample_fmts, enum AVSampleFormat, "sample formats",
    1452             :                           AV_SAMPLE_FMT_NONE, GET_SAMPLE_FMT_NAME);
    1453           0 :     PRINT_CODEC_SUPPORTED(c, channel_layouts, uint64_t, "channel layouts",
    1454             :                           0, GET_CH_LAYOUT_DESC);
    1455             : 
    1456           0 :     if (c->priv_class) {
    1457           0 :         show_help_children(c->priv_class,
    1458             :                            AV_OPT_FLAG_ENCODING_PARAM |
    1459             :                            AV_OPT_FLAG_DECODING_PARAM);
    1460             :     }
    1461           0 : }
    1462             : 
    1463           0 : static char get_media_type_char(enum AVMediaType type)
    1464             : {
    1465           0 :     switch (type) {
    1466           0 :         case AVMEDIA_TYPE_VIDEO:    return 'V';
    1467           0 :         case AVMEDIA_TYPE_AUDIO:    return 'A';
    1468           0 :         case AVMEDIA_TYPE_DATA:     return 'D';
    1469           0 :         case AVMEDIA_TYPE_SUBTITLE: return 'S';
    1470           0 :         case AVMEDIA_TYPE_ATTACHMENT:return 'T';
    1471           0 :         default:                    return '?';
    1472             :     }
    1473             : }
    1474             : 
    1475           0 : static const AVCodec *next_codec_for_id(enum AVCodecID id, const AVCodec *prev,
    1476             :                                         int encoder)
    1477             : {
    1478           0 :     while ((prev = av_codec_next(prev))) {
    1479           0 :         if (prev->id == id &&
    1480           0 :             (encoder ? av_codec_is_encoder(prev) : av_codec_is_decoder(prev)))
    1481           0 :             return prev;
    1482             :     }
    1483           0 :     return NULL;
    1484             : }
    1485             : 
    1486           0 : static int compare_codec_desc(const void *a, const void *b)
    1487             : {
    1488           0 :     const AVCodecDescriptor * const *da = a;
    1489           0 :     const AVCodecDescriptor * const *db = b;
    1490             : 
    1491           0 :     return (*da)->type != (*db)->type ? FFDIFFSIGN((*da)->type, (*db)->type) :
    1492           0 :            strcmp((*da)->name, (*db)->name);
    1493             : }
    1494             : 
    1495           0 : static unsigned get_codecs_sorted(const AVCodecDescriptor ***rcodecs)
    1496             : {
    1497           0 :     const AVCodecDescriptor *desc = NULL;
    1498             :     const AVCodecDescriptor **codecs;
    1499           0 :     unsigned nb_codecs = 0, i = 0;
    1500             : 
    1501           0 :     while ((desc = avcodec_descriptor_next(desc)))
    1502           0 :         nb_codecs++;
    1503           0 :     if (!(codecs = av_calloc(nb_codecs, sizeof(*codecs)))) {
    1504           0 :         av_log(NULL, AV_LOG_ERROR, "Out of memory\n");
    1505           0 :         exit_program(1);
    1506             :     }
    1507           0 :     desc = NULL;
    1508           0 :     while ((desc = avcodec_descriptor_next(desc)))
    1509           0 :         codecs[i++] = desc;
    1510           0 :     av_assert0(i == nb_codecs);
    1511           0 :     qsort(codecs, nb_codecs, sizeof(*codecs), compare_codec_desc);
    1512           0 :     *rcodecs = codecs;
    1513           0 :     return nb_codecs;
    1514             : }
    1515             : 
    1516           0 : static void print_codecs_for_id(enum AVCodecID id, int encoder)
    1517             : {
    1518           0 :     const AVCodec *codec = NULL;
    1519             : 
    1520           0 :     printf(" (%s: ", encoder ? "encoders" : "decoders");
    1521             : 
    1522           0 :     while ((codec = next_codec_for_id(id, codec, encoder)))
    1523           0 :         printf("%s ", codec->name);
    1524             : 
    1525           0 :     printf(")");
    1526           0 : }
    1527             : 
    1528           0 : int show_codecs(void *optctx, const char *opt, const char *arg)
    1529             : {
    1530             :     const AVCodecDescriptor **codecs;
    1531           0 :     unsigned i, nb_codecs = get_codecs_sorted(&codecs);
    1532             : 
    1533           0 :     printf("Codecs:\n"
    1534             :            " D..... = Decoding supported\n"
    1535             :            " .E.... = Encoding supported\n"
    1536             :            " ..V... = Video codec\n"
    1537             :            " ..A... = Audio codec\n"
    1538             :            " ..S... = Subtitle codec\n"
    1539             :            " ...I.. = Intra frame-only codec\n"
    1540             :            " ....L. = Lossy compression\n"
    1541             :            " .....S = Lossless compression\n"
    1542             :            " -------\n");
    1543           0 :     for (i = 0; i < nb_codecs; i++) {
    1544           0 :         const AVCodecDescriptor *desc = codecs[i];
    1545           0 :         const AVCodec *codec = NULL;
    1546             : 
    1547           0 :         if (strstr(desc->name, "_deprecated"))
    1548           0 :             continue;
    1549             : 
    1550           0 :         printf(" ");
    1551           0 :         printf(avcodec_find_decoder(desc->id) ? "D" : ".");
    1552           0 :         printf(avcodec_find_encoder(desc->id) ? "E" : ".");
    1553             : 
    1554           0 :         printf("%c", get_media_type_char(desc->type));
    1555           0 :         printf((desc->props & AV_CODEC_PROP_INTRA_ONLY) ? "I" : ".");
    1556           0 :         printf((desc->props & AV_CODEC_PROP_LOSSY)      ? "L" : ".");
    1557           0 :         printf((desc->props & AV_CODEC_PROP_LOSSLESS)   ? "S" : ".");
    1558             : 
    1559           0 :         printf(" %-20s %s", desc->name, desc->long_name ? desc->long_name : "");
    1560             : 
    1561             :         /* print decoders/encoders when there's more than one or their
    1562             :          * names are different from codec name */
    1563           0 :         while ((codec = next_codec_for_id(desc->id, codec, 0))) {
    1564           0 :             if (strcmp(codec->name, desc->name)) {
    1565           0 :                 print_codecs_for_id(desc->id, 0);
    1566           0 :                 break;
    1567             :             }
    1568             :         }
    1569           0 :         codec = NULL;
    1570           0 :         while ((codec = next_codec_for_id(desc->id, codec, 1))) {
    1571           0 :             if (strcmp(codec->name, desc->name)) {
    1572           0 :                 print_codecs_for_id(desc->id, 1);
    1573           0 :                 break;
    1574             :             }
    1575             :         }
    1576             : 
    1577           0 :         printf("\n");
    1578             :     }
    1579           0 :     av_free(codecs);
    1580           0 :     return 0;
    1581             : }
    1582             : 
    1583           0 : static void print_codecs(int encoder)
    1584             : {
    1585             :     const AVCodecDescriptor **codecs;
    1586           0 :     unsigned i, nb_codecs = get_codecs_sorted(&codecs);
    1587             : 
    1588           0 :     printf("%s:\n"
    1589             :            " V..... = Video\n"
    1590             :            " A..... = Audio\n"
    1591             :            " S..... = Subtitle\n"
    1592             :            " .F.... = Frame-level multithreading\n"
    1593             :            " ..S... = Slice-level multithreading\n"
    1594             :            " ...X.. = Codec is experimental\n"
    1595             :            " ....B. = Supports draw_horiz_band\n"
    1596             :            " .....D = Supports direct rendering method 1\n"
    1597             :            " ------\n",
    1598             :            encoder ? "Encoders" : "Decoders");
    1599           0 :     for (i = 0; i < nb_codecs; i++) {
    1600           0 :         const AVCodecDescriptor *desc = codecs[i];
    1601           0 :         const AVCodec *codec = NULL;
    1602             : 
    1603           0 :         while ((codec = next_codec_for_id(desc->id, codec, encoder))) {
    1604           0 :             printf(" %c", get_media_type_char(desc->type));
    1605           0 :             printf((codec->capabilities & AV_CODEC_CAP_FRAME_THREADS) ? "F" : ".");
    1606           0 :             printf((codec->capabilities & AV_CODEC_CAP_SLICE_THREADS) ? "S" : ".");
    1607           0 :             printf((codec->capabilities & AV_CODEC_CAP_EXPERIMENTAL)  ? "X" : ".");
    1608           0 :             printf((codec->capabilities & AV_CODEC_CAP_DRAW_HORIZ_BAND)?"B" : ".");
    1609           0 :             printf((codec->capabilities & AV_CODEC_CAP_DR1)           ? "D" : ".");
    1610             : 
    1611           0 :             printf(" %-20s %s", codec->name, codec->long_name ? codec->long_name : "");
    1612           0 :             if (strcmp(codec->name, desc->name))
    1613           0 :                 printf(" (codec %s)", desc->name);
    1614             : 
    1615           0 :             printf("\n");
    1616             :         }
    1617             :     }
    1618           0 :     av_free(codecs);
    1619           0 : }
    1620             : 
    1621           0 : int show_decoders(void *optctx, const char *opt, const char *arg)
    1622             : {
    1623           0 :     print_codecs(0);
    1624           0 :     return 0;
    1625             : }
    1626             : 
    1627           0 : int show_encoders(void *optctx, const char *opt, const char *arg)
    1628             : {
    1629           0 :     print_codecs(1);
    1630           0 :     return 0;
    1631             : }
    1632             : 
    1633           0 : int show_bsfs(void *optctx, const char *opt, const char *arg)
    1634             : {
    1635           0 :     const AVBitStreamFilter *bsf = NULL;
    1636           0 :     void *opaque = NULL;
    1637             : 
    1638           0 :     printf("Bitstream filters:\n");
    1639           0 :     while ((bsf = av_bsf_iterate(&opaque)))
    1640           0 :         printf("%s\n", bsf->name);
    1641           0 :     printf("\n");
    1642           0 :     return 0;
    1643             : }
    1644             : 
    1645           0 : int show_protocols(void *optctx, const char *opt, const char *arg)
    1646             : {
    1647           0 :     void *opaque = NULL;
    1648             :     const char *name;
    1649             : 
    1650           0 :     printf("Supported file protocols:\n"
    1651             :            "Input:\n");
    1652           0 :     while ((name = avio_enum_protocols(&opaque, 0)))
    1653           0 :         printf("  %s\n", name);
    1654           0 :     printf("Output:\n");
    1655           0 :     while ((name = avio_enum_protocols(&opaque, 1)))
    1656           0 :         printf("  %s\n", name);
    1657           0 :     return 0;
    1658             : }
    1659             : 
    1660           0 : int show_filters(void *optctx, const char *opt, const char *arg)
    1661             : {
    1662             : #if CONFIG_AVFILTER
    1663           0 :     const AVFilter *filter = NULL;
    1664             :     char descr[64], *descr_cur;
    1665           0 :     void *opaque = NULL;
    1666             :     int i, j;
    1667             :     const AVFilterPad *pad;
    1668             : 
    1669           0 :     printf("Filters:\n"
    1670             :            "  T.. = Timeline support\n"
    1671             :            "  .S. = Slice threading\n"
    1672             :            "  ..C = Command support\n"
    1673             :            "  A = Audio input/output\n"
    1674             :            "  V = Video input/output\n"
    1675             :            "  N = Dynamic number and/or type of input/output\n"
    1676             :            "  | = Source or sink filter\n");
    1677           0 :     while ((filter = av_filter_iterate(&opaque))) {
    1678           0 :         descr_cur = descr;
    1679           0 :         for (i = 0; i < 2; i++) {
    1680           0 :             if (i) {
    1681           0 :                 *(descr_cur++) = '-';
    1682           0 :                 *(descr_cur++) = '>';
    1683             :             }
    1684           0 :             pad = i ? filter->outputs : filter->inputs;
    1685           0 :             for (j = 0; pad && avfilter_pad_get_name(pad, j); j++) {
    1686           0 :                 if (descr_cur >= descr + sizeof(descr) - 4)
    1687           0 :                     break;
    1688           0 :                 *(descr_cur++) = get_media_type_char(avfilter_pad_get_type(pad, j));
    1689             :             }
    1690           0 :             if (!j)
    1691           0 :                 *(descr_cur++) = ((!i && (filter->flags & AVFILTER_FLAG_DYNAMIC_INPUTS)) ||
    1692           0 :                                   ( i && (filter->flags & AVFILTER_FLAG_DYNAMIC_OUTPUTS))) ? 'N' : '|';
    1693             :         }
    1694           0 :         *descr_cur = 0;
    1695           0 :         printf(" %c%c%c %-17s %-10s %s\n",
    1696           0 :                filter->flags & AVFILTER_FLAG_SUPPORT_TIMELINE ? 'T' : '.',
    1697           0 :                filter->flags & AVFILTER_FLAG_SLICE_THREADS    ? 'S' : '.',
    1698           0 :                filter->process_command                        ? 'C' : '.',
    1699             :                filter->name, descr, filter->description);
    1700             :     }
    1701             : #else
    1702             :     printf("No filters available: libavfilter disabled\n");
    1703             : #endif
    1704           0 :     return 0;
    1705             : }
    1706             : 
    1707           0 : int show_colors(void *optctx, const char *opt, const char *arg)
    1708             : {
    1709             :     const char *name;
    1710             :     const uint8_t *rgb;
    1711             :     int i;
    1712             : 
    1713           0 :     printf("%-32s #RRGGBB\n", "name");
    1714             : 
    1715           0 :     for (i = 0; name = av_get_known_color_name(i, &rgb); i++)
    1716           0 :         printf("%-32s #%02x%02x%02x\n", name, rgb[0], rgb[1], rgb[2]);
    1717             : 
    1718           0 :     return 0;
    1719             : }
    1720             : 
    1721           1 : int show_pix_fmts(void *optctx, const char *opt, const char *arg)
    1722             : {
    1723           1 :     const AVPixFmtDescriptor *pix_desc = NULL;
    1724             : 
    1725           1 :     printf("Pixel formats:\n"
    1726             :            "I.... = Supported Input  format for conversion\n"
    1727             :            ".O... = Supported Output format for conversion\n"
    1728             :            "..H.. = Hardware accelerated format\n"
    1729             :            "...P. = Paletted format\n"
    1730             :            "....B = Bitstream format\n"
    1731             :            "FLAGS NAME            NB_COMPONENTS BITS_PER_PIXEL\n"
    1732             :            "-----\n");
    1733             : 
    1734             : #if !CONFIG_SWSCALE
    1735             : #   define sws_isSupportedInput(x)  0
    1736             : #   define sws_isSupportedOutput(x) 0
    1737             : #endif
    1738             : 
    1739         187 :     while ((pix_desc = av_pix_fmt_desc_next(pix_desc))) {
    1740         185 :         enum AVPixelFormat av_unused pix_fmt = av_pix_fmt_desc_get_id(pix_desc);
    1741        1295 :         printf("%c%c%c%c%c %-16s       %d            %2d\n",
    1742         185 :                sws_isSupportedInput (pix_fmt)              ? 'I' : '.',
    1743         185 :                sws_isSupportedOutput(pix_fmt)              ? 'O' : '.',
    1744         185 :                pix_desc->flags & AV_PIX_FMT_FLAG_HWACCEL   ? 'H' : '.',
    1745         185 :                pix_desc->flags & AV_PIX_FMT_FLAG_PAL       ? 'P' : '.',
    1746         185 :                pix_desc->flags & AV_PIX_FMT_FLAG_BITSTREAM ? 'B' : '.',
    1747             :                pix_desc->name,
    1748         185 :                pix_desc->nb_components,
    1749             :                av_get_bits_per_pixel(pix_desc));
    1750             :     }
    1751           1 :     return 0;
    1752             : }
    1753             : 
    1754           0 : int show_layouts(void *optctx, const char *opt, const char *arg)
    1755             : {
    1756           0 :     int i = 0;
    1757             :     uint64_t layout, j;
    1758             :     const char *name, *descr;
    1759             : 
    1760           0 :     printf("Individual channels:\n"
    1761             :            "NAME           DESCRIPTION\n");
    1762           0 :     for (i = 0; i < 63; i++) {
    1763           0 :         name = av_get_channel_name((uint64_t)1 << i);
    1764           0 :         if (!name)
    1765           0 :             continue;
    1766           0 :         descr = av_get_channel_description((uint64_t)1 << i);
    1767           0 :         printf("%-14s %s\n", name, descr);
    1768             :     }
    1769           0 :     printf("\nStandard channel layouts:\n"
    1770             :            "NAME           DECOMPOSITION\n");
    1771           0 :     for (i = 0; !av_get_standard_channel_layout(i, &layout, &name); i++) {
    1772           0 :         if (name) {
    1773           0 :             printf("%-14s ", name);
    1774           0 :             for (j = 1; j; j <<= 1)
    1775           0 :                 if ((layout & j))
    1776           0 :                     printf("%s%s", (layout & (j - 1)) ? "+" : "", av_get_channel_name(j));
    1777           0 :             printf("\n");
    1778             :         }
    1779             :     }
    1780           0 :     return 0;
    1781             : }
    1782             : 
    1783           0 : int show_sample_fmts(void *optctx, const char *opt, const char *arg)
    1784             : {
    1785             :     int i;
    1786             :     char fmt_str[128];
    1787           0 :     for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
    1788           0 :         printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
    1789           0 :     return 0;
    1790             : }
    1791             : 
    1792           0 : static void show_help_codec(const char *name, int encoder)
    1793             : {
    1794             :     const AVCodecDescriptor *desc;
    1795             :     const AVCodec *codec;
    1796             : 
    1797           0 :     if (!name) {
    1798           0 :         av_log(NULL, AV_LOG_ERROR, "No codec name specified.\n");
    1799           0 :         return;
    1800             :     }
    1801             : 
    1802           0 :     codec = encoder ? avcodec_find_encoder_by_name(name) :
    1803             :                       avcodec_find_decoder_by_name(name);
    1804             : 
    1805           0 :     if (codec)
    1806           0 :         print_codec(codec);
    1807           0 :     else if ((desc = avcodec_descriptor_get_by_name(name))) {
    1808           0 :         int printed = 0;
    1809             : 
    1810           0 :         while ((codec = next_codec_for_id(desc->id, codec, encoder))) {
    1811           0 :             printed = 1;
    1812           0 :             print_codec(codec);
    1813             :         }
    1814             : 
    1815           0 :         if (!printed) {
    1816           0 :             av_log(NULL, AV_LOG_ERROR, "Codec '%s' is known to FFmpeg, "
    1817             :                    "but no %s for it are available. FFmpeg might need to be "
    1818             :                    "recompiled with additional external libraries.\n",
    1819             :                    name, encoder ? "encoders" : "decoders");
    1820             :         }
    1821             :     } else {
    1822           0 :         av_log(NULL, AV_LOG_ERROR, "Codec '%s' is not recognized by FFmpeg.\n",
    1823             :                name);
    1824             :     }
    1825             : }
    1826             : 
    1827           0 : static void show_help_demuxer(const char *name)
    1828             : {
    1829           0 :     const AVInputFormat *fmt = av_find_input_format(name);
    1830             : 
    1831           0 :     if (!fmt) {
    1832           0 :         av_log(NULL, AV_LOG_ERROR, "Unknown format '%s'.\n", name);
    1833           0 :         return;
    1834             :     }
    1835             : 
    1836           0 :     printf("Demuxer %s [%s]:\n", fmt->name, fmt->long_name);
    1837             : 
    1838           0 :     if (fmt->extensions)
    1839           0 :         printf("    Common extensions: %s.\n", fmt->extensions);
    1840             : 
    1841           0 :     if (fmt->priv_class)
    1842           0 :         show_help_children(fmt->priv_class, AV_OPT_FLAG_DECODING_PARAM);
    1843             : }
    1844             : 
    1845           0 : static void show_help_muxer(const char *name)
    1846             : {
    1847             :     const AVCodecDescriptor *desc;
    1848           0 :     const AVOutputFormat *fmt = av_guess_format(name, NULL, NULL);
    1849             : 
    1850           0 :     if (!fmt) {
    1851           0 :         av_log(NULL, AV_LOG_ERROR, "Unknown format '%s'.\n", name);
    1852           0 :         return;
    1853             :     }
    1854             : 
    1855           0 :     printf("Muxer %s [%s]:\n", fmt->name, fmt->long_name);
    1856             : 
    1857           0 :     if (fmt->extensions)
    1858           0 :         printf("    Common extensions: %s.\n", fmt->extensions);
    1859           0 :     if (fmt->mime_type)
    1860           0 :         printf("    Mime type: %s.\n", fmt->mime_type);
    1861           0 :     if (fmt->video_codec != AV_CODEC_ID_NONE &&
    1862           0 :         (desc = avcodec_descriptor_get(fmt->video_codec))) {
    1863           0 :         printf("    Default video codec: %s.\n", desc->name);
    1864             :     }
    1865           0 :     if (fmt->audio_codec != AV_CODEC_ID_NONE &&
    1866           0 :         (desc = avcodec_descriptor_get(fmt->audio_codec))) {
    1867           0 :         printf("    Default audio codec: %s.\n", desc->name);
    1868             :     }
    1869           0 :     if (fmt->subtitle_codec != AV_CODEC_ID_NONE &&
    1870           0 :         (desc = avcodec_descriptor_get(fmt->subtitle_codec))) {
    1871           0 :         printf("    Default subtitle codec: %s.\n", desc->name);
    1872             :     }
    1873             : 
    1874           0 :     if (fmt->priv_class)
    1875           0 :         show_help_children(fmt->priv_class, AV_OPT_FLAG_ENCODING_PARAM);
    1876             : }
    1877             : 
    1878             : #if CONFIG_AVFILTER
    1879           0 : static void show_help_filter(const char *name)
    1880             : {
    1881             : #if CONFIG_AVFILTER
    1882           0 :     const AVFilter *f = avfilter_get_by_name(name);
    1883             :     int i, count;
    1884             : 
    1885           0 :     if (!name) {
    1886           0 :         av_log(NULL, AV_LOG_ERROR, "No filter name specified.\n");
    1887           0 :         return;
    1888           0 :     } else if (!f) {
    1889           0 :         av_log(NULL, AV_LOG_ERROR, "Unknown filter '%s'.\n", name);
    1890           0 :         return;
    1891             :     }
    1892             : 
    1893           0 :     printf("Filter %s\n", f->name);
    1894           0 :     if (f->description)
    1895           0 :         printf("  %s\n", f->description);
    1896             : 
    1897           0 :     if (f->flags & AVFILTER_FLAG_SLICE_THREADS)
    1898           0 :         printf("    slice threading supported\n");
    1899             : 
    1900           0 :     printf("    Inputs:\n");
    1901           0 :     count = avfilter_pad_count(f->inputs);
    1902           0 :     for (i = 0; i < count; i++) {
    1903           0 :         printf("       #%d: %s (%s)\n", i, avfilter_pad_get_name(f->inputs, i),
    1904             :                media_type_string(avfilter_pad_get_type(f->inputs, i)));
    1905             :     }
    1906           0 :     if (f->flags & AVFILTER_FLAG_DYNAMIC_INPUTS)
    1907           0 :         printf("        dynamic (depending on the options)\n");
    1908           0 :     else if (!count)
    1909           0 :         printf("        none (source filter)\n");
    1910             : 
    1911           0 :     printf("    Outputs:\n");
    1912           0 :     count = avfilter_pad_count(f->outputs);
    1913           0 :     for (i = 0; i < count; i++) {
    1914           0 :         printf("       #%d: %s (%s)\n", i, avfilter_pad_get_name(f->outputs, i),
    1915             :                media_type_string(avfilter_pad_get_type(f->outputs, i)));
    1916             :     }
    1917           0 :     if (f->flags & AVFILTER_FLAG_DYNAMIC_OUTPUTS)
    1918           0 :         printf("        dynamic (depending on the options)\n");
    1919           0 :     else if (!count)
    1920           0 :         printf("        none (sink filter)\n");
    1921             : 
    1922           0 :     if (f->priv_class)
    1923           0 :         show_help_children(f->priv_class, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_FILTERING_PARAM |
    1924             :                                           AV_OPT_FLAG_AUDIO_PARAM);
    1925           0 :     if (f->flags & AVFILTER_FLAG_SUPPORT_TIMELINE)
    1926           0 :         printf("This filter has support for timeline through the 'enable' option.\n");
    1927             : #else
    1928             :     av_log(NULL, AV_LOG_ERROR, "Build without libavfilter; "
    1929             :            "can not to satisfy request\n");
    1930             : #endif
    1931             : }
    1932             : #endif
    1933             : 
    1934           0 : static void show_help_bsf(const char *name)
    1935             : {
    1936           0 :     const AVBitStreamFilter *bsf = av_bsf_get_by_name(name);
    1937             : 
    1938           0 :     if (!bsf) {
    1939           0 :         av_log(NULL, AV_LOG_ERROR, "Unknown bit stream filter '%s'.\n", name);
    1940           0 :         return;
    1941             :     }
    1942             : 
    1943           0 :     printf("Bit stream filter %s\n", bsf->name);
    1944           0 :     PRINT_CODEC_SUPPORTED(bsf, codec_ids, enum AVCodecID, "codecs",
    1945             :                           AV_CODEC_ID_NONE, GET_CODEC_NAME);
    1946           0 :     if (bsf->priv_class)
    1947           0 :         show_help_children(bsf->priv_class, AV_OPT_FLAG_BSF_PARAM);
    1948             : }
    1949             : 
    1950           0 : int show_help(void *optctx, const char *opt, const char *arg)
    1951             : {
    1952             :     char *topic, *par;
    1953           0 :     av_log_set_callback(log_callback_help);
    1954             : 
    1955           0 :     topic = av_strdup(arg ? arg : "");
    1956           0 :     if (!topic)
    1957           0 :         return AVERROR(ENOMEM);
    1958           0 :     par = strchr(topic, '=');
    1959           0 :     if (par)
    1960           0 :         *par++ = 0;
    1961             : 
    1962           0 :     if (!*topic) {
    1963           0 :         show_help_default(topic, par);
    1964           0 :     } else if (!strcmp(topic, "decoder")) {
    1965           0 :         show_help_codec(par, 0);
    1966           0 :     } else if (!strcmp(topic, "encoder")) {
    1967           0 :         show_help_codec(par, 1);
    1968           0 :     } else if (!strcmp(topic, "demuxer")) {
    1969           0 :         show_help_demuxer(par);
    1970           0 :     } else if (!strcmp(topic, "muxer")) {
    1971           0 :         show_help_muxer(par);
    1972             : #if CONFIG_AVFILTER
    1973           0 :     } else if (!strcmp(topic, "filter")) {
    1974           0 :         show_help_filter(par);
    1975             : #endif
    1976           0 :     } else if (!strcmp(topic, "bsf")) {
    1977           0 :         show_help_bsf(par);
    1978             :     } else {
    1979           0 :         show_help_default(topic, par);
    1980             :     }
    1981             : 
    1982           0 :     av_freep(&topic);
    1983           0 :     return 0;
    1984             : }
    1985             : 
    1986           0 : int read_yesno(void)
    1987             : {
    1988           0 :     int c = getchar();
    1989           0 :     int yesno = (av_toupper(c) == 'Y');
    1990             : 
    1991           0 :     while (c != '\n' && c != EOF)
    1992           0 :         c = getchar();
    1993             : 
    1994           0 :     return yesno;
    1995             : }
    1996             : 
    1997           0 : FILE *get_preset_file(char *filename, size_t filename_size,
    1998             :                       const char *preset_name, int is_path,
    1999             :                       const char *codec_name)
    2000             : {
    2001           0 :     FILE *f = NULL;
    2002             :     int i;
    2003           0 :     const char *base[3] = { getenv("FFMPEG_DATADIR"),
    2004           0 :                             getenv("HOME"),
    2005             :                             FFMPEG_DATADIR, };
    2006             : 
    2007           0 :     if (is_path) {
    2008           0 :         av_strlcpy(filename, preset_name, filename_size);
    2009           0 :         f = fopen(filename, "r");
    2010             :     } else {
    2011             : #ifdef _WIN32
    2012             :         char datadir[MAX_PATH], *ls;
    2013             :         base[2] = NULL;
    2014             : 
    2015             :         if (GetModuleFileNameA(GetModuleHandleA(NULL), datadir, sizeof(datadir) - 1))
    2016             :         {
    2017             :             for (ls = datadir; ls < datadir + strlen(datadir); ls++)
    2018             :                 if (*ls == '\\') *ls = '/';
    2019             : 
    2020             :             if (ls = strrchr(datadir, '/'))
    2021             :             {
    2022             :                 *ls = 0;
    2023             :                 strncat(datadir, "/ffpresets",  sizeof(datadir) - 1 - strlen(datadir));
    2024             :                 base[2] = datadir;
    2025             :             }
    2026             :         }
    2027             : #endif
    2028           0 :         for (i = 0; i < 3 && !f; i++) {
    2029           0 :             if (!base[i])
    2030           0 :                 continue;
    2031           0 :             snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i],
    2032             :                      i != 1 ? "" : "/.ffmpeg", preset_name);
    2033           0 :             f = fopen(filename, "r");
    2034           0 :             if (!f && codec_name) {
    2035           0 :                 snprintf(filename, filename_size,
    2036             :                          "%s%s/%s-%s.ffpreset",
    2037             :                          base[i], i != 1 ? "" : "/.ffmpeg", codec_name,
    2038             :                          preset_name);
    2039           0 :                 f = fopen(filename, "r");
    2040             :             }
    2041             :         }
    2042             :     }
    2043             : 
    2044           0 :     return f;
    2045             : }
    2046             : 
    2047       22867 : int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
    2048             : {
    2049       22867 :     int ret = avformat_match_stream_specifier(s, st, spec);
    2050       22867 :     if (ret < 0)
    2051           0 :         av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
    2052       22867 :     return ret;
    2053             : }
    2054             : 
    2055       17775 : AVDictionary *filter_codec_opts(AVDictionary *opts, enum AVCodecID codec_id,
    2056             :                                 AVFormatContext *s, AVStream *st, AVCodec *codec)
    2057             : {
    2058       17775 :     AVDictionary    *ret = NULL;
    2059       17775 :     AVDictionaryEntry *t = NULL;
    2060       35550 :     int            flags = s->oformat ? AV_OPT_FLAG_ENCODING_PARAM
    2061       17775 :                                       : AV_OPT_FLAG_DECODING_PARAM;
    2062       17775 :     char          prefix = 0;
    2063       17775 :     const AVClass    *cc = avcodec_get_class();
    2064             : 
    2065       17775 :     if (!codec)
    2066       12522 :         codec            = s->oformat ? avcodec_find_encoder(codec_id)
    2067        6261 :                                       : avcodec_find_decoder(codec_id);
    2068             : 
    2069       17775 :     switch (st->codecpar->codec_type) {
    2070       13739 :     case AVMEDIA_TYPE_VIDEO:
    2071       13739 :         prefix  = 'v';
    2072       13739 :         flags  |= AV_OPT_FLAG_VIDEO_PARAM;
    2073       13739 :         break;
    2074        3809 :     case AVMEDIA_TYPE_AUDIO:
    2075        3809 :         prefix  = 'a';
    2076        3809 :         flags  |= AV_OPT_FLAG_AUDIO_PARAM;
    2077        3809 :         break;
    2078         120 :     case AVMEDIA_TYPE_SUBTITLE:
    2079         120 :         prefix  = 's';
    2080         120 :         flags  |= AV_OPT_FLAG_SUBTITLE_PARAM;
    2081         120 :         break;
    2082             :     }
    2083             : 
    2084       85701 :     while (t = av_dict_get(opts, "", t, AV_DICT_IGNORE_SUFFIX)) {
    2085       50151 :         char *p = strchr(t->key, ':');
    2086             : 
    2087             :         /* check stream specification in opt name */
    2088       50151 :         if (p)
    2089         227 :             switch (check_stream_specifier(s, st, p + 1)) {
    2090         185 :             case  1: *p = 0; break;
    2091          42 :             case  0:         continue;
    2092           0 :             default:         exit_program(1);
    2093             :             }
    2094             : 
    2095       49924 :         if (av_opt_find(&cc, t->key, NULL, flags, AV_OPT_SEARCH_FAKE_OBJ) ||
    2096        1166 :             !codec ||
    2097        1483 :             (codec->priv_class &&
    2098         317 :              av_opt_find(&codec->priv_class, t->key, NULL, flags,
    2099             :                          AV_OPT_SEARCH_FAKE_OBJ)))
    2100       49125 :             av_dict_set(&ret, t->key, t->value, 0);
    2101         985 :         else if (t->key[0] == prefix &&
    2102           1 :                  av_opt_find(&cc, t->key + 1, NULL, flags,
    2103             :                              AV_OPT_SEARCH_FAKE_OBJ))
    2104           1 :             av_dict_set(&ret, t->key + 1, t->value, 0);
    2105             : 
    2106       50109 :         if (p)
    2107         185 :             *p = ':';
    2108             :     }
    2109       17775 :     return ret;
    2110             : }
    2111             : 
    2112        5713 : AVDictionary **setup_find_stream_info_opts(AVFormatContext *s,
    2113             :                                            AVDictionary *codec_opts)
    2114             : {
    2115             :     int i;
    2116             :     AVDictionary **opts;
    2117             : 
    2118        5713 :     if (!s->nb_streams)
    2119          61 :         return NULL;
    2120        5652 :     opts = av_mallocz_array(s->nb_streams, sizeof(*opts));
    2121        5652 :     if (!opts) {
    2122           0 :         av_log(NULL, AV_LOG_ERROR,
    2123             :                "Could not alloc memory for stream options.\n");
    2124           0 :         return NULL;
    2125             :     }
    2126       11615 :     for (i = 0; i < s->nb_streams; i++)
    2127        5963 :         opts[i] = filter_codec_opts(codec_opts, s->streams[i]->codecpar->codec_id,
    2128        5963 :                                     s, s->streams[i], NULL);
    2129        5652 :     return opts;
    2130             : }
    2131             : 
    2132      130520 : void *grow_array(void *array, int elem_size, int *size, int new_size)
    2133             : {
    2134      130520 :     if (new_size >= INT_MAX / elem_size) {
    2135           0 :         av_log(NULL, AV_LOG_ERROR, "Array too big.\n");
    2136           0 :         exit_program(1);
    2137             :     }
    2138      130520 :     if (*size < new_size) {
    2139      130520 :         uint8_t *tmp = av_realloc_array(array, new_size, elem_size);
    2140      130520 :         if (!tmp) {
    2141           0 :             av_log(NULL, AV_LOG_ERROR, "Could not alloc buffer.\n");
    2142           0 :             exit_program(1);
    2143             :         }
    2144      130520 :         memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
    2145      130520 :         *size = new_size;
    2146      130520 :         return tmp;
    2147             :     }
    2148           0 :     return array;
    2149             : }
    2150             : 
    2151        4423 : double get_rotation(AVStream *st)
    2152             : {
    2153        4423 :     uint8_t* displaymatrix = av_stream_get_side_data(st,
    2154             :                                                      AV_PKT_DATA_DISPLAYMATRIX, NULL);
    2155        4423 :     double theta = 0;
    2156        4423 :     if (displaymatrix)
    2157           0 :         theta = -av_display_rotation_get((int32_t*) displaymatrix);
    2158             : 
    2159        4423 :     theta -= 360*floor(theta/360 + 0.9/360);
    2160             : 
    2161        4423 :     if (fabs(theta - 90*round(theta/90)) > 2)
    2162           0 :         av_log(NULL, AV_LOG_WARNING, "Odd rotation angle.\n"
    2163             :                "If you want to help, upload a sample "
    2164             :                "of this file to ftp://upload.ffmpeg.org/incoming/ "
    2165             :                "and contact the ffmpeg-devel mailing list. (ffmpeg-devel@ffmpeg.org)");
    2166             : 
    2167        4423 :     return theta;
    2168             : }
    2169             : 
    2170             : #if CONFIG_AVDEVICE
    2171           0 : static int print_device_sources(AVInputFormat *fmt, AVDictionary *opts)
    2172             : {
    2173             :     int ret, i;
    2174           0 :     AVDeviceInfoList *device_list = NULL;
    2175             : 
    2176           0 :     if (!fmt || !fmt->priv_class  || !AV_IS_INPUT_DEVICE(fmt->priv_class->category))
    2177           0 :         return AVERROR(EINVAL);
    2178             : 
    2179           0 :     printf("Auto-detected sources for %s:\n", fmt->name);
    2180           0 :     if (!fmt->get_device_list) {
    2181           0 :         ret = AVERROR(ENOSYS);
    2182           0 :         printf("Cannot list sources. Not implemented.\n");
    2183           0 :         goto fail;
    2184             :     }
    2185             : 
    2186           0 :     if ((ret = avdevice_list_input_sources(fmt, NULL, opts, &device_list)) < 0) {
    2187           0 :         printf("Cannot list sources.\n");
    2188           0 :         goto fail;
    2189             :     }
    2190             : 
    2191           0 :     for (i = 0; i < device_list->nb_devices; i++) {
    2192           0 :         printf("%s %s [%s]\n", device_list->default_device == i ? "*" : " ",
    2193           0 :                device_list->devices[i]->device_name, device_list->devices[i]->device_description);
    2194             :     }
    2195             : 
    2196           0 :   fail:
    2197           0 :     avdevice_free_list_devices(&device_list);
    2198           0 :     return ret;
    2199             : }
    2200             : 
    2201           0 : static int print_device_sinks(AVOutputFormat *fmt, AVDictionary *opts)
    2202             : {
    2203             :     int ret, i;
    2204           0 :     AVDeviceInfoList *device_list = NULL;
    2205             : 
    2206           0 :     if (!fmt || !fmt->priv_class  || !AV_IS_OUTPUT_DEVICE(fmt->priv_class->category))
    2207           0 :         return AVERROR(EINVAL);
    2208             : 
    2209           0 :     printf("Auto-detected sinks for %s:\n", fmt->name);
    2210           0 :     if (!fmt->get_device_list) {
    2211           0 :         ret = AVERROR(ENOSYS);
    2212           0 :         printf("Cannot list sinks. Not implemented.\n");
    2213           0 :         goto fail;
    2214             :     }
    2215             : 
    2216           0 :     if ((ret = avdevice_list_output_sinks(fmt, NULL, opts, &device_list)) < 0) {
    2217           0 :         printf("Cannot list sinks.\n");
    2218           0 :         goto fail;
    2219             :     }
    2220             : 
    2221           0 :     for (i = 0; i < device_list->nb_devices; i++) {
    2222           0 :         printf("%s %s [%s]\n", device_list->default_device == i ? "*" : " ",
    2223           0 :                device_list->devices[i]->device_name, device_list->devices[i]->device_description);
    2224             :     }
    2225             : 
    2226           0 :   fail:
    2227           0 :     avdevice_free_list_devices(&device_list);
    2228           0 :     return ret;
    2229             : }
    2230             : 
    2231           0 : static int show_sinks_sources_parse_arg(const char *arg, char **dev, AVDictionary **opts)
    2232             : {
    2233             :     int ret;
    2234           0 :     if (arg) {
    2235           0 :         char *opts_str = NULL;
    2236           0 :         av_assert0(dev && opts);
    2237           0 :         *dev = av_strdup(arg);
    2238           0 :         if (!*dev)
    2239           0 :             return AVERROR(ENOMEM);
    2240           0 :         if ((opts_str = strchr(*dev, ','))) {
    2241           0 :             *(opts_str++) = '\0';
    2242           0 :             if (opts_str[0] && ((ret = av_dict_parse_string(opts, opts_str, "=", ":", 0)) < 0)) {
    2243           0 :                 av_freep(dev);
    2244           0 :                 return ret;
    2245             :             }
    2246             :         }
    2247             :     } else
    2248           0 :         printf("\nDevice name is not provided.\n"
    2249             :                 "You can pass devicename[,opt1=val1[,opt2=val2...]] as an argument.\n\n");
    2250           0 :     return 0;
    2251             : }
    2252             : 
    2253           0 : int show_sources(void *optctx, const char *opt, const char *arg)
    2254             : {
    2255           0 :     AVInputFormat *fmt = NULL;
    2256           0 :     char *dev = NULL;
    2257           0 :     AVDictionary *opts = NULL;
    2258           0 :     int ret = 0;
    2259           0 :     int error_level = av_log_get_level();
    2260             : 
    2261           0 :     av_log_set_level(AV_LOG_ERROR);
    2262             : 
    2263           0 :     if ((ret = show_sinks_sources_parse_arg(arg, &dev, &opts)) < 0)
    2264           0 :         goto fail;
    2265             : 
    2266             :     do {
    2267           0 :         fmt = av_input_audio_device_next(fmt);
    2268           0 :         if (fmt) {
    2269           0 :             if (!strcmp(fmt->name, "lavfi"))
    2270           0 :                 continue; //it's pointless to probe lavfi
    2271           0 :             if (dev && !av_match_name(dev, fmt->name))
    2272           0 :                 continue;
    2273           0 :             print_device_sources(fmt, opts);
    2274             :         }
    2275           0 :     } while (fmt);
    2276             :     do {
    2277           0 :         fmt = av_input_video_device_next(fmt);
    2278           0 :         if (fmt) {
    2279           0 :             if (dev && !av_match_name(dev, fmt->name))
    2280           0 :                 continue;
    2281           0 :             print_device_sources(fmt, opts);
    2282             :         }
    2283           0 :     } while (fmt);
    2284           0 :   fail:
    2285           0 :     av_dict_free(&opts);
    2286           0 :     av_free(dev);
    2287           0 :     av_log_set_level(error_level);
    2288           0 :     return ret;
    2289             : }
    2290             : 
    2291           0 : int show_sinks(void *optctx, const char *opt, const char *arg)
    2292             : {
    2293           0 :     AVOutputFormat *fmt = NULL;
    2294           0 :     char *dev = NULL;
    2295           0 :     AVDictionary *opts = NULL;
    2296           0 :     int ret = 0;
    2297           0 :     int error_level = av_log_get_level();
    2298             : 
    2299           0 :     av_log_set_level(AV_LOG_ERROR);
    2300             : 
    2301           0 :     if ((ret = show_sinks_sources_parse_arg(arg, &dev, &opts)) < 0)
    2302           0 :         goto fail;
    2303             : 
    2304             :     do {
    2305           0 :         fmt = av_output_audio_device_next(fmt);
    2306           0 :         if (fmt) {
    2307           0 :             if (dev && !av_match_name(dev, fmt->name))
    2308           0 :                 continue;
    2309           0 :             print_device_sinks(fmt, opts);
    2310             :         }
    2311           0 :     } while (fmt);
    2312             :     do {
    2313           0 :         fmt = av_output_video_device_next(fmt);
    2314           0 :         if (fmt) {
    2315           0 :             if (dev && !av_match_name(dev, fmt->name))
    2316           0 :                 continue;
    2317           0 :             print_device_sinks(fmt, opts);
    2318             :         }
    2319           0 :     } while (fmt);
    2320           0 :   fail:
    2321           0 :     av_dict_free(&opts);
    2322           0 :     av_free(dev);
    2323           0 :     av_log_set_level(error_level);
    2324           0 :     return ret;
    2325             : }
    2326             : 
    2327             : #endif

Generated by: LCOV version 1.13