apetag: make sure avio_get_str() doesn't read more than it should.
[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 "libavresample/avresample.h"
36 #include "libswscale/swscale.h"
37 #include "libavutil/avassert.h"
38 #include "libavutil/avstring.h"
39 #include "libavutil/mathematics.h"
40 #include "libavutil/imgutils.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 = 2012;
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             bool_val = 0;
238     }
239     if (!po->name)
240         po = find_option(options, "default");
241     if (!po->name) {
242         av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);
243         return AVERROR(EINVAL);
244     }
245     if (po->flags & HAS_ARG && !arg) {
246         av_log(NULL, AV_LOG_ERROR, "Missing argument for option '%s'\n", opt);
247         return AVERROR(EINVAL);
248     }
249
250     /* new-style options contain an offset into optctx, old-style address of
251      * a global var*/
252     dst = po->flags & (OPT_OFFSET | OPT_SPEC) ? (uint8_t *)optctx + po->u.off
253                                               : po->u.dst_ptr;
254
255     if (po->flags & OPT_SPEC) {
256         SpecifierOpt **so = dst;
257         char *p = strchr(opt, ':');
258
259         dstcount = (int *)(so + 1);
260         *so = grow_array(*so, sizeof(**so), dstcount, *dstcount + 1);
261         (*so)[*dstcount - 1].specifier = av_strdup(p ? p + 1 : "");
262         dst = &(*so)[*dstcount - 1].u;
263     }
264
265     if (po->flags & OPT_STRING) {
266         char *str;
267         str = av_strdup(arg);
268         *(char **)dst = str;
269     } else if (po->flags & OPT_BOOL) {
270         *(int *)dst = bool_val;
271     } else if (po->flags & OPT_INT) {
272         *(int *)dst = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
273     } else if (po->flags & OPT_INT64) {
274         *(int64_t *)dst = parse_number_or_die(opt, arg, OPT_INT64, INT64_MIN, INT64_MAX);
275     } else if (po->flags & OPT_TIME) {
276         *(int64_t *)dst = parse_time_or_die(opt, arg, 1);
277     } else if (po->flags & OPT_FLOAT) {
278         *(float *)dst = parse_number_or_die(opt, arg, OPT_FLOAT, -INFINITY, INFINITY);
279     } else if (po->flags & OPT_DOUBLE) {
280         *(double *)dst = parse_number_or_die(opt, arg, OPT_DOUBLE, -INFINITY, INFINITY);
281     } else if (po->u.func_arg) {
282         int ret = po->flags & OPT_FUNC2 ? po->u.func2_arg(optctx, opt, arg)
283                                         : po->u.func_arg(opt, arg);
284         if (ret < 0) {
285             av_log(NULL, AV_LOG_ERROR,
286                    "Failed to set value '%s' for option '%s'\n", arg, opt);
287             return ret;
288         }
289     }
290     if (po->flags & OPT_EXIT)
291         exit_program(0);
292     return !!(po->flags & HAS_ARG);
293 }
294
295 void parse_options(void *optctx, int argc, char **argv, const OptionDef *options,
296                    void (*parse_arg_function)(void *, const char*))
297 {
298     const char *opt;
299     int optindex, handleoptions = 1, ret;
300
301     /* perform system-dependent conversions for arguments list */
302     prepare_app_arguments(&argc, &argv);
303
304     /* parse options */
305     optindex = 1;
306     while (optindex < argc) {
307         opt = argv[optindex++];
308
309         if (handleoptions && opt[0] == '-' && opt[1] != '\0') {
310             if (opt[1] == '-' && opt[2] == '\0') {
311                 handleoptions = 0;
312                 continue;
313             }
314             opt++;
315
316             if ((ret = parse_option(optctx, opt, argv[optindex], options)) < 0)
317                 exit_program(1);
318             optindex += ret;
319         } else {
320             if (parse_arg_function)
321                 parse_arg_function(optctx, opt);
322         }
323     }
324 }
325
326 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,                                         \
467                    "%slib%-10s %2d.%3d.%2d / %2d.%3d.%2d\n",            \
468                    indent, #libname,                                    \
469                    LIB##LIBNAME##_VERSION_MAJOR,                        \
470                    LIB##LIBNAME##_VERSION_MINOR,                        \
471                    LIB##LIBNAME##_VERSION_MICRO,                        \
472                    version >> 16, version >> 8 & 0xff, version & 0xff); \
473         }                                                               \
474         if (flags & SHOW_CONFIG) {                                      \
475             const char *cfg = libname##_configuration();                \
476             if (strcmp(LIBAV_CONFIGURATION, cfg)) {                     \
477                 if (!warned_cfg) {                                      \
478                     av_log(NULL, level,                                 \
479                             "%sWARNING: library configuration mismatch\n", \
480                             indent);                                    \
481                     warned_cfg = 1;                                     \
482                 }                                                       \
483                 av_log(NULL, level, "%s%-11s configuration: %s\n",      \
484                         indent, #libname, cfg);                         \
485             }                                                           \
486         }                                                               \
487     }                                                                   \
488
489 static void print_all_libs_info(int flags, int level)
490 {
491     PRINT_LIB_INFO(avutil,   AVUTIL,   flags, level);
492     PRINT_LIB_INFO(avcodec,  AVCODEC,  flags, level);
493     PRINT_LIB_INFO(avformat, AVFORMAT, flags, level);
494     PRINT_LIB_INFO(avdevice, AVDEVICE, flags, level);
495     PRINT_LIB_INFO(avfilter, AVFILTER, flags, level);
496     PRINT_LIB_INFO(avresample, AVRESAMPLE, flags, level);
497     PRINT_LIB_INFO(swscale,  SWSCALE,  flags, level);
498 }
499
500 void show_banner(void)
501 {
502     av_log(NULL, AV_LOG_INFO,
503            "%s version " LIBAV_VERSION ", Copyright (c) %d-%d the Libav developers\n",
504            program_name, program_birth_year, this_year);
505     av_log(NULL, AV_LOG_INFO, "  built on %s %s with %s %s\n",
506            __DATE__, __TIME__, CC_TYPE, CC_VERSION);
507     av_log(NULL, AV_LOG_VERBOSE, "  configuration: " LIBAV_CONFIGURATION "\n");
508     print_all_libs_info(INDENT|SHOW_CONFIG,  AV_LOG_VERBOSE);
509     print_all_libs_info(INDENT|SHOW_VERSION, AV_LOG_VERBOSE);
510 }
511
512 void show_version(void) {
513     av_log_set_callback(log_callback_help);
514     printf("%s " LIBAV_VERSION "\n", program_name);
515     print_all_libs_info(SHOW_VERSION, AV_LOG_INFO);
516 }
517
518 void show_license(void)
519 {
520     printf(
521 #if CONFIG_NONFREE
522     "This version of %s has nonfree parts compiled in.\n"
523     "Therefore it is not legally redistributable.\n",
524     program_name
525 #elif CONFIG_GPLV3
526     "%s is free software; you can redistribute it and/or modify\n"
527     "it under the terms of the GNU General Public License as published by\n"
528     "the Free Software Foundation; either version 3 of the License, or\n"
529     "(at your option) any later version.\n"
530     "\n"
531     "%s is distributed in the hope that it will be useful,\n"
532     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
533     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
534     "GNU General Public License for more details.\n"
535     "\n"
536     "You should have received a copy of the GNU General Public License\n"
537     "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
538     program_name, program_name, program_name
539 #elif CONFIG_GPL
540     "%s is free software; you can redistribute it and/or modify\n"
541     "it under the terms of the GNU General Public License as published by\n"
542     "the Free Software Foundation; either version 2 of the License, or\n"
543     "(at your option) any later version.\n"
544     "\n"
545     "%s is distributed in the hope that it will be useful,\n"
546     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
547     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
548     "GNU General Public License for more details.\n"
549     "\n"
550     "You should have received a copy of the GNU General Public License\n"
551     "along with %s; if not, write to the Free Software\n"
552     "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
553     program_name, program_name, program_name
554 #elif CONFIG_LGPLV3
555     "%s is free software; you can redistribute it and/or modify\n"
556     "it under the terms of the GNU Lesser General Public License as published by\n"
557     "the Free Software Foundation; either version 3 of the License, or\n"
558     "(at your option) any later version.\n"
559     "\n"
560     "%s is distributed in the hope that it will be useful,\n"
561     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
562     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
563     "GNU Lesser General Public License for more details.\n"
564     "\n"
565     "You should have received a copy of the GNU Lesser General Public License\n"
566     "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
567     program_name, program_name, program_name
568 #else
569     "%s is free software; you can redistribute it and/or\n"
570     "modify it under the terms of the GNU Lesser General Public\n"
571     "License as published by the Free Software Foundation; either\n"
572     "version 2.1 of the License, or (at your option) any later version.\n"
573     "\n"
574     "%s is distributed in the hope that it will be useful,\n"
575     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
576     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
577     "Lesser General Public License for more details.\n"
578     "\n"
579     "You should have received a copy of the GNU Lesser General Public\n"
580     "License along with %s; if not, write to the Free Software\n"
581     "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
582     program_name, program_name, program_name
583 #endif
584     );
585 }
586
587 void show_formats(void)
588 {
589     AVInputFormat *ifmt  = NULL;
590     AVOutputFormat *ofmt = NULL;
591     const char *last_name;
592
593     printf("File formats:\n"
594            " D. = Demuxing supported\n"
595            " .E = Muxing supported\n"
596            " --\n");
597     last_name = "000";
598     for (;;) {
599         int decode = 0;
600         int encode = 0;
601         const char *name      = NULL;
602         const char *long_name = NULL;
603
604         while ((ofmt = av_oformat_next(ofmt))) {
605             if ((name == NULL || strcmp(ofmt->name, name) < 0) &&
606                 strcmp(ofmt->name, last_name) > 0) {
607                 name      = ofmt->name;
608                 long_name = ofmt->long_name;
609                 encode    = 1;
610             }
611         }
612         while ((ifmt = av_iformat_next(ifmt))) {
613             if ((name == NULL || strcmp(ifmt->name, name) < 0) &&
614                 strcmp(ifmt->name, last_name) > 0) {
615                 name      = ifmt->name;
616                 long_name = ifmt->long_name;
617                 encode    = 0;
618             }
619             if (name && strcmp(ifmt->name, name) == 0)
620                 decode = 1;
621         }
622         if (name == NULL)
623             break;
624         last_name = name;
625
626         printf(" %s%s %-15s %s\n",
627                decode ? "D" : " ",
628                encode ? "E" : " ",
629                name,
630             long_name ? long_name:" ");
631     }
632 }
633
634 void show_codecs(void)
635 {
636     AVCodec *p = NULL, *p2;
637     const char *last_name;
638     printf("Codecs:\n"
639            " D..... = Decoding supported\n"
640            " .E.... = Encoding supported\n"
641            " ..V... = Video codec\n"
642            " ..A... = Audio codec\n"
643            " ..S... = Subtitle codec\n"
644            " ...S.. = Supports draw_horiz_band\n"
645            " ....D. = Supports direct rendering method 1\n"
646            " .....T = Supports weird frame truncation\n"
647            " ------\n");
648     last_name= "000";
649     for (;;) {
650         int decode = 0;
651         int encode = 0;
652         int cap    = 0;
653         const char *type_str;
654
655         p2 = NULL;
656         while ((p = av_codec_next(p))) {
657             if ((p2 == NULL || strcmp(p->name, p2->name) < 0) &&
658                 strcmp(p->name, last_name) > 0) {
659                 p2 = p;
660                 decode = encode = cap = 0;
661             }
662             if (p2 && strcmp(p->name, p2->name) == 0) {
663                 if (av_codec_is_decoder(p))
664                     decode = 1;
665                 if (av_codec_is_encoder(p))
666                     encode = 1;
667                 cap |= p->capabilities;
668             }
669         }
670         if (p2 == NULL)
671             break;
672         last_name = p2->name;
673
674         switch (p2->type) {
675         case AVMEDIA_TYPE_VIDEO:
676             type_str = "V";
677             break;
678         case AVMEDIA_TYPE_AUDIO:
679             type_str = "A";
680             break;
681         case AVMEDIA_TYPE_SUBTITLE:
682             type_str = "S";
683             break;
684         default:
685             type_str = "?";
686             break;
687         }
688         printf(" %s%s%s%s%s%s %-15s %s",
689                decode ? "D" : (/* p2->decoder ? "d" : */ " "),
690                encode ? "E" : " ",
691                type_str,
692                cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S" : " ",
693                cap & CODEC_CAP_DR1 ? "D" : " ",
694                cap & CODEC_CAP_TRUNCATED ? "T" : " ",
695                p2->name,
696                p2->long_name ? p2->long_name : "");
697 #if 0
698             if (p2->decoder && decode == 0)
699                 printf(" use %s for decoding", p2->decoder->name);
700 #endif
701         printf("\n");
702     }
703     printf("\n");
704     printf("Note, the names of encoders and decoders do not always match, so there are\n"
705            "several cases where the above table shows encoder only or decoder only entries\n"
706            "even though both encoding and decoding are supported. For example, the h263\n"
707            "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
708            "worse.\n");
709 }
710
711 void show_bsfs(void)
712 {
713     AVBitStreamFilter *bsf = NULL;
714
715     printf("Bitstream filters:\n");
716     while ((bsf = av_bitstream_filter_next(bsf)))
717         printf("%s\n", bsf->name);
718     printf("\n");
719 }
720
721 void show_protocols(void)
722 {
723     void *opaque = NULL;
724     const char *name;
725
726     printf("Supported file protocols:\n"
727            "Input:\n");
728     while ((name = avio_enum_protocols(&opaque, 0)))
729         printf("%s\n", name);
730     printf("Output:\n");
731     while ((name = avio_enum_protocols(&opaque, 1)))
732         printf("%s\n", name);
733 }
734
735 void show_filters(void)
736 {
737     AVFilter av_unused(**filter) = NULL;
738
739     printf("Filters:\n");
740 #if CONFIG_AVFILTER
741     while ((filter = av_filter_next(filter)) && *filter)
742         printf("%-16s %s\n", (*filter)->name, (*filter)->description);
743 #endif
744 }
745
746 void show_pix_fmts(void)
747 {
748     enum PixelFormat pix_fmt;
749
750     printf("Pixel formats:\n"
751            "I.... = Supported Input  format for conversion\n"
752            ".O... = Supported Output format for conversion\n"
753            "..H.. = Hardware accelerated format\n"
754            "...P. = Paletted format\n"
755            "....B = Bitstream format\n"
756            "FLAGS NAME            NB_COMPONENTS BITS_PER_PIXEL\n"
757            "-----\n");
758
759 #if !CONFIG_SWSCALE
760 #   define sws_isSupportedInput(x)  0
761 #   define sws_isSupportedOutput(x) 0
762 #endif
763
764     for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {
765         const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[pix_fmt];
766         printf("%c%c%c%c%c %-16s       %d            %2d\n",
767                sws_isSupportedInput (pix_fmt)      ? 'I' : '.',
768                sws_isSupportedOutput(pix_fmt)      ? 'O' : '.',
769                pix_desc->flags & PIX_FMT_HWACCEL   ? 'H' : '.',
770                pix_desc->flags & PIX_FMT_PAL       ? 'P' : '.',
771                pix_desc->flags & PIX_FMT_BITSTREAM ? 'B' : '.',
772                pix_desc->name,
773                pix_desc->nb_components,
774                av_get_bits_per_pixel(pix_desc));
775     }
776 }
777
778 int show_sample_fmts(const char *opt, const char *arg)
779 {
780     int i;
781     char fmt_str[128];
782     for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
783         printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
784     return 0;
785 }
786
787 int read_yesno(void)
788 {
789     int c = getchar();
790     int yesno = (toupper(c) == 'Y');
791
792     while (c != '\n' && c != EOF)
793         c = getchar();
794
795     return yesno;
796 }
797
798 int cmdutils_read_file(const char *filename, char **bufptr, size_t *size)
799 {
800     int ret;
801     FILE *f = fopen(filename, "rb");
802
803     if (!f) {
804         av_log(NULL, AV_LOG_ERROR, "Cannot read file '%s': %s\n", filename,
805                strerror(errno));
806         return AVERROR(errno);
807     }
808     fseek(f, 0, SEEK_END);
809     *size = ftell(f);
810     fseek(f, 0, SEEK_SET);
811     *bufptr = av_malloc(*size + 1);
812     if (!*bufptr) {
813         av_log(NULL, AV_LOG_ERROR, "Could not allocate file buffer\n");
814         fclose(f);
815         return AVERROR(ENOMEM);
816     }
817     ret = fread(*bufptr, 1, *size, f);
818     if (ret < *size) {
819         av_free(*bufptr);
820         if (ferror(f)) {
821             av_log(NULL, AV_LOG_ERROR, "Error while reading file '%s': %s\n",
822                    filename, strerror(errno));
823             ret = AVERROR(errno);
824         } else
825             ret = AVERROR_EOF;
826     } else {
827         ret = 0;
828         (*bufptr)[*size++] = '\0';
829     }
830
831     fclose(f);
832     return ret;
833 }
834
835 void init_pts_correction(PtsCorrectionContext *ctx)
836 {
837     ctx->num_faulty_pts = ctx->num_faulty_dts = 0;
838     ctx->last_pts = ctx->last_dts = INT64_MIN;
839 }
840
841 int64_t guess_correct_pts(PtsCorrectionContext *ctx, int64_t reordered_pts,
842                           int64_t dts)
843 {
844     int64_t pts = AV_NOPTS_VALUE;
845
846     if (dts != AV_NOPTS_VALUE) {
847         ctx->num_faulty_dts += dts <= ctx->last_dts;
848         ctx->last_dts = dts;
849     }
850     if (reordered_pts != AV_NOPTS_VALUE) {
851         ctx->num_faulty_pts += reordered_pts <= ctx->last_pts;
852         ctx->last_pts = reordered_pts;
853     }
854     if ((ctx->num_faulty_pts<=ctx->num_faulty_dts || dts == AV_NOPTS_VALUE)
855         && reordered_pts != AV_NOPTS_VALUE)
856         pts = reordered_pts;
857     else
858         pts = dts;
859
860     return pts;
861 }
862
863 FILE *get_preset_file(char *filename, size_t filename_size,
864                       const char *preset_name, int is_path,
865                       const char *codec_name)
866 {
867     FILE *f = NULL;
868     int i;
869     const char *base[3] = { getenv("AVCONV_DATADIR"),
870                             getenv("HOME"),
871                             AVCONV_DATADIR, };
872
873     if (is_path) {
874         av_strlcpy(filename, preset_name, filename_size);
875         f = fopen(filename, "r");
876     } else {
877         for (i = 0; i < 3 && !f; i++) {
878             if (!base[i])
879                 continue;
880             snprintf(filename, filename_size, "%s%s/%s.avpreset", base[i],
881                      i != 1 ? "" : "/.avconv", preset_name);
882             f = fopen(filename, "r");
883             if (!f && codec_name) {
884                 snprintf(filename, filename_size,
885                          "%s%s/%s-%s.avpreset",
886                          base[i], i != 1 ? "" : "/.avconv", codec_name,
887                          preset_name);
888                 f = fopen(filename, "r");
889             }
890         }
891     }
892
893     return f;
894 }
895
896 int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
897 {
898     if (*spec <= '9' && *spec >= '0') /* opt:index */
899         return strtol(spec, NULL, 0) == st->index;
900     else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
901              *spec == 't') { /* opt:[vasdt] */
902         enum AVMediaType type;
903
904         switch (*spec++) {
905         case 'v': type = AVMEDIA_TYPE_VIDEO;      break;
906         case 'a': type = AVMEDIA_TYPE_AUDIO;      break;
907         case 's': type = AVMEDIA_TYPE_SUBTITLE;   break;
908         case 'd': type = AVMEDIA_TYPE_DATA;       break;
909         case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
910         default:  av_assert0(0);
911         }
912         if (type != st->codec->codec_type)
913             return 0;
914         if (*spec++ == ':') { /* possibly followed by :index */
915             int i, index = strtol(spec, NULL, 0);
916             for (i = 0; i < s->nb_streams; i++)
917                 if (s->streams[i]->codec->codec_type == type && index-- == 0)
918                    return i == st->index;
919             return 0;
920         }
921         return 1;
922     } else if (*spec == 'p' && *(spec + 1) == ':') {
923         int prog_id, i, j;
924         char *endptr;
925         spec += 2;
926         prog_id = strtol(spec, &endptr, 0);
927         for (i = 0; i < s->nb_programs; i++) {
928             if (s->programs[i]->id != prog_id)
929                 continue;
930
931             if (*endptr++ == ':') {
932                 int stream_idx = strtol(endptr, NULL, 0);
933                 return stream_idx >= 0 &&
934                     stream_idx < s->programs[i]->nb_stream_indexes &&
935                     st->index == s->programs[i]->stream_index[stream_idx];
936             }
937
938             for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
939                 if (st->index == s->programs[i]->stream_index[j])
940                     return 1;
941         }
942         return 0;
943     } else if (!*spec) /* empty specifier, matches everything */
944         return 1;
945
946     av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
947     return AVERROR(EINVAL);
948 }
949
950 AVDictionary *filter_codec_opts(AVDictionary *opts, enum CodecID codec_id,
951                                 AVFormatContext *s, AVStream *st, AVCodec *codec)
952 {
953     AVDictionary    *ret = NULL;
954     AVDictionaryEntry *t = NULL;
955     int            flags = s->oformat ? AV_OPT_FLAG_ENCODING_PARAM
956                                       : AV_OPT_FLAG_DECODING_PARAM;
957     char          prefix = 0;
958     const AVClass    *cc = avcodec_get_class();
959
960     if (!codec)
961         codec            = s->oformat ? avcodec_find_encoder(codec_id)
962                                       : avcodec_find_decoder(codec_id);
963     if (!codec)
964         return NULL;
965
966     switch (codec->type) {
967     case AVMEDIA_TYPE_VIDEO:
968         prefix  = 'v';
969         flags  |= AV_OPT_FLAG_VIDEO_PARAM;
970         break;
971     case AVMEDIA_TYPE_AUDIO:
972         prefix  = 'a';
973         flags  |= AV_OPT_FLAG_AUDIO_PARAM;
974         break;
975     case AVMEDIA_TYPE_SUBTITLE:
976         prefix  = 's';
977         flags  |= AV_OPT_FLAG_SUBTITLE_PARAM;
978         break;
979     }
980
981     while (t = av_dict_get(opts, "", t, AV_DICT_IGNORE_SUFFIX)) {
982         char *p = strchr(t->key, ':');
983
984         /* check stream specification in opt name */
985         if (p)
986             switch (check_stream_specifier(s, st, p + 1)) {
987             case  1: *p = 0; break;
988             case  0:         continue;
989             default:         return NULL;
990             }
991
992         if (av_opt_find(&cc, t->key, NULL, flags, AV_OPT_SEARCH_FAKE_OBJ) ||
993             (codec && codec->priv_class &&
994              av_opt_find(&codec->priv_class, t->key, NULL, flags,
995                          AV_OPT_SEARCH_FAKE_OBJ)))
996             av_dict_set(&ret, t->key, t->value, 0);
997         else if (t->key[0] == prefix &&
998                  av_opt_find(&cc, t->key + 1, NULL, flags,
999                              AV_OPT_SEARCH_FAKE_OBJ))
1000             av_dict_set(&ret, t->key + 1, t->value, 0);
1001
1002         if (p)
1003             *p = ':';
1004     }
1005     return ret;
1006 }
1007
1008 AVDictionary **setup_find_stream_info_opts(AVFormatContext *s,
1009                                            AVDictionary *codec_opts)
1010 {
1011     int i;
1012     AVDictionary **opts;
1013
1014     if (!s->nb_streams)
1015         return NULL;
1016     opts = av_mallocz(s->nb_streams * sizeof(*opts));
1017     if (!opts) {
1018         av_log(NULL, AV_LOG_ERROR,
1019                "Could not alloc memory for stream options.\n");
1020         return NULL;
1021     }
1022     for (i = 0; i < s->nb_streams; i++)
1023         opts[i] = filter_codec_opts(codec_opts, s->streams[i]->codec->codec_id,
1024                                     s, s->streams[i], NULL);
1025     return opts;
1026 }
1027
1028 void *grow_array(void *array, int elem_size, int *size, int new_size)
1029 {
1030     if (new_size >= INT_MAX / elem_size) {
1031         av_log(NULL, AV_LOG_ERROR, "Array too big.\n");
1032         exit_program(1);
1033     }
1034     if (*size < new_size) {
1035         uint8_t *tmp = av_realloc(array, new_size*elem_size);
1036         if (!tmp) {
1037             av_log(NULL, AV_LOG_ERROR, "Could not alloc buffer.\n");
1038             exit_program(1);
1039         }
1040         memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
1041         *size = new_size;
1042         return tmp;
1043     }
1044     return array;
1045 }
1046
1047 static int alloc_buffer(FrameBuffer **pool, AVCodecContext *s, FrameBuffer **pbuf)
1048 {
1049     FrameBuffer  *buf = av_mallocz(sizeof(*buf));
1050     int i, ret;
1051     const int pixel_size = av_pix_fmt_descriptors[s->pix_fmt].comp[0].step_minus1+1;
1052     int h_chroma_shift, v_chroma_shift;
1053     int edge = 32; // XXX should be avcodec_get_edge_width(), but that fails on svq1
1054     int w = s->width, h = s->height;
1055
1056     if (!buf)
1057         return AVERROR(ENOMEM);
1058
1059     if (!(s->flags & CODEC_FLAG_EMU_EDGE)) {
1060         w += 2*edge;
1061         h += 2*edge;
1062     }
1063
1064     avcodec_align_dimensions(s, &w, &h);
1065     if ((ret = av_image_alloc(buf->base, buf->linesize, w, h,
1066                               s->pix_fmt, 32)) < 0) {
1067         av_freep(&buf);
1068         return ret;
1069     }
1070     /* XXX this shouldn't be needed, but some tests break without this line
1071      * those decoders are buggy and need to be fixed.
1072      * the following tests fail:
1073      * cdgraphics, ansi, aasc, fraps-v1, qtrle-1bit
1074      */
1075     memset(buf->base[0], 128, ret);
1076
1077     avcodec_get_chroma_sub_sample(s->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1078     for (i = 0; i < FF_ARRAY_ELEMS(buf->data); i++) {
1079         const int h_shift = i==0 ? 0 : h_chroma_shift;
1080         const int v_shift = i==0 ? 0 : v_chroma_shift;
1081         if (s->flags & CODEC_FLAG_EMU_EDGE)
1082             buf->data[i] = buf->base[i];
1083         else
1084             buf->data[i] = buf->base[i] +
1085                            FFALIGN((buf->linesize[i]*edge >> v_shift) +
1086                                    (pixel_size*edge >> h_shift), 32);
1087     }
1088     buf->w       = s->width;
1089     buf->h       = s->height;
1090     buf->pix_fmt = s->pix_fmt;
1091     buf->pool    = pool;
1092
1093     *pbuf = buf;
1094     return 0;
1095 }
1096
1097 int codec_get_buffer(AVCodecContext *s, AVFrame *frame)
1098 {
1099     FrameBuffer **pool = s->opaque;
1100     FrameBuffer *buf;
1101     int ret, i;
1102
1103     if (!*pool && (ret = alloc_buffer(pool, s, pool)) < 0)
1104         return ret;
1105
1106     buf              = *pool;
1107     *pool            = buf->next;
1108     buf->next        = NULL;
1109     if (buf->w != s->width || buf->h != s->height || buf->pix_fmt != s->pix_fmt) {
1110         av_freep(&buf->base[0]);
1111         av_free(buf);
1112         if ((ret = alloc_buffer(pool, s, &buf)) < 0)
1113             return ret;
1114     }
1115     buf->refcount++;
1116
1117     frame->opaque        = buf;
1118     frame->type          = FF_BUFFER_TYPE_USER;
1119     frame->extended_data = frame->data;
1120     frame->pkt_pts       = s->pkt ? s->pkt->pts : AV_NOPTS_VALUE;
1121     frame->width         = buf->w;
1122     frame->height        = buf->h;
1123     frame->format        = buf->pix_fmt;
1124     frame->sample_aspect_ratio = s->sample_aspect_ratio;
1125
1126     for (i = 0; i < FF_ARRAY_ELEMS(buf->data); i++) {
1127         frame->base[i]     = buf->base[i];  // XXX h264.c uses base though it shouldn't
1128         frame->data[i]     = buf->data[i];
1129         frame->linesize[i] = buf->linesize[i];
1130     }
1131
1132     return 0;
1133 }
1134
1135 static void unref_buffer(FrameBuffer *buf)
1136 {
1137     FrameBuffer **pool = buf->pool;
1138
1139     av_assert0(buf->refcount);
1140     buf->refcount--;
1141     if (!buf->refcount) {
1142         buf->next = *pool;
1143         *pool = buf;
1144     }
1145 }
1146
1147 void codec_release_buffer(AVCodecContext *s, AVFrame *frame)
1148 {
1149     FrameBuffer *buf = frame->opaque;
1150     int i;
1151
1152     for (i = 0; i < FF_ARRAY_ELEMS(frame->data); i++)
1153         frame->data[i] = NULL;
1154
1155     unref_buffer(buf);
1156 }
1157
1158 void filter_release_buffer(AVFilterBuffer *fb)
1159 {
1160     FrameBuffer *buf = fb->priv;
1161     av_free(fb);
1162     unref_buffer(buf);
1163 }
1164
1165 void free_buffer_pool(FrameBuffer **pool)
1166 {
1167     FrameBuffer *buf = *pool;
1168     while (buf) {
1169         *pool = buf->next;
1170         av_freep(&buf->base[0]);
1171         av_free(buf);
1172         buf = *pool;
1173     }
1174 }