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