24a8db2f1bd334ec2c46a0c93131f42790bc9918
[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 "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_SETRLIMIT
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 }