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