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