ffmpeg/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 static char get_media_type_char(enum AVMediaType type)
 768 {
 769     static const char map[AVMEDIA_TYPE_NB] = {
 770         [AVMEDIA_TYPE_VIDEO]      = 'V',
 771         [AVMEDIA_TYPE_AUDIO]      = 'A',
 772         [AVMEDIA_TYPE_DATA]       = 'D',
 773         [AVMEDIA_TYPE_SUBTITLE]   = 'S',
 774         [AVMEDIA_TYPE_ATTACHMENT] = 'T',
 775     };
 776     return type >= 0 && type < AVMEDIA_TYPE_NB && map[type] ? map[type] : '?';
 777 }
 778
 779 int opt_codecs(const char *opt, const char *arg)
 780 {
 781     AVCodec *p = NULL, *p2;
 782     const char *last_name;
 783     printf("Codecs:\n"
 784            " D..... = Decoding supported\n"
 785            " .E.... = Encoding supported\n"
 786            " ..V... = Video codec\n"
 787            " ..A... = Audio codec\n"
 788            " ..S... = Subtitle codec\n"
 789            " ...S.. = Supports draw_horiz_band\n"
 790            " ....D. = Supports direct rendering method 1\n"
 791            " .....T = Supports weird frame truncation\n"
 792            " ------\n");
 793     last_name= "000";
 794     for (;;) {
 795         int decode = 0;
 796         int encode = 0;
 797         int cap    = 0;
 798
 799         p2 = NULL;
 800         while ((p = av_codec_next(p))) {
 801             if ((p2 == NULL || strcmp(p->name, p2->name) < 0) &&
 802                 strcmp(p->name, last_name) > 0) {
 803                 p2 = p;
 804                 decode = encode = cap = 0;
 805             }
 806             if (p2 && strcmp(p->name, p2->name) == 0) {
 807                 if (p->decode)
 808                     decode = 1;
 809                 if (p->encode || p->encode2)
 810                     encode = 1;
 811                 cap |= p->capabilities;
 812             }
 813         }
 814         if (p2 == NULL)
 815             break;
 816         last_name = p2->name;
 817
 818         printf(" %s%s%c%s%s%s %-15s %s",
 819                decode ? "D" : (/* p2->decoder ? "d" : */ " "),
 820                encode ? "E" : " ",
 821                get_media_type_char(p2->type),
 822                cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S" : " ",
 823                cap & CODEC_CAP_DR1 ? "D" : " ",
 824                cap & CODEC_CAP_TRUNCATED ? "T" : " ",
 825                p2->name,
 826                p2->long_name ? p2->long_name : "");
 827 #if 0
 828             if (p2->decoder && decode == 0)
 829                 printf(" use %s for decoding", p2->decoder->name);
 830 #endif
 831         printf("\n");
 832     }
 833     printf("\n");
 834     printf("Note, the names of encoders and decoders do not always match, so there are\n"
 835            "several cases where the above table shows encoder only or decoder only entries\n"
 836            "even though both encoding and decoding are supported. For example, the h263\n"
 837            "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
 838            "worse.\n");
 839     return 0;
 840 }
 841
 842 int opt_bsfs(const char *opt, const char *arg)
 843 {
 844     AVBitStreamFilter *bsf = NULL;
 845
 846     printf("Bitstream filters:\n");
 847     while ((bsf = av_bitstream_filter_next(bsf)))
 848         printf("%s\n", bsf->name);
 849     printf("\n");
 850     return 0;
 851 }
 852
 853 int opt_protocols(const char *opt, const char *arg)
 854 {
 855     URLProtocol *up=NULL;
 856
 857     printf("Supported file protocols:\n"
 858            "I.. = Input  supported\n"
 859            ".O. = Output supported\n"
 860            "..S = Seek   supported\n"
 861            "FLAGS NAME\n"
 862            "----- \n");
 863     while((up = av_protocol_next(up)))
 864         printf("%c%c%c   %s\n",
 865                up->url_read  ? 'I' : '.',
 866                up->url_write ? 'O' : '.',
 867                up->url_seek  ? 'S' : '.',
 868                up->name);
 869     return 0;
 870 }
 871
 872 int opt_filters(const char *opt, const char *arg)
 873 {
 874     AVFilter av_unused(**filter) = NULL;
 875     char descr[64], *descr_cur;
 876     int i, j;
 877     const AVFilterPad *pad;
 878
 879     printf("Filters:\n");
 880 #if CONFIG_AVFILTER
 881     while ((filter = av_filter_next(filter)) && *filter) {
 882         descr_cur = descr;
 883         for (i = 0; i < 2; i++) {
 884             if (i) {
 885                 *(descr_cur++) = '-';
 886                 *(descr_cur++) = '>';
 887             }
 888             pad = i ? (*filter)->outputs : (*filter)->inputs;
 889             for (j = 0; pad[j].name; j++) {
 890                 if (descr_cur >= descr + sizeof(descr) - 4)
 891                     break;
 892                 *(descr_cur++) = get_media_type_char(pad[j].type);
 893             }
 894             if (!j)
 895                 *(descr_cur++) = '|';
 896         }
 897         *descr_cur = 0;
 898         printf("%-16s %-10s %s\n", (*filter)->name, descr, (*filter)->description);
 899     }
 900 #endif
 901     return 0;
 902 }
 903
 904 int opt_pix_fmts(const char *opt, const char *arg)
 905 {
 906     enum PixelFormat pix_fmt;
 907
 908     printf("Pixel formats:\n"
 909            "I.... = Supported Input  format for conversion\n"
 910            ".O... = Supported Output format for conversion\n"
 911            "..H.. = Hardware accelerated format\n"
 912            "...P. = Paletted format\n"
 913            "....B = Bitstream format\n"
 914            "FLAGS NAME            NB_COMPONENTS BITS_PER_PIXEL\n"
 915            "-----\n");
 916
 917 #if !CONFIG_SWSCALE
 918 #   define sws_isSupportedInput(x)  0
 919 #   define sws_isSupportedOutput(x) 0
 920 #endif
 921
 922     for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {
 923         const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[pix_fmt];
 924         if(!pix_desc->name)
 925             continue;
 926         printf("%c%c%c%c%c %-16s       %d            %2d\n",
 927                sws_isSupportedInput (pix_fmt)      ? 'I' : '.',
 928                sws_isSupportedOutput(pix_fmt)      ? 'O' : '.',
 929                pix_desc->flags & PIX_FMT_HWACCEL   ? 'H' : '.',
 930                pix_desc->flags & PIX_FMT_PAL       ? 'P' : '.',
 931                pix_desc->flags & PIX_FMT_BITSTREAM ? 'B' : '.',
 932                pix_desc->name,
 933                pix_desc->nb_components,
 934                av_get_bits_per_pixel(pix_desc));
 935     }
 936     return 0;
 937 }
 938
 939 int show_sample_fmts(const char *opt, const char *arg)
 940 {
 941     int i;
 942     char fmt_str[128];
 943     for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
 944         printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
 945     return 0;
 946 }
 947
 948 int read_yesno(void)
 949 {
 950     int c = getchar();
 951     int yesno = (toupper(c) == 'Y');
 952
 953     while (c != '\n' && c != EOF)
 954         c = getchar();
 955
 956     return yesno;
 957 }
 958
 959 int cmdutils_read_file(const char *filename, char **bufptr, size_t *size)
 960 {
 961     int ret;
 962     FILE *f = fopen(filename, "rb");
 963
 964     if (!f) {
 965         av_log(NULL, AV_LOG_ERROR, "Cannot read file '%s': %s\n", filename,
 966                strerror(errno));
 967         return AVERROR(errno);
 968     }
 969     fseek(f, 0, SEEK_END);
 970     *size = ftell(f);
 971     fseek(f, 0, SEEK_SET);
 972     *bufptr = av_malloc(*size + 1);
 973     if (!*bufptr) {
 974         av_log(NULL, AV_LOG_ERROR, "Could not allocate file buffer\n");
 975         fclose(f);
 976         return AVERROR(ENOMEM);
 977     }
 978     ret = fread(*bufptr, 1, *size, f);
 979     if (ret < *size) {
 980         av_free(*bufptr);
 981         if (ferror(f)) {
 982             av_log(NULL, AV_LOG_ERROR, "Error while reading file '%s': %s\n",
 983                    filename, strerror(errno));
 984             ret = AVERROR(errno);
 985         } else
 986             ret = AVERROR_EOF;
 987     } else {
 988         ret = 0;
 989         (*bufptr)[*size++] = '\0';
 990     }
 991
 992     fclose(f);
 993     return ret;
 994 }
 995
 996 FILE *get_preset_file(char *filename, size_t filename_size,
 997                       const char *preset_name, int is_path,
 998                       const char *codec_name)
 999 {
1000     FILE *f = NULL;
1001     int i;
1002     const char *base[3] = { getenv("FFMPEG_DATADIR"),
1003                             getenv("HOME"),
1004                             FFMPEG_DATADIR, };
1005
1006     if (is_path) {
1007         av_strlcpy(filename, preset_name, filename_size);
1008         f = fopen(filename, "r");
1009     } else {
1010 #ifdef _WIN32
1011         char datadir[MAX_PATH], *ls;
1012         base[2] = NULL;
1013
1014         if (GetModuleFileNameA(GetModuleHandleA(NULL), datadir, sizeof(datadir) - 1))
1015         {
1016             for (ls = datadir; ls < datadir + strlen(datadir); ls++)
1017                 if (*ls == '\\') *ls = '/';
1018
1019             if (ls = strrchr(datadir, '/'))
1020             {
1021                 *ls = 0;
1022                 strncat(datadir, "/ffpresets",  sizeof(datadir) - 1 - strlen(datadir));
1023                 base[2] = datadir;
1024             }
1025         }
1026 #endif
1027         for (i = 0; i < 3 && !f; i++) {
1028             if (!base[i])
1029                 continue;
1030             snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i],
1031                      i != 1 ? "" : "/.ffmpeg", preset_name);
1032             f = fopen(filename, "r");
1033             if (!f && codec_name) {
1034                 snprintf(filename, filename_size,
1035                          "%s%s/%s-%s.ffpreset",
1036                          base[i],  i != 1 ? "" : "/.ffmpeg", codec_name,
1037                          preset_name);
1038                 f = fopen(filename, "r");
1039             }
1040         }
1041     }
1042
1043     return f;
1044 }
1045
1046 int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
1047 {
1048     if (*spec <= '9' && *spec >= '0') /* opt:index */
1049         return strtol(spec, NULL, 0) == st->index;
1050     else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
1051              *spec == 't') { /* opt:[vasdt] */
1052         enum AVMediaType type;
1053
1054         switch (*spec++) {
1055         case 'v': type = AVMEDIA_TYPE_VIDEO;      break;
1056         case 'a': type = AVMEDIA_TYPE_AUDIO;      break;
1057         case 's': type = AVMEDIA_TYPE_SUBTITLE;   break;
1058         case 'd': type = AVMEDIA_TYPE_DATA;       break;
1059         case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
1060         default: abort(); // never reached, silence warning
1061         }
1062         if (type != st->codec->codec_type)
1063             return 0;
1064         if (*spec++ == ':') { /* possibly followed by :index */
1065             int i, index = strtol(spec, NULL, 0);
1066             for (i = 0; i < s->nb_streams; i++)
1067                 if (s->streams[i]->codec->codec_type == type && index-- == 0)
1068                    return i == st->index;
1069             return 0;
1070         }
1071         return 1;
1072     } else if (*spec == 'p' && *(spec + 1) == ':') {
1073         int prog_id, i, j;
1074         char *endptr;
1075         spec += 2;
1076         prog_id = strtol(spec, &endptr, 0);
1077         for (i = 0; i < s->nb_programs; i++) {
1078             if (s->programs[i]->id != prog_id)
1079                 continue;
1080
1081             if (*endptr++ == ':') {
1082                 int stream_idx = strtol(endptr, NULL, 0);
1083                 return stream_idx >= 0 &&
1084                     stream_idx < s->programs[i]->nb_stream_indexes &&
1085                     st->index == s->programs[i]->stream_index[stream_idx];
1086             }
1087
1088             for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
1089                 if (st->index == s->programs[i]->stream_index[j])
1090                     return 1;
1091         }
1092         return 0;
1093     } else if (!*spec) /* empty specifier, matches everything */
1094         return 1;
1095
1096     av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
1097     return AVERROR(EINVAL);
1098 }
1099
1100 AVDictionary *filter_codec_opts(AVDictionary *opts, AVCodec *codec,
1101                                 AVFormatContext *s, AVStream *st)
1102 {
1103     AVDictionary    *ret = NULL;
1104     AVDictionaryEntry *t = NULL;
1105     int            flags = s->oformat ? AV_OPT_FLAG_ENCODING_PARAM
1106                                       : AV_OPT_FLAG_DECODING_PARAM;
1107     char          prefix = 0;
1108     const AVClass    *cc = avcodec_get_class();
1109
1110     if (!codec)
1111         return NULL;
1112
1113     switch (codec->type) {
1114     case AVMEDIA_TYPE_VIDEO:
1115         prefix  = 'v';
1116         flags  |= AV_OPT_FLAG_VIDEO_PARAM;
1117         break;
1118     case AVMEDIA_TYPE_AUDIO:
1119         prefix  = 'a';
1120         flags  |= AV_OPT_FLAG_AUDIO_PARAM;
1121         break;
1122     case AVMEDIA_TYPE_SUBTITLE:
1123         prefix  = 's';
1124         flags  |= AV_OPT_FLAG_SUBTITLE_PARAM;
1125         break;
1126     }
1127
1128     while (t = av_dict_get(opts, "", t, AV_DICT_IGNORE_SUFFIX)) {
1129         char *p = strchr(t->key, ':');
1130
1131         /* check stream specification in opt name */
1132         if (p)
1133             switch (check_stream_specifier(s, st, p + 1)) {
1134             case  1: *p = 0; break;
1135             case  0:         continue;
1136             default:         return NULL;
1137             }
1138
1139         if (av_opt_find(&cc, t->key, NULL, flags, AV_OPT_SEARCH_FAKE_OBJ) ||
1140             (codec && codec->priv_class &&
1141              av_opt_find(&codec->priv_class, t->key, NULL, flags,
1142                          AV_OPT_SEARCH_FAKE_OBJ)))
1143             av_dict_set(&ret, t->key, t->value, 0);
1144         else if (t->key[0] == prefix &&
1145                  av_opt_find(&cc, t->key + 1, NULL, flags,
1146                              AV_OPT_SEARCH_FAKE_OBJ))
1147             av_dict_set(&ret, t->key + 1, t->value, 0);
1148
1149         if (p)
1150             *p = ':';
1151     }
1152     return ret;
1153 }
1154
1155 AVDictionary **setup_find_stream_info_opts(AVFormatContext *s,
1156                                            AVDictionary *codec_opts)
1157 {
1158     int i;
1159     AVDictionary **opts;
1160
1161     if (!s->nb_streams)
1162         return NULL;
1163     opts = av_mallocz(s->nb_streams * sizeof(*opts));
1164     if (!opts) {
1165         av_log(NULL, AV_LOG_ERROR,
1166                "Could not alloc memory for stream options.\n");
1167         return NULL;
1168     }
1169     for (i = 0; i < s->nb_streams; i++)
1170         opts[i] = filter_codec_opts(codec_opts, avcodec_find_decoder(s->streams[i]->codec->codec_id),
1171                                     s, s->streams[i]);
1172     return opts;
1173 }
1174
1175 void *grow_array(void *array, int elem_size, int *size, int new_size)
1176 {
1177     if (new_size >= INT_MAX / elem_size) {
1178         av_log(NULL, AV_LOG_ERROR, "Array too big.\n");
1179         exit_program(1);
1180     }
1181     if (*size < new_size) {
1182         uint8_t *tmp = av_realloc(array, new_size*elem_size);
1183         if (!tmp) {
1184             av_log(NULL, AV_LOG_ERROR, "Could not alloc buffer.\n");
1185             exit_program(1);
1186         }
1187         memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
1188         *size = new_size;
1189         return tmp;
1190     }
1191     return array;
1192 }