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