Merge libavcore into libavutil
[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 "cmdutils.h"
42 #include "version.h"
43 #if CONFIG_NETWORK
44 #include "libavformat/network.h"
45 #endif
46 #if HAVE_SYS_RESOURCE_H
47 #include <sys/resource.h>
48 #endif
49
50 const char **opt_names;
51 const char **opt_values;
52 static int opt_name_count;
53 AVCodecContext *avcodec_opts[AVMEDIA_TYPE_NB];
54 AVFormatContext *avformat_opts;
55 struct SwsContext *sws_opts;
56
57 static const int this_year = 2011;
58
59 void init_opts(void)
60 {
61     int i;
62     for (i = 0; i < AVMEDIA_TYPE_NB; i++)
63         avcodec_opts[i] = avcodec_alloc_context2(i);
64     avformat_opts = avformat_alloc_context();
65 #if CONFIG_SWSCALE
66     sws_opts = sws_getContext(16, 16, 0, 16, 16, 0, SWS_BICUBIC, NULL, NULL, NULL);
67 #endif
68 }
69
70 void uninit_opts(void)
71 {
72     int i;
73     for (i = 0; i < AVMEDIA_TYPE_NB; i++)
74         av_freep(&avcodec_opts[i]);
75     av_freep(&avformat_opts->key);
76     av_freep(&avformat_opts);
77 #if CONFIG_SWSCALE
78     av_freep(&sws_opts);
79 #endif
80     for (i = 0; i < opt_name_count; i++) {
81         //opt_values are only stored for codec-specific options in which case
82         //both the name and value are dup'd
83         if (opt_values[i]) {
84             av_freep(&opt_names[i]);
85             av_freep(&opt_values[i]);
86         }
87     }
88     av_freep(&opt_names);
89     av_freep(&opt_values);
90 }
91
92 void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
93 {
94     vfprintf(stdout, fmt, vl);
95 }
96
97 double parse_number_or_die(const char *context, const char *numstr, int type, double min, double max)
98 {
99     char *tail;
100     const char *error;
101     double d = av_strtod(numstr, &tail);
102     if (*tail)
103         error= "Expected number for %s but found: %s\n";
104     else if (d < min || d > max)
105         error= "The value for %s was %s which is not within %f - %f\n";
106     else if(type == OPT_INT64 && (int64_t)d != d)
107         error= "Expected int64 for %s but found %s\n";
108     else
109         return d;
110     fprintf(stderr, error, context, numstr, min, max);
111     exit(1);
112 }
113
114 int64_t parse_time_or_die(const char *context, const char *timestr, int is_duration)
115 {
116     int64_t us = parse_date(timestr, is_duration);
117     if (us == INT64_MIN) {
118         fprintf(stderr, "Invalid %s specification for %s: %s\n",
119                 is_duration ? "duration" : "date", context, timestr);
120         exit(1);
121     }
122     return us;
123 }
124
125 void show_help_options(const OptionDef *options, const char *msg, int mask, int value)
126 {
127     const OptionDef *po;
128     int first;
129
130     first = 1;
131     for(po = options; po->name != NULL; po++) {
132         char buf[64];
133         if ((po->flags & mask) == value) {
134             if (first) {
135                 printf("%s", msg);
136                 first = 0;
137             }
138             av_strlcpy(buf, po->name, sizeof(buf));
139             if (po->flags & HAS_ARG) {
140                 av_strlcat(buf, " ", sizeof(buf));
141                 av_strlcat(buf, po->argname, sizeof(buf));
142             }
143             printf("-%-17s  %s\n", buf, po->help);
144         }
145     }
146 }
147
148 static const OptionDef* find_option(const OptionDef *po, const char *name){
149     while (po->name != NULL) {
150         if (!strcmp(name, po->name))
151             break;
152         po++;
153     }
154     return po;
155 }
156
157 void parse_options(int argc, char **argv, const OptionDef *options,
158                    void (* parse_arg_function)(const char*))
159 {
160     const char *opt, *arg;
161     int optindex, handleoptions=1;
162     const OptionDef *po;
163
164     /* parse options */
165     optindex = 1;
166     while (optindex < argc) {
167         opt = argv[optindex++];
168
169         if (handleoptions && opt[0] == '-' && opt[1] != '\0') {
170             int bool_val = 1;
171             if (opt[1] == '-' && opt[2] == '\0') {
172                 handleoptions = 0;
173                 continue;
174             }
175             opt++;
176             po= find_option(options, opt);
177             if (!po->name && opt[0] == 'n' && opt[1] == 'o') {
178                 /* handle 'no' bool option */
179                 po = find_option(options, opt + 2);
180                 if (!(po->name && (po->flags & OPT_BOOL)))
181                     goto unknown_opt;
182                 bool_val = 0;
183             }
184             if (!po->name)
185                 po= find_option(options, "default");
186             if (!po->name) {
187 unknown_opt:
188                 fprintf(stderr, "%s: unrecognized option '%s'\n", argv[0], opt);
189                 exit(1);
190             }
191             arg = NULL;
192             if (po->flags & HAS_ARG) {
193                 arg = argv[optindex++];
194                 if (!arg) {
195                     fprintf(stderr, "%s: missing argument for option '%s'\n", argv[0], opt);
196                     exit(1);
197                 }
198             }
199             if (po->flags & OPT_STRING) {
200                 char *str;
201                 str = av_strdup(arg);
202                 *po->u.str_arg = str;
203             } else if (po->flags & OPT_BOOL) {
204                 *po->u.int_arg = bool_val;
205             } else if (po->flags & OPT_INT) {
206                 *po->u.int_arg = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
207             } else if (po->flags & OPT_INT64) {
208                 *po->u.int64_arg = parse_number_or_die(opt, arg, OPT_INT64, INT64_MIN, INT64_MAX);
209             } else if (po->flags & OPT_FLOAT) {
210                 *po->u.float_arg = parse_number_or_die(opt, arg, OPT_FLOAT, -INFINITY, INFINITY);
211             } else if (po->flags & OPT_FUNC2) {
212                 if (po->u.func2_arg(opt, arg) < 0) {
213                     fprintf(stderr, "%s: failed to set value '%s' for option '%s'\n", argv[0], arg, opt);
214                     exit(1);
215                 }
216             } else {
217                 po->u.func_arg(arg);
218             }
219             if(po->flags & OPT_EXIT)
220                 exit(0);
221         } else {
222             if (parse_arg_function)
223                 parse_arg_function(opt);
224         }
225     }
226 }
227
228 int opt_default(const char *opt, const char *arg){
229     int type;
230     int ret= 0;
231     const AVOption *o= NULL;
232     int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
233
234     for(type=0; *avcodec_opts && type<AVMEDIA_TYPE_NB && ret>= 0; type++){
235         const AVOption *o2 = av_find_opt(avcodec_opts[0], opt, NULL, opt_types[type], opt_types[type]);
236         if(o2)
237             ret = av_set_string3(avcodec_opts[type], opt, arg, 1, &o);
238     }
239     if(!o && avformat_opts)
240         ret = av_set_string3(avformat_opts, opt, arg, 1, &o);
241     if(!o && sws_opts)
242         ret = av_set_string3(sws_opts, opt, arg, 1, &o);
243     if(!o){
244         if (opt[0] == 'a' && avcodec_opts[AVMEDIA_TYPE_AUDIO])
245             ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_AUDIO], opt+1, arg, 1, &o);
246         else if(opt[0] == 'v' && avcodec_opts[AVMEDIA_TYPE_VIDEO])
247             ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_VIDEO], opt+1, arg, 1, &o);
248         else if(opt[0] == 's' && avcodec_opts[AVMEDIA_TYPE_SUBTITLE])
249             ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], opt+1, arg, 1, &o);
250     }
251     if (o && ret < 0) {
252         fprintf(stderr, "Invalid value '%s' for option '%s'\n", arg, opt);
253         exit(1);
254     }
255     if (!o) {
256         AVCodec *p = NULL;
257         AVOutputFormat *oformat = NULL;
258         while ((p=av_codec_next(p))){
259             AVClass *c= p->priv_class;
260             if(c && av_find_opt(&c, opt, NULL, 0, 0))
261                 break;
262         }
263         if (!p) {
264             while ((oformat = av_oformat_next(oformat))) {
265                 const AVClass *c = oformat->priv_class;
266                 if (c && av_find_opt(&c, opt, NULL, 0, 0))
267                     break;
268             }
269         }
270         if(!p && !oformat){
271             fprintf(stderr, "Unrecognized option '%s'\n", opt);
272             exit(1);
273         }
274     }
275
276 //    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));
277
278     //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
279     opt_values= av_realloc(opt_values, sizeof(void*)*(opt_name_count+1));
280     opt_values[opt_name_count]= o ? NULL : av_strdup(arg);
281     opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
282     opt_names[opt_name_count++]= o ? o->name : av_strdup(opt);
283
284     if ((*avcodec_opts && avcodec_opts[0]->debug) || (avformat_opts && avformat_opts->debug))
285         av_log_set_level(AV_LOG_DEBUG);
286     return 0;
287 }
288
289 int opt_loglevel(const char *opt, const char *arg)
290 {
291     const struct { const char *name; int level; } log_levels[] = {
292         { "quiet"  , AV_LOG_QUIET   },
293         { "panic"  , AV_LOG_PANIC   },
294         { "fatal"  , AV_LOG_FATAL   },
295         { "error"  , AV_LOG_ERROR   },
296         { "warning", AV_LOG_WARNING },
297         { "info"   , AV_LOG_INFO    },
298         { "verbose", AV_LOG_VERBOSE },
299         { "debug"  , AV_LOG_DEBUG   },
300     };
301     char *tail;
302     int level;
303     int i;
304
305     for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
306         if (!strcmp(log_levels[i].name, arg)) {
307             av_log_set_level(log_levels[i].level);
308             return 0;
309         }
310     }
311
312     level = strtol(arg, &tail, 10);
313     if (*tail) {
314         fprintf(stderr, "Invalid loglevel \"%s\". "
315                         "Possible levels are numbers or:\n", arg);
316         for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
317             fprintf(stderr, "\"%s\"\n", log_levels[i].name);
318         exit(1);
319     }
320     av_log_set_level(level);
321     return 0;
322 }
323
324 int opt_timelimit(const char *opt, const char *arg)
325 {
326 #if HAVE_SETRLIMIT
327     int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
328     struct rlimit rl = { lim, lim + 1 };
329     if (setrlimit(RLIMIT_CPU, &rl))
330         perror("setrlimit");
331 #else
332     fprintf(stderr, "Warning: -%s not implemented on this OS\n", opt);
333 #endif
334     return 0;
335 }
336
337 void set_context_opts(void *ctx, void *opts_ctx, int flags, AVCodec *codec)
338 {
339     int i;
340     void *priv_ctx=NULL;
341     if(!strcmp("AVCodecContext", (*(AVClass**)ctx)->class_name)){
342         AVCodecContext *avctx= ctx;
343         if(codec && codec->priv_class && avctx->priv_data){
344             priv_ctx= avctx->priv_data;
345         }
346     } else if (!strcmp("AVFormatContext", (*(AVClass**)ctx)->class_name)) {
347         AVFormatContext *avctx = ctx;
348         if (avctx->oformat && avctx->oformat->priv_class) {
349             priv_ctx = avctx->priv_data;
350         }
351     }
352
353     for(i=0; i<opt_name_count; i++){
354         char buf[256];
355         const AVOption *opt;
356         const char *str= av_get_string(opts_ctx, opt_names[i], &opt, buf, sizeof(buf));
357         /* if an option with name opt_names[i] is present in opts_ctx then str is non-NULL */
358         if(str && ((opt->flags & flags) == flags))
359             av_set_string3(ctx, opt_names[i], str, 1, NULL);
360         /* We need to use a differnt system to pass options to the private context because
361            it is not known which codec and thus context kind that will be when parsing options
362            we thus use opt_values directly instead of opts_ctx */
363         if(!str && priv_ctx && av_get_string(priv_ctx, opt_names[i], &opt, buf, sizeof(buf))){
364             av_set_string3(priv_ctx, opt_names[i], opt_values[i], 1, NULL);
365         }
366     }
367 }
368
369 void print_error(const char *filename, int err)
370 {
371     char errbuf[128];
372     const char *errbuf_ptr = errbuf;
373
374     if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
375         errbuf_ptr = strerror(AVUNERROR(err));
376     fprintf(stderr, "%s: %s\n", filename, errbuf_ptr);
377 }
378
379 static int warned_cfg = 0;
380
381 #define INDENT        1
382 #define SHOW_VERSION  2
383 #define SHOW_CONFIG   4
384
385 #define PRINT_LIB_INFO(outstream,libname,LIBNAME,flags)                 \
386     if (CONFIG_##LIBNAME) {                                             \
387         const char *indent = flags & INDENT? "  " : "";                 \
388         if (flags & SHOW_VERSION) {                                     \
389             unsigned int version = libname##_version();                 \
390             fprintf(outstream, "%slib%-9s %2d.%3d.%2d / %2d.%3d.%2d\n", \
391                     indent, #libname,                                   \
392                     LIB##LIBNAME##_VERSION_MAJOR,                       \
393                     LIB##LIBNAME##_VERSION_MINOR,                       \
394                     LIB##LIBNAME##_VERSION_MICRO,                       \
395                     version >> 16, version >> 8 & 0xff, version & 0xff); \
396         }                                                               \
397         if (flags & SHOW_CONFIG) {                                      \
398             const char *cfg = libname##_configuration();                \
399             if (strcmp(FFMPEG_CONFIGURATION, cfg)) {                    \
400                 if (!warned_cfg) {                                      \
401                     fprintf(outstream,                                  \
402                             "%sWARNING: library configuration mismatch\n", \
403                             indent);                                    \
404                     warned_cfg = 1;                                     \
405                 }                                                       \
406                 fprintf(stderr, "%s%-11s configuration: %s\n",          \
407                         indent, #libname, cfg);                         \
408             }                                                           \
409         }                                                               \
410     }                                                                   \
411
412 static void print_all_libs_info(FILE* outstream, int flags)
413 {
414     PRINT_LIB_INFO(outstream, avutil,   AVUTIL,   flags);
415     PRINT_LIB_INFO(outstream, avcodec,  AVCODEC,  flags);
416     PRINT_LIB_INFO(outstream, avformat, AVFORMAT, flags);
417     PRINT_LIB_INFO(outstream, avdevice, AVDEVICE, flags);
418     PRINT_LIB_INFO(outstream, avfilter, AVFILTER, flags);
419     PRINT_LIB_INFO(outstream, swscale,  SWSCALE,  flags);
420     PRINT_LIB_INFO(outstream, postproc, POSTPROC, flags);
421 }
422
423 void show_banner(void)
424 {
425     fprintf(stderr, "%s version " FFMPEG_VERSION ", Copyright (c) %d-%d the FFmpeg developers\n",
426             program_name, program_birth_year, this_year);
427     fprintf(stderr, "  built on %s %s with %s %s\n",
428             __DATE__, __TIME__, CC_TYPE, CC_VERSION);
429     fprintf(stderr, "  configuration: " FFMPEG_CONFIGURATION "\n");
430     print_all_libs_info(stderr, INDENT|SHOW_CONFIG);
431     print_all_libs_info(stderr, INDENT|SHOW_VERSION);
432 }
433
434 void show_version(void) {
435     printf("%s " FFMPEG_VERSION "\n", program_name);
436     print_all_libs_info(stdout, SHOW_VERSION);
437 }
438
439 void show_license(void)
440 {
441     printf(
442 #if CONFIG_NONFREE
443     "This version of %s has nonfree parts compiled in.\n"
444     "Therefore it is not legally redistributable.\n",
445     program_name
446 #elif CONFIG_GPLV3
447     "%s is free software; you can redistribute it and/or modify\n"
448     "it under the terms of the GNU General Public License as published by\n"
449     "the Free Software Foundation; either version 3 of the License, or\n"
450     "(at your option) any later version.\n"
451     "\n"
452     "%s is distributed in the hope that it will be useful,\n"
453     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
454     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
455     "GNU General Public License for more details.\n"
456     "\n"
457     "You should have received a copy of the GNU General Public License\n"
458     "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
459     program_name, program_name, program_name
460 #elif CONFIG_GPL
461     "%s is free software; you can redistribute it and/or modify\n"
462     "it under the terms of the GNU General Public License as published by\n"
463     "the Free Software Foundation; either version 2 of the License, or\n"
464     "(at your option) any later version.\n"
465     "\n"
466     "%s is distributed in the hope that it will be useful,\n"
467     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
468     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
469     "GNU General Public License for more details.\n"
470     "\n"
471     "You should have received a copy of the GNU General Public License\n"
472     "along with %s; if not, write to the Free Software\n"
473     "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
474     program_name, program_name, program_name
475 #elif CONFIG_LGPLV3
476     "%s is free software; you can redistribute it and/or modify\n"
477     "it under the terms of the GNU Lesser General Public License as published by\n"
478     "the Free Software Foundation; either version 3 of the License, or\n"
479     "(at your option) any later version.\n"
480     "\n"
481     "%s is distributed in the hope that it will be useful,\n"
482     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
483     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
484     "GNU Lesser General Public License for more details.\n"
485     "\n"
486     "You should have received a copy of the GNU Lesser General Public License\n"
487     "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
488     program_name, program_name, program_name
489 #else
490     "%s is free software; you can redistribute it and/or\n"
491     "modify it under the terms of the GNU Lesser General Public\n"
492     "License as published by the Free Software Foundation; either\n"
493     "version 2.1 of the License, or (at your option) any later version.\n"
494     "\n"
495     "%s is distributed in the hope that it will be useful,\n"
496     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
497     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
498     "Lesser General Public License for more details.\n"
499     "\n"
500     "You should have received a copy of the GNU Lesser General Public\n"
501     "License along with %s; if not, write to the Free Software\n"
502     "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
503     program_name, program_name, program_name
504 #endif
505     );
506 }
507
508 void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
509 {
510     int i;
511     char fmt_str[128];
512     for (i=-1; i < nb_fmts; i++) {
513         get_fmt_string (fmt_str, sizeof(fmt_str), i);
514         fprintf(stdout, "%s\n", fmt_str);
515     }
516 }
517
518 void show_formats(void)
519 {
520     AVInputFormat *ifmt=NULL;
521     AVOutputFormat *ofmt=NULL;
522     const char *last_name;
523
524     printf(
525         "File formats:\n"
526         " D. = Demuxing supported\n"
527         " .E = Muxing supported\n"
528         " --\n");
529     last_name= "000";
530     for(;;){
531         int decode=0;
532         int encode=0;
533         const char *name=NULL;
534         const char *long_name=NULL;
535
536         while((ofmt= av_oformat_next(ofmt))) {
537             if((name == NULL || strcmp(ofmt->name, name)<0) &&
538                 strcmp(ofmt->name, last_name)>0){
539                 name= ofmt->name;
540                 long_name= ofmt->long_name;
541                 encode=1;
542             }
543         }
544         while((ifmt= av_iformat_next(ifmt))) {
545             if((name == NULL || strcmp(ifmt->name, name)<0) &&
546                 strcmp(ifmt->name, last_name)>0){
547                 name= ifmt->name;
548                 long_name= ifmt->long_name;
549                 encode=0;
550             }
551             if(name && strcmp(ifmt->name, name)==0)
552                 decode=1;
553         }
554         if(name==NULL)
555             break;
556         last_name= name;
557
558         printf(
559             " %s%s %-15s %s\n",
560             decode ? "D":" ",
561             encode ? "E":" ",
562             name,
563             long_name ? long_name:" ");
564     }
565 }
566
567 void show_codecs(void)
568 {
569     AVCodec *p=NULL, *p2;
570     const char *last_name;
571     printf(
572         "Codecs:\n"
573         " D..... = Decoding supported\n"
574         " .E.... = Encoding supported\n"
575         " ..V... = Video codec\n"
576         " ..A... = Audio codec\n"
577         " ..S... = Subtitle codec\n"
578         " ...S.. = Supports draw_horiz_band\n"
579         " ....D. = Supports direct rendering method 1\n"
580         " .....T = Supports weird frame truncation\n"
581         " ------\n");
582     last_name= "000";
583     for(;;){
584         int decode=0;
585         int encode=0;
586         int cap=0;
587         const char *type_str;
588
589         p2=NULL;
590         while((p= av_codec_next(p))) {
591             if((p2==NULL || strcmp(p->name, p2->name)<0) &&
592                 strcmp(p->name, last_name)>0){
593                 p2= p;
594                 decode= encode= cap=0;
595             }
596             if(p2 && strcmp(p->name, p2->name)==0){
597                 if(p->decode) decode=1;
598                 if(p->encode) encode=1;
599                 cap |= p->capabilities;
600             }
601         }
602         if(p2==NULL)
603             break;
604         last_name= p2->name;
605
606         switch(p2->type) {
607         case AVMEDIA_TYPE_VIDEO:
608             type_str = "V";
609             break;
610         case AVMEDIA_TYPE_AUDIO:
611             type_str = "A";
612             break;
613         case AVMEDIA_TYPE_SUBTITLE:
614             type_str = "S";
615             break;
616         default:
617             type_str = "?";
618             break;
619         }
620         printf(
621             " %s%s%s%s%s%s %-15s %s",
622             decode ? "D": (/*p2->decoder ? "d":*/" "),
623             encode ? "E":" ",
624             type_str,
625             cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
626             cap & CODEC_CAP_DR1 ? "D":" ",
627             cap & CODEC_CAP_TRUNCATED ? "T":" ",
628             p2->name,
629             p2->long_name ? p2->long_name : "");
630        /* if(p2->decoder && decode==0)
631             printf(" use %s for decoding", p2->decoder->name);*/
632         printf("\n");
633     }
634     printf("\n");
635     printf(
636 "Note, the names of encoders and decoders do not always match, so there are\n"
637 "several cases where the above table shows encoder only or decoder only entries\n"
638 "even though both encoding and decoding are supported. For example, the h263\n"
639 "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
640 "worse.\n");
641 }
642
643 void show_bsfs(void)
644 {
645     AVBitStreamFilter *bsf=NULL;
646
647     printf("Bitstream filters:\n");
648     while((bsf = av_bitstream_filter_next(bsf)))
649         printf("%s\n", bsf->name);
650     printf("\n");
651 }
652
653 void show_protocols(void)
654 {
655     URLProtocol *up=NULL;
656
657     printf("Supported file protocols:\n"
658            "I.. = Input  supported\n"
659            ".O. = Output supported\n"
660            "..S = Seek   supported\n"
661            "FLAGS NAME\n"
662            "----- \n");
663     while((up = av_protocol_next(up)))
664         printf("%c%c%c   %s\n",
665                up->url_read  ? 'I' : '.',
666                up->url_write ? 'O' : '.',
667                up->url_seek  ? 'S' : '.',
668                up->name);
669 }
670
671 void show_filters(void)
672 {
673     AVFilter av_unused(**filter) = NULL;
674
675     printf("Filters:\n");
676 #if CONFIG_AVFILTER
677     while ((filter = av_filter_next(filter)) && *filter)
678         printf("%-16s %s\n", (*filter)->name, (*filter)->description);
679 #endif
680 }
681
682 void show_pix_fmts(void)
683 {
684     enum PixelFormat pix_fmt;
685
686     printf(
687         "Pixel formats:\n"
688         "I.... = Supported Input  format for conversion\n"
689         ".O... = Supported Output format for conversion\n"
690         "..H.. = Hardware accelerated format\n"
691         "...P. = Paletted format\n"
692         "....B = Bitstream format\n"
693         "FLAGS NAME            NB_COMPONENTS BITS_PER_PIXEL\n"
694         "-----\n");
695
696 #if !CONFIG_SWSCALE
697 #   define sws_isSupportedInput(x)  0
698 #   define sws_isSupportedOutput(x) 0
699 #endif
700
701     for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {
702         const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[pix_fmt];
703         printf("%c%c%c%c%c %-16s       %d            %2d\n",
704                sws_isSupportedInput (pix_fmt)      ? 'I' : '.',
705                sws_isSupportedOutput(pix_fmt)      ? 'O' : '.',
706                pix_desc->flags & PIX_FMT_HWACCEL   ? 'H' : '.',
707                pix_desc->flags & PIX_FMT_PAL       ? 'P' : '.',
708                pix_desc->flags & PIX_FMT_BITSTREAM ? 'B' : '.',
709                pix_desc->name,
710                pix_desc->nb_components,
711                av_get_bits_per_pixel(pix_desc));
712     }
713 }
714
715 int read_yesno(void)
716 {
717     int c = getchar();
718     int yesno = (toupper(c) == 'Y');
719
720     while (c != '\n' && c != EOF)
721         c = getchar();
722
723     return yesno;
724 }
725
726 int read_file(const char *filename, char **bufptr, size_t *size)
727 {
728     FILE *f = fopen(filename, "rb");
729
730     if (!f) {
731         fprintf(stderr, "Cannot read file '%s': %s\n", filename, strerror(errno));
732         return AVERROR(errno);
733     }
734     fseek(f, 0, SEEK_END);
735     *size = ftell(f);
736     fseek(f, 0, SEEK_SET);
737     *bufptr = av_malloc(*size + 1);
738     if (!*bufptr) {
739         fprintf(stderr, "Could not allocate file buffer\n");
740         fclose(f);
741         return AVERROR(ENOMEM);
742     }
743     fread(*bufptr, 1, *size, f);
744     (*bufptr)[*size++] = '\0';
745
746     fclose(f);
747     return 0;
748 }
749
750 void init_pts_correction(PtsCorrectionContext *ctx)
751 {
752     ctx->num_faulty_pts = ctx->num_faulty_dts = 0;
753     ctx->last_pts = ctx->last_dts = INT64_MIN;
754 }
755
756 int64_t guess_correct_pts(PtsCorrectionContext *ctx, int64_t reordered_pts, int64_t dts)
757 {
758     int64_t pts = AV_NOPTS_VALUE;
759
760     if (dts != AV_NOPTS_VALUE) {
761         ctx->num_faulty_dts += dts <= ctx->last_dts;
762         ctx->last_dts = dts;
763     }
764     if (reordered_pts != AV_NOPTS_VALUE) {
765         ctx->num_faulty_pts += reordered_pts <= ctx->last_pts;
766         ctx->last_pts = reordered_pts;
767     }
768     if ((ctx->num_faulty_pts<=ctx->num_faulty_dts || dts == AV_NOPTS_VALUE)
769        && reordered_pts != AV_NOPTS_VALUE)
770         pts = reordered_pts;
771     else
772         pts = dts;
773
774     return pts;
775 }
776
777 FILE *get_preset_file(char *filename, size_t filename_size,
778                       const char *preset_name, int is_path, const char *codec_name)
779 {
780     FILE *f = NULL;
781     int i;
782     const char *base[3]= { getenv("FFMPEG_DATADIR"),
783                            getenv("HOME"),
784                            FFMPEG_DATADIR,
785                          };
786
787     if (is_path) {
788         av_strlcpy(filename, preset_name, filename_size);
789         f = fopen(filename, "r");
790     } else {
791         for (i = 0; i < 3 && !f; i++) {
792             if (!base[i])
793                 continue;
794             snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", preset_name);
795             f = fopen(filename, "r");
796             if (!f && codec_name) {
797                 snprintf(filename, filename_size,
798                          "%s%s/%s-%s.ffpreset", base[i],  i != 1 ? "" : "/.ffmpeg", codec_name, preset_name);
799                 f = fopen(filename, "r");
800             }
801         }
802     }
803
804     return f;
805 }
806
807 #if CONFIG_AVFILTER
808
809 static int ffsink_init(AVFilterContext *ctx, const char *args, void *opaque)
810 {
811     FFSinkContext *priv = ctx->priv;
812
813     if (!opaque)
814         return AVERROR(EINVAL);
815     *priv = *(FFSinkContext *)opaque;
816
817     return 0;
818 }
819
820 static void null_end_frame(AVFilterLink *inlink) { }
821
822 static int ffsink_query_formats(AVFilterContext *ctx)
823 {
824     FFSinkContext *priv = ctx->priv;
825     enum PixelFormat pix_fmts[] = { priv->pix_fmt, PIX_FMT_NONE };
826
827     avfilter_set_common_formats(ctx, avfilter_make_format_list(pix_fmts));
828     return 0;
829 }
830
831 AVFilter ffsink = {
832     .name      = "ffsink",
833     .priv_size = sizeof(FFSinkContext),
834     .init      = ffsink_init,
835
836     .query_formats = ffsink_query_formats,
837
838     .inputs    = (AVFilterPad[]) {{ .name          = "default",
839                                     .type          = AVMEDIA_TYPE_VIDEO,
840                                     .end_frame     = null_end_frame,
841                                     .min_perms     = AV_PERM_READ, },
842                                   { .name = NULL }},
843     .outputs   = (AVFilterPad[]) {{ .name = NULL }},
844 };
845
846 int get_filtered_video_frame(AVFilterContext *ctx, AVFrame *frame,
847                              AVFilterBufferRef **picref_ptr, AVRational *tb)
848 {
849     int ret;
850     AVFilterBufferRef *picref;
851
852     if ((ret = avfilter_request_frame(ctx->inputs[0])) < 0)
853         return ret;
854     if (!(picref = ctx->inputs[0]->cur_buf))
855         return AVERROR(ENOENT);
856     *picref_ptr = picref;
857     ctx->inputs[0]->cur_buf = NULL;
858     *tb = ctx->inputs[0]->time_base;
859
860     memcpy(frame->data,     picref->data,     sizeof(frame->data));
861     memcpy(frame->linesize, picref->linesize, sizeof(frame->linesize));
862     frame->interlaced_frame = picref->video->interlaced;
863     frame->top_field_first  = picref->video->top_field_first;
864
865     return 1;
866 }
867
868 #endif /* CONFIG_AVFILTER */