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