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