User application side of Codec specific parameters.
[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 const char **opt_values;
53 static int opt_name_count;
54 AVCodecContext *avcodec_opts[AVMEDIA_TYPE_NB];
55 AVFormatContext *avformat_opts;
56 struct SwsContext *sws_opts;
57
58 const int this_year = 2010;
59
60 void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
61 {
62     vfprintf(stdout, fmt, vl);
63 }
64
65 double parse_number_or_die(const char *context, const char *numstr, int type, double min, double max)
66 {
67     char *tail;
68     const char *error;
69     double d = av_strtod(numstr, &tail);
70     if (*tail)
71         error= "Expected number for %s but found: %s\n";
72     else if (d < min || d > max)
73         error= "The value for %s was %s which is not within %f - %f\n";
74     else if(type == OPT_INT64 && (int64_t)d != d)
75         error= "Expected int64 for %s but found %s\n";
76     else
77         return d;
78     fprintf(stderr, error, context, numstr, min, max);
79     exit(1);
80 }
81
82 int64_t parse_time_or_die(const char *context, const char *timestr, int is_duration)
83 {
84     int64_t us = parse_date(timestr, is_duration);
85     if (us == INT64_MIN) {
86         fprintf(stderr, "Invalid %s specification for %s: %s\n",
87                 is_duration ? "duration" : "date", context, timestr);
88         exit(1);
89     }
90     return us;
91 }
92
93 void show_help_options(const OptionDef *options, const char *msg, int mask, int value)
94 {
95     const OptionDef *po;
96     int first;
97
98     first = 1;
99     for(po = options; po->name != NULL; po++) {
100         char buf[64];
101         if ((po->flags & mask) == value) {
102             if (first) {
103                 printf("%s", msg);
104                 first = 0;
105             }
106             av_strlcpy(buf, po->name, sizeof(buf));
107             if (po->flags & HAS_ARG) {
108                 av_strlcat(buf, " ", sizeof(buf));
109                 av_strlcat(buf, po->argname, sizeof(buf));
110             }
111             printf("-%-17s  %s\n", buf, po->help);
112         }
113     }
114 }
115
116 static const OptionDef* find_option(const OptionDef *po, const char *name){
117     while (po->name != NULL) {
118         if (!strcmp(name, po->name))
119             break;
120         po++;
121     }
122     return po;
123 }
124
125 void parse_options(int argc, char **argv, const OptionDef *options,
126                    void (* parse_arg_function)(const char*))
127 {
128     const char *opt, *arg;
129     int optindex, handleoptions=1;
130     const OptionDef *po;
131
132     /* parse options */
133     optindex = 1;
134     while (optindex < argc) {
135         opt = argv[optindex++];
136
137         if (handleoptions && opt[0] == '-' && opt[1] != '\0') {
138             int bool_val = 1;
139             if (opt[1] == '-' && opt[2] == '\0') {
140                 handleoptions = 0;
141                 continue;
142             }
143             opt++;
144             po= find_option(options, opt);
145             if (!po->name && opt[0] == 'n' && opt[1] == 'o') {
146                 /* handle 'no' bool option */
147                 po = find_option(options, opt + 2);
148                 if (!(po->name && (po->flags & OPT_BOOL)))
149                     goto unknown_opt;
150                 bool_val = 0;
151             }
152             if (!po->name)
153                 po= find_option(options, "default");
154             if (!po->name) {
155 unknown_opt:
156                 fprintf(stderr, "%s: unrecognized option '%s'\n", argv[0], opt);
157                 exit(1);
158             }
159             arg = NULL;
160             if (po->flags & HAS_ARG) {
161                 arg = argv[optindex++];
162                 if (!arg) {
163                     fprintf(stderr, "%s: missing argument for option '%s'\n", argv[0], opt);
164                     exit(1);
165                 }
166             }
167             if (po->flags & OPT_STRING) {
168                 char *str;
169                 str = av_strdup(arg);
170                 *po->u.str_arg = str;
171             } else if (po->flags & OPT_BOOL) {
172                 *po->u.int_arg = bool_val;
173             } else if (po->flags & OPT_INT) {
174                 *po->u.int_arg = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
175             } else if (po->flags & OPT_INT64) {
176                 *po->u.int64_arg = parse_number_or_die(opt, arg, OPT_INT64, INT64_MIN, INT64_MAX);
177             } else if (po->flags & OPT_FLOAT) {
178                 *po->u.float_arg = parse_number_or_die(opt, arg, OPT_FLOAT, -1.0/0.0, 1.0/0.0);
179             } else if (po->flags & OPT_FUNC2) {
180                 if (po->u.func2_arg(opt, arg) < 0) {
181                     fprintf(stderr, "%s: failed to set value '%s' for option '%s'\n", argv[0], arg, opt);
182                     exit(1);
183                 }
184             } else {
185                 po->u.func_arg(arg);
186             }
187             if(po->flags & OPT_EXIT)
188                 exit(0);
189         } else {
190             if (parse_arg_function)
191                 parse_arg_function(opt);
192         }
193     }
194 }
195
196 int opt_default(const char *opt, const char *arg){
197     int type;
198     int ret= 0;
199     const AVOption *o= NULL;
200     int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
201
202     for(type=0; *avcodec_opts && type<AVMEDIA_TYPE_NB && ret>= 0; type++){
203         const AVOption *o2 = av_find_opt(avcodec_opts[0], opt, NULL, opt_types[type], opt_types[type]);
204         if(o2)
205             ret = av_set_string3(avcodec_opts[type], opt, arg, 1, &o);
206     }
207     if(!o && avformat_opts)
208         ret = av_set_string3(avformat_opts, opt, arg, 1, &o);
209     if(!o && sws_opts)
210         ret = av_set_string3(sws_opts, opt, arg, 1, &o);
211     if(!o){
212         if(opt[0] == 'a')
213             ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_AUDIO], opt+1, arg, 1, &o);
214         else if(opt[0] == 'v')
215             ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_VIDEO], opt+1, arg, 1, &o);
216         else if(opt[0] == 's')
217             ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], opt+1, arg, 1, &o);
218     }
219     if (o && ret < 0) {
220         fprintf(stderr, "Invalid value '%s' for option '%s'\n", arg, opt);
221         exit(1);
222     }
223     if (!o) {
224         AVCodec *p = NULL;
225         while ((p=av_codec_next(p))){
226             AVClass *c= p->priv_class;
227             if(c && av_find_opt(&c, opt, NULL, 0, 0))
228                 break;
229         }
230         if(!p){
231         fprintf(stderr, "Unrecognized option '%s'\n", opt);
232         exit(1);
233         }
234     }
235
236 //    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));
237
238     //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
239     opt_values= av_realloc(opt_values, sizeof(void*)*(opt_name_count+1));
240     opt_values[opt_name_count]= o ? NULL : arg;
241     opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
242     opt_names[opt_name_count++]= o ? o->name : opt;
243
244     if ((*avcodec_opts && avcodec_opts[0]->debug) || (avformat_opts && avformat_opts->debug))
245         av_log_set_level(AV_LOG_DEBUG);
246     return 0;
247 }
248
249 int opt_loglevel(const char *opt, const char *arg)
250 {
251     const struct { const char *name; int level; } log_levels[] = {
252         { "quiet"  , AV_LOG_QUIET   },
253         { "panic"  , AV_LOG_PANIC   },
254         { "fatal"  , AV_LOG_FATAL   },
255         { "error"  , AV_LOG_ERROR   },
256         { "warning", AV_LOG_WARNING },
257         { "info"   , AV_LOG_INFO    },
258         { "verbose", AV_LOG_VERBOSE },
259         { "debug"  , AV_LOG_DEBUG   },
260     };
261     char *tail;
262     int level;
263     int i;
264
265     for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
266         if (!strcmp(log_levels[i].name, arg)) {
267             av_log_set_level(log_levels[i].level);
268             return 0;
269         }
270     }
271
272     level = strtol(arg, &tail, 10);
273     if (*tail) {
274         fprintf(stderr, "Invalid loglevel \"%s\". "
275                         "Possible levels are numbers or:\n", arg);
276         for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
277             fprintf(stderr, "\"%s\"\n", log_levels[i].name);
278         exit(1);
279     }
280     av_log_set_level(level);
281     return 0;
282 }
283
284 int opt_timelimit(const char *opt, const char *arg)
285 {
286 #if HAVE_SETRLIMIT
287     int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
288     struct rlimit rl = { lim, lim + 1 };
289     if (setrlimit(RLIMIT_CPU, &rl))
290         perror("setrlimit");
291 #else
292     fprintf(stderr, "Warning: -%s not implemented on this OS\n", opt);
293 #endif
294     return 0;
295 }
296
297 void set_context_opts(void *ctx, void *opts_ctx, int flags, AVCodec *codec)
298 {
299     int i;
300     void *priv_ctx=NULL;
301     if(!strcmp("AVCodecContext", (*(AVClass**)ctx)->class_name)){
302         AVCodecContext *avctx= ctx;
303         if(codec && codec->priv_class && avctx->priv_data){
304             priv_ctx= avctx->priv_data;
305         }
306     }
307     for(i=0; i<opt_name_count; i++){
308         char buf[256];
309         const AVOption *opt;
310         const char *str= av_get_string(opts_ctx, opt_names[i], &opt, buf, sizeof(buf));
311         /* if an option with name opt_names[i] is present in opts_ctx then str is non-NULL */
312         if(str && ((opt->flags & flags) == flags))
313             av_set_string3(ctx, opt_names[i], str, 1, NULL);
314         /* We need to use a differnt system to pass options to the private context because
315            it is not known which codec and thus context kind that will be when parsing options
316            we thus use opt_values directly instead of opts_ctx */
317         if(!str && priv_ctx && av_get_string(priv_ctx, opt_names[i], &opt, buf, sizeof(buf))){
318             av_set_string3(priv_ctx, opt_names[i], opt_values[i], 1, NULL);
319         }
320     }
321 }
322
323 void print_error(const char *filename, int err)
324 {
325     char errbuf[128];
326     const char *errbuf_ptr = errbuf;
327
328     if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
329         errbuf_ptr = strerror(AVUNERROR(err));
330     fprintf(stderr, "%s: %s\n", filename, errbuf_ptr);
331 }
332
333 static int warned_cfg = 0;
334
335 #define INDENT        1
336 #define SHOW_VERSION  2
337 #define SHOW_CONFIG   4
338
339 #define PRINT_LIB_INFO(outstream,libname,LIBNAME,flags)                 \
340     if (CONFIG_##LIBNAME) {                                             \
341         const char *indent = flags & INDENT? "  " : "";                 \
342         if (flags & SHOW_VERSION) {                                     \
343             unsigned int version = libname##_version();                 \
344             fprintf(outstream, "%slib%-10s %2d.%2d.%2d / %2d.%2d.%2d\n", \
345                     indent, #libname,                                   \
346                     LIB##LIBNAME##_VERSION_MAJOR,                       \
347                     LIB##LIBNAME##_VERSION_MINOR,                       \
348                     LIB##LIBNAME##_VERSION_MICRO,                       \
349                     version >> 16, version >> 8 & 0xff, version & 0xff); \
350         }                                                               \
351         if (flags & SHOW_CONFIG) {                                      \
352             const char *cfg = libname##_configuration();                \
353             if (strcmp(FFMPEG_CONFIGURATION, cfg)) {                    \
354                 if (!warned_cfg) {                                      \
355                     fprintf(outstream,                                  \
356                             "%sWARNING: library configuration mismatch\n", \
357                             indent);                                    \
358                     warned_cfg = 1;                                     \
359                 }                                                       \
360                 fprintf(stderr, "%s%-11s configuration: %s\n",          \
361                         indent, #libname, cfg);                         \
362             }                                                           \
363         }                                                               \
364     }                                                                   \
365
366 static void print_all_libs_info(FILE* outstream, int flags)
367 {
368     PRINT_LIB_INFO(outstream, avutil,   AVUTIL,   flags);
369     PRINT_LIB_INFO(outstream, avcore,   AVCORE,   flags);
370     PRINT_LIB_INFO(outstream, avcodec,  AVCODEC,  flags);
371     PRINT_LIB_INFO(outstream, avformat, AVFORMAT, flags);
372     PRINT_LIB_INFO(outstream, avdevice, AVDEVICE, flags);
373     PRINT_LIB_INFO(outstream, avfilter, AVFILTER, flags);
374     PRINT_LIB_INFO(outstream, swscale,  SWSCALE,  flags);
375     PRINT_LIB_INFO(outstream, postproc, POSTPROC, flags);
376 }
377
378 void show_banner(void)
379 {
380     fprintf(stderr, "%s version " FFMPEG_VERSION ", Copyright (c) %d-%d the FFmpeg developers\n",
381             program_name, program_birth_year, this_year);
382     fprintf(stderr, "  built on %s %s with %s %s\n",
383             __DATE__, __TIME__, CC_TYPE, CC_VERSION);
384     fprintf(stderr, "  configuration: " FFMPEG_CONFIGURATION "\n");
385     print_all_libs_info(stderr, INDENT|SHOW_CONFIG);
386     print_all_libs_info(stderr, INDENT|SHOW_VERSION);
387 }
388
389 void show_version(void) {
390     printf("%s " FFMPEG_VERSION "\n", program_name);
391     print_all_libs_info(stdout, SHOW_VERSION);
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 AVMEDIA_TYPE_VIDEO:
563             type_str = "V";
564             break;
565         case AVMEDIA_TYPE_AUDIO:
566             type_str = "A";
567             break;
568         case AVMEDIA_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            "I.. = Input  supported\n"
614            ".O. = Output supported\n"
615            "..S = Seek   supported\n"
616            "FLAGS NAME\n"
617            "----- \n");
618     while((up = av_protocol_next(up)))
619         printf("%c%c%c   %s\n",
620                up->url_read  ? 'I' : '.',
621                up->url_write ? 'O' : '.',
622                up->url_seek  ? 'S' : '.',
623                up->name);
624 }
625
626 void show_filters(void)
627 {
628     AVFilter av_unused(**filter) = NULL;
629
630     printf("Filters:\n");
631 #if CONFIG_AVFILTER
632     while ((filter = av_filter_next(filter)) && *filter)
633         printf("%-16s %s\n", (*filter)->name, (*filter)->description);
634 #endif
635 }
636
637 void show_pix_fmts(void)
638 {
639     enum PixelFormat pix_fmt;
640
641     printf(
642         "Pixel formats:\n"
643         "I.... = Supported Input  format for conversion\n"
644         ".O... = Supported Output format for conversion\n"
645         "..H.. = Hardware accelerated format\n"
646         "...P. = Paletted format\n"
647         "....B = Bitstream format\n"
648         "FLAGS NAME            NB_COMPONENTS BITS_PER_PIXEL\n"
649         "-----\n");
650
651 #if !CONFIG_SWSCALE
652 #   define sws_isSupportedInput(x)  0
653 #   define sws_isSupportedOutput(x) 0
654 #endif
655
656     for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {
657         const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[pix_fmt];
658         printf("%c%c%c%c%c %-16s       %d            %2d\n",
659                sws_isSupportedInput (pix_fmt)      ? 'I' : '.',
660                sws_isSupportedOutput(pix_fmt)      ? 'O' : '.',
661                pix_desc->flags & PIX_FMT_HWACCEL   ? 'H' : '.',
662                pix_desc->flags & PIX_FMT_PAL       ? 'P' : '.',
663                pix_desc->flags & PIX_FMT_BITSTREAM ? 'B' : '.',
664                pix_desc->name,
665                pix_desc->nb_components,
666                av_get_bits_per_pixel(pix_desc));
667     }
668 }
669
670 int read_yesno(void)
671 {
672     int c = getchar();
673     int yesno = (toupper(c) == 'Y');
674
675     while (c != '\n' && c != EOF)
676         c = getchar();
677
678     return yesno;
679 }
680
681 int read_file(const char *filename, char **bufptr, size_t *size)
682 {
683     FILE *f = fopen(filename, "rb");
684
685     if (!f) {
686         fprintf(stderr, "Cannot read file '%s': %s\n", filename, strerror(errno));
687         return AVERROR(errno);
688     }
689     fseek(f, 0, SEEK_END);
690     *size = ftell(f);
691     fseek(f, 0, SEEK_SET);
692     *bufptr = av_malloc(*size + 1);
693     if (!*bufptr) {
694         fprintf(stderr, "Could not allocate file buffer\n");
695         fclose(f);
696         return AVERROR(ENOMEM);
697     }
698     fread(*bufptr, 1, *size, f);
699     (*bufptr)[*size++] = '\0';
700
701     fclose(f);
702     return 0;
703 }
704
705 void init_pts_correction(PtsCorrectionContext *ctx)
706 {
707     ctx->num_faulty_pts = ctx->num_faulty_dts = 0;
708     ctx->last_pts = ctx->last_dts = INT64_MIN;
709 }
710
711 int64_t guess_correct_pts(PtsCorrectionContext *ctx, int64_t reordered_pts, int64_t dts)
712 {
713     int64_t pts = AV_NOPTS_VALUE;
714
715     if (dts != AV_NOPTS_VALUE) {
716         ctx->num_faulty_dts += dts <= ctx->last_dts;
717         ctx->last_dts = dts;
718     }
719     if (reordered_pts != AV_NOPTS_VALUE) {
720         ctx->num_faulty_pts += reordered_pts <= ctx->last_pts;
721         ctx->last_pts = reordered_pts;
722     }
723     if ((ctx->num_faulty_pts<=ctx->num_faulty_dts || dts == AV_NOPTS_VALUE)
724        && reordered_pts != AV_NOPTS_VALUE)
725         pts = reordered_pts;
726     else
727         pts = dts;
728
729     return pts;
730 }