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