git.sesse.net Git - ffmpeg/blob - cmdutils.c

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