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