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