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