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