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