Replace more FFmpeg references by Libav.
[ffmpeg.git] / cmdutils.c
1 /*
2  * Various utilities for command line tools
3  * Copyright (c) 2000-2003 Fabrice Bellard
4  *
5  * This file is part of Libav.
6  *
7  * Libav is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * Libav is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with Libav; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21
22 #include <string.h>
23 #include <stdlib.h>
24 #include <errno.h>
25 #include <math.h>
26
27 /* Include only the enabled headers since some compilers (namely, Sun
28    Studio) will not omit unused inline functions and create undefined
29    references to libraries that are not being built. */
30
31 #include "config.h"
32 #include "libavformat/avformat.h"
33 #include "libavfilter/avfilter.h"
34 #include "libavdevice/avdevice.h"
35 #include "libswscale/swscale.h"
36 #include "libpostproc/postprocess.h"
37 #include "libavutil/avstring.h"
38 #include "libavutil/parseutils.h"
39 #include "libavutil/pixdesc.h"
40 #include "libavutil/eval.h"
41 #include "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 {
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(LIBAV_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, avcodec,  AVCODEC,  flags);
417     PRINT_LIB_INFO(outstream, avformat, AVFORMAT, flags);
418     PRINT_LIB_INFO(outstream, avdevice, AVDEVICE, flags);
419     PRINT_LIB_INFO(outstream, avfilter, AVFILTER, flags);
420     PRINT_LIB_INFO(outstream, swscale,  SWSCALE,  flags);
421     PRINT_LIB_INFO(outstream, postproc, POSTPROC, flags);
422 }
423
424 void show_banner(void)
425 {
426     fprintf(stderr, "%s version " LIBAV_VERSION ", Copyright (c) %d-%d the Libav developers\n",
427             program_name, program_birth_year, this_year);
428     fprintf(stderr, "  built on %s %s with %s %s\n",
429             __DATE__, __TIME__, CC_TYPE, CC_VERSION);
430     fprintf(stderr, "  configuration: " LIBAV_CONFIGURATION "\n");
431     print_all_libs_info(stderr, INDENT|SHOW_CONFIG);
432     print_all_libs_info(stderr, INDENT|SHOW_VERSION);
433 }
434
435 void show_version(void) {
436     printf("%s " LIBAV_VERSION "\n", program_name);
437     print_all_libs_info(stdout, SHOW_VERSION);
438 }
439
440 void show_license(void)
441 {
442     printf(
443 #if CONFIG_NONFREE
444     "This version of %s has nonfree parts compiled in.\n"
445     "Therefore it is not legally redistributable.\n",
446     program_name
447 #elif CONFIG_GPLV3
448     "%s is free software; you can redistribute it and/or modify\n"
449     "it under the terms of the GNU General Public License as published by\n"
450     "the Free Software Foundation; either version 3 of the License, or\n"
451     "(at your option) any later version.\n"
452     "\n"
453     "%s is distributed in the hope that it will be useful,\n"
454     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
455     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
456     "GNU General Public License for more details.\n"
457     "\n"
458     "You should have received a copy of the GNU General Public License\n"
459     "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
460     program_name, program_name, program_name
461 #elif CONFIG_GPL
462     "%s is free software; you can redistribute it and/or modify\n"
463     "it under the terms of the GNU General Public License as published by\n"
464     "the Free Software Foundation; either version 2 of the License, or\n"
465     "(at your option) any later version.\n"
466     "\n"
467     "%s is distributed in the hope that it will be useful,\n"
468     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
469     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
470     "GNU General Public License for more details.\n"
471     "\n"
472     "You should have received a copy of the GNU General Public License\n"
473     "along with %s; if not, write to the Free Software\n"
474     "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
475     program_name, program_name, program_name
476 #elif CONFIG_LGPLV3
477     "%s is free software; you can redistribute it and/or modify\n"
478     "it under the terms of the GNU Lesser General Public License as published by\n"
479     "the Free Software Foundation; either version 3 of the License, or\n"
480     "(at your option) any later version.\n"
481     "\n"
482     "%s is distributed in the hope that it will be useful,\n"
483     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
484     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
485     "GNU Lesser General Public License for more details.\n"
486     "\n"
487     "You should have received a copy of the GNU Lesser General Public License\n"
488     "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
489     program_name, program_name, program_name
490 #else
491     "%s is free software; you can redistribute it and/or\n"
492     "modify it under the terms of the GNU Lesser General Public\n"
493     "License as published by the Free Software Foundation; either\n"
494     "version 2.1 of the License, or (at your option) any later version.\n"
495     "\n"
496     "%s is distributed in the hope that it will be useful,\n"
497     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
498     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
499     "Lesser General Public License for more details.\n"
500     "\n"
501     "You should have received a copy of the GNU Lesser General Public\n"
502     "License along with %s; if not, write to the Free Software\n"
503     "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
504     program_name, program_name, program_name
505 #endif
506     );
507 }
508
509 void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
510 {
511     int i;
512     char fmt_str[128];
513     for (i=-1; i < nb_fmts; i++) {
514         get_fmt_string (fmt_str, sizeof(fmt_str), i);
515         fprintf(stdout, "%s\n", fmt_str);
516     }
517 }
518
519 void show_formats(void)
520 {
521     AVInputFormat *ifmt=NULL;
522     AVOutputFormat *ofmt=NULL;
523     const char *last_name;
524
525     printf(
526         "File formats:\n"
527         " D. = Demuxing supported\n"
528         " .E = Muxing supported\n"
529         " --\n");
530     last_name= "000";
531     for(;;){
532         int decode=0;
533         int encode=0;
534         const char *name=NULL;
535         const char *long_name=NULL;
536
537         while((ofmt= av_oformat_next(ofmt))) {
538             if((name == NULL || strcmp(ofmt->name, name)<0) &&
539                 strcmp(ofmt->name, last_name)>0){
540                 name= ofmt->name;
541                 long_name= ofmt->long_name;
542                 encode=1;
543             }
544         }
545         while((ifmt= av_iformat_next(ifmt))) {
546             if((name == NULL || strcmp(ifmt->name, name)<0) &&
547                 strcmp(ifmt->name, last_name)>0){
548                 name= ifmt->name;
549                 long_name= ifmt->long_name;
550                 encode=0;
551             }
552             if(name && strcmp(ifmt->name, name)==0)
553                 decode=1;
554         }
555         if(name==NULL)
556             break;
557         last_name= name;
558
559         printf(
560             " %s%s %-15s %s\n",
561             decode ? "D":" ",
562             encode ? "E":" ",
563             name,
564             long_name ? long_name:" ");
565     }
566 }
567
568 void show_codecs(void)
569 {
570     AVCodec *p=NULL, *p2;
571     const char *last_name;
572     printf(
573         "Codecs:\n"
574         " D..... = Decoding supported\n"
575         " .E.... = Encoding supported\n"
576         " ..V... = Video codec\n"
577         " ..A... = Audio codec\n"
578         " ..S... = Subtitle codec\n"
579         " ...S.. = Supports draw_horiz_band\n"
580         " ....D. = Supports direct rendering method 1\n"
581         " .....T = Supports weird frame truncation\n"
582         " ------\n");
583     last_name= "000";
584     for(;;){
585         int decode=0;
586         int encode=0;
587         int cap=0;
588         const char *type_str;
589
590         p2=NULL;
591         while((p= av_codec_next(p))) {
592             if((p2==NULL || strcmp(p->name, p2->name)<0) &&
593                 strcmp(p->name, last_name)>0){
594                 p2= p;
595                 decode= encode= cap=0;
596             }
597             if(p2 && strcmp(p->name, p2->name)==0){
598                 if(p->decode) decode=1;
599                 if(p->encode) encode=1;
600                 cap |= p->capabilities;
601             }
602         }
603         if(p2==NULL)
604             break;
605         last_name= p2->name;
606
607         switch(p2->type) {
608         case AVMEDIA_TYPE_VIDEO:
609             type_str = "V";
610             break;
611         case AVMEDIA_TYPE_AUDIO:
612             type_str = "A";
613             break;
614         case AVMEDIA_TYPE_SUBTITLE:
615             type_str = "S";
616             break;
617         default:
618             type_str = "?";
619             break;
620         }
621         printf(
622             " %s%s%s%s%s%s %-15s %s",
623             decode ? "D": (/*p2->decoder ? "d":*/" "),
624             encode ? "E":" ",
625             type_str,
626             cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
627             cap & CODEC_CAP_DR1 ? "D":" ",
628             cap & CODEC_CAP_TRUNCATED ? "T":" ",
629             p2->name,
630             p2->long_name ? p2->long_name : "");
631        /* if(p2->decoder && decode==0)
632             printf(" use %s for decoding", p2->decoder->name);*/
633         printf("\n");
634     }
635     printf("\n");
636     printf(
637 "Note, the names of encoders and decoders do not always match, so there are\n"
638 "several cases where the above table shows encoder only or decoder only entries\n"
639 "even though both encoding and decoding are supported. For example, the h263\n"
640 "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
641 "worse.\n");
642 }
643
644 void show_bsfs(void)
645 {
646     AVBitStreamFilter *bsf=NULL;
647
648     printf("Bitstream filters:\n");
649     while((bsf = av_bitstream_filter_next(bsf)))
650         printf("%s\n", bsf->name);
651     printf("\n");
652 }
653
654 void show_protocols(void)
655 {
656     void *opaque = NULL;
657     const char *name;
658
659     printf("Supported file protocols:\n"
660            "Input:\n");
661     while ((name = avio_enum_protocols(&opaque, 0)))
662         printf("%s\n", name);
663     printf("Output:\n");
664     while ((name = avio_enum_protocols(&opaque, 1)))
665         printf("%s\n", name);
666 }
667
668 void show_filters(void)
669 {
670     AVFilter av_unused(**filter) = NULL;
671
672     printf("Filters:\n");
673 #if CONFIG_AVFILTER
674     while ((filter = av_filter_next(filter)) && *filter)
675         printf("%-16s %s\n", (*filter)->name, (*filter)->description);
676 #endif
677 }
678
679 void show_pix_fmts(void)
680 {
681     enum PixelFormat pix_fmt;
682
683     printf(
684         "Pixel formats:\n"
685         "I.... = Supported Input  format for conversion\n"
686         ".O... = Supported Output format for conversion\n"
687         "..H.. = Hardware accelerated format\n"
688         "...P. = Paletted format\n"
689         "....B = Bitstream format\n"
690         "FLAGS NAME            NB_COMPONENTS BITS_PER_PIXEL\n"
691         "-----\n");
692
693 #if !CONFIG_SWSCALE
694 #   define sws_isSupportedInput(x)  0
695 #   define sws_isSupportedOutput(x) 0
696 #endif
697
698     for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {
699         const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[pix_fmt];
700         printf("%c%c%c%c%c %-16s       %d            %2d\n",
701                sws_isSupportedInput (pix_fmt)      ? 'I' : '.',
702                sws_isSupportedOutput(pix_fmt)      ? 'O' : '.',
703                pix_desc->flags & PIX_FMT_HWACCEL   ? 'H' : '.',
704                pix_desc->flags & PIX_FMT_PAL       ? 'P' : '.',
705                pix_desc->flags & PIX_FMT_BITSTREAM ? 'B' : '.',
706                pix_desc->name,
707                pix_desc->nb_components,
708                av_get_bits_per_pixel(pix_desc));
709     }
710 }
711
712 int read_yesno(void)
713 {
714     int c = getchar();
715     int yesno = (toupper(c) == 'Y');
716
717     while (c != '\n' && c != EOF)
718         c = getchar();
719
720     return yesno;
721 }
722
723 int read_file(const char *filename, char **bufptr, size_t *size)
724 {
725     FILE *f = fopen(filename, "rb");
726
727     if (!f) {
728         fprintf(stderr, "Cannot read file '%s': %s\n", filename, strerror(errno));
729         return AVERROR(errno);
730     }
731     fseek(f, 0, SEEK_END);
732     *size = ftell(f);
733     fseek(f, 0, SEEK_SET);
734     *bufptr = av_malloc(*size + 1);
735     if (!*bufptr) {
736         fprintf(stderr, "Could not allocate file buffer\n");
737         fclose(f);
738         return AVERROR(ENOMEM);
739     }
740     fread(*bufptr, 1, *size, f);
741     (*bufptr)[*size++] = '\0';
742
743     fclose(f);
744     return 0;
745 }
746
747 void init_pts_correction(PtsCorrectionContext *ctx)
748 {
749     ctx->num_faulty_pts = ctx->num_faulty_dts = 0;
750     ctx->last_pts = ctx->last_dts = INT64_MIN;
751 }
752
753 int64_t guess_correct_pts(PtsCorrectionContext *ctx, int64_t reordered_pts, int64_t dts)
754 {
755     int64_t pts = AV_NOPTS_VALUE;
756
757     if (dts != AV_NOPTS_VALUE) {
758         ctx->num_faulty_dts += dts <= ctx->last_dts;
759         ctx->last_dts = dts;
760     }
761     if (reordered_pts != AV_NOPTS_VALUE) {
762         ctx->num_faulty_pts += reordered_pts <= ctx->last_pts;
763         ctx->last_pts = reordered_pts;
764     }
765     if ((ctx->num_faulty_pts<=ctx->num_faulty_dts || dts == AV_NOPTS_VALUE)
766        && reordered_pts != AV_NOPTS_VALUE)
767         pts = reordered_pts;
768     else
769         pts = dts;
770
771     return pts;
772 }
773
774 FILE *get_preset_file(char *filename, size_t filename_size,
775                       const char *preset_name, int is_path, const char *codec_name)
776 {
777     FILE *f = NULL;
778     int i;
779     const char *base[3]= { getenv("FFMPEG_DATADIR"),
780                            getenv("HOME"),
781                            FFMPEG_DATADIR,
782                          };
783
784     if (is_path) {
785         av_strlcpy(filename, preset_name, filename_size);
786         f = fopen(filename, "r");
787     } else {
788         for (i = 0; i < 3 && !f; i++) {
789             if (!base[i])
790                 continue;
791             snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", preset_name);
792             f = fopen(filename, "r");
793             if (!f && codec_name) {
794                 snprintf(filename, filename_size,
795                          "%s%s/%s-%s.ffpreset", base[i],  i != 1 ? "" : "/.ffmpeg", codec_name, preset_name);
796                 f = fopen(filename, "r");
797             }
798         }
799     }
800
801     return f;
802 }
803
804 #if CONFIG_AVFILTER
805
806 static int ffsink_init(AVFilterContext *ctx, const char *args, void *opaque)
807 {
808     FFSinkContext *priv = ctx->priv;
809
810     if (!opaque)
811         return AVERROR(EINVAL);
812     *priv = *(FFSinkContext *)opaque;
813
814     return 0;
815 }
816
817 static void null_end_frame(AVFilterLink *inlink) { }
818
819 static int ffsink_query_formats(AVFilterContext *ctx)
820 {
821     FFSinkContext *priv = ctx->priv;
822     enum PixelFormat pix_fmts[] = { priv->pix_fmt, PIX_FMT_NONE };
823
824     avfilter_set_common_formats(ctx, avfilter_make_format_list(pix_fmts));
825     return 0;
826 }
827
828 AVFilter ffsink = {
829     .name      = "ffsink",
830     .priv_size = sizeof(FFSinkContext),
831     .init      = ffsink_init,
832
833     .query_formats = ffsink_query_formats,
834
835     .inputs    = (AVFilterPad[]) {{ .name          = "default",
836                                     .type          = AVMEDIA_TYPE_VIDEO,
837                                     .end_frame     = null_end_frame,
838                                     .min_perms     = AV_PERM_READ, },
839                                   { .name = NULL }},
840     .outputs   = (AVFilterPad[]) {{ .name = NULL }},
841 };
842
843 int get_filtered_video_frame(AVFilterContext *ctx, AVFrame *frame,
844                              AVFilterBufferRef **picref_ptr, AVRational *tb)
845 {
846     int ret;
847     AVFilterBufferRef *picref;
848
849     if ((ret = avfilter_request_frame(ctx->inputs[0])) < 0)
850         return ret;
851     if (!(picref = ctx->inputs[0]->cur_buf))
852         return AVERROR(ENOENT);
853     *picref_ptr = picref;
854     ctx->inputs[0]->cur_buf = NULL;
855     *tb = ctx->inputs[0]->time_base;
856
857     memcpy(frame->data,     picref->data,     sizeof(frame->data));
858     memcpy(frame->linesize, picref->linesize, sizeof(frame->linesize));
859     frame->interlaced_frame = picref->video->interlaced;
860     frame->top_field_first  = picref->video->top_field_first;
861
862     return 1;
863 }
864
865 #endif /* CONFIG_AVFILTER */