git.sesse.net Git - ffmpeg/blob - cmdutils.c

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