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 <stdlib.h>
  24 #include <errno.h>
  25 #include <math.h>
  26
  27 /* Include only the enabled headers since some compilers (namely, Sun
  28    Studio) will not omit unused inline functions and create undefined
  29    references to libraries that are not being built. */
  30
  31 #include "config.h"
  32 #include "libavformat/avformat.h"
  33 #include "libavfilter/avfilter.h"
  34 #include "libavdevice/avdevice.h"
  35 #include "libavresample/avresample.h"
  36 #include "libswscale/swscale.h"
  37 #include "libswresample/swresample.h"
  38 #if CONFIG_POSTPROC
  39 #include "libpostproc/postprocess.h"
  40 #endif
  41 #include "libavutil/avassert.h"
  42 #include "libavutil/avstring.h"
  43 #include "libavutil/mathematics.h"
  44 #include "libavutil/imgutils.h"
  45 #include "libavutil/parseutils.h"
  46 #include "libavutil/pixdesc.h"
  47 #include "libavutil/eval.h"
  48 #include "libavutil/dict.h"
  49 #include "libavutil/opt.h"
  50 #include "cmdutils.h"
  51 #include "version.h"
  52 #if CONFIG_NETWORK
  53 #include "libavformat/network.h"
  54 #endif
  55 #if HAVE_SYS_RESOURCE_H
  56 #include <sys/resource.h>
  57 #endif
  58
  59 struct SwsContext *sws_opts;
  60 SwrContext *swr_opts;
  61 AVDictionary *format_opts, *codec_opts;
  62
  63 const int this_year = 2012;
  64
  65 static FILE *report_file;
  66
  67 void init_opts(void)
  68 {
  69
  70     if(CONFIG_SWSCALE)
  71         sws_opts = sws_getContext(16, 16, 0, 16, 16, 0, SWS_BICUBIC,
  72                               NULL, NULL, NULL);
  73
  74     if(CONFIG_SWRESAMPLE)
  75         swr_opts = swr_alloc();
  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     if(CONFIG_SWRESAMPLE)
  86         swr_free(&swr_opts);
  87
  88     av_dict_free(&format_opts);
  89     av_dict_free(&codec_opts);
  90 }
  91
  92 void log_callback_help(void *ptr, int level, const char *fmt, va_list vl)
  93 {
  94     vfprintf(stdout, fmt, vl);
  95 }
  96
  97 static void log_callback_report(void *ptr, int level, const char *fmt, va_list vl)
  98 {
  99     va_list vl2;
 100     char line[1024];
 101     static int print_prefix = 1;
 102
 103     va_copy(vl2, vl);
 104     av_log_default_callback(ptr, level, fmt, vl);
 105     av_log_format_line(ptr, level, fmt, vl2, line, sizeof(line), &print_prefix);
 106     va_end(vl2);
 107     fputs(line, report_file);
 108     fflush(report_file);
 109 }
 110
 111 double parse_number_or_die(const char *context, const char *numstr, int type,
 112                            double min, double max)
 113 {
 114     char *tail;
 115     const char *error;
 116     double d = av_strtod(numstr, &tail);
 117     if (*tail)
 118         error = "Expected number for %s but found: %s\n";
 119     else if (d < min || d > max)
 120         error = "The value for %s was %s which is not within %f - %f\n";
 121     else if (type == OPT_INT64 && (int64_t)d != d)
 122         error = "Expected int64 for %s but found %s\n";
 123     else if (type == OPT_INT && (int)d != d)
 124         error = "Expected int for %s but found %s\n";
 125     else
 126         return d;
 127     av_log(NULL, AV_LOG_FATAL, error, context, numstr, min, max);
 128     exit_program(1);
 129     return 0;
 130 }
 131
 132 int64_t parse_time_or_die(const char *context, const char *timestr,
 133                           int is_duration)
 134 {
 135     int64_t us;
 136     if (av_parse_time(&us, timestr, is_duration) < 0) {
 137         av_log(NULL, AV_LOG_FATAL, "Invalid %s specification for %s: %s\n",
 138                is_duration ? "duration" : "date", context, timestr);
 139         exit_program(1);
 140     }
 141     return us;
 142 }
 143
 144 void show_help_options(const OptionDef *options, const char *msg, int mask,
 145                        int value)
 146 {
 147     const OptionDef *po;
 148     int first;
 149
 150     first = 1;
 151     for (po = options; po->name != NULL; po++) {
 152         char buf[64];
 153         if ((po->flags & mask) == value) {
 154             if (first) {
 155                 printf("%s", msg);
 156                 first = 0;
 157             }
 158             av_strlcpy(buf, po->name, sizeof(buf));
 159             if (po->flags & HAS_ARG) {
 160                 av_strlcat(buf, " ", sizeof(buf));
 161                 av_strlcat(buf, po->argname, sizeof(buf));
 162             }
 163             printf("-%-17s  %s\n", buf, po->help);
 164         }
 165     }
 166 }
 167
 168 void show_help_children(const AVClass *class, int flags)
 169 {
 170     const AVClass *child = NULL;
 171     av_opt_show2(&class, NULL, flags, 0);
 172     printf("\n");
 173
 174     while (child = av_opt_child_class_next(class, child))
 175         show_help_children(child, flags);
 176 }
 177
 178 static const OptionDef *find_option(const OptionDef *po, const char *name)
 179 {
 180     const char *p = strchr(name, ':');
 181     int len = p ? p - name : strlen(name);
 182
 183     while (po->name != NULL) {
 184         if (!strncmp(name, po->name, len) && strlen(po->name) == len)
 185             break;
 186         po++;
 187     }
 188     return po;
 189 }
 190
 191 #if defined(_WIN32) && !defined(__MINGW32CE__)
 192 #include <windows.h>
 193 /* Will be leaked on exit */
 194 static char** win32_argv_utf8 = NULL;
 195 static int win32_argc = 0;
 196
 197 /**
 198  * Prepare command line arguments for executable.
 199  * For Windows - perform wide-char to UTF-8 conversion.
 200  * Input arguments should be main() function arguments.
 201  * @param argc_ptr Arguments number (including executable)
 202  * @param argv_ptr Arguments list.
 203  */
 204 static void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
 205 {
 206     char *argstr_flat;
 207     wchar_t **argv_w;
 208     int i, buffsize = 0, offset = 0;
 209
 210     if (win32_argv_utf8) {
 211         *argc_ptr = win32_argc;
 212         *argv_ptr = win32_argv_utf8;
 213         return;
 214     }
 215
 216     win32_argc = 0;
 217     argv_w = CommandLineToArgvW(GetCommandLineW(), &win32_argc);
 218     if (win32_argc <= 0 || !argv_w)
 219         return;
 220
 221     /* determine the UTF-8 buffer size (including NULL-termination symbols) */
 222     for (i = 0; i < win32_argc; i++)
 223         buffsize += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
 224                                         NULL, 0, NULL, NULL);
 225
 226     win32_argv_utf8 = av_mallocz(sizeof(char *) * (win32_argc + 1) + buffsize);
 227     argstr_flat     = (char *)win32_argv_utf8 + sizeof(char *) * (win32_argc + 1);
 228     if (win32_argv_utf8 == NULL) {
 229         LocalFree(argv_w);
 230         return;
 231     }
 232
 233     for (i = 0; i < win32_argc; i++) {
 234         win32_argv_utf8[i] = &argstr_flat[offset];
 235         offset += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
 236                                       &argstr_flat[offset],
 237                                       buffsize - offset, NULL, NULL);
 238     }
 239     win32_argv_utf8[i] = NULL;
 240     LocalFree(argv_w);
 241
 242     *argc_ptr = win32_argc;
 243     *argv_ptr = win32_argv_utf8;
 244 }
 245 #else
 246 static inline void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
 247 {
 248     /* nothing to do */
 249 }
 250 #endif /* WIN32 && !__MINGW32CE__ */
 251
 252 int parse_option(void *optctx, const char *opt, const char *arg,
 253                  const OptionDef *options)
 254 {
 255     const OptionDef *po;
 256     int bool_val = 1;
 257     int *dstcount;
 258     void *dst;
 259
 260     po = find_option(options, opt);
 261     if (!po->name && opt[0] == 'n' && opt[1] == 'o') {
 262         /* handle 'no' bool option */
 263         po = find_option(options, opt + 2);
 264         if ((po->name && (po->flags & OPT_BOOL)))
 265             bool_val = 0;
 266     }
 267     if (!po->name)
 268         po = find_option(options, "default");
 269     if (!po->name) {
 270         av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);
 271         return AVERROR(EINVAL);
 272     }
 273     if (po->flags & HAS_ARG && !arg) {
 274         av_log(NULL, AV_LOG_ERROR, "Missing argument for option '%s'\n", opt);
 275         return AVERROR(EINVAL);
 276     }
 277
 278     /* new-style options contain an offset into optctx, old-style address of
 279      * a global var*/
 280     dst = po->flags & (OPT_OFFSET | OPT_SPEC) ? (uint8_t *)optctx + po->u.off
 281                                               : po->u.dst_ptr;
 282
 283     if (po->flags & OPT_SPEC) {
 284         SpecifierOpt **so = dst;
 285         char *p = strchr(opt, ':');
 286
 287         dstcount = (int *)(so + 1);
 288         *so = grow_array(*so, sizeof(**so), dstcount, *dstcount + 1);
 289         (*so)[*dstcount - 1].specifier = av_strdup(p ? p + 1 : "");
 290         dst = &(*so)[*dstcount - 1].u;
 291     }
 292
 293     if (po->flags & OPT_STRING) {
 294         char *str;
 295         str = av_strdup(arg);
 296         *(char **)dst = str;
 297     } else if (po->flags & OPT_BOOL) {
 298         *(int *)dst = bool_val;
 299     } else if (po->flags & OPT_INT) {
 300         *(int *)dst = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
 301     } else if (po->flags & OPT_INT64) {
 302         *(int64_t *)dst = parse_number_or_die(opt, arg, OPT_INT64, INT64_MIN, INT64_MAX);
 303     } else if (po->flags & OPT_TIME) {
 304         *(int64_t *)dst = parse_time_or_die(opt, arg, 1);
 305     } else if (po->flags & OPT_FLOAT) {
 306         *(float *)dst = parse_number_or_die(opt, arg, OPT_FLOAT, -INFINITY, INFINITY);
 307     } else if (po->flags & OPT_DOUBLE) {
 308         *(double *)dst = parse_number_or_die(opt, arg, OPT_DOUBLE, -INFINITY, INFINITY);
 309     } else if (po->u.func_arg) {
 310         int ret = po->flags & OPT_FUNC2 ? po->u.func2_arg(optctx, opt, arg)
 311                                         : po->u.func_arg(opt, arg);
 312         if (ret < 0) {
 313             av_log(NULL, AV_LOG_ERROR,
 314                    "Failed to set value '%s' for option '%s'\n", arg, opt);
 315             return ret;
 316         }
 317     }
 318     if (po->flags & OPT_EXIT)
 319         exit_program(0);
 320     return !!(po->flags & HAS_ARG);
 321 }
 322
 323 void parse_options(void *optctx, int argc, char **argv, const OptionDef *options,
 324                    void (*parse_arg_function)(void *, const char*))
 325 {
 326     const char *opt;
 327     int optindex, handleoptions = 1, ret;
 328
 329     /* perform system-dependent conversions for arguments list */
 330     prepare_app_arguments(&argc, &argv);
 331
 332     /* parse options */
 333     optindex = 1;
 334     while (optindex < argc) {
 335         opt = argv[optindex++];
 336
 337         if (handleoptions && opt[0] == '-' && opt[1] != '\0') {
 338             if (opt[1] == '-' && opt[2] == '\0') {
 339                 handleoptions = 0;
 340                 continue;
 341             }
 342             opt++;
 343
 344             if ((ret = parse_option(optctx, opt, argv[optindex], options)) < 0)
 345                 exit_program(1);
 346             optindex += ret;
 347         } else {
 348             if (parse_arg_function)
 349                 parse_arg_function(optctx, opt);
 350         }
 351     }
 352 }
 353
 354 int locate_option(int argc, char **argv, const OptionDef *options,
 355                   const char *optname)
 356 {
 357     const OptionDef *po;
 358     int i;
 359
 360     for (i = 1; i < argc; i++) {
 361         const char *cur_opt = argv[i];
 362
 363         if (*cur_opt++ != '-')
 364             continue;
 365
 366         po = find_option(options, cur_opt);
 367         if (!po->name && cur_opt[0] == 'n' && cur_opt[1] == 'o')
 368             po = find_option(options, cur_opt + 2);
 369
 370         if ((!po->name && !strcmp(cur_opt, optname)) ||
 371              (po->name && !strcmp(optname, po->name)))
 372             return i;
 373
 374         if (!po || po->flags & HAS_ARG)
 375             i++;
 376     }
 377     return 0;
 378 }
 379
 380 static void dump_argument(const char *a)
 381 {
 382     const unsigned char *p;
 383
 384     for (p = a; *p; p++)
 385         if (!((*p >= '+' && *p <= ':') || (*p >= '@' && *p <= 'Z') ||
 386               *p == '_' || (*p >= 'a' && *p <= 'z')))
 387             break;
 388     if (!*p) {
 389         fputs(a, report_file);
 390         return;
 391     }
 392     fputc('"', report_file);
 393     for (p = a; *p; p++) {
 394         if (*p == '\\' || *p == '"' || *p == '$' || *p == '`')
 395             fprintf(report_file, "\\%c", *p);
 396         else if (*p < ' ' || *p > '~')
 397             fprintf(report_file, "\\x%02x", *p);
 398         else
 399             fputc(*p, report_file);
 400     }
 401     fputc('"', report_file);
 402 }
 403
 404 void parse_loglevel(int argc, char **argv, const OptionDef *options)
 405 {
 406     int idx = locate_option(argc, argv, options, "loglevel");
 407     if (!idx)
 408         idx = locate_option(argc, argv, options, "v");
 409     if (idx && argv[idx + 1])
 410         opt_loglevel("loglevel", argv[idx + 1]);
 411     idx = locate_option(argc, argv, options, "report");
 412     if (idx || getenv("FFREPORT")) {
 413         opt_report("report");
 414         if (report_file) {
 415             int i;
 416             fprintf(report_file, "Command line:\n");
 417             for (i = 0; i < argc; i++) {
 418                 dump_argument(argv[i]);
 419                 fputc(i < argc - 1 ? ' ' : '\n', report_file);
 420             }
 421             fflush(report_file);
 422         }
 423     }
 424 }
 425
 426 #define FLAGS (o->type == AV_OPT_TYPE_FLAGS) ? AV_DICT_APPEND : 0
 427 int opt_default(const char *opt, const char *arg)
 428 {
 429     const AVOption *o;
 430     char opt_stripped[128];
 431     const char *p;
 432     const AVClass *cc = avcodec_get_class(), *fc = avformat_get_class(), *sc, *swr_class;
 433
 434     if (!(p = strchr(opt, ':')))
 435         p = opt + strlen(opt);
 436     av_strlcpy(opt_stripped, opt, FFMIN(sizeof(opt_stripped), p - opt + 1));
 437
 438     if ((o = av_opt_find(&cc, opt_stripped, NULL, 0,
 439                          AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)) ||
 440         ((opt[0] == 'v' || opt[0] == 'a' || opt[0] == 's') &&
 441          (o = av_opt_find(&cc, opt + 1, NULL, 0, AV_OPT_SEARCH_FAKE_OBJ))))
 442         av_dict_set(&codec_opts, opt, arg, FLAGS);
 443     else if ((o = av_opt_find(&fc, opt, NULL, 0,
 444                               AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)))
 445         av_dict_set(&format_opts, opt, arg, FLAGS);
 446 #if CONFIG_SWSCALE
 447     sc = sws_get_class();
 448     if (!o && (o = av_opt_find(&sc, opt, NULL, 0,
 449                          AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) {
 450         // XXX we only support sws_flags, not arbitrary sws options
 451         int ret = av_opt_set(sws_opts, opt, arg, 0);
 452         if (ret < 0) {
 453             av_log(NULL, AV_LOG_ERROR, "Error setting option %s.\n", opt);
 454             return ret;
 455         }
 456     }
 457 #endif
 458 #if CONFIG_SWRESAMPLE
 459     swr_class = swr_get_class();
 460     if (!o && (o = av_opt_find(&swr_class, opt, NULL, 0,
 461                                AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) {
 462         int ret = av_opt_set(swr_opts, opt, arg, 0);
 463         if (ret < 0) {
 464             av_log(NULL, AV_LOG_ERROR, "Error setting option %s.\n", opt);
 465             return ret;
 466         }
 467     }
 468 #endif
 469
 470     if (o)
 471         return 0;
 472     av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);
 473     return AVERROR_OPTION_NOT_FOUND;
 474 }
 475
 476 int opt_loglevel(const char *opt, const char *arg)
 477 {
 478     const struct { const char *name; int level; } log_levels[] = {
 479         { "quiet"  , AV_LOG_QUIET   },
 480         { "panic"  , AV_LOG_PANIC   },
 481         { "fatal"  , AV_LOG_FATAL   },
 482         { "error"  , AV_LOG_ERROR   },
 483         { "warning", AV_LOG_WARNING },
 484         { "info"   , AV_LOG_INFO    },
 485         { "verbose", AV_LOG_VERBOSE },
 486         { "debug"  , AV_LOG_DEBUG   },
 487     };
 488     char *tail;
 489     int level;
 490     int i;
 491
 492     for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
 493         if (!strcmp(log_levels[i].name, arg)) {
 494             av_log_set_level(log_levels[i].level);
 495             return 0;
 496         }
 497     }
 498
 499     level = strtol(arg, &tail, 10);
 500     if (*tail) {
 501         av_log(NULL, AV_LOG_FATAL, "Invalid loglevel \"%s\". "
 502                "Possible levels are numbers or:\n", arg);
 503         for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
 504             av_log(NULL, AV_LOG_FATAL, "\"%s\"\n", log_levels[i].name);
 505         exit_program(1);
 506     }
 507     av_log_set_level(level);
 508     return 0;
 509 }
 510
 511 int opt_report(const char *opt)
 512 {
 513     char filename[64];
 514     time_t now;
 515     struct tm *tm;
 516
 517     if (report_file) /* already opened */
 518         return 0;
 519     time(&now);
 520     tm = localtime(&now);
 521     snprintf(filename, sizeof(filename), "%s-%04d%02d%02d-%02d%02d%02d.log",
 522              program_name,
 523              tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
 524              tm->tm_hour, tm->tm_min, tm->tm_sec);
 525     report_file = fopen(filename, "w");
 526     if (!report_file) {
 527         av_log(NULL, AV_LOG_ERROR, "Failed to open report \"%s\": %s\n",
 528                filename, strerror(errno));
 529         return AVERROR(errno);
 530     }
 531     av_log_set_callback(log_callback_report);
 532     av_log(NULL, AV_LOG_INFO,
 533            "%s started on %04d-%02d-%02d at %02d:%02d:%02d\n"
 534            "Report written to \"%s\"\n",
 535            program_name,
 536            tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
 537            tm->tm_hour, tm->tm_min, tm->tm_sec,
 538            filename);
 539     av_log_set_level(FFMAX(av_log_get_level(), AV_LOG_VERBOSE));
 540     return 0;
 541 }
 542
 543 int opt_max_alloc(const char *opt, const char *arg)
 544 {
 545     char *tail;
 546     size_t max;
 547
 548     max = strtol(arg, &tail, 10);
 549     if (*tail) {
 550         av_log(NULL, AV_LOG_FATAL, "Invalid max_alloc \"%s\".\n", arg);
 551         exit_program(1);
 552     }
 553     av_max_alloc(max);
 554     return 0;
 555 }
 556
 557 int opt_cpuflags(const char *opt, const char *arg)
 558 {
 559     int ret;
 560     unsigned flags = av_get_cpu_flags();
 561
 562     if ((ret = av_parse_cpu_caps(&flags, arg)) < 0)
 563         return ret;
 564
 565     av_force_cpu_flags(flags);
 566     return 0;
 567 }
 568
 569 int opt_codec_debug(const char *opt, const char *arg)
 570 {
 571     av_log_set_level(AV_LOG_DEBUG);
 572     return opt_default(opt, arg);
 573 }
 574
 575 int opt_timelimit(const char *opt, const char *arg)
 576 {
 577 #if HAVE_SETRLIMIT
 578     int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
 579     struct rlimit rl = { lim, lim + 1 };
 580     if (setrlimit(RLIMIT_CPU, &rl))
 581         perror("setrlimit");
 582 #else
 583     av_log(NULL, AV_LOG_WARNING, "-%s not implemented on this OS\n", opt);
 584 #endif
 585     return 0;
 586 }
 587
 588 void print_error(const char *filename, int err)
 589 {
 590     char errbuf[128];
 591     const char *errbuf_ptr = errbuf;
 592
 593     if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
 594         errbuf_ptr = strerror(AVUNERROR(err));
 595     av_log(NULL, AV_LOG_ERROR, "%s: %s\n", filename, errbuf_ptr);
 596 }
 597
 598 static int warned_cfg = 0;
 599
 600 #define INDENT        1
 601 #define SHOW_VERSION  2
 602 #define SHOW_CONFIG   4
 603 #define SHOW_COPYRIGHT 8
 604
 605 #define PRINT_LIB_INFO(libname, LIBNAME, flags, level)                  \
 606     if (CONFIG_##LIBNAME) {                                             \
 607         const char *indent = flags & INDENT? "  " : "";                 \
 608         if (flags & SHOW_VERSION) {                                     \
 609             unsigned int version = libname##_version();                 \
 610             av_log(NULL, level,                                         \
 611                    "%slib%-11s %2d.%3d.%3d / %2d.%3d.%3d\n",            \
 612                    indent, #libname,                                    \
 613                    LIB##LIBNAME##_VERSION_MAJOR,                        \
 614                    LIB##LIBNAME##_VERSION_MINOR,                        \
 615                    LIB##LIBNAME##_VERSION_MICRO,                        \
 616                    version >> 16, version >> 8 & 0xff, version & 0xff); \
 617         }                                                               \
 618         if (flags & SHOW_CONFIG) {                                      \
 619             const char *cfg = libname##_configuration();                \
 620             if (strcmp(FFMPEG_CONFIGURATION, cfg)) {                    \
 621                 if (!warned_cfg) {                                      \
 622                     av_log(NULL, level,                                 \
 623                             "%sWARNING: library configuration mismatch\n", \
 624                             indent);                                    \
 625                     warned_cfg = 1;                                     \
 626                 }                                                       \
 627                 av_log(NULL, level, "%s%-11s configuration: %s\n",      \
 628                         indent, #libname, cfg);                         \
 629             }                                                           \
 630         }                                                               \
 631     }                                                                   \
 632
 633 static void print_all_libs_info(int flags, int level)
 634 {
 635     PRINT_LIB_INFO(avutil,   AVUTIL,   flags, level);
 636     PRINT_LIB_INFO(avcodec,  AVCODEC,  flags, level);
 637     PRINT_LIB_INFO(avformat, AVFORMAT, flags, level);
 638     PRINT_LIB_INFO(avdevice, AVDEVICE, flags, level);
 639     PRINT_LIB_INFO(avfilter, AVFILTER, flags, level);
 640 //    PRINT_LIB_INFO(avresample, AVRESAMPLE, flags, level);
 641     PRINT_LIB_INFO(swscale,  SWSCALE,  flags, level);
 642     PRINT_LIB_INFO(swresample,SWRESAMPLE,  flags, level);
 643 #if CONFIG_POSTPROC
 644     PRINT_LIB_INFO(postproc, POSTPROC, flags, level);
 645 #endif
 646 }
 647
 648 static void print_program_info(int flags, int level)
 649 {
 650     const char *indent = flags & INDENT? "  " : "";
 651
 652     av_log(NULL, level, "%s version " FFMPEG_VERSION, program_name);
 653     if (flags & SHOW_COPYRIGHT)
 654         av_log(NULL, level, " Copyright (c) %d-%d the FFmpeg developers",
 655                program_birth_year, this_year);
 656     av_log(NULL, level, "\n");
 657     av_log(NULL, level, "%sbuilt on %s %s with %s %s\n",
 658            indent, __DATE__, __TIME__, CC_TYPE, CC_VERSION);
 659     av_log(NULL, level, "%sconfiguration: " FFMPEG_CONFIGURATION "\n", indent);
 660 }
 661
 662 void show_banner(int argc, char **argv, const OptionDef *options)
 663 {
 664     int idx = locate_option(argc, argv, options, "version");
 665     if (idx)
 666         return;
 667
 668     print_program_info (INDENT|SHOW_COPYRIGHT, AV_LOG_INFO);
 669     print_all_libs_info(INDENT|SHOW_CONFIG,  AV_LOG_INFO);
 670     print_all_libs_info(INDENT|SHOW_VERSION, AV_LOG_INFO);
 671 }
 672
 673 int opt_version(const char *opt, const char *arg) {
 674     av_log_set_callback(log_callback_help);
 675     print_program_info (0           , AV_LOG_INFO);
 676     print_all_libs_info(SHOW_VERSION, AV_LOG_INFO);
 677     return 0;
 678 }
 679
 680 int opt_license(const char *opt, const char *arg)
 681 {
 682     printf(
 683 #if CONFIG_NONFREE
 684     "This version of %s has nonfree parts compiled in.\n"
 685     "Therefore it is not legally redistributable.\n",
 686     program_name
 687 #elif CONFIG_GPLV3
 688     "%s is free software; you can redistribute it and/or modify\n"
 689     "it under the terms of the GNU General Public License as published by\n"
 690     "the Free Software Foundation; either version 3 of the License, or\n"
 691     "(at your option) any later version.\n"
 692     "\n"
 693     "%s is distributed in the hope that it will be useful,\n"
 694     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 695     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
 696     "GNU General Public License for more details.\n"
 697     "\n"
 698     "You should have received a copy of the GNU General Public License\n"
 699     "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
 700     program_name, program_name, program_name
 701 #elif CONFIG_GPL
 702     "%s is free software; you can redistribute it and/or modify\n"
 703     "it under the terms of the GNU General Public License as published by\n"
 704     "the Free Software Foundation; either version 2 of the License, or\n"
 705     "(at your option) any later version.\n"
 706     "\n"
 707     "%s is distributed in the hope that it will be useful,\n"
 708     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 709     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
 710     "GNU General Public License for more details.\n"
 711     "\n"
 712     "You should have received a copy of the GNU General Public License\n"
 713     "along with %s; if not, write to the Free Software\n"
 714     "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
 715     program_name, program_name, program_name
 716 #elif CONFIG_LGPLV3
 717     "%s is free software; you can redistribute it and/or modify\n"
 718     "it under the terms of the GNU Lesser General Public License as published by\n"
 719     "the Free Software Foundation; either version 3 of the License, or\n"
 720     "(at your option) any later version.\n"
 721     "\n"
 722     "%s is distributed in the hope that it will be useful,\n"
 723     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 724     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
 725     "GNU Lesser General Public License for more details.\n"
 726     "\n"
 727     "You should have received a copy of the GNU Lesser General Public License\n"
 728     "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
 729     program_name, program_name, program_name
 730 #else
 731     "%s is free software; you can redistribute it and/or\n"
 732     "modify it under the terms of the GNU Lesser General Public\n"
 733     "License as published by the Free Software Foundation; either\n"
 734     "version 2.1 of the License, or (at your option) any later version.\n"
 735     "\n"
 736     "%s is distributed in the hope that it will be useful,\n"
 737     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 738     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
 739     "Lesser General Public License for more details.\n"
 740     "\n"
 741     "You should have received a copy of the GNU Lesser General Public\n"
 742     "License along with %s; if not, write to the Free Software\n"
 743     "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
 744     program_name, program_name, program_name
 745 #endif
 746     );
 747     return 0;
 748 }
 749
 750 int opt_formats(const char *opt, const char *arg)
 751 {
 752     AVInputFormat *ifmt  = NULL;
 753     AVOutputFormat *ofmt = NULL;
 754     const char *last_name;
 755
 756     printf("File formats:\n"
 757            " D. = Demuxing supported\n"
 758            " .E = Muxing supported\n"
 759            " --\n");
 760     last_name = "000";
 761     for (;;) {
 762         int decode = 0;
 763         int encode = 0;
 764         const char *name      = NULL;
 765         const char *long_name = NULL;
 766
 767         while ((ofmt = av_oformat_next(ofmt))) {
 768             if ((name == NULL || strcmp(ofmt->name, name) < 0) &&
 769                 strcmp(ofmt->name, last_name) > 0) {
 770                 name      = ofmt->name;
 771                 long_name = ofmt->long_name;
 772                 encode    = 1;
 773             }
 774         }
 775         while ((ifmt = av_iformat_next(ifmt))) {
 776             if ((name == NULL || strcmp(ifmt->name, name) < 0) &&
 777                 strcmp(ifmt->name, last_name) > 0) {
 778                 name      = ifmt->name;
 779                 long_name = ifmt->long_name;
 780                 encode    = 0;
 781             }
 782             if (name && strcmp(ifmt->name, name) == 0)
 783                 decode = 1;
 784         }
 785         if (name == NULL)
 786             break;
 787         last_name = name;
 788
 789         printf(" %s%s %-15s %s\n",
 790                decode ? "D" : " ",
 791                encode ? "E" : " ",
 792                name,
 793             long_name ? long_name:" ");
 794     }
 795     return 0;
 796 }
 797
 798 static char get_media_type_char(enum AVMediaType type)
 799 {
 800     static const char map[AVMEDIA_TYPE_NB] = {
 801         [AVMEDIA_TYPE_VIDEO]      = 'V',
 802         [AVMEDIA_TYPE_AUDIO]      = 'A',
 803         [AVMEDIA_TYPE_DATA]       = 'D',
 804         [AVMEDIA_TYPE_SUBTITLE]   = 'S',
 805         [AVMEDIA_TYPE_ATTACHMENT] = 'T',
 806     };
 807     return type >= 0 && type < AVMEDIA_TYPE_NB && map[type] ? map[type] : '?';
 808 }
 809
 810 int opt_codecs(const char *opt, const char *arg)
 811 {
 812     AVCodec *p = NULL, *p2;
 813     const char *last_name;
 814     printf("Codecs:\n"
 815            " D...... = Decoding supported\n"
 816            " .E..... = Encoding supported\n"
 817            " ..V.... = Video codec\n"
 818            " ..A.... = Audio codec\n"
 819            " ..S.... = Subtitle codec\n"
 820            " ...S... = Supports draw_horiz_band\n"
 821            " ....D.. = Supports direct rendering method 1\n"
 822            " .....T. = Supports weird frame truncation\n"
 823            " ......F = Supports frame-based multi-threading\n"
 824            " ......S = Supports slice-based multi-threading\n"
 825            " ......B = Supports both frame-based and slice-based multi-threading\n"
 826            " --------\n");
 827     last_name= "000";
 828     for (;;) {
 829         int decode = 0;
 830         int encode = 0;
 831         int cap    = 0;
 832
 833         p2 = NULL;
 834         while ((p = av_codec_next(p))) {
 835             if ((p2 == NULL || strcmp(p->name, p2->name) < 0) &&
 836                 strcmp(p->name, last_name) > 0) {
 837                 p2 = p;
 838                 decode = encode = cap = 0;
 839             }
 840             if (p2 && strcmp(p->name, p2->name) == 0) {
 841                 if (av_codec_is_decoder(p))
 842                     decode = 1;
 843                 if (av_codec_is_encoder(p))
 844                     encode = 1;
 845                 cap |= p->capabilities;
 846             }
 847         }
 848         if (p2 == NULL)
 849             break;
 850         last_name = p2->name;
 851
 852         printf(" %s%s%c%s%s%s%s %-15s %s",
 853                decode ? "D" : (/* p2->decoder ? "d" : */ " "),
 854                encode ? "E" : " ",
 855                get_media_type_char(p2->type),
 856                cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S" : " ",
 857                cap & CODEC_CAP_DR1 ? "D" : " ",
 858                cap & CODEC_CAP_TRUNCATED ? "T" : " ",
 859                cap & CODEC_CAP_FRAME_THREADS ? cap & CODEC_CAP_SLICE_THREADS ? "B" : "F" :
 860                                                cap & CODEC_CAP_SLICE_THREADS ? "S" : " ",
 861                p2->name,
 862                p2->long_name ? p2->long_name : "");
 863 #if 0
 864             if (p2->decoder && decode == 0)
 865                 printf(" use %s for decoding", p2->decoder->name);
 866 #endif
 867         printf("\n");
 868     }
 869     printf("\n");
 870     printf("Note, the names of encoders and decoders do not always match, so there are\n"
 871            "several cases where the above table shows encoder only or decoder only entries\n"
 872            "even though both encoding and decoding are supported. For example, the h263\n"
 873            "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
 874            "worse.\n");
 875     return 0;
 876 }
 877
 878 int opt_bsfs(const char *opt, const char *arg)
 879 {
 880     AVBitStreamFilter *bsf = NULL;
 881
 882     printf("Bitstream filters:\n");
 883     while ((bsf = av_bitstream_filter_next(bsf)))
 884         printf("%s\n", bsf->name);
 885     printf("\n");
 886     return 0;
 887 }
 888
 889 int opt_protocols(const char *opt, const char *arg)
 890 {
 891     void *opaque = NULL;
 892     const char *name;
 893
 894     printf("Supported file protocols:\n"
 895            "Input:\n");
 896     while ((name = avio_enum_protocols(&opaque, 0)))
 897         printf("%s\n", name);
 898     printf("Output:\n");
 899     while ((name = avio_enum_protocols(&opaque, 1)))
 900         printf("%s\n", name);
 901     return 0;
 902 }
 903
 904 int opt_filters(const char *opt, const char *arg)
 905 {
 906     AVFilter av_unused(**filter) = NULL;
 907     char descr[64], *descr_cur;
 908     int i, j;
 909     const AVFilterPad *pad;
 910
 911     printf("Filters:\n");
 912 #if CONFIG_AVFILTER
 913     while ((filter = av_filter_next(filter)) && *filter) {
 914         descr_cur = descr;
 915         for (i = 0; i < 2; i++) {
 916             if (i) {
 917                 *(descr_cur++) = '-';
 918                 *(descr_cur++) = '>';
 919             }
 920             pad = i ? (*filter)->outputs : (*filter)->inputs;
 921             for (j = 0; pad[j].name; j++) {
 922                 if (descr_cur >= descr + sizeof(descr) - 4)
 923                     break;
 924                 *(descr_cur++) = get_media_type_char(pad[j].type);
 925             }
 926             if (!j)
 927                 *(descr_cur++) = '|';
 928         }
 929         *descr_cur = 0;
 930         printf("%-16s %-10s %s\n", (*filter)->name, descr, (*filter)->description);
 931     }
 932 #endif
 933     return 0;
 934 }
 935
 936 int opt_pix_fmts(const char *opt, const char *arg)
 937 {
 938     enum PixelFormat pix_fmt;
 939
 940     printf("Pixel formats:\n"
 941            "I.... = Supported Input  format for conversion\n"
 942            ".O... = Supported Output format for conversion\n"
 943            "..H.. = Hardware accelerated format\n"
 944            "...P. = Paletted format\n"
 945            "....B = Bitstream format\n"
 946            "FLAGS NAME            NB_COMPONENTS BITS_PER_PIXEL\n"
 947            "-----\n");
 948
 949 #if !CONFIG_SWSCALE
 950 #   define sws_isSupportedInput(x)  0
 951 #   define sws_isSupportedOutput(x) 0
 952 #endif
 953
 954     for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {
 955         const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[pix_fmt];
 956         if(!pix_desc->name)
 957             continue;
 958         printf("%c%c%c%c%c %-16s       %d            %2d\n",
 959                sws_isSupportedInput (pix_fmt)      ? 'I' : '.',
 960                sws_isSupportedOutput(pix_fmt)      ? 'O' : '.',
 961                pix_desc->flags & PIX_FMT_HWACCEL   ? 'H' : '.',
 962                pix_desc->flags & PIX_FMT_PAL       ? 'P' : '.',
 963                pix_desc->flags & PIX_FMT_BITSTREAM ? 'B' : '.',
 964                pix_desc->name,
 965                pix_desc->nb_components,
 966                av_get_bits_per_pixel(pix_desc));
 967     }
 968     return 0;
 969 }
 970
 971 int show_sample_fmts(const char *opt, const char *arg)
 972 {
 973     int i;
 974     char fmt_str[128];
 975     for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
 976         printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
 977     return 0;
 978 }
 979
 980 int read_yesno(void)
 981 {
 982     int c = getchar();
 983     int yesno = (toupper(c) == 'Y');
 984
 985     while (c != '\n' && c != EOF)
 986         c = getchar();
 987
 988     return yesno;
 989 }
 990
 991 int cmdutils_read_file(const char *filename, char **bufptr, size_t *size)
 992 {
 993     int ret;
 994     FILE *f = fopen(filename, "rb");
 995
 996     if (!f) {
 997         av_log(NULL, AV_LOG_ERROR, "Cannot read file '%s': %s\n", filename,
 998                strerror(errno));
 999         return AVERROR(errno);
1000     }
1001     fseek(f, 0, SEEK_END);
1002     *size = ftell(f);
1003     fseek(f, 0, SEEK_SET);
1004     *bufptr = av_malloc(*size + 1);
1005     if (!*bufptr) {
1006         av_log(NULL, AV_LOG_ERROR, "Could not allocate file buffer\n");
1007         fclose(f);
1008         return AVERROR(ENOMEM);
1009     }
1010     ret = fread(*bufptr, 1, *size, f);
1011     if (ret < *size) {
1012         av_free(*bufptr);
1013         if (ferror(f)) {
1014             av_log(NULL, AV_LOG_ERROR, "Error while reading file '%s': %s\n",
1015                    filename, strerror(errno));
1016             ret = AVERROR(errno);
1017         } else
1018             ret = AVERROR_EOF;
1019     } else {
1020         ret = 0;
1021         (*bufptr)[*size++] = '\0';
1022     }
1023
1024     fclose(f);
1025     return ret;
1026 }
1027
1028 FILE *get_preset_file(char *filename, size_t filename_size,
1029                       const char *preset_name, int is_path,
1030                       const char *codec_name)
1031 {
1032     FILE *f = NULL;
1033     int i;
1034     const char *base[3] = { getenv("FFMPEG_DATADIR"),
1035                             getenv("HOME"),
1036                             FFMPEG_DATADIR, };
1037
1038     if (is_path) {
1039         av_strlcpy(filename, preset_name, filename_size);
1040         f = fopen(filename, "r");
1041     } else {
1042 #ifdef _WIN32
1043         char datadir[MAX_PATH], *ls;
1044         base[2] = NULL;
1045
1046         if (GetModuleFileNameA(GetModuleHandleA(NULL), datadir, sizeof(datadir) - 1))
1047         {
1048             for (ls = datadir; ls < datadir + strlen(datadir); ls++)
1049                 if (*ls == '\\') *ls = '/';
1050
1051             if (ls = strrchr(datadir, '/'))
1052             {
1053                 *ls = 0;
1054                 strncat(datadir, "/ffpresets",  sizeof(datadir) - 1 - strlen(datadir));
1055                 base[2] = datadir;
1056             }
1057         }
1058 #endif
1059         for (i = 0; i < 3 && !f; i++) {
1060             if (!base[i])
1061                 continue;
1062             snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i],
1063                      i != 1 ? "" : "/.ffmpeg", preset_name);
1064             f = fopen(filename, "r");
1065             if (!f && codec_name) {
1066                 snprintf(filename, filename_size,
1067                          "%s%s/%s-%s.ffpreset",
1068                          base[i], i != 1 ? "" : "/.ffmpeg", codec_name,
1069                          preset_name);
1070                 f = fopen(filename, "r");
1071             }
1072         }
1073     }
1074
1075     return f;
1076 }
1077
1078 int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
1079 {
1080     if (*spec <= '9' && *spec >= '0') /* opt:index */
1081         return strtol(spec, NULL, 0) == st->index;
1082     else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
1083              *spec == 't') { /* opt:[vasdt] */
1084         enum AVMediaType type;
1085
1086         switch (*spec++) {
1087         case 'v': type = AVMEDIA_TYPE_VIDEO;      break;
1088         case 'a': type = AVMEDIA_TYPE_AUDIO;      break;
1089         case 's': type = AVMEDIA_TYPE_SUBTITLE;   break;
1090         case 'd': type = AVMEDIA_TYPE_DATA;       break;
1091         case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
1092         default:  av_assert0(0);
1093         }
1094         if (type != st->codec->codec_type)
1095             return 0;
1096         if (*spec++ == ':') { /* possibly followed by :index */
1097             int i, index = strtol(spec, NULL, 0);
1098             for (i = 0; i < s->nb_streams; i++)
1099                 if (s->streams[i]->codec->codec_type == type && index-- == 0)
1100                    return i == st->index;
1101             return 0;
1102         }
1103         return 1;
1104     } else if (*spec == 'p' && *(spec + 1) == ':') {
1105         int prog_id, i, j;
1106         char *endptr;
1107         spec += 2;
1108         prog_id = strtol(spec, &endptr, 0);
1109         for (i = 0; i < s->nb_programs; i++) {
1110             if (s->programs[i]->id != prog_id)
1111                 continue;
1112
1113             if (*endptr++ == ':') {
1114                 int stream_idx = strtol(endptr, NULL, 0);
1115                 return stream_idx >= 0 &&
1116                     stream_idx < s->programs[i]->nb_stream_indexes &&
1117                     st->index == s->programs[i]->stream_index[stream_idx];
1118             }
1119
1120             for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
1121                 if (st->index == s->programs[i]->stream_index[j])
1122                     return 1;
1123         }
1124         return 0;
1125     } else if (*spec == '#') {
1126         int sid;
1127         char *endptr;
1128         sid = strtol(spec + 1, &endptr, 0);
1129         if (!*endptr)
1130             return st->id == sid;
1131     } else if (!*spec) /* empty specifier, matches everything */
1132         return 1;
1133
1134     av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
1135     return AVERROR(EINVAL);
1136 }
1137
1138 AVDictionary *filter_codec_opts(AVDictionary *opts, AVCodec *codec,
1139                                 AVFormatContext *s, AVStream *st)
1140 {
1141     AVDictionary    *ret = NULL;
1142     AVDictionaryEntry *t = NULL;
1143     int            flags = s->oformat ? AV_OPT_FLAG_ENCODING_PARAM
1144                                       : AV_OPT_FLAG_DECODING_PARAM;
1145     char          prefix = 0;
1146     const AVClass    *cc = avcodec_get_class();
1147
1148     if (!codec)
1149         return NULL;
1150
1151     switch (codec->type) {
1152     case AVMEDIA_TYPE_VIDEO:
1153         prefix  = 'v';
1154         flags  |= AV_OPT_FLAG_VIDEO_PARAM;
1155         break;
1156     case AVMEDIA_TYPE_AUDIO:
1157         prefix  = 'a';
1158         flags  |= AV_OPT_FLAG_AUDIO_PARAM;
1159         break;
1160     case AVMEDIA_TYPE_SUBTITLE:
1161         prefix  = 's';
1162         flags  |= AV_OPT_FLAG_SUBTITLE_PARAM;
1163         break;
1164     }
1165
1166     while (t = av_dict_get(opts, "", t, AV_DICT_IGNORE_SUFFIX)) {
1167         char *p = strchr(t->key, ':');
1168
1169         /* check stream specification in opt name */
1170         if (p)
1171             switch (check_stream_specifier(s, st, p + 1)) {
1172             case  1: *p = 0; break;
1173             case  0:         continue;
1174             default:         return NULL;
1175             }
1176
1177         if (av_opt_find(&cc, t->key, NULL, flags, AV_OPT_SEARCH_FAKE_OBJ) ||
1178             (codec && codec->priv_class &&
1179              av_opt_find(&codec->priv_class, t->key, NULL, flags,
1180                          AV_OPT_SEARCH_FAKE_OBJ)))
1181             av_dict_set(&ret, t->key, t->value, 0);
1182         else if (t->key[0] == prefix &&
1183                  av_opt_find(&cc, t->key + 1, NULL, flags,
1184                              AV_OPT_SEARCH_FAKE_OBJ))
1185             av_dict_set(&ret, t->key + 1, t->value, 0);
1186
1187         if (p)
1188             *p = ':';
1189     }
1190     return ret;
1191 }
1192
1193 AVDictionary **setup_find_stream_info_opts(AVFormatContext *s,
1194                                            AVDictionary *codec_opts)
1195 {
1196     int i;
1197     AVDictionary **opts;
1198
1199     if (!s->nb_streams)
1200         return NULL;
1201     opts = av_mallocz(s->nb_streams * sizeof(*opts));
1202     if (!opts) {
1203         av_log(NULL, AV_LOG_ERROR,
1204                "Could not alloc memory for stream options.\n");
1205         return NULL;
1206     }
1207     for (i = 0; i < s->nb_streams; i++)
1208         opts[i] = filter_codec_opts(codec_opts, avcodec_find_decoder(s->streams[i]->codec->codec_id),
1209                                     s, s->streams[i]);
1210     return opts;
1211 }
1212
1213 void *grow_array(void *array, int elem_size, int *size, int new_size)
1214 {
1215     if (new_size >= INT_MAX / elem_size) {
1216         av_log(NULL, AV_LOG_ERROR, "Array too big.\n");
1217         exit_program(1);
1218     }
1219     if (*size < new_size) {
1220         uint8_t *tmp = av_realloc(array, new_size*elem_size);
1221         if (!tmp) {
1222             av_log(NULL, AV_LOG_ERROR, "Could not alloc buffer.\n");
1223             exit_program(1);
1224         }
1225         memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
1226         *size = new_size;
1227         return tmp;
1228     }
1229     return array;
1230 }
1231
1232 static int alloc_buffer(FrameBuffer **pool, AVCodecContext *s, FrameBuffer **pbuf)
1233 {
1234     FrameBuffer  *buf = av_mallocz(sizeof(*buf));
1235     int i, ret;
1236     const int pixel_size = av_pix_fmt_descriptors[s->pix_fmt].comp[0].step_minus1+1;
1237     int h_chroma_shift, v_chroma_shift;
1238     int edge = 32; // XXX should be avcodec_get_edge_width(), but that fails on svq1
1239     int w = s->width, h = s->height;
1240
1241     if (!buf)
1242         return AVERROR(ENOMEM);
1243
1244     avcodec_align_dimensions(s, &w, &h);
1245
1246     if (!(s->flags & CODEC_FLAG_EMU_EDGE)) {
1247         w += 2*edge;
1248         h += 2*edge;
1249     }
1250
1251     if ((ret = av_image_alloc(buf->base, buf->linesize, w, h,
1252                               s->pix_fmt, 32)) < 0) {
1253         av_freep(&buf);
1254         return ret;
1255     }
1256     /* XXX this shouldn't be needed, but some tests break without this line
1257      * those decoders are buggy and need to be fixed.
1258      * the following tests fail:
1259      * cdgraphics, ansi, aasc, fraps-v1, qtrle-1bit
1260      */
1261     memset(buf->base[0], 128, ret);
1262
1263     avcodec_get_chroma_sub_sample(s->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1264     for (i = 0; i < FF_ARRAY_ELEMS(buf->data); i++) {
1265         const int h_shift = i==0 ? 0 : h_chroma_shift;
1266         const int v_shift = i==0 ? 0 : v_chroma_shift;
1267         if ((s->flags & CODEC_FLAG_EMU_EDGE) || !buf->linesize[1] || !buf->base[i])
1268             buf->data[i] = buf->base[i];
1269         else
1270             buf->data[i] = buf->base[i] +
1271                            FFALIGN((buf->linesize[i]*edge >> v_shift) +
1272                                    (pixel_size*edge >> h_shift), 32);
1273     }
1274     buf->w       = s->width;
1275     buf->h       = s->height;
1276     buf->pix_fmt = s->pix_fmt;
1277     buf->pool    = pool;
1278
1279     *pbuf = buf;
1280     return 0;
1281 }
1282
1283 int codec_get_buffer(AVCodecContext *s, AVFrame *frame)
1284 {
1285     FrameBuffer **pool = s->opaque;
1286     FrameBuffer *buf;
1287     int ret, i;
1288
1289     if(av_image_check_size(s->width, s->height, 0, s) || s->pix_fmt<0)
1290         return -1;
1291
1292     if (!*pool && (ret = alloc_buffer(pool, s, pool)) < 0)
1293         return ret;
1294
1295     buf              = *pool;
1296     *pool            = buf->next;
1297     buf->next        = NULL;
1298     if (buf->w != s->width || buf->h != s->height || buf->pix_fmt != s->pix_fmt) {
1299         av_freep(&buf->base[0]);
1300         av_free(buf);
1301         if ((ret = alloc_buffer(pool, s, &buf)) < 0)
1302             return ret;
1303     }
1304     av_assert0(!buf->refcount);
1305     buf->refcount++;
1306
1307     frame->opaque        = buf;
1308     frame->type          = FF_BUFFER_TYPE_USER;
1309     frame->extended_data = frame->data;
1310     frame->pkt_pts       = s->pkt ? s->pkt->pts : AV_NOPTS_VALUE;
1311     frame->width         = buf->w;
1312     frame->height        = buf->h;
1313     frame->format        = buf->pix_fmt;
1314     frame->sample_aspect_ratio = s->sample_aspect_ratio;
1315
1316     for (i = 0; i < FF_ARRAY_ELEMS(buf->data); i++) {
1317         frame->base[i]     = buf->base[i];  // XXX h264.c uses base though it shouldn't
1318         frame->data[i]     = buf->data[i];
1319         frame->linesize[i] = buf->linesize[i];
1320     }
1321
1322     return 0;
1323 }
1324
1325 static void unref_buffer(FrameBuffer *buf)
1326 {
1327     FrameBuffer **pool = buf->pool;
1328
1329     av_assert0(buf->refcount > 0);
1330     buf->refcount--;
1331     if (!buf->refcount) {
1332         FrameBuffer *tmp;
1333         for(tmp= *pool; tmp; tmp= tmp->next)
1334             av_assert1(tmp != buf);
1335
1336         buf->next = *pool;
1337         *pool = buf;
1338     }
1339 }
1340
1341 void codec_release_buffer(AVCodecContext *s, AVFrame *frame)
1342 {
1343     FrameBuffer *buf = frame->opaque;
1344     int i;
1345
1346     if(frame->type!=FF_BUFFER_TYPE_USER) {
1347         avcodec_default_release_buffer(s, frame);
1348         return;
1349     }
1350
1351     for (i = 0; i < FF_ARRAY_ELEMS(frame->data); i++)
1352         frame->data[i] = NULL;
1353
1354     unref_buffer(buf);
1355 }
1356
1357 void filter_release_buffer(AVFilterBuffer *fb)
1358 {
1359     FrameBuffer *buf = fb->priv;
1360     av_free(fb);
1361     unref_buffer(buf);
1362 }
1363
1364 void free_buffer_pool(FrameBuffer **pool)
1365 {
1366     FrameBuffer *buf = *pool;
1367     while (buf) {
1368         *pool = buf->next;
1369         av_freep(&buf->base[0]);
1370         av_free(buf);
1371         buf = *pool;
1372     }
1373 }