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/opt.h"
  42 #include "cmdutils.h"
  43 #include "version.h"
  44 #if CONFIG_NETWORK
  45 #include "libavformat/network.h"
  46 #endif
  47 #if HAVE_SYS_RESOURCE_H
  48 #include <sys/resource.h>
  49 #endif
  50
  51 const char **opt_names;
  52 const char **opt_values;
  53 static int opt_name_count;
  54 AVCodecContext *avcodec_opts[AVMEDIA_TYPE_NB];
  55 AVFormatContext *avformat_opts;
  56 struct SwsContext *sws_opts;
  57
  58 static const int this_year = 2011;
  59
  60 void init_opts(void)
  61 {
  62     int i;
  63     for (i = 0; i < AVMEDIA_TYPE_NB; i++)
  64         avcodec_opts[i] = avcodec_alloc_context2(i);
  65     avformat_opts = avformat_alloc_context();
  66 #if CONFIG_SWSCALE
  67     sws_opts = sws_getContext(16, 16, 0, 16, 16, 0, SWS_BICUBIC, NULL, NULL, NULL);
  68 #endif
  69 }
  70
  71 void uninit_opts(void)
  72 {
  73     int i;
  74     for (i = 0; i < AVMEDIA_TYPE_NB; i++)
  75         av_freep(&avcodec_opts[i]);
  76     av_freep(&avformat_opts->key);
  77     av_freep(&avformat_opts);
  78 #if CONFIG_SWSCALE
  79     av_freep(&sws_opts);
  80 #endif
  81     for (i = 0; i < opt_name_count; i++) {
  82         //opt_values are only stored for codec-specific options in which case
  83         //both the name and value are dup'd
  84         if (opt_values[i]) {
  85             av_freep(&opt_names[i]);
  86             av_freep(&opt_values[i]);
  87         }
  88     }
  89     av_freep(&opt_names);
  90     av_freep(&opt_values);
  91     opt_name_count = 0;
  92 }
  93
  94 void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
  95 {
  96     vfprintf(stdout, fmt, vl);
  97 }
  98
  99 double parse_number_or_die(const char *context, const char *numstr, int type, double min, double max)
 100 {
 101     char *tail;
 102     const char *error;
 103     double d = av_strtod(numstr, &tail);
 104     if (*tail)
 105         error= "Expected number for %s but found: %s\n";
 106     else if (d < min || d > max)
 107         error= "The value for %s was %s which is not within %f - %f\n";
 108     else if(type == OPT_INT64 && (int64_t)d != d)
 109         error= "Expected int64 for %s but found %s\n";
 110     else if (type == OPT_INT && (int)d != d)
 111         error= "Expected int for %s but found %s\n";
 112     else
 113         return d;
 114     fprintf(stderr, error, context, numstr, min, max);
 115     exit(1);
 116 }
 117
 118 int64_t parse_time_or_die(const char *context, const char *timestr, int is_duration)
 119 {
 120     int64_t us;
 121     if (av_parse_time(&us, timestr, is_duration) < 0) {
 122         fprintf(stderr, "Invalid %s specification for %s: %s\n",
 123                 is_duration ? "duration" : "date", context, timestr);
 124         exit(1);
 125     }
 126     return us;
 127 }
 128
 129 void show_help_options(const OptionDef *options, const char *msg, int mask, int value)
 130 {
 131     const OptionDef *po;
 132     int first;
 133
 134     first = 1;
 135     for(po = options; po->name != NULL; po++) {
 136         char buf[64];
 137         if ((po->flags & mask) == value) {
 138             if (first) {
 139                 printf("%s", msg);
 140                 first = 0;
 141             }
 142             av_strlcpy(buf, po->name, sizeof(buf));
 143             if (po->flags & HAS_ARG) {
 144                 av_strlcat(buf, " ", sizeof(buf));
 145                 av_strlcat(buf, po->argname, sizeof(buf));
 146             }
 147             printf("-%-17s  %s\n", buf, po->help);
 148         }
 149     }
 150 }
 151
 152 static const OptionDef* find_option(const OptionDef *po, const char *name){
 153     while (po->name != NULL) {
 154         if (!strcmp(name, po->name))
 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 void parse_options(int argc, char **argv, const OptionDef *options,
 223                    void (* parse_arg_function)(const char*))
 224 {
 225     const char *opt, *arg;
 226     int optindex, handleoptions=1;
 227     const OptionDef *po;
 228
 229     /* perform system-dependent conversions for arguments list */
 230     prepare_app_arguments(&argc, &argv);
 231
 232     /* parse options */
 233     optindex = 1;
 234     while (optindex < argc) {
 235         opt = argv[optindex++];
 236
 237         if (handleoptions && opt[0] == '-' && opt[1] != '\0') {
 238             int bool_val = 1;
 239             if (opt[1] == '-' && opt[2] == '\0') {
 240                 handleoptions = 0;
 241                 continue;
 242             }
 243             opt++;
 244             po= find_option(options, opt);
 245             if (!po->name && opt[0] == 'n' && opt[1] == 'o') {
 246                 /* handle 'no' bool option */
 247                 po = find_option(options, opt + 2);
 248                 if (!(po->name && (po->flags & OPT_BOOL)))
 249                     goto unknown_opt;
 250                 bool_val = 0;
 251             }
 252             if (!po->name)
 253                 po= find_option(options, "default");
 254             if (!po->name) {
 255 unknown_opt:
 256                 fprintf(stderr, "%s: unrecognized option '%s'\n", argv[0], opt);
 257                 exit(1);
 258             }
 259             arg = NULL;
 260             if (po->flags & HAS_ARG) {
 261                 arg = argv[optindex++];
 262                 if (!arg) {
 263                     fprintf(stderr, "%s: missing argument for option '%s'\n", argv[0], opt);
 264                     exit(1);
 265                 }
 266             }
 267             if (po->flags & OPT_STRING) {
 268                 char *str;
 269                 str = av_strdup(arg);
 270                 *po->u.str_arg = str;
 271             } else if (po->flags & OPT_BOOL) {
 272                 *po->u.int_arg = bool_val;
 273             } else if (po->flags & OPT_INT) {
 274                 *po->u.int_arg = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
 275             } else if (po->flags & OPT_INT64) {
 276                 *po->u.int64_arg = parse_number_or_die(opt, arg, OPT_INT64, INT64_MIN, INT64_MAX);
 277             } else if (po->flags & OPT_FLOAT) {
 278                 *po->u.float_arg = parse_number_or_die(opt, arg, OPT_FLOAT, -INFINITY, INFINITY);
 279             } else if (po->flags & OPT_FUNC2) {
 280                 if (po->u.func2_arg(opt, arg) < 0) {
 281                     fprintf(stderr, "%s: failed to set value '%s' for option '%s'\n", argv[0], arg, opt);
 282                     exit(1);
 283                 }
 284             } else if (po->u.func_arg) {
 285                     po->u.func_arg(arg);
 286             }
 287             if(po->flags & OPT_EXIT)
 288                 exit(0);
 289         } else {
 290             if (parse_arg_function)
 291                 parse_arg_function(opt);
 292         }
 293     }
 294 }
 295
 296 int opt_default(const char *opt, const char *arg){
 297     int type;
 298     int ret= 0;
 299     const AVOption *o= NULL;
 300     int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
 301
 302     for(type=0; *avcodec_opts && type<AVMEDIA_TYPE_NB && ret>= 0; type++){
 303         const AVOption *o2 = av_find_opt(avcodec_opts[0], opt, NULL, opt_types[type], opt_types[type]);
 304         if(o2)
 305             ret = av_set_string3(avcodec_opts[type], opt, arg, 1, &o);
 306     }
 307     if(!o && avformat_opts)
 308         ret = av_set_string3(avformat_opts, opt, arg, 1, &o);
 309     if(!o && sws_opts)
 310         ret = av_set_string3(sws_opts, opt, arg, 1, &o);
 311     if(!o){
 312         if (opt[0] == 'a' && avcodec_opts[AVMEDIA_TYPE_AUDIO])
 313             ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_AUDIO], opt+1, arg, 1, &o);
 314         else if(opt[0] == 'v' && avcodec_opts[AVMEDIA_TYPE_VIDEO])
 315             ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_VIDEO], opt+1, arg, 1, &o);
 316         else if(opt[0] == 's' && avcodec_opts[AVMEDIA_TYPE_SUBTITLE])
 317             ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], opt+1, arg, 1, &o);
 318     }
 319     if (o && ret < 0) {
 320         fprintf(stderr, "Invalid value '%s' for option '%s'\n", arg, opt);
 321         exit(1);
 322     }
 323     if (!o) {
 324         AVCodec *p = NULL;
 325         AVOutputFormat *oformat = NULL;
 326         while ((p=av_codec_next(p))){
 327             AVClass *c= p->priv_class;
 328             if(c && av_find_opt(&c, opt, NULL, 0, 0))
 329                 break;
 330         }
 331         if (!p) {
 332             while ((oformat = av_oformat_next(oformat))) {
 333                 const AVClass *c = oformat->priv_class;
 334                 if (c && av_find_opt(&c, opt, NULL, 0, 0))
 335                     break;
 336             }
 337         }
 338         if(!p && !oformat){
 339             fprintf(stderr, "Unrecognized option '%s'\n", opt);
 340             exit(1);
 341         }
 342     }
 343
 344 //    av_log(NULL, AV_LOG_ERROR, "%s:%s: %f 0x%0X\n", opt, arg, av_get_double(avcodec_opts, opt, NULL), (int)av_get_int(avcodec_opts, opt, NULL));
 345
 346     //FIXME we should always use avcodec_opts, ... for storing options so there will not be any need to keep track of what i set over this
 347     opt_values= av_realloc(opt_values, sizeof(void*)*(opt_name_count+1));
 348     opt_values[opt_name_count]= o ? NULL : av_strdup(arg);
 349     opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
 350     opt_names[opt_name_count++]= o ? o->name : av_strdup(opt);
 351
 352     if ((*avcodec_opts && avcodec_opts[0]->debug) || (avformat_opts && avformat_opts->debug))
 353         av_log_set_level(AV_LOG_DEBUG);
 354     return 0;
 355 }
 356
 357 int opt_loglevel(const char *opt, const char *arg)
 358 {
 359     const struct { const char *name; int level; } log_levels[] = {
 360         { "quiet"  , AV_LOG_QUIET   },
 361         { "panic"  , AV_LOG_PANIC   },
 362         { "fatal"  , AV_LOG_FATAL   },
 363         { "error"  , AV_LOG_ERROR   },
 364         { "warning", AV_LOG_WARNING },
 365         { "info"   , AV_LOG_INFO    },
 366         { "verbose", AV_LOG_VERBOSE },
 367         { "debug"  , AV_LOG_DEBUG   },
 368     };
 369     char *tail;
 370     int level;
 371     int i;
 372
 373     for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
 374         if (!strcmp(log_levels[i].name, arg)) {
 375             av_log_set_level(log_levels[i].level);
 376             return 0;
 377         }
 378     }
 379
 380     level = strtol(arg, &tail, 10);
 381     if (*tail) {
 382         fprintf(stderr, "Invalid loglevel \"%s\". "
 383                         "Possible levels are numbers or:\n", arg);
 384         for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
 385             fprintf(stderr, "\"%s\"\n", log_levels[i].name);
 386         exit(1);
 387     }
 388     av_log_set_level(level);
 389     return 0;
 390 }
 391
 392 int opt_timelimit(const char *opt, const char *arg)
 393 {
 394 #if HAVE_SETRLIMIT
 395     int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
 396     struct rlimit rl = { lim, lim + 1 };
 397     if (setrlimit(RLIMIT_CPU, &rl))
 398         perror("setrlimit");
 399 #else
 400     fprintf(stderr, "Warning: -%s not implemented on this OS\n", opt);
 401 #endif
 402     return 0;
 403 }
 404
 405 void set_context_opts(void *ctx, void *opts_ctx, int flags, AVCodec *codec)
 406 {
 407     int i;
 408     void *priv_ctx=NULL;
 409     if(!strcmp("AVCodecContext", (*(AVClass**)ctx)->class_name)){
 410         AVCodecContext *avctx= ctx;
 411         if(codec && codec->priv_class && avctx->priv_data){
 412             priv_ctx= avctx->priv_data;
 413         }
 414     } else if (!strcmp("AVFormatContext", (*(AVClass**)ctx)->class_name)) {
 415         AVFormatContext *avctx = ctx;
 416         if (avctx->oformat && avctx->oformat->priv_class) {
 417             priv_ctx = avctx->priv_data;
 418         }
 419     }
 420
 421     for(i=0; i<opt_name_count; i++){
 422         char buf[256];
 423         const AVOption *opt;
 424         const char *str= av_get_string(opts_ctx, opt_names[i], &opt, buf, sizeof(buf));
 425         /* if an option with name opt_names[i] is present in opts_ctx then str is non-NULL */
 426         if(str && ((opt->flags & flags) == flags))
 427             av_set_string3(ctx, opt_names[i], str, 1, NULL);
 428         /* We need to use a differnt system to pass options to the private context because
 429            it is not known which codec and thus context kind that will be when parsing options
 430            we thus use opt_values directly instead of opts_ctx */
 431         if(!str && priv_ctx && av_get_string(priv_ctx, opt_names[i], &opt, buf, sizeof(buf))){
 432             av_set_string3(priv_ctx, opt_names[i], opt_values[i], 1, NULL);
 433         }
 434     }
 435 }
 436
 437 void print_error(const char *filename, int err)
 438 {
 439     char errbuf[128];
 440     const char *errbuf_ptr = errbuf;
 441
 442     if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
 443         errbuf_ptr = strerror(AVUNERROR(err));
 444     fprintf(stderr, "%s: %s\n", filename, errbuf_ptr);
 445 }
 446
 447 static int warned_cfg = 0;
 448
 449 #define INDENT        1
 450 #define SHOW_VERSION  2
 451 #define SHOW_CONFIG   4
 452
 453 #define PRINT_LIB_INFO(outstream,libname,LIBNAME,flags)                 \
 454     if (CONFIG_##LIBNAME) {                                             \
 455         const char *indent = flags & INDENT? "  " : "";                 \
 456         if (flags & SHOW_VERSION) {                                     \
 457             unsigned int version = libname##_version();                 \
 458             fprintf(outstream, "%slib%-9s %2d.%3d.%2d / %2d.%3d.%2d\n", \
 459                     indent, #libname,                                   \
 460                     LIB##LIBNAME##_VERSION_MAJOR,                       \
 461                     LIB##LIBNAME##_VERSION_MINOR,                       \
 462                     LIB##LIBNAME##_VERSION_MICRO,                       \
 463                     version >> 16, version >> 8 & 0xff, version & 0xff); \
 464         }                                                               \
 465         if (flags & SHOW_CONFIG) {                                      \
 466             const char *cfg = libname##_configuration();                \
 467             if (strcmp(LIBAV_CONFIGURATION, cfg)) {                     \
 468                 if (!warned_cfg) {                                      \
 469                     fprintf(outstream,                                  \
 470                             "%sWARNING: library configuration mismatch\n", \
 471                             indent);                                    \
 472                     warned_cfg = 1;                                     \
 473                 }                                                       \
 474                 fprintf(stderr, "%s%-11s configuration: %s\n",          \
 475                         indent, #libname, cfg);                         \
 476             }                                                           \
 477         }                                                               \
 478     }                                                                   \
 479
 480 static void print_all_libs_info(FILE* outstream, int flags)
 481 {
 482     PRINT_LIB_INFO(outstream, avutil,   AVUTIL,   flags);
 483     PRINT_LIB_INFO(outstream, avcodec,  AVCODEC,  flags);
 484     PRINT_LIB_INFO(outstream, avformat, AVFORMAT, flags);
 485     PRINT_LIB_INFO(outstream, avdevice, AVDEVICE, flags);
 486     PRINT_LIB_INFO(outstream, avfilter, AVFILTER, flags);
 487     PRINT_LIB_INFO(outstream, swscale,  SWSCALE,  flags);
 488     PRINT_LIB_INFO(outstream, postproc, POSTPROC, flags);
 489 }
 490
 491 void show_banner(void)
 492 {
 493     fprintf(stderr, "%s version " LIBAV_VERSION ", Copyright (c) %d-%d the Libav developers\n",
 494             program_name, program_birth_year, this_year);
 495     fprintf(stderr, "  built on %s %s with %s %s\n",
 496             __DATE__, __TIME__, CC_TYPE, CC_VERSION);
 497     fprintf(stderr, "  configuration: " LIBAV_CONFIGURATION "\n");
 498     print_all_libs_info(stderr, INDENT|SHOW_CONFIG);
 499     print_all_libs_info(stderr, INDENT|SHOW_VERSION);
 500 }
 501
 502 void show_version(void) {
 503     printf("%s " LIBAV_VERSION "\n", program_name);
 504     print_all_libs_info(stdout, SHOW_VERSION);
 505 }
 506
 507 void show_license(void)
 508 {
 509     printf(
 510 #if CONFIG_NONFREE
 511     "This version of %s has nonfree parts compiled in.\n"
 512     "Therefore it is not legally redistributable.\n",
 513     program_name
 514 #elif CONFIG_GPLV3
 515     "%s is free software; you can redistribute it and/or modify\n"
 516     "it under the terms of the GNU General Public License as published by\n"
 517     "the Free Software Foundation; either version 3 of the License, or\n"
 518     "(at your option) any later version.\n"
 519     "\n"
 520     "%s is distributed in the hope that it will be useful,\n"
 521     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 522     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
 523     "GNU General Public License for more details.\n"
 524     "\n"
 525     "You should have received a copy of the GNU General Public License\n"
 526     "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
 527     program_name, program_name, program_name
 528 #elif CONFIG_GPL
 529     "%s is free software; you can redistribute it and/or modify\n"
 530     "it under the terms of the GNU General Public License as published by\n"
 531     "the Free Software Foundation; either version 2 of the License, or\n"
 532     "(at your option) any later version.\n"
 533     "\n"
 534     "%s is distributed in the hope that it will be useful,\n"
 535     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 536     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
 537     "GNU General Public License for more details.\n"
 538     "\n"
 539     "You should have received a copy of the GNU General Public License\n"
 540     "along with %s; if not, write to the Free Software\n"
 541     "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
 542     program_name, program_name, program_name
 543 #elif CONFIG_LGPLV3
 544     "%s is free software; you can redistribute it and/or modify\n"
 545     "it under the terms of the GNU Lesser General Public License as published by\n"
 546     "the Free Software Foundation; either version 3 of the License, or\n"
 547     "(at your option) any later version.\n"
 548     "\n"
 549     "%s is distributed in the hope that it will be useful,\n"
 550     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 551     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
 552     "GNU Lesser General Public License for more details.\n"
 553     "\n"
 554     "You should have received a copy of the GNU Lesser General Public License\n"
 555     "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
 556     program_name, program_name, program_name
 557 #else
 558     "%s is free software; you can redistribute it and/or\n"
 559     "modify it under the terms of the GNU Lesser General Public\n"
 560     "License as published by the Free Software Foundation; either\n"
 561     "version 2.1 of the License, or (at your option) any later version.\n"
 562     "\n"
 563     "%s is distributed in the hope that it will be useful,\n"
 564     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 565     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
 566     "Lesser General Public License for more details.\n"
 567     "\n"
 568     "You should have received a copy of the GNU Lesser General Public\n"
 569     "License along with %s; if not, write to the Free Software\n"
 570     "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
 571     program_name, program_name, program_name
 572 #endif
 573     );
 574 }
 575
 576 void show_formats(void)
 577 {
 578     AVInputFormat *ifmt=NULL;
 579     AVOutputFormat *ofmt=NULL;
 580     const char *last_name;
 581
 582     printf(
 583         "File formats:\n"
 584         " D. = Demuxing supported\n"
 585         " .E = Muxing supported\n"
 586         " --\n");
 587     last_name= "000";
 588     for(;;){
 589         int decode=0;
 590         int encode=0;
 591         const char *name=NULL;
 592         const char *long_name=NULL;
 593
 594         while((ofmt= av_oformat_next(ofmt))) {
 595             if((name == NULL || strcmp(ofmt->name, name)<0) &&
 596                 strcmp(ofmt->name, last_name)>0){
 597                 name= ofmt->name;
 598                 long_name= ofmt->long_name;
 599                 encode=1;
 600             }
 601         }
 602         while((ifmt= av_iformat_next(ifmt))) {
 603             if((name == NULL || strcmp(ifmt->name, name)<0) &&
 604                 strcmp(ifmt->name, last_name)>0){
 605                 name= ifmt->name;
 606                 long_name= ifmt->long_name;
 607                 encode=0;
 608             }
 609             if(name && strcmp(ifmt->name, name)==0)
 610                 decode=1;
 611         }
 612         if(name==NULL)
 613             break;
 614         last_name= name;
 615
 616         printf(
 617             " %s%s %-15s %s\n",
 618             decode ? "D":" ",
 619             encode ? "E":" ",
 620             name,
 621             long_name ? long_name:" ");
 622     }
 623 }
 624
 625 void show_codecs(void)
 626 {
 627     AVCodec *p=NULL, *p2;
 628     const char *last_name;
 629     printf(
 630         "Codecs:\n"
 631         " D..... = Decoding supported\n"
 632         " .E.... = Encoding supported\n"
 633         " ..V... = Video codec\n"
 634         " ..A... = Audio codec\n"
 635         " ..S... = Subtitle codec\n"
 636         " ...S.. = Supports draw_horiz_band\n"
 637         " ....D. = Supports direct rendering method 1\n"
 638         " .....T = Supports weird frame truncation\n"
 639         " ------\n");
 640     last_name= "000";
 641     for(;;){
 642         int decode=0;
 643         int encode=0;
 644         int cap=0;
 645         const char *type_str;
 646
 647         p2=NULL;
 648         while((p= av_codec_next(p))) {
 649             if((p2==NULL || strcmp(p->name, p2->name)<0) &&
 650                 strcmp(p->name, last_name)>0){
 651                 p2= p;
 652                 decode= encode= cap=0;
 653             }
 654             if(p2 && strcmp(p->name, p2->name)==0){
 655                 if(p->decode) decode=1;
 656                 if(p->encode) encode=1;
 657                 cap |= p->capabilities;
 658             }
 659         }
 660         if(p2==NULL)
 661             break;
 662         last_name= p2->name;
 663
 664         switch(p2->type) {
 665         case AVMEDIA_TYPE_VIDEO:
 666             type_str = "V";
 667             break;
 668         case AVMEDIA_TYPE_AUDIO:
 669             type_str = "A";
 670             break;
 671         case AVMEDIA_TYPE_SUBTITLE:
 672             type_str = "S";
 673             break;
 674         default:
 675             type_str = "?";
 676             break;
 677         }
 678         printf(
 679             " %s%s%s%s%s%s %-15s %s",
 680             decode ? "D": (/*p2->decoder ? "d":*/" "),
 681             encode ? "E":" ",
 682             type_str,
 683             cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
 684             cap & CODEC_CAP_DR1 ? "D":" ",
 685             cap & CODEC_CAP_TRUNCATED ? "T":" ",
 686             p2->name,
 687             p2->long_name ? p2->long_name : "");
 688        /* if(p2->decoder && decode==0)
 689             printf(" use %s for decoding", p2->decoder->name);*/
 690         printf("\n");
 691     }
 692     printf("\n");
 693     printf(
 694 "Note, the names of encoders and decoders do not always match, so there are\n"
 695 "several cases where the above table shows encoder only or decoder only entries\n"
 696 "even though both encoding and decoding are supported. For example, the h263\n"
 697 "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
 698 "worse.\n");
 699 }
 700
 701 void show_bsfs(void)
 702 {
 703     AVBitStreamFilter *bsf=NULL;
 704
 705     printf("Bitstream filters:\n");
 706     while((bsf = av_bitstream_filter_next(bsf)))
 707         printf("%s\n", bsf->name);
 708     printf("\n");
 709 }
 710
 711 void show_protocols(void)
 712 {
 713     void *opaque = NULL;
 714     const char *name;
 715
 716     printf("Supported file protocols:\n"
 717            "Input:\n");
 718     while ((name = avio_enum_protocols(&opaque, 0)))
 719         printf("%s\n", name);
 720     printf("Output:\n");
 721     while ((name = avio_enum_protocols(&opaque, 1)))
 722         printf("%s\n", name);
 723 }
 724
 725 void show_filters(void)
 726 {
 727     AVFilter av_unused(**filter) = NULL;
 728
 729     printf("Filters:\n");
 730 #if CONFIG_AVFILTER
 731     while ((filter = av_filter_next(filter)) && *filter)
 732         printf("%-16s %s\n", (*filter)->name, (*filter)->description);
 733 #endif
 734 }
 735
 736 void show_pix_fmts(void)
 737 {
 738     enum PixelFormat pix_fmt;
 739
 740     printf(
 741         "Pixel formats:\n"
 742         "I.... = Supported Input  format for conversion\n"
 743         ".O... = Supported Output format for conversion\n"
 744         "..H.. = Hardware accelerated format\n"
 745         "...P. = Paletted format\n"
 746         "....B = Bitstream format\n"
 747         "FLAGS NAME            NB_COMPONENTS BITS_PER_PIXEL\n"
 748         "-----\n");
 749
 750 #if !CONFIG_SWSCALE
 751 #   define sws_isSupportedInput(x)  0
 752 #   define sws_isSupportedOutput(x) 0
 753 #endif
 754
 755     for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {
 756         const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[pix_fmt];
 757         printf("%c%c%c%c%c %-16s       %d            %2d\n",
 758                sws_isSupportedInput (pix_fmt)      ? 'I' : '.',
 759                sws_isSupportedOutput(pix_fmt)      ? 'O' : '.',
 760                pix_desc->flags & PIX_FMT_HWACCEL   ? 'H' : '.',
 761                pix_desc->flags & PIX_FMT_PAL       ? 'P' : '.',
 762                pix_desc->flags & PIX_FMT_BITSTREAM ? 'B' : '.',
 763                pix_desc->name,
 764                pix_desc->nb_components,
 765                av_get_bits_per_pixel(pix_desc));
 766     }
 767 }
 768
 769 int read_yesno(void)
 770 {
 771     int c = getchar();
 772     int yesno = (toupper(c) == 'Y');
 773
 774     while (c != '\n' && c != EOF)
 775         c = getchar();
 776
 777     return yesno;
 778 }
 779
 780 int read_file(const char *filename, char **bufptr, size_t *size)
 781 {
 782     FILE *f = fopen(filename, "rb");
 783
 784     if (!f) {
 785         fprintf(stderr, "Cannot read file '%s': %s\n", filename, strerror(errno));
 786         return AVERROR(errno);
 787     }
 788     fseek(f, 0, SEEK_END);
 789     *size = ftell(f);
 790     fseek(f, 0, SEEK_SET);
 791     *bufptr = av_malloc(*size + 1);
 792     if (!*bufptr) {
 793         fprintf(stderr, "Could not allocate file buffer\n");
 794         fclose(f);
 795         return AVERROR(ENOMEM);
 796     }
 797     fread(*bufptr, 1, *size, f);
 798     (*bufptr)[*size++] = '\0';
 799
 800     fclose(f);
 801     return 0;
 802 }
 803
 804 void init_pts_correction(PtsCorrectionContext *ctx)
 805 {
 806     ctx->num_faulty_pts = ctx->num_faulty_dts = 0;
 807     ctx->last_pts = ctx->last_dts = INT64_MIN;
 808 }
 809
 810 int64_t guess_correct_pts(PtsCorrectionContext *ctx, int64_t reordered_pts, int64_t dts)
 811 {
 812     int64_t pts = AV_NOPTS_VALUE;
 813
 814     if (dts != AV_NOPTS_VALUE) {
 815         ctx->num_faulty_dts += dts <= ctx->last_dts;
 816         ctx->last_dts = dts;
 817     }
 818     if (reordered_pts != AV_NOPTS_VALUE) {
 819         ctx->num_faulty_pts += reordered_pts <= ctx->last_pts;
 820         ctx->last_pts = reordered_pts;
 821     }
 822     if ((ctx->num_faulty_pts<=ctx->num_faulty_dts || dts == AV_NOPTS_VALUE)
 823        && reordered_pts != AV_NOPTS_VALUE)
 824         pts = reordered_pts;
 825     else
 826         pts = dts;
 827
 828     return pts;
 829 }
 830
 831 FILE *get_preset_file(char *filename, size_t filename_size,
 832                       const char *preset_name, int is_path, const char *codec_name)
 833 {
 834     FILE *f = NULL;
 835     int i;
 836     const char *base[3]= { getenv("FFMPEG_DATADIR"),
 837                            getenv("HOME"),
 838                            FFMPEG_DATADIR,
 839                          };
 840
 841     if (is_path) {
 842         av_strlcpy(filename, preset_name, filename_size);
 843         f = fopen(filename, "r");
 844     } else {
 845         for (i = 0; i < 3 && !f; i++) {
 846             if (!base[i])
 847                 continue;
 848             snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", preset_name);
 849             f = fopen(filename, "r");
 850             if (!f && codec_name) {
 851                 snprintf(filename, filename_size,
 852                          "%s%s/%s-%s.ffpreset", base[i],  i != 1 ? "" : "/.ffmpeg", codec_name, preset_name);
 853                 f = fopen(filename, "r");
 854             }
 855         }
 856     }
 857
 858     return f;
 859 }
 860
 861 #if CONFIG_AVFILTER
 862
 863 static int ffsink_init(AVFilterContext *ctx, const char *args, void *opaque)
 864 {
 865     FFSinkContext *priv = ctx->priv;
 866
 867     if (!opaque)
 868         return AVERROR(EINVAL);
 869     *priv = *(FFSinkContext *)opaque;
 870
 871     return 0;
 872 }
 873
 874 static void null_end_frame(AVFilterLink *inlink) { }
 875
 876 static int ffsink_query_formats(AVFilterContext *ctx)
 877 {
 878     FFSinkContext *priv = ctx->priv;
 879     enum PixelFormat pix_fmts[] = { priv->pix_fmt, PIX_FMT_NONE };
 880
 881     avfilter_set_common_formats(ctx, avfilter_make_format_list(pix_fmts));
 882     return 0;
 883 }
 884
 885 AVFilter ffsink = {
 886     .name      = "ffsink",
 887     .priv_size = sizeof(FFSinkContext),
 888     .init      = ffsink_init,
 889
 890     .query_formats = ffsink_query_formats,
 891
 892     .inputs    = (AVFilterPad[]) {{ .name          = "default",
 893                                     .type          = AVMEDIA_TYPE_VIDEO,
 894                                     .end_frame     = null_end_frame,
 895                                     .min_perms     = AV_PERM_READ, },
 896                                   { .name = NULL }},
 897     .outputs   = (AVFilterPad[]) {{ .name = NULL }},
 898 };
 899
 900 int get_filtered_video_frame(AVFilterContext *ctx, AVFrame *frame,
 901                              AVFilterBufferRef **picref_ptr, AVRational *tb)
 902 {
 903     int ret;
 904     AVFilterBufferRef *picref;
 905
 906     if ((ret = avfilter_request_frame(ctx->inputs[0])) < 0)
 907         return ret;
 908     if (!(picref = ctx->inputs[0]->cur_buf))
 909         return AVERROR(ENOENT);
 910     *picref_ptr = picref;
 911     ctx->inputs[0]->cur_buf = NULL;
 912     *tb = ctx->inputs[0]->time_base;
 913
 914     memcpy(frame->data,     picref->data,     sizeof(frame->data));
 915     memcpy(frame->linesize, picref->linesize, sizeof(frame->linesize));
 916     frame->interlaced_frame = picref->video->interlaced;
 917     frame->top_field_first  = picref->video->top_field_first;
 918     frame->key_frame        = picref->video->key_frame;
 919     frame->pict_type        = picref->video->pict_type;
 920
 921     return 1;
 922 }
 923
 924 #endif /* CONFIG_AVFILTER */