westwood: Make sure audio header info is present when parsing audio packets
[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/mathematics.h"
39 #include "libavutil/parseutils.h"
40 #include "libavutil/pixdesc.h"
41 #include "libavutil/eval.h"
42 #include "libavutil/dict.h"
43 #include "libavutil/opt.h"
44 #include "cmdutils.h"
45 #include "version.h"
46 #if CONFIG_NETWORK
47 #include "libavformat/network.h"
48 #endif
49 #if HAVE_SYS_RESOURCE_H
50 #include <sys/resource.h>
51 #endif
52
53 struct SwsContext *sws_opts;
54 AVDictionary *format_opts, *codec_opts;
55
56 static const int this_year = 2011;
57
58 void init_opts(void)
59 {
60 #if CONFIG_SWSCALE
61     sws_opts = sws_getContext(16, 16, 0, 16, 16, 0, SWS_BICUBIC, NULL, NULL, NULL);
62 #endif
63 }
64
65 void uninit_opts(void)
66 {
67 #if CONFIG_SWSCALE
68     sws_freeContext(sws_opts);
69     sws_opts = NULL;
70 #endif
71     av_dict_free(&format_opts);
72     av_dict_free(&codec_opts);
73 }
74
75 void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
76 {
77     vfprintf(stdout, fmt, vl);
78 }
79
80 double parse_number_or_die(const char *context, const char *numstr, int type, double min, double max)
81 {
82     char *tail;
83     const char *error;
84     double d = av_strtod(numstr, &tail);
85     if (*tail)
86         error= "Expected number for %s but found: %s\n";
87     else if (d < min || d > max)
88         error= "The value for %s was %s which is not within %f - %f\n";
89     else if(type == OPT_INT64 && (int64_t)d != d)
90         error= "Expected int64 for %s but found %s\n";
91     else if (type == OPT_INT && (int)d != d)
92         error= "Expected int for %s but found %s\n";
93     else
94         return d;
95     av_log(NULL, AV_LOG_FATAL, error, context, numstr, min, max);
96     exit_program(1);
97     return 0;
98 }
99
100 int64_t parse_time_or_die(const char *context, const char *timestr, int is_duration)
101 {
102     int64_t us;
103     if (av_parse_time(&us, timestr, is_duration) < 0) {
104         av_log(NULL, AV_LOG_FATAL, "Invalid %s specification for %s: %s\n",
105                is_duration ? "duration" : "date", context, timestr);
106         exit_program(1);
107     }
108     return us;
109 }
110
111 void show_help_options(const OptionDef *options, const char *msg, int mask, int value)
112 {
113     const OptionDef *po;
114     int first;
115
116     first = 1;
117     for(po = options; po->name != NULL; po++) {
118         char buf[64];
119         if ((po->flags & mask) == value) {
120             if (first) {
121                 printf("%s", msg);
122                 first = 0;
123             }
124             av_strlcpy(buf, po->name, sizeof(buf));
125             if (po->flags & HAS_ARG) {
126                 av_strlcat(buf, " ", sizeof(buf));
127                 av_strlcat(buf, po->argname, sizeof(buf));
128             }
129             printf("-%-17s  %s\n", buf, po->help);
130         }
131     }
132 }
133
134 void show_help_children(const AVClass *class, int flags)
135 {
136     const AVClass *child = NULL;
137     av_opt_show2(&class, NULL, flags, 0);
138     printf("\n");
139
140     while (child = av_opt_child_class_next(class, child))
141         show_help_children(child, flags);
142 }
143
144 static const OptionDef* find_option(const OptionDef *po, const char *name){
145     const char *p = strchr(name, ':');
146     int len = p ? p - name : strlen(name);
147
148     while (po->name != NULL) {
149         if (!strncmp(name, po->name, len) && strlen(po->name) == len)
150             break;
151         po++;
152     }
153     return po;
154 }
155
156 #if defined(_WIN32) && !defined(__MINGW32CE__)
157 #include <windows.h>
158 /* Will be leaked on exit */
159 static char** win32_argv_utf8 = NULL;
160 static int win32_argc = 0;
161
162 /**
163  * Prepare command line arguments for executable.
164  * For Windows - perform wide-char to UTF-8 conversion.
165  * Input arguments should be main() function arguments.
166  * @param argc_ptr Arguments number (including executable)
167  * @param argv_ptr Arguments list.
168  */
169 static void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
170 {
171     char *argstr_flat;
172     wchar_t **argv_w;
173     int i, buffsize = 0, offset = 0;
174
175     if (win32_argv_utf8) {
176         *argc_ptr = win32_argc;
177         *argv_ptr = win32_argv_utf8;
178         return;
179     }
180
181     win32_argc = 0;
182     argv_w = CommandLineToArgvW(GetCommandLineW(), &win32_argc);
183     if (win32_argc <= 0 || !argv_w)
184         return;
185
186     /* determine the UTF-8 buffer size (including NULL-termination symbols) */
187     for (i = 0; i < win32_argc; i++)
188         buffsize += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
189                                         NULL, 0, NULL, NULL);
190
191     win32_argv_utf8 = av_mallocz(sizeof(char*) * (win32_argc + 1) + buffsize);
192     argstr_flat     = (char*)win32_argv_utf8 + sizeof(char*) * (win32_argc + 1);
193     if (win32_argv_utf8 == NULL) {
194         LocalFree(argv_w);
195         return;
196     }
197
198     for (i = 0; i < win32_argc; i++) {
199         win32_argv_utf8[i] = &argstr_flat[offset];
200         offset += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
201                                       &argstr_flat[offset],
202                                       buffsize - offset, NULL, NULL);
203     }
204     win32_argv_utf8[i] = NULL;
205     LocalFree(argv_w);
206
207     *argc_ptr = win32_argc;
208     *argv_ptr = win32_argv_utf8;
209 }
210 #else
211 static inline void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
212 {
213     /* nothing to do */
214 }
215 #endif /* WIN32 && !__MINGW32CE__ */
216
217 int parse_option(void *optctx, const char *opt, const char *arg, const OptionDef *options)
218 {
219     const OptionDef *po;
220     int bool_val = 1;
221     int *dstcount;
222     void *dst;
223
224     po = find_option(options, opt);
225     if (!po->name && opt[0] == 'n' && opt[1] == 'o') {
226         /* handle 'no' bool option */
227         po = find_option(options, opt + 2);
228         if (!(po->name && (po->flags & OPT_BOOL)))
229             goto unknown_opt;
230         bool_val = 0;
231     }
232     if (!po->name)
233         po = find_option(options, "default");
234     if (!po->name) {
235 unknown_opt:
236         av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);
237         return AVERROR(EINVAL);
238     }
239     if (po->flags & HAS_ARG && !arg) {
240         av_log(NULL, AV_LOG_ERROR, "Missing argument for option '%s'\n", opt);
241         return AVERROR(EINVAL);
242     }
243
244     /* new-style options contain an offset into optctx, old-style address of
245      * a global var*/
246     dst = po->flags & (OPT_OFFSET|OPT_SPEC) ? (uint8_t*)optctx + po->u.off : po->u.dst_ptr;
247
248     if (po->flags & OPT_SPEC) {
249         SpecifierOpt **so = dst;
250         char *p = strchr(opt, ':');
251
252         dstcount = (int*)(so + 1);
253         *so = grow_array(*so, sizeof(**so), dstcount, *dstcount + 1);
254         (*so)[*dstcount - 1].specifier = av_strdup(p ? p + 1 : "");
255         dst = &(*so)[*dstcount - 1].u;
256     }
257
258     if (po->flags & OPT_STRING) {
259         char *str;
260         str = av_strdup(arg);
261         *(char**)dst = str;
262     } else if (po->flags & OPT_BOOL) {
263         *(int*)dst = bool_val;
264     } else if (po->flags & OPT_INT) {
265         *(int*)dst = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
266     } else if (po->flags & OPT_INT64) {
267         *(int64_t*)dst = parse_number_or_die(opt, arg, OPT_INT64, INT64_MIN, INT64_MAX);
268     } else if (po->flags & OPT_TIME) {
269         *(int64_t*)dst = parse_time_or_die(opt, arg, 1);
270     } else if (po->flags & OPT_FLOAT) {
271         *(float*)dst = parse_number_or_die(opt, arg, OPT_FLOAT, -INFINITY, INFINITY);
272     } else if (po->flags & OPT_DOUBLE) {
273         *(double*)dst = parse_number_or_die(opt, arg, OPT_DOUBLE, -INFINITY, INFINITY);
274     } else if (po->u.func_arg) {
275         int ret = po->flags & OPT_FUNC2 ? po->u.func2_arg(optctx, opt, arg) :
276                                           po->u.func_arg(opt, arg);
277         if (ret < 0) {
278             av_log(NULL, AV_LOG_ERROR, "Failed to set value '%s' for option '%s'\n", arg, opt);
279             return ret;
280         }
281     }
282     if (po->flags & OPT_EXIT)
283         exit_program(0);
284     return !!(po->flags & HAS_ARG);
285 }
286
287 void parse_options(void *optctx, int argc, char **argv, const OptionDef *options,
288                    void (* parse_arg_function)(void *, const char*))
289 {
290     const char *opt;
291     int optindex, handleoptions = 1, ret;
292
293     /* perform system-dependent conversions for arguments list */
294     prepare_app_arguments(&argc, &argv);
295
296     /* parse options */
297     optindex = 1;
298     while (optindex < argc) {
299         opt = argv[optindex++];
300
301         if (handleoptions && opt[0] == '-' && opt[1] != '\0') {
302             if (opt[1] == '-' && opt[2] == '\0') {
303                 handleoptions = 0;
304                 continue;
305             }
306             opt++;
307
308             if ((ret = parse_option(optctx, opt, argv[optindex], options)) < 0)
309                 exit_program(1);
310             optindex += ret;
311         } else {
312             if (parse_arg_function)
313                 parse_arg_function(optctx, opt);
314         }
315     }
316 }
317
318 /*
319  * Return index of option opt in argv or 0 if not found.
320  */
321 static int locate_option(int argc, char **argv, const OptionDef *options, const char *optname)
322 {
323     const OptionDef *po;
324     int i;
325
326     for (i = 1; i < argc; i++) {
327         const char *cur_opt = argv[i];
328
329         if (*cur_opt++ != '-')
330             continue;
331
332         po = find_option(options, cur_opt);
333         if (!po->name && cur_opt[0] == 'n' && cur_opt[1] == 'o')
334             po = find_option(options, cur_opt + 2);
335
336         if ((!po->name && !strcmp(cur_opt, optname)) ||
337              (po->name && !strcmp(optname, po->name)))
338             return i;
339
340         if (!po || po->flags & HAS_ARG)
341             i++;
342     }
343     return 0;
344 }
345
346 void parse_loglevel(int argc, char **argv, const OptionDef *options)
347 {
348     int idx = locate_option(argc, argv, options, "loglevel");
349     if (!idx)
350         idx = locate_option(argc, argv, options, "v");
351     if (idx && argv[idx + 1])
352         opt_loglevel("loglevel", argv[idx + 1]);
353 }
354
355 #define FLAGS (o->type == AV_OPT_TYPE_FLAGS) ? AV_DICT_APPEND : 0
356 int opt_default(const char *opt, const char *arg)
357 {
358     const AVOption *o;
359     char opt_stripped[128];
360     const char *p;
361     const AVClass *cc = avcodec_get_class(), *fc = avformat_get_class(), *sc = sws_get_class();
362
363     if (!(p = strchr(opt, ':')))
364         p = opt + strlen(opt);
365     av_strlcpy(opt_stripped, opt, FFMIN(sizeof(opt_stripped), p - opt + 1));
366
367     if ((o = av_opt_find(&cc, opt_stripped, NULL, 0, AV_OPT_SEARCH_CHILDREN|AV_OPT_SEARCH_FAKE_OBJ)) ||
368          ((opt[0] == 'v' || opt[0] == 'a' || opt[0] == 's') &&
369           (o = av_opt_find(&cc, opt+1, NULL, 0, AV_OPT_SEARCH_FAKE_OBJ))))
370         av_dict_set(&codec_opts, opt, arg, FLAGS);
371     else if ((o = av_opt_find(&fc, opt, NULL, 0, AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)))
372         av_dict_set(&format_opts, opt, arg, FLAGS);
373     else if ((o = av_opt_find(&sc, opt, NULL, 0, AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) {
374         // XXX we only support sws_flags, not arbitrary sws options
375         int ret = av_opt_set(sws_opts, opt, arg, 0);
376         if (ret < 0) {
377             av_log(NULL, AV_LOG_ERROR, "Error setting option %s.\n", opt);
378             return ret;
379         }
380     }
381
382     if (o)
383         return 0;
384     av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);
385     return AVERROR_OPTION_NOT_FOUND;
386 }
387
388 int opt_loglevel(const char *opt, const char *arg)
389 {
390     const struct { const char *name; int level; } log_levels[] = {
391         { "quiet"  , AV_LOG_QUIET   },
392         { "panic"  , AV_LOG_PANIC   },
393         { "fatal"  , AV_LOG_FATAL   },
394         { "error"  , AV_LOG_ERROR   },
395         { "warning", AV_LOG_WARNING },
396         { "info"   , AV_LOG_INFO    },
397         { "verbose", AV_LOG_VERBOSE },
398         { "debug"  , AV_LOG_DEBUG   },
399     };
400     char *tail;
401     int level;
402     int i;
403
404     for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
405         if (!strcmp(log_levels[i].name, arg)) {
406             av_log_set_level(log_levels[i].level);
407             return 0;
408         }
409     }
410
411     level = strtol(arg, &tail, 10);
412     if (*tail) {
413         av_log(NULL, AV_LOG_FATAL, "Invalid loglevel \"%s\". "
414                "Possible levels are numbers or:\n", arg);
415         for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
416             av_log(NULL, AV_LOG_FATAL, "\"%s\"\n", log_levels[i].name);
417         exit_program(1);
418     }
419     av_log_set_level(level);
420     return 0;
421 }
422
423 int opt_timelimit(const char *opt, const char *arg)
424 {
425 #if HAVE_SETRLIMIT
426     int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
427     struct rlimit rl = { lim, lim + 1 };
428     if (setrlimit(RLIMIT_CPU, &rl))
429         perror("setrlimit");
430 #else
431     av_log(NULL, AV_LOG_WARNING, "-%s not implemented on this OS\n", opt);
432 #endif
433     return 0;
434 }
435
436 void print_error(const char *filename, int err)
437 {
438     char errbuf[128];
439     const char *errbuf_ptr = errbuf;
440
441     if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
442         errbuf_ptr = strerror(AVUNERROR(err));
443     av_log(NULL, AV_LOG_ERROR, "%s: %s\n", filename, errbuf_ptr);
444 }
445
446 static int warned_cfg = 0;
447
448 #define INDENT        1
449 #define SHOW_VERSION  2
450 #define SHOW_CONFIG   4
451
452 #define PRINT_LIB_INFO(libname, LIBNAME, flags, level)                  \
453     if (CONFIG_##LIBNAME) {                                             \
454         const char *indent = flags & INDENT? "  " : "";                 \
455         if (flags & SHOW_VERSION) {                                     \
456             unsigned int version = libname##_version();                 \
457             av_log(NULL, level, "%slib%-9s %2d.%3d.%2d / %2d.%3d.%2d\n",\
458                    indent, #libname,                                    \
459                    LIB##LIBNAME##_VERSION_MAJOR,                        \
460                    LIB##LIBNAME##_VERSION_MINOR,                        \
461                    LIB##LIBNAME##_VERSION_MICRO,                        \
462                    version >> 16, version >> 8 & 0xff, version & 0xff); \
463         }                                                               \
464         if (flags & SHOW_CONFIG) {                                      \
465             const char *cfg = libname##_configuration();                \
466             if (strcmp(LIBAV_CONFIGURATION, cfg)) {                     \
467                 if (!warned_cfg) {                                      \
468                     av_log(NULL, level,                                 \
469                             "%sWARNING: library configuration mismatch\n", \
470                             indent);                                    \
471                     warned_cfg = 1;                                     \
472                 }                                                       \
473                 av_log(NULL, level, "%s%-11s configuration: %s\n",      \
474                         indent, #libname, cfg);                         \
475             }                                                           \
476         }                                                               \
477     }                                                                   \
478
479 static void print_all_libs_info(int flags, int level)
480 {
481     PRINT_LIB_INFO(avutil,   AVUTIL,   flags, level);
482     PRINT_LIB_INFO(avcodec,  AVCODEC,  flags, level);
483     PRINT_LIB_INFO(avformat, AVFORMAT, flags, level);
484     PRINT_LIB_INFO(avdevice, AVDEVICE, flags, level);
485     PRINT_LIB_INFO(avfilter, AVFILTER, flags, level);
486     PRINT_LIB_INFO(swscale,  SWSCALE,  flags, level);
487     PRINT_LIB_INFO(postproc, POSTPROC, flags, level);
488 }
489
490 void show_banner(void)
491 {
492     av_log(NULL, AV_LOG_INFO, "%s version " LIBAV_VERSION ", Copyright (c) %d-%d the Libav developers\n",
493            program_name, program_birth_year, this_year);
494     av_log(NULL, AV_LOG_INFO, "  built on %s %s with %s %s\n",
495            __DATE__, __TIME__, CC_TYPE, CC_VERSION);
496     av_log(NULL, AV_LOG_VERBOSE, "  configuration: " LIBAV_CONFIGURATION "\n");
497     print_all_libs_info(INDENT|SHOW_CONFIG,  AV_LOG_VERBOSE);
498     print_all_libs_info(INDENT|SHOW_VERSION, AV_LOG_VERBOSE);
499 }
500
501 void show_version(void) {
502     av_log_set_callback(log_callback_help);
503     printf("%s " LIBAV_VERSION "\n", program_name);
504     print_all_libs_info(SHOW_VERSION, AV_LOG_INFO);
505 }
506
507 void show_license(void)
508 {
509     printf(
510 #if CONFIG_NONFREE
511     "This version of %s has nonfree parts compiled in.\n"
512     "Therefore it is not legally redistributable.\n",
513     program_name
514 #elif CONFIG_GPLV3
515     "%s is free software; you can redistribute it and/or modify\n"
516     "it under the terms of the GNU General Public License as published by\n"
517     "the Free Software Foundation; either version 3 of the License, or\n"
518     "(at your option) any later version.\n"
519     "\n"
520     "%s is distributed in the hope that it will be useful,\n"
521     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
522     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
523     "GNU General Public License for more details.\n"
524     "\n"
525     "You should have received a copy of the GNU General Public License\n"
526     "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
527     program_name, program_name, program_name
528 #elif CONFIG_GPL
529     "%s is free software; you can redistribute it and/or modify\n"
530     "it under the terms of the GNU General Public License as published by\n"
531     "the Free Software Foundation; either version 2 of the License, or\n"
532     "(at your option) any later version.\n"
533     "\n"
534     "%s is distributed in the hope that it will be useful,\n"
535     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
536     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
537     "GNU General Public License for more details.\n"
538     "\n"
539     "You should have received a copy of the GNU General Public License\n"
540     "along with %s; if not, write to the Free Software\n"
541     "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
542     program_name, program_name, program_name
543 #elif CONFIG_LGPLV3
544     "%s is free software; you can redistribute it and/or modify\n"
545     "it under the terms of the GNU Lesser General Public License as published by\n"
546     "the Free Software Foundation; either version 3 of the License, or\n"
547     "(at your option) any later version.\n"
548     "\n"
549     "%s is distributed in the hope that it will be useful,\n"
550     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
551     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
552     "GNU Lesser General Public License for more details.\n"
553     "\n"
554     "You should have received a copy of the GNU Lesser General Public License\n"
555     "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
556     program_name, program_name, program_name
557 #else
558     "%s is free software; you can redistribute it and/or\n"
559     "modify it under the terms of the GNU Lesser General Public\n"
560     "License as published by the Free Software Foundation; either\n"
561     "version 2.1 of the License, or (at your option) any later version.\n"
562     "\n"
563     "%s is distributed in the hope that it will be useful,\n"
564     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
565     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
566     "Lesser General Public License for more details.\n"
567     "\n"
568     "You should have received a copy of the GNU Lesser General Public\n"
569     "License along with %s; if not, write to the Free Software\n"
570     "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
571     program_name, program_name, program_name
572 #endif
573     );
574 }
575
576 void show_formats(void)
577 {
578     AVInputFormat *ifmt=NULL;
579     AVOutputFormat *ofmt=NULL;
580     const char *last_name;
581
582     printf(
583         "File formats:\n"
584         " D. = Demuxing supported\n"
585         " .E = Muxing supported\n"
586         " --\n");
587     last_name= "000";
588     for(;;){
589         int decode=0;
590         int encode=0;
591         const char *name=NULL;
592         const char *long_name=NULL;
593
594         while((ofmt= av_oformat_next(ofmt))) {
595             if((name == NULL || strcmp(ofmt->name, name)<0) &&
596                 strcmp(ofmt->name, last_name)>0){
597                 name= ofmt->name;
598                 long_name= ofmt->long_name;
599                 encode=1;
600             }
601         }
602         while((ifmt= av_iformat_next(ifmt))) {
603             if((name == NULL || strcmp(ifmt->name, name)<0) &&
604                 strcmp(ifmt->name, last_name)>0){
605                 name= ifmt->name;
606                 long_name= ifmt->long_name;
607                 encode=0;
608             }
609             if(name && strcmp(ifmt->name, name)==0)
610                 decode=1;
611         }
612         if(name==NULL)
613             break;
614         last_name= name;
615
616         printf(
617             " %s%s %-15s %s\n",
618             decode ? "D":" ",
619             encode ? "E":" ",
620             name,
621             long_name ? long_name:" ");
622     }
623 }
624
625 void show_codecs(void)
626 {
627     AVCodec *p=NULL, *p2;
628     const char *last_name;
629     printf(
630         "Codecs:\n"
631         " D..... = Decoding supported\n"
632         " .E.... = Encoding supported\n"
633         " ..V... = Video codec\n"
634         " ..A... = Audio codec\n"
635         " ..S... = Subtitle codec\n"
636         " ...S.. = Supports draw_horiz_band\n"
637         " ....D. = Supports direct rendering method 1\n"
638         " .....T = Supports weird frame truncation\n"
639         " ------\n");
640     last_name= "000";
641     for(;;){
642         int decode=0;
643         int encode=0;
644         int cap=0;
645         const char *type_str;
646
647         p2=NULL;
648         while((p= av_codec_next(p))) {
649             if((p2==NULL || strcmp(p->name, p2->name)<0) &&
650                 strcmp(p->name, last_name)>0){
651                 p2= p;
652                 decode= encode= cap=0;
653             }
654             if(p2 && strcmp(p->name, p2->name)==0){
655                 if(p->decode) decode=1;
656                 if(p->encode) encode=1;
657                 cap |= p->capabilities;
658             }
659         }
660         if(p2==NULL)
661             break;
662         last_name= p2->name;
663
664         switch(p2->type) {
665         case AVMEDIA_TYPE_VIDEO:
666             type_str = "V";
667             break;
668         case AVMEDIA_TYPE_AUDIO:
669             type_str = "A";
670             break;
671         case AVMEDIA_TYPE_SUBTITLE:
672             type_str = "S";
673             break;
674         default:
675             type_str = "?";
676             break;
677         }
678         printf(
679             " %s%s%s%s%s%s %-15s %s",
680             decode ? "D": (/*p2->decoder ? "d":*/" "),
681             encode ? "E":" ",
682             type_str,
683             cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
684             cap & CODEC_CAP_DR1 ? "D":" ",
685             cap & CODEC_CAP_TRUNCATED ? "T":" ",
686             p2->name,
687             p2->long_name ? p2->long_name : "");
688        /* if(p2->decoder && decode==0)
689             printf(" use %s for decoding", p2->decoder->name);*/
690         printf("\n");
691     }
692     printf("\n");
693     printf(
694 "Note, the names of encoders and decoders do not always match, so there are\n"
695 "several cases where the above table shows encoder only or decoder only entries\n"
696 "even though both encoding and decoding are supported. For example, the h263\n"
697 "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
698 "worse.\n");
699 }
700
701 void show_bsfs(void)
702 {
703     AVBitStreamFilter *bsf=NULL;
704
705     printf("Bitstream filters:\n");
706     while((bsf = av_bitstream_filter_next(bsf)))
707         printf("%s\n", bsf->name);
708     printf("\n");
709 }
710
711 void show_protocols(void)
712 {
713     void *opaque = NULL;
714     const char *name;
715
716     printf("Supported file protocols:\n"
717            "Input:\n");
718     while ((name = avio_enum_protocols(&opaque, 0)))
719         printf("%s\n", name);
720     printf("Output:\n");
721     while ((name = avio_enum_protocols(&opaque, 1)))
722         printf("%s\n", name);
723 }
724
725 void show_filters(void)
726 {
727     AVFilter av_unused(**filter) = NULL;
728
729     printf("Filters:\n");
730 #if CONFIG_AVFILTER
731     while ((filter = av_filter_next(filter)) && *filter)
732         printf("%-16s %s\n", (*filter)->name, (*filter)->description);
733 #endif
734 }
735
736 void show_pix_fmts(void)
737 {
738     enum PixelFormat pix_fmt;
739
740     printf(
741         "Pixel formats:\n"
742         "I.... = Supported Input  format for conversion\n"
743         ".O... = Supported Output format for conversion\n"
744         "..H.. = Hardware accelerated format\n"
745         "...P. = Paletted format\n"
746         "....B = Bitstream format\n"
747         "FLAGS NAME            NB_COMPONENTS BITS_PER_PIXEL\n"
748         "-----\n");
749
750 #if !CONFIG_SWSCALE
751 #   define sws_isSupportedInput(x)  0
752 #   define sws_isSupportedOutput(x) 0
753 #endif
754
755     for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {
756         const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[pix_fmt];
757         printf("%c%c%c%c%c %-16s       %d            %2d\n",
758                sws_isSupportedInput (pix_fmt)      ? 'I' : '.',
759                sws_isSupportedOutput(pix_fmt)      ? 'O' : '.',
760                pix_desc->flags & PIX_FMT_HWACCEL   ? 'H' : '.',
761                pix_desc->flags & PIX_FMT_PAL       ? 'P' : '.',
762                pix_desc->flags & PIX_FMT_BITSTREAM ? 'B' : '.',
763                pix_desc->name,
764                pix_desc->nb_components,
765                av_get_bits_per_pixel(pix_desc));
766     }
767 }
768
769 int show_sample_fmts(const char *opt, const char *arg)
770 {
771     int i;
772     char fmt_str[128];
773     for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
774         printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
775     return 0;
776 }
777
778 int read_yesno(void)
779 {
780     int c = getchar();
781     int yesno = (toupper(c) == 'Y');
782
783     while (c != '\n' && c != EOF)
784         c = getchar();
785
786     return yesno;
787 }
788
789 int cmdutils_read_file(const char *filename, char **bufptr, size_t *size)
790 {
791     int ret;
792     FILE *f = fopen(filename, "rb");
793
794     if (!f) {
795         av_log(NULL, AV_LOG_ERROR, "Cannot read file '%s': %s\n", filename, strerror(errno));
796         return AVERROR(errno);
797     }
798     fseek(f, 0, SEEK_END);
799     *size = ftell(f);
800     fseek(f, 0, SEEK_SET);
801     *bufptr = av_malloc(*size + 1);
802     if (!*bufptr) {
803         av_log(NULL, AV_LOG_ERROR, "Could not allocate file buffer\n");
804         fclose(f);
805         return AVERROR(ENOMEM);
806     }
807     ret = fread(*bufptr, 1, *size, f);
808     if (ret < *size) {
809         av_free(*bufptr);
810         if (ferror(f)) {
811             av_log(NULL, AV_LOG_ERROR, "Error while reading file '%s': %s\n",
812                    filename, strerror(errno));
813             ret = AVERROR(errno);
814         } else
815             ret = AVERROR_EOF;
816     } else {
817         ret = 0;
818         (*bufptr)[*size++] = '\0';
819     }
820
821     fclose(f);
822     return ret;
823 }
824
825 void init_pts_correction(PtsCorrectionContext *ctx)
826 {
827     ctx->num_faulty_pts = ctx->num_faulty_dts = 0;
828     ctx->last_pts = ctx->last_dts = INT64_MIN;
829 }
830
831 int64_t guess_correct_pts(PtsCorrectionContext *ctx, int64_t reordered_pts, int64_t dts)
832 {
833     int64_t pts = AV_NOPTS_VALUE;
834
835     if (dts != AV_NOPTS_VALUE) {
836         ctx->num_faulty_dts += dts <= ctx->last_dts;
837         ctx->last_dts = dts;
838     }
839     if (reordered_pts != AV_NOPTS_VALUE) {
840         ctx->num_faulty_pts += reordered_pts <= ctx->last_pts;
841         ctx->last_pts = reordered_pts;
842     }
843     if ((ctx->num_faulty_pts<=ctx->num_faulty_dts || dts == AV_NOPTS_VALUE)
844        && reordered_pts != AV_NOPTS_VALUE)
845         pts = reordered_pts;
846     else
847         pts = dts;
848
849     return pts;
850 }
851
852 FILE *get_preset_file(char *filename, size_t filename_size,
853                       const char *preset_name, int is_path, const char *codec_name)
854 {
855     FILE *f = NULL;
856     int i;
857     const char *base[3]= { getenv("AVCONV_DATADIR"),
858                            getenv("HOME"),
859                            AVCONV_DATADIR,
860                          };
861
862     if (is_path) {
863         av_strlcpy(filename, preset_name, filename_size);
864         f = fopen(filename, "r");
865     } else {
866         for (i = 0; i < 3 && !f; i++) {
867             if (!base[i])
868                 continue;
869             snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.avconv", preset_name);
870             f = fopen(filename, "r");
871             if (!f && codec_name) {
872                 snprintf(filename, filename_size,
873                          "%s%s/%s-%s.ffpreset", base[i],  i != 1 ? "" : "/.avconv", codec_name, preset_name);
874                 f = fopen(filename, "r");
875             }
876         }
877     }
878
879     return f;
880 }
881
882 int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
883 {
884     if (*spec <= '9' && *spec >= '0')                                        /* opt:index */
885         return strtol(spec, NULL, 0) == st->index;
886     else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' || *spec == 't') { /* opt:[vasdt] */
887         enum AVMediaType type;
888
889         switch (*spec++) {
890         case 'v': type = AVMEDIA_TYPE_VIDEO;    break;
891         case 'a': type = AVMEDIA_TYPE_AUDIO;    break;
892         case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
893         case 'd': type = AVMEDIA_TYPE_DATA;     break;
894         case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
895         }
896         if (type != st->codec->codec_type)
897             return 0;
898         if (*spec++ == ':') {                                   /* possibly followed by :index */
899             int i, index = strtol(spec, NULL, 0);
900             for (i = 0; i < s->nb_streams; i++)
901                 if (s->streams[i]->codec->codec_type == type && index-- == 0)
902                    return i == st->index;
903             return 0;
904         }
905         return 1;
906     } else if (*spec == 'p' && *(spec + 1) == ':') {
907         int prog_id, i, j;
908         char *endptr;
909         spec += 2;
910         prog_id = strtol(spec, &endptr, 0);
911         for (i = 0; i < s->nb_programs; i++) {
912             if (s->programs[i]->id != prog_id)
913                 continue;
914
915             if (*endptr++ == ':') {
916                 int stream_idx = strtol(endptr, NULL, 0);
917                 return (stream_idx >= 0 && stream_idx < s->programs[i]->nb_stream_indexes &&
918                         st->index == s->programs[i]->stream_index[stream_idx]);
919             }
920
921             for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
922                 if (st->index == s->programs[i]->stream_index[j])
923                     return 1;
924         }
925         return 0;
926     } else if (!*spec) /* empty specifier, matches everything */
927         return 1;
928
929     av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
930     return AVERROR(EINVAL);
931 }
932
933 AVDictionary *filter_codec_opts(AVDictionary *opts, enum CodecID codec_id, AVFormatContext *s, AVStream *st)
934 {
935     AVDictionary    *ret = NULL;
936     AVDictionaryEntry *t = NULL;
937     AVCodec       *codec = s->oformat ? avcodec_find_encoder(codec_id) : avcodec_find_decoder(codec_id);
938     int            flags = s->oformat ? AV_OPT_FLAG_ENCODING_PARAM : AV_OPT_FLAG_DECODING_PARAM;
939     char          prefix = 0;
940     const AVClass    *cc = avcodec_get_class();
941
942     if (!codec)
943         return NULL;
944
945     switch (codec->type) {
946     case AVMEDIA_TYPE_VIDEO:    prefix = 'v'; flags |= AV_OPT_FLAG_VIDEO_PARAM;    break;
947     case AVMEDIA_TYPE_AUDIO:    prefix = 'a'; flags |= AV_OPT_FLAG_AUDIO_PARAM;    break;
948     case AVMEDIA_TYPE_SUBTITLE: prefix = 's'; flags |= AV_OPT_FLAG_SUBTITLE_PARAM; break;
949     }
950
951     while (t = av_dict_get(opts, "", t, AV_DICT_IGNORE_SUFFIX)) {
952         char *p = strchr(t->key, ':');
953
954         /* check stream specification in opt name */
955         if (p)
956             switch (check_stream_specifier(s, st, p + 1)) {
957             case  1: *p = 0; break;
958             case  0:         continue;
959             default:         return NULL;
960             }
961
962         if (av_opt_find(&cc, t->key, NULL, flags, AV_OPT_SEARCH_FAKE_OBJ) ||
963             (codec && codec->priv_class && av_opt_find(&codec->priv_class, t->key, NULL, flags, AV_OPT_SEARCH_FAKE_OBJ)))
964             av_dict_set(&ret, t->key, t->value, 0);
965         else if (t->key[0] == prefix && av_opt_find(&cc, t->key+1, NULL, flags, AV_OPT_SEARCH_FAKE_OBJ))
966             av_dict_set(&ret, t->key+1, t->value, 0);
967
968         if (p)
969             *p = ':';
970     }
971     return ret;
972 }
973
974 AVDictionary **setup_find_stream_info_opts(AVFormatContext *s, AVDictionary *codec_opts)
975 {
976     int i;
977     AVDictionary **opts;
978
979     if (!s->nb_streams)
980         return NULL;
981     opts = av_mallocz(s->nb_streams * sizeof(*opts));
982     if (!opts) {
983         av_log(NULL, AV_LOG_ERROR, "Could not alloc memory for stream options.\n");
984         return NULL;
985     }
986     for (i = 0; i < s->nb_streams; i++)
987         opts[i] = filter_codec_opts(codec_opts, s->streams[i]->codec->codec_id, s, s->streams[i]);
988     return opts;
989 }
990
991 #if CONFIG_AVFILTER
992
993 static int ffsink_init(AVFilterContext *ctx, const char *args, void *opaque)
994 {
995     FFSinkContext *priv = ctx->priv;
996
997     if (!opaque)
998         return AVERROR(EINVAL);
999     *priv = *(FFSinkContext *)opaque;
1000
1001     return 0;
1002 }
1003
1004 static void null_end_frame(AVFilterLink *inlink) { }
1005
1006 static int ffsink_query_formats(AVFilterContext *ctx)
1007 {
1008     FFSinkContext *priv = ctx->priv;
1009     enum PixelFormat pix_fmts[] = { priv->pix_fmt, PIX_FMT_NONE };
1010
1011     avfilter_set_common_formats(ctx, avfilter_make_format_list(pix_fmts));
1012     return 0;
1013 }
1014
1015 AVFilter ffsink = {
1016     .name      = "ffsink",
1017     .priv_size = sizeof(FFSinkContext),
1018     .init      = ffsink_init,
1019
1020     .query_formats = ffsink_query_formats,
1021
1022     .inputs    = (AVFilterPad[]) {{ .name          = "default",
1023                                     .type          = AVMEDIA_TYPE_VIDEO,
1024                                     .end_frame     = null_end_frame,
1025                                     .min_perms     = AV_PERM_READ, },
1026                                   { .name = NULL }},
1027     .outputs   = (AVFilterPad[]) {{ .name = NULL }},
1028 };
1029
1030 int get_filtered_video_frame(AVFilterContext *ctx, AVFrame *frame,
1031                              AVFilterBufferRef **picref_ptr, AVRational *tb)
1032 {
1033     int ret;
1034     AVFilterBufferRef *picref;
1035
1036     if ((ret = avfilter_request_frame(ctx->inputs[0])) < 0)
1037         return ret;
1038     if (!(picref = ctx->inputs[0]->cur_buf))
1039         return AVERROR(ENOENT);
1040     *picref_ptr = picref;
1041     ctx->inputs[0]->cur_buf = NULL;
1042     *tb = ctx->inputs[0]->time_base;
1043
1044     memcpy(frame->data,     picref->data,     sizeof(frame->data));
1045     memcpy(frame->linesize, picref->linesize, sizeof(frame->linesize));
1046     frame->interlaced_frame = picref->video->interlaced;
1047     frame->top_field_first  = picref->video->top_field_first;
1048     frame->key_frame        = picref->video->key_frame;
1049     frame->pict_type        = picref->video->pict_type;
1050
1051     return 1;
1052 }
1053
1054 #endif /* CONFIG_AVFILTER */
1055
1056 void *grow_array(void *array, int elem_size, int *size, int new_size)
1057 {
1058     if (new_size >= INT_MAX / elem_size) {
1059         av_log(NULL, AV_LOG_ERROR, "Array too big.\n");
1060         exit_program(1);
1061     }
1062     if (*size < new_size) {
1063         uint8_t *tmp = av_realloc(array, new_size*elem_size);
1064         if (!tmp) {
1065             av_log(NULL, AV_LOG_ERROR, "Could not alloc buffer.\n");
1066             exit_program(1);
1067         }
1068         memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
1069         *size = new_size;
1070         return tmp;
1071     }
1072     return array;
1073 }