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