Support demuxing of streamed Bink files
[ffmpeg.git] / 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 }