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