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