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