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