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 Libav.
   6  *
   7  * Libav 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  * Libav 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 Libav; 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 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->type == AV_OPT_TYPE_FLAGS) ? AV_DICT_APPEND : 0
 356 int opt_default(const char *opt, const char *arg)
 357 {
 358     const AVOption *o;
 359     char opt_stripped[128];
 360     const char *p;
 361     const AVClass *cc = avcodec_get_class(), *fc = avformat_get_class(), *sc = sws_get_class();
 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 ((o = 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           (o = av_opt_find(&cc, opt+1, NULL, 0, AV_OPT_SEARCH_FAKE_OBJ))))
 370         av_dict_set(&codec_opts, opt, arg, FLAGS);
 371     else if ((o = 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);
 373     else if ((o = av_opt_find(&sc, opt, NULL, 0, AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) {
 374         // XXX we only support sws_flags, not arbitrary sws options
 375         int ret = av_opt_set(sws_opts, opt, arg, 0);
 376         if (ret < 0) {
 377             av_log(NULL, AV_LOG_ERROR, "Error setting option %s.\n", opt);
 378             return ret;
 379         }
 380     }
 381
 382     if (o)
 383         return 0;
 384     av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);
 385     return AVERROR_OPTION_NOT_FOUND;
 386 }
 387
 388 int opt_loglevel(const char *opt, const char *arg)
 389 {
 390     const struct { const char *name; int level; } log_levels[] = {
 391         { "quiet"  , AV_LOG_QUIET   },
 392         { "panic"  , AV_LOG_PANIC   },
 393         { "fatal"  , AV_LOG_FATAL   },
 394         { "error"  , AV_LOG_ERROR   },
 395         { "warning", AV_LOG_WARNING },
 396         { "info"   , AV_LOG_INFO    },
 397         { "verbose", AV_LOG_VERBOSE },
 398         { "debug"  , AV_LOG_DEBUG   },
 399     };
 400     char *tail;
 401     int level;
 402     int i;
 403
 404     for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
 405         if (!strcmp(log_levels[i].name, arg)) {
 406             av_log_set_level(log_levels[i].level);
 407             return 0;
 408         }
 409     }
 410
 411     level = strtol(arg, &tail, 10);
 412     if (*tail) {
 413         av_log(NULL, AV_LOG_FATAL, "Invalid loglevel \"%s\". "
 414                "Possible levels are numbers or:\n", arg);
 415         for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
 416             av_log(NULL, AV_LOG_FATAL, "\"%s\"\n", log_levels[i].name);
 417         exit_program(1);
 418     }
 419     av_log_set_level(level);
 420     return 0;
 421 }
 422
 423 int opt_timelimit(const char *opt, const char *arg)
 424 {
 425 #if HAVE_SETRLIMIT
 426     int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
 427     struct rlimit rl = { lim, lim + 1 };
 428     if (setrlimit(RLIMIT_CPU, &rl))
 429         perror("setrlimit");
 430 #else
 431     av_log(NULL, AV_LOG_WARNING, "-%s not implemented on this OS\n", opt);
 432 #endif
 433     return 0;
 434 }
 435
 436 void print_error(const char *filename, int err)
 437 {
 438     char errbuf[128];
 439     const char *errbuf_ptr = errbuf;
 440
 441     if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
 442         errbuf_ptr = strerror(AVUNERROR(err));
 443     av_log(NULL, AV_LOG_ERROR, "%s: %s\n", filename, errbuf_ptr);
 444 }
 445
 446 static int warned_cfg = 0;
 447
 448 #define INDENT        1
 449 #define SHOW_VERSION  2
 450 #define SHOW_CONFIG   4
 451
 452 #define PRINT_LIB_INFO(libname, LIBNAME, flags, level)                  \
 453     if (CONFIG_##LIBNAME) {                                             \
 454         const char *indent = flags & INDENT? "  " : "";                 \
 455         if (flags & SHOW_VERSION) {                                     \
 456             unsigned int version = libname##_version();                 \
 457             av_log(NULL, level, "%slib%-9s %2d.%3d.%2d / %2d.%3d.%2d\n",\
 458                    indent, #libname,                                    \
 459                    LIB##LIBNAME##_VERSION_MAJOR,                        \
 460                    LIB##LIBNAME##_VERSION_MINOR,                        \
 461                    LIB##LIBNAME##_VERSION_MICRO,                        \
 462                    version >> 16, version >> 8 & 0xff, version & 0xff); \
 463         }                                                               \
 464         if (flags & SHOW_CONFIG) {                                      \
 465             const char *cfg = libname##_configuration();                \
 466             if (strcmp(LIBAV_CONFIGURATION, cfg)) {                     \
 467                 if (!warned_cfg) {                                      \
 468                     av_log(NULL, level,                                 \
 469                             "%sWARNING: library configuration mismatch\n", \
 470                             indent);                                    \
 471                     warned_cfg = 1;                                     \
 472                 }                                                       \
 473                 av_log(NULL, level, "%s%-11s configuration: %s\n",      \
 474                         indent, #libname, cfg);                         \
 475             }                                                           \
 476         }                                                               \
 477     }                                                                   \
 478
 479 static void print_all_libs_info(int flags, int level)
 480 {
 481     PRINT_LIB_INFO(avutil,   AVUTIL,   flags, level);
 482     PRINT_LIB_INFO(avcodec,  AVCODEC,  flags, level);
 483     PRINT_LIB_INFO(avformat, AVFORMAT, flags, level);
 484     PRINT_LIB_INFO(avdevice, AVDEVICE, flags, level);
 485     PRINT_LIB_INFO(avfilter, AVFILTER, flags, level);
 486     PRINT_LIB_INFO(swscale,  SWSCALE,  flags, level);
 487     PRINT_LIB_INFO(postproc, POSTPROC, flags, level);
 488 }
 489
 490 void show_banner(void)
 491 {
 492     av_log(NULL, AV_LOG_INFO, "%s version " LIBAV_VERSION ", Copyright (c) %d-%d the Libav developers\n",
 493            program_name, program_birth_year, this_year);
 494     av_log(NULL, AV_LOG_INFO, "  built on %s %s with %s %s\n",
 495            __DATE__, __TIME__, CC_TYPE, CC_VERSION);
 496     av_log(NULL, AV_LOG_VERBOSE, "  configuration: " LIBAV_CONFIGURATION "\n");
 497     print_all_libs_info(INDENT|SHOW_CONFIG,  AV_LOG_VERBOSE);
 498     print_all_libs_info(INDENT|SHOW_VERSION, AV_LOG_VERBOSE);
 499 }
 500
 501 void show_version(void) {
 502     av_log_set_callback(log_callback_help);
 503     printf("%s " LIBAV_VERSION "\n", program_name);
 504     print_all_libs_info(SHOW_VERSION, AV_LOG_INFO);
 505 }
 506
 507 void show_license(void)
 508 {
 509     printf(
 510 #if CONFIG_NONFREE
 511     "This version of %s has nonfree parts compiled in.\n"
 512     "Therefore it is not legally redistributable.\n",
 513     program_name
 514 #elif CONFIG_GPLV3
 515     "%s is free software; you can redistribute it and/or modify\n"
 516     "it under the terms of the GNU General Public License as published by\n"
 517     "the Free Software Foundation; either version 3 of the License, or\n"
 518     "(at your option) any later version.\n"
 519     "\n"
 520     "%s is distributed in the hope that it will be useful,\n"
 521     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 522     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
 523     "GNU General Public License for more details.\n"
 524     "\n"
 525     "You should have received a copy of the GNU General Public License\n"
 526     "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
 527     program_name, program_name, program_name
 528 #elif CONFIG_GPL
 529     "%s is free software; you can redistribute it and/or modify\n"
 530     "it under the terms of the GNU General Public License as published by\n"
 531     "the Free Software Foundation; either version 2 of the License, or\n"
 532     "(at your option) any later version.\n"
 533     "\n"
 534     "%s is distributed in the hope that it will be useful,\n"
 535     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 536     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
 537     "GNU General Public License for more details.\n"
 538     "\n"
 539     "You should have received a copy of the GNU General Public License\n"
 540     "along with %s; if not, write to the Free Software\n"
 541     "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
 542     program_name, program_name, program_name
 543 #elif CONFIG_LGPLV3
 544     "%s is free software; you can redistribute it and/or modify\n"
 545     "it under the terms of the GNU Lesser General Public License as published by\n"
 546     "the Free Software Foundation; either version 3 of the License, or\n"
 547     "(at your option) any later version.\n"
 548     "\n"
 549     "%s is distributed in the hope that it will be useful,\n"
 550     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 551     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
 552     "GNU Lesser General Public License for more details.\n"
 553     "\n"
 554     "You should have received a copy of the GNU Lesser General Public License\n"
 555     "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
 556     program_name, program_name, program_name
 557 #else
 558     "%s is free software; you can redistribute it and/or\n"
 559     "modify it under the terms of the GNU Lesser General Public\n"
 560     "License as published by the Free Software Foundation; either\n"
 561     "version 2.1 of the License, or (at your option) any later version.\n"
 562     "\n"
 563     "%s is distributed in the hope that it will be useful,\n"
 564     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 565     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
 566     "Lesser General Public License for more details.\n"
 567     "\n"
 568     "You should have received a copy of the GNU Lesser General Public\n"
 569     "License along with %s; if not, write to the Free Software\n"
 570     "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
 571     program_name, program_name, program_name
 572 #endif
 573     );
 574 }
 575
 576 void show_formats(void)
 577 {
 578     AVInputFormat *ifmt=NULL;
 579     AVOutputFormat *ofmt=NULL;
 580     const char *last_name;
 581
 582     printf(
 583         "File formats:\n"
 584         " D. = Demuxing supported\n"
 585         " .E = Muxing supported\n"
 586         " --\n");
 587     last_name= "000";
 588     for(;;){
 589         int decode=0;
 590         int encode=0;
 591         const char *name=NULL;
 592         const char *long_name=NULL;
 593
 594         while((ofmt= av_oformat_next(ofmt))) {
 595             if((name == NULL || strcmp(ofmt->name, name)<0) &&
 596                 strcmp(ofmt->name, last_name)>0){
 597                 name= ofmt->name;
 598                 long_name= ofmt->long_name;
 599                 encode=1;
 600             }
 601         }
 602         while((ifmt= av_iformat_next(ifmt))) {
 603             if((name == NULL || strcmp(ifmt->name, name)<0) &&
 604                 strcmp(ifmt->name, last_name)>0){
 605                 name= ifmt->name;
 606                 long_name= ifmt->long_name;
 607                 encode=0;
 608             }
 609             if(name && strcmp(ifmt->name, name)==0)
 610                 decode=1;
 611         }
 612         if(name==NULL)
 613             break;
 614         last_name= name;
 615
 616         printf(
 617             " %s%s %-15s %s\n",
 618             decode ? "D":" ",
 619             encode ? "E":" ",
 620             name,
 621             long_name ? long_name:" ");
 622     }
 623 }
 624
 625 void show_codecs(void)
 626 {
 627     AVCodec *p=NULL, *p2;
 628     const char *last_name;
 629     printf(
 630         "Codecs:\n"
 631         " D..... = Decoding supported\n"
 632         " .E.... = Encoding supported\n"
 633         " ..V... = Video codec\n"
 634         " ..A... = Audio codec\n"
 635         " ..S... = Subtitle codec\n"
 636         " ...S.. = Supports draw_horiz_band\n"
 637         " ....D. = Supports direct rendering method 1\n"
 638         " .....T = Supports weird frame truncation\n"
 639         " ------\n");
 640     last_name= "000";
 641     for(;;){
 642         int decode=0;
 643         int encode=0;
 644         int cap=0;
 645         const char *type_str;
 646
 647         p2=NULL;
 648         while((p= av_codec_next(p))) {
 649             if((p2==NULL || strcmp(p->name, p2->name)<0) &&
 650                 strcmp(p->name, last_name)>0){
 651                 p2= p;
 652                 decode= encode= cap=0;
 653             }
 654             if(p2 && strcmp(p->name, p2->name)==0){
 655                 if(p->decode) decode=1;
 656                 if(p->encode) encode=1;
 657                 cap |= p->capabilities;
 658             }
 659         }
 660         if(p2==NULL)
 661             break;
 662         last_name= p2->name;
 663
 664         switch(p2->type) {
 665         case AVMEDIA_TYPE_VIDEO:
 666             type_str = "V";
 667             break;
 668         case AVMEDIA_TYPE_AUDIO:
 669             type_str = "A";
 670             break;
 671         case AVMEDIA_TYPE_SUBTITLE:
 672             type_str = "S";
 673             break;
 674         default:
 675             type_str = "?";
 676             break;
 677         }
 678         printf(
 679             " %s%s%s%s%s%s %-15s %s",
 680             decode ? "D": (/*p2->decoder ? "d":*/" "),
 681             encode ? "E":" ",
 682             type_str,
 683             cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
 684             cap & CODEC_CAP_DR1 ? "D":" ",
 685             cap & CODEC_CAP_TRUNCATED ? "T":" ",
 686             p2->name,
 687             p2->long_name ? p2->long_name : "");
 688        /* if(p2->decoder && decode==0)
 689             printf(" use %s for decoding", p2->decoder->name);*/
 690         printf("\n");
 691     }
 692     printf("\n");
 693     printf(
 694 "Note, the names of encoders and decoders do not always match, so there are\n"
 695 "several cases where the above table shows encoder only or decoder only entries\n"
 696 "even though both encoding and decoding are supported. For example, the h263\n"
 697 "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
 698 "worse.\n");
 699 }
 700
 701 void show_bsfs(void)
 702 {
 703     AVBitStreamFilter *bsf=NULL;
 704
 705     printf("Bitstream filters:\n");
 706     while((bsf = av_bitstream_filter_next(bsf)))
 707         printf("%s\n", bsf->name);
 708     printf("\n");
 709 }
 710
 711 void show_protocols(void)
 712 {
 713     void *opaque = NULL;
 714     const char *name;
 715
 716     printf("Supported file protocols:\n"
 717            "Input:\n");
 718     while ((name = avio_enum_protocols(&opaque, 0)))
 719         printf("%s\n", name);
 720     printf("Output:\n");
 721     while ((name = avio_enum_protocols(&opaque, 1)))
 722         printf("%s\n", name);
 723 }
 724
 725 void show_filters(void)
 726 {
 727     AVFilter av_unused(**filter) = NULL;
 728
 729     printf("Filters:\n");
 730 #if CONFIG_AVFILTER
 731     while ((filter = av_filter_next(filter)) && *filter)
 732         printf("%-16s %s\n", (*filter)->name, (*filter)->description);
 733 #endif
 734 }
 735
 736 void show_pix_fmts(void)
 737 {
 738     enum PixelFormat pix_fmt;
 739
 740     printf(
 741         "Pixel formats:\n"
 742         "I.... = Supported Input  format for conversion\n"
 743         ".O... = Supported Output format for conversion\n"
 744         "..H.. = Hardware accelerated format\n"
 745         "...P. = Paletted format\n"
 746         "....B = Bitstream format\n"
 747         "FLAGS NAME            NB_COMPONENTS BITS_PER_PIXEL\n"
 748         "-----\n");
 749
 750 #if !CONFIG_SWSCALE
 751 #   define sws_isSupportedInput(x)  0
 752 #   define sws_isSupportedOutput(x) 0
 753 #endif
 754
 755     for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {
 756         const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[pix_fmt];
 757         printf("%c%c%c%c%c %-16s       %d            %2d\n",
 758                sws_isSupportedInput (pix_fmt)      ? 'I' : '.',
 759                sws_isSupportedOutput(pix_fmt)      ? 'O' : '.',
 760                pix_desc->flags & PIX_FMT_HWACCEL   ? 'H' : '.',
 761                pix_desc->flags & PIX_FMT_PAL       ? 'P' : '.',
 762                pix_desc->flags & PIX_FMT_BITSTREAM ? 'B' : '.',
 763                pix_desc->name,
 764                pix_desc->nb_components,
 765                av_get_bits_per_pixel(pix_desc));
 766     }
 767 }
 768
 769 int show_sample_fmts(const char *opt, const char *arg)
 770 {
 771     int i;
 772     char fmt_str[128];
 773     for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
 774         printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
 775     return 0;
 776 }
 777
 778 int read_yesno(void)
 779 {
 780     int c = getchar();
 781     int yesno = (toupper(c) == 'Y');
 782
 783     while (c != '\n' && c != EOF)
 784         c = getchar();
 785
 786     return yesno;
 787 }
 788
 789 int cmdutils_read_file(const char *filename, char **bufptr, size_t *size)
 790 {
 791     int ret;
 792     FILE *f = fopen(filename, "rb");
 793
 794     if (!f) {
 795         av_log(NULL, AV_LOG_ERROR, "Cannot read file '%s': %s\n", filename, strerror(errno));
 796         return AVERROR(errno);
 797     }
 798     fseek(f, 0, SEEK_END);
 799     *size = ftell(f);
 800     fseek(f, 0, SEEK_SET);
 801     *bufptr = av_malloc(*size + 1);
 802     if (!*bufptr) {
 803         av_log(NULL, AV_LOG_ERROR, "Could not allocate file buffer\n");
 804         fclose(f);
 805         return AVERROR(ENOMEM);
 806     }
 807     ret = fread(*bufptr, 1, *size, f);
 808     if (ret < *size) {
 809         av_free(*bufptr);
 810         if (ferror(f)) {
 811             av_log(NULL, AV_LOG_ERROR, "Error while reading file '%s': %s\n",
 812                    filename, strerror(errno));
 813             ret = AVERROR(errno);
 814         } else
 815             ret = AVERROR_EOF;
 816     } else {
 817         ret = 0;
 818         (*bufptr)[*size++] = '\0';
 819     }
 820
 821     fclose(f);
 822     return ret;
 823 }
 824
 825 void init_pts_correction(PtsCorrectionContext *ctx)
 826 {
 827     ctx->num_faulty_pts = ctx->num_faulty_dts = 0;
 828     ctx->last_pts = ctx->last_dts = INT64_MIN;
 829 }
 830
 831 int64_t guess_correct_pts(PtsCorrectionContext *ctx, int64_t reordered_pts, int64_t dts)
 832 {
 833     int64_t pts = AV_NOPTS_VALUE;
 834
 835     if (dts != AV_NOPTS_VALUE) {
 836         ctx->num_faulty_dts += dts <= ctx->last_dts;
 837         ctx->last_dts = dts;
 838     }
 839     if (reordered_pts != AV_NOPTS_VALUE) {
 840         ctx->num_faulty_pts += reordered_pts <= ctx->last_pts;
 841         ctx->last_pts = reordered_pts;
 842     }
 843     if ((ctx->num_faulty_pts<=ctx->num_faulty_dts || dts == AV_NOPTS_VALUE)
 844        && reordered_pts != AV_NOPTS_VALUE)
 845         pts = reordered_pts;
 846     else
 847         pts = dts;
 848
 849     return pts;
 850 }
 851
 852 FILE *get_preset_file(char *filename, size_t filename_size,
 853                       const char *preset_name, int is_path, const char *codec_name)
 854 {
 855     FILE *f = NULL;
 856     int i;
 857     const char *base[3]= { getenv("AVCONV_DATADIR"),
 858                            getenv("HOME"),
 859                            AVCONV_DATADIR,
 860                          };
 861
 862     if (is_path) {
 863         av_strlcpy(filename, preset_name, filename_size);
 864         f = fopen(filename, "r");
 865     } else {
 866         for (i = 0; i < 3 && !f; i++) {
 867             if (!base[i])
 868                 continue;
 869             snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.avconv", preset_name);
 870             f = fopen(filename, "r");
 871             if (!f && codec_name) {
 872                 snprintf(filename, filename_size,
 873                          "%s%s/%s-%s.ffpreset", base[i],  i != 1 ? "" : "/.avconv", codec_name, preset_name);
 874                 f = fopen(filename, "r");
 875             }
 876         }
 877     }
 878
 879     return f;
 880 }
 881
 882 int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
 883 {
 884     if (*spec <= '9' && *spec >= '0')                                        /* opt:index */
 885         return strtol(spec, NULL, 0) == st->index;
 886     else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' || *spec == 't') { /* opt:[vasdt] */
 887         enum AVMediaType type;
 888
 889         switch (*spec++) {
 890         case 'v': type = AVMEDIA_TYPE_VIDEO;    break;
 891         case 'a': type = AVMEDIA_TYPE_AUDIO;    break;
 892         case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
 893         case 'd': type = AVMEDIA_TYPE_DATA;     break;
 894         case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
 895         }
 896         if (type != st->codec->codec_type)
 897             return 0;
 898         if (*spec++ == ':') {                                   /* possibly followed by :index */
 899             int i, index = strtol(spec, NULL, 0);
 900             for (i = 0; i < s->nb_streams; i++)
 901                 if (s->streams[i]->codec->codec_type == type && index-- == 0)
 902                    return i == st->index;
 903             return 0;
 904         }
 905         return 1;
 906     } else if (*spec == 'p' && *(spec + 1) == ':') {
 907         int prog_id, i, j;
 908         char *endptr;
 909         spec += 2;
 910         prog_id = strtol(spec, &endptr, 0);
 911         for (i = 0; i < s->nb_programs; i++) {
 912             if (s->programs[i]->id != prog_id)
 913                 continue;
 914
 915             if (*endptr++ == ':') {
 916                 int stream_idx = strtol(endptr, NULL, 0);
 917                 return (stream_idx >= 0 && stream_idx < s->programs[i]->nb_stream_indexes &&
 918                         st->index == s->programs[i]->stream_index[stream_idx]);
 919             }
 920
 921             for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
 922                 if (st->index == s->programs[i]->stream_index[j])
 923                     return 1;
 924         }
 925         return 0;
 926     } else if (!*spec) /* empty specifier, matches everything */
 927         return 1;
 928
 929     av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
 930     return AVERROR(EINVAL);
 931 }
 932
 933 AVDictionary *filter_codec_opts(AVDictionary *opts, enum CodecID codec_id, AVFormatContext *s, AVStream *st)
 934 {
 935     AVDictionary    *ret = NULL;
 936     AVDictionaryEntry *t = NULL;
 937     AVCodec       *codec = s->oformat ? avcodec_find_encoder(codec_id) : avcodec_find_decoder(codec_id);
 938     int            flags = s->oformat ? AV_OPT_FLAG_ENCODING_PARAM : AV_OPT_FLAG_DECODING_PARAM;
 939     char          prefix = 0;
 940     const AVClass    *cc = avcodec_get_class();
 941
 942     if (!codec)
 943         return NULL;
 944
 945     switch (codec->type) {
 946     case AVMEDIA_TYPE_VIDEO:    prefix = 'v'; flags |= AV_OPT_FLAG_VIDEO_PARAM;    break;
 947     case AVMEDIA_TYPE_AUDIO:    prefix = 'a'; flags |= AV_OPT_FLAG_AUDIO_PARAM;    break;
 948     case AVMEDIA_TYPE_SUBTITLE: prefix = 's'; flags |= AV_OPT_FLAG_SUBTITLE_PARAM; break;
 949     }
 950
 951     while (t = av_dict_get(opts, "", t, AV_DICT_IGNORE_SUFFIX)) {
 952         char *p = strchr(t->key, ':');
 953
 954         /* check stream specification in opt name */
 955         if (p)
 956             switch (check_stream_specifier(s, st, p + 1)) {
 957             case  1: *p = 0; break;
 958             case  0:         continue;
 959             default:         return NULL;
 960             }
 961
 962         if (av_opt_find(&cc, t->key, NULL, flags, AV_OPT_SEARCH_FAKE_OBJ) ||
 963             (codec && codec->priv_class && av_opt_find(&codec->priv_class, t->key, NULL, flags, AV_OPT_SEARCH_FAKE_OBJ)))
 964             av_dict_set(&ret, t->key, t->value, 0);
 965         else if (t->key[0] == prefix && av_opt_find(&cc, t->key+1, NULL, flags, AV_OPT_SEARCH_FAKE_OBJ))
 966             av_dict_set(&ret, t->key+1, t->value, 0);
 967
 968         if (p)
 969             *p = ':';
 970     }
 971     return ret;
 972 }
 973
 974 AVDictionary **setup_find_stream_info_opts(AVFormatContext *s, AVDictionary *codec_opts)
 975 {
 976     int i;
 977     AVDictionary **opts;
 978
 979     if (!s->nb_streams)
 980         return NULL;
 981     opts = av_mallocz(s->nb_streams * sizeof(*opts));
 982     if (!opts) {
 983         av_log(NULL, AV_LOG_ERROR, "Could not alloc memory for stream options.\n");
 984         return NULL;
 985     }
 986     for (i = 0; i < s->nb_streams; i++)
 987         opts[i] = filter_codec_opts(codec_opts, s->streams[i]->codec->codec_id, s, s->streams[i]);
 988     return opts;
 989 }
 990
 991 #if CONFIG_AVFILTER
 992
 993 static int ffsink_init(AVFilterContext *ctx, const char *args, void *opaque)
 994 {
 995     FFSinkContext *priv = ctx->priv;
 996
 997     if (!opaque)
 998         return AVERROR(EINVAL);
 999     *priv = *(FFSinkContext *)opaque;
1000
1001     return 0;
1002 }
1003
1004 static void null_end_frame(AVFilterLink *inlink) { }
1005
1006 static int ffsink_query_formats(AVFilterContext *ctx)
1007 {
1008     FFSinkContext *priv = ctx->priv;
1009     enum PixelFormat pix_fmts[] = { priv->pix_fmt, PIX_FMT_NONE };
1010
1011     avfilter_set_common_formats(ctx, avfilter_make_format_list(pix_fmts));
1012     return 0;
1013 }
1014
1015 AVFilter ffsink = {
1016     .name      = "ffsink",
1017     .priv_size = sizeof(FFSinkContext),
1018     .init      = ffsink_init,
1019
1020     .query_formats = ffsink_query_formats,
1021
1022     .inputs    = (AVFilterPad[]) {{ .name          = "default",
1023                                     .type          = AVMEDIA_TYPE_VIDEO,
1024                                     .end_frame     = null_end_frame,
1025                                     .min_perms     = AV_PERM_READ, },
1026                                   { .name = NULL }},
1027     .outputs   = (AVFilterPad[]) {{ .name = NULL }},
1028 };
1029
1030 int get_filtered_video_frame(AVFilterContext *ctx, AVFrame *frame,
1031                              AVFilterBufferRef **picref_ptr, AVRational *tb)
1032 {
1033     int ret;
1034     AVFilterBufferRef *picref;
1035
1036     if ((ret = avfilter_request_frame(ctx->inputs[0])) < 0)
1037         return ret;
1038     if (!(picref = ctx->inputs[0]->cur_buf))
1039         return AVERROR(ENOENT);
1040     *picref_ptr = picref;
1041     ctx->inputs[0]->cur_buf = NULL;
1042     *tb = ctx->inputs[0]->time_base;
1043
1044     memcpy(frame->data,     picref->data,     sizeof(frame->data));
1045     memcpy(frame->linesize, picref->linesize, sizeof(frame->linesize));
1046     frame->interlaced_frame = picref->video->interlaced;
1047     frame->top_field_first  = picref->video->top_field_first;
1048     frame->key_frame        = picref->video->key_frame;
1049     frame->pict_type        = picref->video->pict_type;
1050     frame->sample_aspect_ratio = picref->video->pixel_aspect;
1051
1052     return 1;
1053 }
1054
1055 #endif /* CONFIG_AVFILTER */
1056
1057 void *grow_array(void *array, int elem_size, int *size, int new_size)
1058 {
1059     if (new_size >= INT_MAX / elem_size) {
1060         av_log(NULL, AV_LOG_ERROR, "Array too big.\n");
1061         exit_program(1);
1062     }
1063     if (*size < new_size) {
1064         uint8_t *tmp = av_realloc(array, new_size*elem_size);
1065         if (!tmp) {
1066             av_log(NULL, AV_LOG_ERROR, "Could not alloc buffer.\n");
1067             exit_program(1);
1068         }
1069         memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
1070         *size = new_size;
1071         return tmp;
1072     }
1073     return array;
1074 }