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