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