cmdutils.c

   1 /*
   2  * Various utilities for command line tools
   3  * Copyright (c) 2000-2003 Fabrice Bellard
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg 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  * FFmpeg 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 FFmpeg; 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/pixdesc.h"
  39 #include "libavutil/eval.h"
  40 #include "libavcodec/opt.h"
  41 #include "libavcore/avcore.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 const int this_year = 2010;
  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     sws_opts = sws_getContext(16, 16, 0, 16, 16, 0, SWS_BICUBIC, NULL, NULL, NULL);
  67 }
  68
  69 void uninit_opts(void)
  70 {
  71     int i;
  72     for (i = 0; i < AVMEDIA_TYPE_NB; i++)
  73         av_freep(&avcodec_opts[i]);
  74     av_freep(&avformat_opts->key);
  75     av_freep(&avformat_opts);
  76     av_freep(&sws_opts);
  77 }
  78
  79 void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
  80 {
  81     vfprintf(stdout, fmt, vl);
  82 }
  83
  84 double parse_number_or_die(const char *context, const char *numstr, int type, 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
  96         return d;
  97     fprintf(stderr, error, context, numstr, min, max);
  98     exit(1);
  99 }
 100
 101 int64_t parse_time_or_die(const char *context, const char *timestr, int is_duration)
 102 {
 103     int64_t us = parse_date(timestr, is_duration);
 104     if (us == INT64_MIN) {
 105         fprintf(stderr, "Invalid %s specification for %s: %s\n",
 106                 is_duration ? "duration" : "date", context, timestr);
 107         exit(1);
 108     }
 109     return us;
 110 }
 111
 112 void show_help_options(const OptionDef *options, const char *msg, int mask, int value)
 113 {
 114     const OptionDef *po;
 115     int first;
 116
 117     first = 1;
 118     for(po = options; po->name != NULL; po++) {
 119         char buf[64];
 120         if ((po->flags & mask) == value) {
 121             if (first) {
 122                 printf("%s", msg);
 123                 first = 0;
 124             }
 125             av_strlcpy(buf, po->name, sizeof(buf));
 126             if (po->flags & HAS_ARG) {
 127                 av_strlcat(buf, " ", sizeof(buf));
 128                 av_strlcat(buf, po->argname, sizeof(buf));
 129             }
 130             printf("-%-17s  %s\n", buf, po->help);
 131         }
 132     }
 133 }
 134
 135 static const OptionDef* find_option(const OptionDef *po, const char *name){
 136     while (po->name != NULL) {
 137         if (!strcmp(name, po->name))
 138             break;
 139         po++;
 140     }
 141     return po;
 142 }
 143
 144 void parse_options(int argc, char **argv, const OptionDef *options,
 145                    void (* parse_arg_function)(const char*))
 146 {
 147     const char *opt, *arg;
 148     int optindex, handleoptions=1;
 149     const OptionDef *po;
 150
 151     /* parse options */
 152     optindex = 1;
 153     while (optindex < argc) {
 154         opt = argv[optindex++];
 155
 156         if (handleoptions && opt[0] == '-' && opt[1] != '\0') {
 157             int bool_val = 1;
 158             if (opt[1] == '-' && opt[2] == '\0') {
 159                 handleoptions = 0;
 160                 continue;
 161             }
 162             opt++;
 163             po= find_option(options, opt);
 164             if (!po->name && opt[0] == 'n' && opt[1] == 'o') {
 165                 /* handle 'no' bool option */
 166                 po = find_option(options, opt + 2);
 167                 if (!(po->name && (po->flags & OPT_BOOL)))
 168                     goto unknown_opt;
 169                 bool_val = 0;
 170             }
 171             if (!po->name)
 172                 po= find_option(options, "default");
 173             if (!po->name) {
 174 unknown_opt:
 175                 fprintf(stderr, "%s: unrecognized option '%s'\n", argv[0], opt);
 176                 exit(1);
 177             }
 178             arg = NULL;
 179             if (po->flags & HAS_ARG) {
 180                 arg = argv[optindex++];
 181                 if (!arg) {
 182                     fprintf(stderr, "%s: missing argument for option '%s'\n", argv[0], opt);
 183                     exit(1);
 184                 }
 185             }
 186             if (po->flags & OPT_STRING) {
 187                 char *str;
 188                 str = av_strdup(arg);
 189                 *po->u.str_arg = str;
 190             } else if (po->flags & OPT_BOOL) {
 191                 *po->u.int_arg = bool_val;
 192             } else if (po->flags & OPT_INT) {
 193                 *po->u.int_arg = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
 194             } else if (po->flags & OPT_INT64) {
 195                 *po->u.int64_arg = parse_number_or_die(opt, arg, OPT_INT64, INT64_MIN, INT64_MAX);
 196             } else if (po->flags & OPT_FLOAT) {
 197                 *po->u.float_arg = parse_number_or_die(opt, arg, OPT_FLOAT, -1.0/0.0, 1.0/0.0);
 198             } else if (po->flags & OPT_FUNC2) {
 199                 if (po->u.func2_arg(opt, arg) < 0) {
 200                     fprintf(stderr, "%s: failed to set value '%s' for option '%s'\n", argv[0], arg, opt);
 201                     exit(1);
 202                 }
 203             } else {
 204                 po->u.func_arg(arg);
 205             }
 206             if(po->flags & OPT_EXIT)
 207                 exit(0);
 208         } else {
 209             if (parse_arg_function)
 210                 parse_arg_function(opt);
 211         }
 212     }
 213 }
 214
 215 int opt_default(const char *opt, const char *arg){
 216     int type;
 217     int ret= 0;
 218     const AVOption *o= NULL;
 219     int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
 220
 221     for(type=0; *avcodec_opts && type<AVMEDIA_TYPE_NB && ret>= 0; type++){
 222         const AVOption *o2 = av_find_opt(avcodec_opts[0], opt, NULL, opt_types[type], opt_types[type]);
 223         if(o2)
 224             ret = av_set_string3(avcodec_opts[type], opt, arg, 1, &o);
 225     }
 226     if(!o && avformat_opts)
 227         ret = av_set_string3(avformat_opts, opt, arg, 1, &o);
 228     if(!o && sws_opts)
 229         ret = av_set_string3(sws_opts, opt, arg, 1, &o);
 230     if(!o){
 231         if(opt[0] == 'a')
 232             ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_AUDIO], opt+1, arg, 1, &o);
 233         else if(opt[0] == 'v')
 234             ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_VIDEO], opt+1, arg, 1, &o);
 235         else if(opt[0] == 's')
 236             ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], opt+1, arg, 1, &o);
 237     }
 238     if (o && ret < 0) {
 239         fprintf(stderr, "Invalid value '%s' for option '%s'\n", arg, opt);
 240         exit(1);
 241     }
 242     if (!o) {
 243         AVCodec *p = NULL;
 244         while ((p=av_codec_next(p))){
 245             AVClass *c= p->priv_class;
 246             if(c && av_find_opt(&c, opt, NULL, 0, 0))
 247                 break;
 248         }
 249         if(!p){
 250         fprintf(stderr, "Unrecognized option '%s'\n", opt);
 251         exit(1);
 252         }
 253     }
 254
 255 //    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));
 256
 257     //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
 258     opt_values= av_realloc(opt_values, sizeof(void*)*(opt_name_count+1));
 259     opt_values[opt_name_count]= o ? NULL : arg;
 260     opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
 261     opt_names[opt_name_count++]= o ? o->name : opt;
 262
 263     if ((*avcodec_opts && avcodec_opts[0]->debug) || (avformat_opts && avformat_opts->debug))
 264         av_log_set_level(AV_LOG_DEBUG);
 265     return 0;
 266 }
 267
 268 int opt_loglevel(const char *opt, const char *arg)
 269 {
 270     const struct { const char *name; int level; } log_levels[] = {
 271         { "quiet"  , AV_LOG_QUIET   },
 272         { "panic"  , AV_LOG_PANIC   },
 273         { "fatal"  , AV_LOG_FATAL   },
 274         { "error"  , AV_LOG_ERROR   },
 275         { "warning", AV_LOG_WARNING },
 276         { "info"   , AV_LOG_INFO    },
 277         { "verbose", AV_LOG_VERBOSE },
 278         { "debug"  , AV_LOG_DEBUG   },
 279     };
 280     char *tail;
 281     int level;
 282     int i;
 283
 284     for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
 285         if (!strcmp(log_levels[i].name, arg)) {
 286             av_log_set_level(log_levels[i].level);
 287             return 0;
 288         }
 289     }
 290
 291     level = strtol(arg, &tail, 10);
 292     if (*tail) {
 293         fprintf(stderr, "Invalid loglevel \"%s\". "
 294                         "Possible levels are numbers or:\n", arg);
 295         for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
 296             fprintf(stderr, "\"%s\"\n", log_levels[i].name);
 297         exit(1);
 298     }
 299     av_log_set_level(level);
 300     return 0;
 301 }
 302
 303 int opt_timelimit(const char *opt, const char *arg)
 304 {
 305 #if HAVE_SETRLIMIT
 306     int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
 307     struct rlimit rl = { lim, lim + 1 };
 308     if (setrlimit(RLIMIT_CPU, &rl))
 309         perror("setrlimit");
 310 #else
 311     fprintf(stderr, "Warning: -%s not implemented on this OS\n", opt);
 312 #endif
 313     return 0;
 314 }
 315
 316 void set_context_opts(void *ctx, void *opts_ctx, int flags, AVCodec *codec)
 317 {
 318     int i;
 319     void *priv_ctx=NULL;
 320     if(!strcmp("AVCodecContext", (*(AVClass**)ctx)->class_name)){
 321         AVCodecContext *avctx= ctx;
 322         if(codec && codec->priv_class && avctx->priv_data){
 323             priv_ctx= avctx->priv_data;
 324         }
 325     }
 326     for(i=0; i<opt_name_count; i++){
 327         char buf[256];
 328         const AVOption *opt;
 329         const char *str= av_get_string(opts_ctx, opt_names[i], &opt, buf, sizeof(buf));
 330         /* if an option with name opt_names[i] is present in opts_ctx then str is non-NULL */
 331         if(str && ((opt->flags & flags) == flags))
 332             av_set_string3(ctx, opt_names[i], str, 1, NULL);
 333         /* We need to use a differnt system to pass options to the private context because
 334            it is not known which codec and thus context kind that will be when parsing options
 335            we thus use opt_values directly instead of opts_ctx */
 336         if(!str && priv_ctx && av_get_string(priv_ctx, opt_names[i], &opt, buf, sizeof(buf))){
 337             av_set_string3(priv_ctx, opt_names[i], opt_values[i], 1, NULL);
 338         }
 339     }
 340 }
 341
 342 void print_error(const char *filename, int err)
 343 {
 344     char errbuf[128];
 345     const char *errbuf_ptr = errbuf;
 346
 347     if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
 348         errbuf_ptr = strerror(AVUNERROR(err));
 349     fprintf(stderr, "%s: %s\n", filename, errbuf_ptr);
 350 }
 351
 352 static int warned_cfg = 0;
 353
 354 #define INDENT        1
 355 #define SHOW_VERSION  2
 356 #define SHOW_CONFIG   4
 357
 358 #define PRINT_LIB_INFO(outstream,libname,LIBNAME,flags)                 \
 359     if (CONFIG_##LIBNAME) {                                             \
 360         const char *indent = flags & INDENT? "  " : "";                 \
 361         if (flags & SHOW_VERSION) {                                     \
 362             unsigned int version = libname##_version();                 \
 363             fprintf(outstream, "%slib%-10s %2d.%2d.%2d / %2d.%2d.%2d\n", \
 364                     indent, #libname,                                   \
 365                     LIB##LIBNAME##_VERSION_MAJOR,                       \
 366                     LIB##LIBNAME##_VERSION_MINOR,                       \
 367                     LIB##LIBNAME##_VERSION_MICRO,                       \
 368                     version >> 16, version >> 8 & 0xff, version & 0xff); \
 369         }                                                               \
 370         if (flags & SHOW_CONFIG) {                                      \
 371             const char *cfg = libname##_configuration();                \
 372             if (strcmp(FFMPEG_CONFIGURATION, cfg)) {                    \
 373                 if (!warned_cfg) {                                      \
 374                     fprintf(outstream,                                  \
 375                             "%sWARNING: library configuration mismatch\n", \
 376                             indent);                                    \
 377                     warned_cfg = 1;                                     \
 378                 }                                                       \
 379                 fprintf(stderr, "%s%-11s configuration: %s\n",          \
 380                         indent, #libname, cfg);                         \
 381             }                                                           \
 382         }                                                               \
 383     }                                                                   \
 384
 385 static void print_all_libs_info(FILE* outstream, int flags)
 386 {
 387     PRINT_LIB_INFO(outstream, avutil,   AVUTIL,   flags);
 388     PRINT_LIB_INFO(outstream, avcore,   AVCORE,   flags);
 389     PRINT_LIB_INFO(outstream, avcodec,  AVCODEC,  flags);
 390     PRINT_LIB_INFO(outstream, avformat, AVFORMAT, flags);
 391     PRINT_LIB_INFO(outstream, avdevice, AVDEVICE, flags);
 392     PRINT_LIB_INFO(outstream, avfilter, AVFILTER, flags);
 393     PRINT_LIB_INFO(outstream, swscale,  SWSCALE,  flags);
 394     PRINT_LIB_INFO(outstream, postproc, POSTPROC, flags);
 395 }
 396
 397 void show_banner(void)
 398 {
 399     fprintf(stderr, "%s version " FFMPEG_VERSION ", Copyright (c) %d-%d the FFmpeg developers\n",
 400             program_name, program_birth_year, this_year);
 401     fprintf(stderr, "  built on %s %s with %s %s\n",
 402             __DATE__, __TIME__, CC_TYPE, CC_VERSION);
 403     fprintf(stderr, "  configuration: " FFMPEG_CONFIGURATION "\n");
 404     print_all_libs_info(stderr, INDENT|SHOW_CONFIG);
 405     print_all_libs_info(stderr, INDENT|SHOW_VERSION);
 406 }
 407
 408 void show_version(void) {
 409     printf("%s " FFMPEG_VERSION "\n", program_name);
 410     print_all_libs_info(stdout, SHOW_VERSION);
 411 }
 412
 413 void show_license(void)
 414 {
 415     printf(
 416 #if CONFIG_NONFREE
 417     "This version of %s has nonfree parts compiled in.\n"
 418     "Therefore it is not legally redistributable.\n",
 419     program_name
 420 #elif CONFIG_GPLV3
 421     "%s is free software; you can redistribute it and/or modify\n"
 422     "it under the terms of the GNU General Public License as published by\n"
 423     "the Free Software Foundation; either version 3 of the License, or\n"
 424     "(at your option) any later version.\n"
 425     "\n"
 426     "%s is distributed in the hope that it will be useful,\n"
 427     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 428     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
 429     "GNU General Public License for more details.\n"
 430     "\n"
 431     "You should have received a copy of the GNU General Public License\n"
 432     "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
 433     program_name, program_name, program_name
 434 #elif CONFIG_GPL
 435     "%s is free software; you can redistribute it and/or modify\n"
 436     "it under the terms of the GNU General Public License as published by\n"
 437     "the Free Software Foundation; either version 2 of the License, or\n"
 438     "(at your option) any later version.\n"
 439     "\n"
 440     "%s is distributed in the hope that it will be useful,\n"
 441     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 442     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
 443     "GNU General Public License for more details.\n"
 444     "\n"
 445     "You should have received a copy of the GNU General Public License\n"
 446     "along with %s; if not, write to the Free Software\n"
 447     "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
 448     program_name, program_name, program_name
 449 #elif CONFIG_LGPLV3
 450     "%s is free software; you can redistribute it and/or modify\n"
 451     "it under the terms of the GNU Lesser General Public License as published by\n"
 452     "the Free Software Foundation; either version 3 of the License, or\n"
 453     "(at your option) any later version.\n"
 454     "\n"
 455     "%s is distributed in the hope that it will be useful,\n"
 456     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 457     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
 458     "GNU Lesser General Public License for more details.\n"
 459     "\n"
 460     "You should have received a copy of the GNU Lesser General Public License\n"
 461     "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
 462     program_name, program_name, program_name
 463 #else
 464     "%s is free software; you can redistribute it and/or\n"
 465     "modify it under the terms of the GNU Lesser General Public\n"
 466     "License as published by the Free Software Foundation; either\n"
 467     "version 2.1 of the License, or (at your option) any later version.\n"
 468     "\n"
 469     "%s is distributed in the hope that it will be useful,\n"
 470     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 471     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
 472     "Lesser General Public License for more details.\n"
 473     "\n"
 474     "You should have received a copy of the GNU Lesser General Public\n"
 475     "License along with %s; if not, write to the Free Software\n"
 476     "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
 477     program_name, program_name, program_name
 478 #endif
 479     );
 480 }
 481
 482 void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
 483 {
 484     int i;
 485     char fmt_str[128];
 486     for (i=-1; i < nb_fmts; i++) {
 487         get_fmt_string (fmt_str, sizeof(fmt_str), i);
 488         fprintf(stdout, "%s\n", fmt_str);
 489     }
 490 }
 491
 492 void show_formats(void)
 493 {
 494     AVInputFormat *ifmt=NULL;
 495     AVOutputFormat *ofmt=NULL;
 496     const char *last_name;
 497
 498     printf(
 499         "File formats:\n"
 500         " D. = Demuxing supported\n"
 501         " .E = Muxing supported\n"
 502         " --\n");
 503     last_name= "000";
 504     for(;;){
 505         int decode=0;
 506         int encode=0;
 507         const char *name=NULL;
 508         const char *long_name=NULL;
 509
 510         while((ofmt= av_oformat_next(ofmt))) {
 511             if((name == NULL || strcmp(ofmt->name, name)<0) &&
 512                 strcmp(ofmt->name, last_name)>0){
 513                 name= ofmt->name;
 514                 long_name= ofmt->long_name;
 515                 encode=1;
 516             }
 517         }
 518         while((ifmt= av_iformat_next(ifmt))) {
 519             if((name == NULL || strcmp(ifmt->name, name)<0) &&
 520                 strcmp(ifmt->name, last_name)>0){
 521                 name= ifmt->name;
 522                 long_name= ifmt->long_name;
 523                 encode=0;
 524             }
 525             if(name && strcmp(ifmt->name, name)==0)
 526                 decode=1;
 527         }
 528         if(name==NULL)
 529             break;
 530         last_name= name;
 531
 532         printf(
 533             " %s%s %-15s %s\n",
 534             decode ? "D":" ",
 535             encode ? "E":" ",
 536             name,
 537             long_name ? long_name:" ");
 538     }
 539 }
 540
 541 void show_codecs(void)
 542 {
 543     AVCodec *p=NULL, *p2;
 544     const char *last_name;
 545     printf(
 546         "Codecs:\n"
 547         " D..... = Decoding supported\n"
 548         " .E.... = Encoding supported\n"
 549         " ..V... = Video codec\n"
 550         " ..A... = Audio codec\n"
 551         " ..S... = Subtitle codec\n"
 552         " ...S.. = Supports draw_horiz_band\n"
 553         " ....D. = Supports direct rendering method 1\n"
 554         " .....T = Supports weird frame truncation\n"
 555         " ------\n");
 556     last_name= "000";
 557     for(;;){
 558         int decode=0;
 559         int encode=0;
 560         int cap=0;
 561         const char *type_str;
 562
 563         p2=NULL;
 564         while((p= av_codec_next(p))) {
 565             if((p2==NULL || strcmp(p->name, p2->name)<0) &&
 566                 strcmp(p->name, last_name)>0){
 567                 p2= p;
 568                 decode= encode= cap=0;
 569             }
 570             if(p2 && strcmp(p->name, p2->name)==0){
 571                 if(p->decode) decode=1;
 572                 if(p->encode) encode=1;
 573                 cap |= p->capabilities;
 574             }
 575         }
 576         if(p2==NULL)
 577             break;
 578         last_name= p2->name;
 579
 580         switch(p2->type) {
 581         case AVMEDIA_TYPE_VIDEO:
 582             type_str = "V";
 583             break;
 584         case AVMEDIA_TYPE_AUDIO:
 585             type_str = "A";
 586             break;
 587         case AVMEDIA_TYPE_SUBTITLE:
 588             type_str = "S";
 589             break;
 590         default:
 591             type_str = "?";
 592             break;
 593         }
 594         printf(
 595             " %s%s%s%s%s%s %-15s %s",
 596             decode ? "D": (/*p2->decoder ? "d":*/" "),
 597             encode ? "E":" ",
 598             type_str,
 599             cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
 600             cap & CODEC_CAP_DR1 ? "D":" ",
 601             cap & CODEC_CAP_TRUNCATED ? "T":" ",
 602             p2->name,
 603             p2->long_name ? p2->long_name : "");
 604        /* if(p2->decoder && decode==0)
 605             printf(" use %s for decoding", p2->decoder->name);*/
 606         printf("\n");
 607     }
 608     printf("\n");
 609     printf(
 610 "Note, the names of encoders and decoders do not always match, so there are\n"
 611 "several cases where the above table shows encoder only or decoder only entries\n"
 612 "even though both encoding and decoding are supported. For example, the h263\n"
 613 "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
 614 "worse.\n");
 615 }
 616
 617 void show_bsfs(void)
 618 {
 619     AVBitStreamFilter *bsf=NULL;
 620
 621     printf("Bitstream filters:\n");
 622     while((bsf = av_bitstream_filter_next(bsf)))
 623         printf("%s\n", bsf->name);
 624     printf("\n");
 625 }
 626
 627 void show_protocols(void)
 628 {
 629     URLProtocol *up=NULL;
 630
 631     printf("Supported file protocols:\n"
 632            "I.. = Input  supported\n"
 633            ".O. = Output supported\n"
 634            "..S = Seek   supported\n"
 635            "FLAGS NAME\n"
 636            "----- \n");
 637     while((up = av_protocol_next(up)))
 638         printf("%c%c%c   %s\n",
 639                up->url_read  ? 'I' : '.',
 640                up->url_write ? 'O' : '.',
 641                up->url_seek  ? 'S' : '.',
 642                up->name);
 643 }
 644
 645 void show_filters(void)
 646 {
 647     AVFilter av_unused(**filter) = NULL;
 648
 649     printf("Filters:\n");
 650 #if CONFIG_AVFILTER
 651     while ((filter = av_filter_next(filter)) && *filter)
 652         printf("%-16s %s\n", (*filter)->name, (*filter)->description);
 653 #endif
 654 }
 655
 656 void show_pix_fmts(void)
 657 {
 658     enum PixelFormat pix_fmt;
 659
 660     printf(
 661         "Pixel formats:\n"
 662         "I.... = Supported Input  format for conversion\n"
 663         ".O... = Supported Output format for conversion\n"
 664         "..H.. = Hardware accelerated format\n"
 665         "...P. = Paletted format\n"
 666         "....B = Bitstream format\n"
 667         "FLAGS NAME            NB_COMPONENTS BITS_PER_PIXEL\n"
 668         "-----\n");
 669
 670 #if !CONFIG_SWSCALE
 671 #   define sws_isSupportedInput(x)  0
 672 #   define sws_isSupportedOutput(x) 0
 673 #endif
 674
 675     for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {
 676         const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[pix_fmt];
 677         printf("%c%c%c%c%c %-16s       %d            %2d\n",
 678                sws_isSupportedInput (pix_fmt)      ? 'I' : '.',
 679                sws_isSupportedOutput(pix_fmt)      ? 'O' : '.',
 680                pix_desc->flags & PIX_FMT_HWACCEL   ? 'H' : '.',
 681                pix_desc->flags & PIX_FMT_PAL       ? 'P' : '.',
 682                pix_desc->flags & PIX_FMT_BITSTREAM ? 'B' : '.',
 683                pix_desc->name,
 684                pix_desc->nb_components,
 685                av_get_bits_per_pixel(pix_desc));
 686     }
 687 }
 688
 689 int read_yesno(void)
 690 {
 691     int c = getchar();
 692     int yesno = (toupper(c) == 'Y');
 693
 694     while (c != '\n' && c != EOF)
 695         c = getchar();
 696
 697     return yesno;
 698 }
 699
 700 int read_file(const char *filename, char **bufptr, size_t *size)
 701 {
 702     FILE *f = fopen(filename, "rb");
 703
 704     if (!f) {
 705         fprintf(stderr, "Cannot read file '%s': %s\n", filename, strerror(errno));
 706         return AVERROR(errno);
 707     }
 708     fseek(f, 0, SEEK_END);
 709     *size = ftell(f);
 710     fseek(f, 0, SEEK_SET);
 711     *bufptr = av_malloc(*size + 1);
 712     if (!*bufptr) {
 713         fprintf(stderr, "Could not allocate file buffer\n");
 714         fclose(f);
 715         return AVERROR(ENOMEM);
 716     }
 717     fread(*bufptr, 1, *size, f);
 718     (*bufptr)[*size++] = '\0';
 719
 720     fclose(f);
 721     return 0;
 722 }
 723
 724 void init_pts_correction(PtsCorrectionContext *ctx)
 725 {
 726     ctx->num_faulty_pts = ctx->num_faulty_dts = 0;
 727     ctx->last_pts = ctx->last_dts = INT64_MIN;
 728 }
 729
 730 int64_t guess_correct_pts(PtsCorrectionContext *ctx, int64_t reordered_pts, int64_t dts)
 731 {
 732     int64_t pts = AV_NOPTS_VALUE;
 733
 734     if (dts != AV_NOPTS_VALUE) {
 735         ctx->num_faulty_dts += dts <= ctx->last_dts;
 736         ctx->last_dts = dts;
 737     }
 738     if (reordered_pts != AV_NOPTS_VALUE) {
 739         ctx->num_faulty_pts += reordered_pts <= ctx->last_pts;
 740         ctx->last_pts = reordered_pts;
 741     }
 742     if ((ctx->num_faulty_pts<=ctx->num_faulty_dts || dts == AV_NOPTS_VALUE)
 743        && reordered_pts != AV_NOPTS_VALUE)
 744         pts = reordered_pts;
 745     else
 746         pts = dts;
 747
 748     return pts;
 749 }