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 static int warned_cfg = 0;
 305
 306 #define INDENT        1
 307 #define SHOW_VERSION  2
 308 #define SHOW_CONFIG   4
 309
 310 #define PRINT_LIB_INFO(outstream,libname,LIBNAME,flags)                 \
 311     if (CONFIG_##LIBNAME) {                                             \
 312         if (flags & SHOW_VERSION) {                                     \
 313             unsigned int version = libname##_version();                 \
 314             fprintf(outstream, "%slib%-10s %2d.%2d.%2d / %2d.%2d.%2d\n", \
 315                     flags & INDENT? "  " : "", #libname,                \
 316                     LIB##LIBNAME##_VERSION_MAJOR,                       \
 317                     LIB##LIBNAME##_VERSION_MINOR,                       \
 318                     LIB##LIBNAME##_VERSION_MICRO,                       \
 319                     version >> 16, version >> 8 & 0xff, version & 0xff); \
 320         }                                                               \
 321         if (flags & SHOW_CONFIG) {                                      \
 322             const char *cfg = libname##_configuration();                \
 323             if (strcmp(FFMPEG_CONFIGURATION, cfg)) {                    \
 324                 if (!warned_cfg) {                                      \
 325                     fprintf(outstream,                                  \
 326                             "%sWARNING: library configuration mismatch\n", \
 327                             flags & INDENT? "  " : "");                 \
 328                     warned_cfg = 1;                                     \
 329                 }                                                       \
 330                 fprintf(stderr, "%s%-11s configuration: %s\n",          \
 331                         flags & INDENT? "  " : "", #libname, cfg);      \
 332             }                                                           \
 333         }                                                               \
 334     }                                                                   \
 335
 336 static void print_all_libs_info(FILE* outstream, int flags)
 337 {
 338     PRINT_LIB_INFO(outstream, avutil,   AVUTIL,   flags);
 339     PRINT_LIB_INFO(outstream, avcore,   AVCORE,   flags);
 340     PRINT_LIB_INFO(outstream, avcodec,  AVCODEC,  flags);
 341     PRINT_LIB_INFO(outstream, avformat, AVFORMAT, flags);
 342     PRINT_LIB_INFO(outstream, avdevice, AVDEVICE, flags);
 343     PRINT_LIB_INFO(outstream, avfilter, AVFILTER, flags);
 344     PRINT_LIB_INFO(outstream, swscale,  SWSCALE,  flags);
 345     PRINT_LIB_INFO(outstream, postproc, POSTPROC, flags);
 346 }
 347
 348 void show_banner(void)
 349 {
 350     fprintf(stderr, "%s version " FFMPEG_VERSION ", Copyright (c) %d-%d the FFmpeg developers\n",
 351             program_name, program_birth_year, this_year);
 352     fprintf(stderr, "  built on %s %s with %s %s\n",
 353             __DATE__, __TIME__, CC_TYPE, CC_VERSION);
 354     fprintf(stderr, "  configuration: " FFMPEG_CONFIGURATION "\n");
 355     print_all_libs_info(stderr, INDENT|SHOW_CONFIG);
 356     print_all_libs_info(stderr, INDENT|SHOW_VERSION);
 357 }
 358
 359 void show_version(void) {
 360     printf("%s " FFMPEG_VERSION "\n", program_name);
 361     print_all_libs_info(stdout, SHOW_VERSION);
 362 }
 363
 364 void show_license(void)
 365 {
 366     printf(
 367 #if CONFIG_NONFREE
 368     "This version of %s has nonfree parts compiled in.\n"
 369     "Therefore it is not legally redistributable.\n",
 370     program_name
 371 #elif CONFIG_GPLV3
 372     "%s is free software; you can redistribute it and/or modify\n"
 373     "it under the terms of the GNU General Public License as published by\n"
 374     "the Free Software Foundation; either version 3 of the License, or\n"
 375     "(at your option) any later version.\n"
 376     "\n"
 377     "%s is distributed in the hope that it will be useful,\n"
 378     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 379     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
 380     "GNU General Public License for more details.\n"
 381     "\n"
 382     "You should have received a copy of the GNU General Public License\n"
 383     "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
 384     program_name, program_name, program_name
 385 #elif CONFIG_GPL
 386     "%s is free software; you can redistribute it and/or modify\n"
 387     "it under the terms of the GNU General Public License as published by\n"
 388     "the Free Software Foundation; either version 2 of the License, or\n"
 389     "(at your option) any later version.\n"
 390     "\n"
 391     "%s is distributed in the hope that it will be useful,\n"
 392     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 393     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
 394     "GNU General Public License for more details.\n"
 395     "\n"
 396     "You should have received a copy of the GNU General Public License\n"
 397     "along with %s; if not, write to the Free Software\n"
 398     "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
 399     program_name, program_name, program_name
 400 #elif CONFIG_LGPLV3
 401     "%s is free software; you can redistribute it and/or modify\n"
 402     "it under the terms of the GNU Lesser General Public License as published by\n"
 403     "the Free Software Foundation; either version 3 of the License, or\n"
 404     "(at your option) any later version.\n"
 405     "\n"
 406     "%s is distributed in the hope that it will be useful,\n"
 407     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 408     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
 409     "GNU Lesser General Public License for more details.\n"
 410     "\n"
 411     "You should have received a copy of the GNU Lesser General Public License\n"
 412     "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
 413     program_name, program_name, program_name
 414 #else
 415     "%s is free software; you can redistribute it and/or\n"
 416     "modify it under the terms of the GNU Lesser General Public\n"
 417     "License as published by the Free Software Foundation; either\n"
 418     "version 2.1 of the License, or (at your option) any later version.\n"
 419     "\n"
 420     "%s is distributed in the hope that it will be useful,\n"
 421     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 422     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
 423     "Lesser General Public License for more details.\n"
 424     "\n"
 425     "You should have received a copy of the GNU Lesser General Public\n"
 426     "License along with %s; if not, write to the Free Software\n"
 427     "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
 428     program_name, program_name, program_name
 429 #endif
 430     );
 431 }
 432
 433 void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
 434 {
 435     int i;
 436     char fmt_str[128];
 437     for (i=-1; i < nb_fmts; i++) {
 438         get_fmt_string (fmt_str, sizeof(fmt_str), i);
 439         fprintf(stdout, "%s\n", fmt_str);
 440     }
 441 }
 442
 443 void show_formats(void)
 444 {
 445     AVInputFormat *ifmt=NULL;
 446     AVOutputFormat *ofmt=NULL;
 447     const char *last_name;
 448
 449     printf(
 450         "File formats:\n"
 451         " D. = Demuxing supported\n"
 452         " .E = Muxing supported\n"
 453         " --\n");
 454     last_name= "000";
 455     for(;;){
 456         int decode=0;
 457         int encode=0;
 458         const char *name=NULL;
 459         const char *long_name=NULL;
 460
 461         while((ofmt= av_oformat_next(ofmt))) {
 462             if((name == NULL || strcmp(ofmt->name, name)<0) &&
 463                 strcmp(ofmt->name, last_name)>0){
 464                 name= ofmt->name;
 465                 long_name= ofmt->long_name;
 466                 encode=1;
 467             }
 468         }
 469         while((ifmt= av_iformat_next(ifmt))) {
 470             if((name == NULL || strcmp(ifmt->name, name)<0) &&
 471                 strcmp(ifmt->name, last_name)>0){
 472                 name= ifmt->name;
 473                 long_name= ifmt->long_name;
 474                 encode=0;
 475             }
 476             if(name && strcmp(ifmt->name, name)==0)
 477                 decode=1;
 478         }
 479         if(name==NULL)
 480             break;
 481         last_name= name;
 482
 483         printf(
 484             " %s%s %-15s %s\n",
 485             decode ? "D":" ",
 486             encode ? "E":" ",
 487             name,
 488             long_name ? long_name:" ");
 489     }
 490 }
 491
 492 void show_codecs(void)
 493 {
 494     AVCodec *p=NULL, *p2;
 495     const char *last_name;
 496     printf(
 497         "Codecs:\n"
 498         " D..... = Decoding supported\n"
 499         " .E.... = Encoding supported\n"
 500         " ..V... = Video codec\n"
 501         " ..A... = Audio codec\n"
 502         " ..S... = Subtitle codec\n"
 503         " ...S.. = Supports draw_horiz_band\n"
 504         " ....D. = Supports direct rendering method 1\n"
 505         " .....T = Supports weird frame truncation\n"
 506         " ------\n");
 507     last_name= "000";
 508     for(;;){
 509         int decode=0;
 510         int encode=0;
 511         int cap=0;
 512         const char *type_str;
 513
 514         p2=NULL;
 515         while((p= av_codec_next(p))) {
 516             if((p2==NULL || strcmp(p->name, p2->name)<0) &&
 517                 strcmp(p->name, last_name)>0){
 518                 p2= p;
 519                 decode= encode= cap=0;
 520             }
 521             if(p2 && strcmp(p->name, p2->name)==0){
 522                 if(p->decode) decode=1;
 523                 if(p->encode) encode=1;
 524                 cap |= p->capabilities;
 525             }
 526         }
 527         if(p2==NULL)
 528             break;
 529         last_name= p2->name;
 530
 531         switch(p2->type) {
 532         case AVMEDIA_TYPE_VIDEO:
 533             type_str = "V";
 534             break;
 535         case AVMEDIA_TYPE_AUDIO:
 536             type_str = "A";
 537             break;
 538         case AVMEDIA_TYPE_SUBTITLE:
 539             type_str = "S";
 540             break;
 541         default:
 542             type_str = "?";
 543             break;
 544         }
 545         printf(
 546             " %s%s%s%s%s%s %-15s %s",
 547             decode ? "D": (/*p2->decoder ? "d":*/" "),
 548             encode ? "E":" ",
 549             type_str,
 550             cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
 551             cap & CODEC_CAP_DR1 ? "D":" ",
 552             cap & CODEC_CAP_TRUNCATED ? "T":" ",
 553             p2->name,
 554             p2->long_name ? p2->long_name : "");
 555        /* if(p2->decoder && decode==0)
 556             printf(" use %s for decoding", p2->decoder->name);*/
 557         printf("\n");
 558     }
 559     printf("\n");
 560     printf(
 561 "Note, the names of encoders and decoders do not always match, so there are\n"
 562 "several cases where the above table shows encoder only or decoder only entries\n"
 563 "even though both encoding and decoding are supported. For example, the h263\n"
 564 "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
 565 "worse.\n");
 566 }
 567
 568 void show_bsfs(void)
 569 {
 570     AVBitStreamFilter *bsf=NULL;
 571
 572     printf("Bitstream filters:\n");
 573     while((bsf = av_bitstream_filter_next(bsf)))
 574         printf("%s\n", bsf->name);
 575     printf("\n");
 576 }
 577
 578 void show_protocols(void)
 579 {
 580     URLProtocol *up=NULL;
 581
 582     printf("Supported file protocols:\n");
 583     while((up = av_protocol_next(up)))
 584         printf("%s\n", up->name);
 585 }
 586
 587 void show_filters(void)
 588 {
 589     AVFilter av_unused(**filter) = NULL;
 590
 591     printf("Filters:\n");
 592 #if CONFIG_AVFILTER
 593     while ((filter = av_filter_next(filter)) && *filter)
 594         printf("%-16s %s\n", (*filter)->name, (*filter)->description);
 595 #endif
 596 }
 597
 598 void show_pix_fmts(void)
 599 {
 600     enum PixelFormat pix_fmt;
 601
 602     printf(
 603         "Pixel formats:\n"
 604         "I.... = Supported Input  format for conversion\n"
 605         ".O... = Supported Output format for conversion\n"
 606         "..H.. = Hardware accelerated format\n"
 607         "...P. = Paletted format\n"
 608         "....B = Bitstream format\n"
 609         "FLAGS NAME            NB_COMPONENTS BITS_PER_PIXEL\n"
 610         "-----\n");
 611
 612 #if !CONFIG_SWSCALE
 613 #   define sws_isSupportedInput(x)  0
 614 #   define sws_isSupportedOutput(x) 0
 615 #endif
 616
 617     for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {
 618         const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[pix_fmt];
 619         printf("%c%c%c%c%c %-16s       %d            %2d\n",
 620                sws_isSupportedInput (pix_fmt)      ? 'I' : '.',
 621                sws_isSupportedOutput(pix_fmt)      ? 'O' : '.',
 622                pix_desc->flags & PIX_FMT_HWACCEL   ? 'H' : '.',
 623                pix_desc->flags & PIX_FMT_PAL       ? 'P' : '.',
 624                pix_desc->flags & PIX_FMT_BITSTREAM ? 'B' : '.',
 625                pix_desc->name,
 626                pix_desc->nb_components,
 627                av_get_bits_per_pixel(pix_desc));
 628     }
 629 }
 630
 631 int read_yesno(void)
 632 {
 633     int c = getchar();
 634     int yesno = (toupper(c) == 'Y');
 635
 636     while (c != '\n' && c != EOF)
 637         c = getchar();
 638
 639     return yesno;
 640 }
 641
 642 int read_file(const char *filename, char **bufptr, size_t *size)
 643 {
 644     FILE *f = fopen(filename, "rb");
 645
 646     if (!f) {
 647         fprintf(stderr, "Cannot read file '%s': %s\n", filename, strerror(errno));
 648         return AVERROR(errno);
 649     }
 650     fseek(f, 0, SEEK_END);
 651     *size = ftell(f);
 652     fseek(f, 0, SEEK_SET);
 653     *bufptr = av_malloc(*size + 1);
 654     if (!*bufptr) {
 655         fprintf(stderr, "Could not allocate file buffer\n");
 656         fclose(f);
 657         return AVERROR(ENOMEM);
 658     }
 659     fread(*bufptr, 1, *size, f);
 660     (*bufptr)[*size++] = '\0';
 661
 662     fclose(f);
 663     return 0;
 664 }