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