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