2 * Various utilities for command line tools
3 * Copyright (c) 2000-2003 Fabrice Bellard
5 * This file is part of Libav.
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.
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.
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
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. */
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"
49 #include "libavformat/network.h"
51 #if HAVE_SYS_RESOURCE_H
52 #include <sys/resource.h>
55 struct SwsContext *sws_opts;
56 AVDictionary *format_opts, *codec_opts;
58 static const int this_year = 2012;
63 sws_opts = sws_getContext(16, 16, 0, 16, 16, 0, SWS_BICUBIC,
68 void uninit_opts(void)
71 sws_freeContext(sws_opts);
74 av_dict_free(&format_opts);
75 av_dict_free(&codec_opts);
78 void log_callback_help(void *ptr, int level, const char *fmt, va_list vl)
80 vfprintf(stdout, fmt, vl);
83 double parse_number_or_die(const char *context, const char *numstr, int type,
84 double min, double max)
88 double d = av_strtod(numstr, &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";
99 av_log(NULL, AV_LOG_FATAL, error, context, numstr, min, max);
104 int64_t parse_time_or_die(const char *context, const char *timestr,
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);
116 void show_help_options(const OptionDef *options, const char *msg, int mask,
123 for (po = options; po->name != NULL; po++) {
125 if ((po->flags & mask) == value) {
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));
135 printf("-%-17s %s\n", buf, po->help);
140 void show_help_children(const AVClass *class, int flags)
142 const AVClass *child = NULL;
143 av_opt_show2(&class, NULL, flags, 0);
146 while (child = av_opt_child_class_next(class, child))
147 show_help_children(child, flags);
150 static const OptionDef *find_option(const OptionDef *po, const char *name)
152 const char *p = strchr(name, ':');
153 int len = p ? p - name : strlen(name);
155 while (po->name != NULL) {
156 if (!strncmp(name, po->name, len) && strlen(po->name) == len)
163 #if defined(_WIN32) && !defined(__MINGW32CE__)
165 #include <shellapi.h>
166 /* Will be leaked on exit */
167 static char** win32_argv_utf8 = NULL;
168 static int win32_argc = 0;
171 * Prepare command line arguments for executable.
172 * For Windows - perform wide-char to UTF-8 conversion.
173 * Input arguments should be main() function arguments.
174 * @param argc_ptr Arguments number (including executable)
175 * @param argv_ptr Arguments list.
177 static void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
181 int i, buffsize = 0, offset = 0;
183 if (win32_argv_utf8) {
184 *argc_ptr = win32_argc;
185 *argv_ptr = win32_argv_utf8;
190 argv_w = CommandLineToArgvW(GetCommandLineW(), &win32_argc);
191 if (win32_argc <= 0 || !argv_w)
194 /* determine the UTF-8 buffer size (including NULL-termination symbols) */
195 for (i = 0; i < win32_argc; i++)
196 buffsize += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
197 NULL, 0, NULL, NULL);
199 win32_argv_utf8 = av_mallocz(sizeof(char *) * (win32_argc + 1) + buffsize);
200 argstr_flat = (char *)win32_argv_utf8 + sizeof(char *) * (win32_argc + 1);
201 if (win32_argv_utf8 == NULL) {
206 for (i = 0; i < win32_argc; i++) {
207 win32_argv_utf8[i] = &argstr_flat[offset];
208 offset += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
209 &argstr_flat[offset],
210 buffsize - offset, NULL, NULL);
212 win32_argv_utf8[i] = NULL;
215 *argc_ptr = win32_argc;
216 *argv_ptr = win32_argv_utf8;
219 static inline void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
223 #endif /* WIN32 && !__MINGW32CE__ */
225 int parse_option(void *optctx, const char *opt, const char *arg,
226 const OptionDef *options)
233 po = find_option(options, opt);
234 if (!po->name && opt[0] == 'n' && opt[1] == 'o') {
235 /* handle 'no' bool option */
236 po = find_option(options, opt + 2);
237 if ((po->name && (po->flags & OPT_BOOL)))
241 po = find_option(options, "default");
243 av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);
244 return AVERROR(EINVAL);
246 if (po->flags & HAS_ARG && !arg) {
247 av_log(NULL, AV_LOG_ERROR, "Missing argument for option '%s'\n", opt);
248 return AVERROR(EINVAL);
251 /* new-style options contain an offset into optctx, old-style address of
253 dst = po->flags & (OPT_OFFSET | OPT_SPEC) ? (uint8_t *)optctx + po->u.off
256 if (po->flags & OPT_SPEC) {
257 SpecifierOpt **so = dst;
258 char *p = strchr(opt, ':');
260 dstcount = (int *)(so + 1);
261 *so = grow_array(*so, sizeof(**so), dstcount, *dstcount + 1);
262 (*so)[*dstcount - 1].specifier = av_strdup(p ? p + 1 : "");
263 dst = &(*so)[*dstcount - 1].u;
266 if (po->flags & OPT_STRING) {
268 str = av_strdup(arg);
270 } else if (po->flags & OPT_BOOL) {
271 *(int *)dst = bool_val;
272 } else if (po->flags & OPT_INT) {
273 *(int *)dst = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
274 } else if (po->flags & OPT_INT64) {
275 *(int64_t *)dst = parse_number_or_die(opt, arg, OPT_INT64, INT64_MIN, INT64_MAX);
276 } else if (po->flags & OPT_TIME) {
277 *(int64_t *)dst = parse_time_or_die(opt, arg, 1);
278 } else if (po->flags & OPT_FLOAT) {
279 *(float *)dst = parse_number_or_die(opt, arg, OPT_FLOAT, -INFINITY, INFINITY);
280 } else if (po->flags & OPT_DOUBLE) {
281 *(double *)dst = parse_number_or_die(opt, arg, OPT_DOUBLE, -INFINITY, INFINITY);
282 } else if (po->u.func_arg) {
283 int ret = po->flags & OPT_FUNC2 ? po->u.func2_arg(optctx, opt, arg)
284 : po->u.func_arg(opt, arg);
286 av_log(NULL, AV_LOG_ERROR,
287 "Failed to set value '%s' for option '%s'\n", arg, opt);
291 if (po->flags & OPT_EXIT)
293 return !!(po->flags & HAS_ARG);
296 void parse_options(void *optctx, int argc, char **argv, const OptionDef *options,
297 void (*parse_arg_function)(void *, const char*))
300 int optindex, handleoptions = 1, ret;
302 /* perform system-dependent conversions for arguments list */
303 prepare_app_arguments(&argc, &argv);
307 while (optindex < argc) {
308 opt = argv[optindex++];
310 if (handleoptions && opt[0] == '-' && opt[1] != '\0') {
311 if (opt[1] == '-' && opt[2] == '\0') {
317 if ((ret = parse_option(optctx, opt, argv[optindex], options)) < 0)
321 if (parse_arg_function)
322 parse_arg_function(optctx, opt);
327 int locate_option(int argc, char **argv, const OptionDef *options,
333 for (i = 1; i < argc; i++) {
334 const char *cur_opt = argv[i];
336 if (*cur_opt++ != '-')
339 po = find_option(options, cur_opt);
340 if (!po->name && cur_opt[0] == 'n' && cur_opt[1] == 'o')
341 po = find_option(options, cur_opt + 2);
343 if ((!po->name && !strcmp(cur_opt, optname)) ||
344 (po->name && !strcmp(optname, po->name)))
347 if (!po || po->flags & HAS_ARG)
353 void parse_loglevel(int argc, char **argv, const OptionDef *options)
355 int idx = locate_option(argc, argv, options, "loglevel");
357 idx = locate_option(argc, argv, options, "v");
358 if (idx && argv[idx + 1])
359 opt_loglevel("loglevel", argv[idx + 1]);
362 #define FLAGS (o->type == AV_OPT_TYPE_FLAGS) ? AV_DICT_APPEND : 0
363 int opt_default(const char *opt, const char *arg)
366 char opt_stripped[128];
368 const AVClass *cc = avcodec_get_class(), *fc = avformat_get_class(), *sc = sws_get_class();
370 if (!(p = strchr(opt, ':')))
371 p = opt + strlen(opt);
372 av_strlcpy(opt_stripped, opt, FFMIN(sizeof(opt_stripped), p - opt + 1));
374 if ((o = av_opt_find(&cc, opt_stripped, NULL, 0,
375 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)) ||
376 ((opt[0] == 'v' || opt[0] == 'a' || opt[0] == 's') &&
377 (o = av_opt_find(&cc, opt + 1, NULL, 0, AV_OPT_SEARCH_FAKE_OBJ))))
378 av_dict_set(&codec_opts, opt, arg, FLAGS);
379 else if ((o = av_opt_find(&fc, opt, NULL, 0,
380 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)))
381 av_dict_set(&format_opts, opt, arg, FLAGS);
382 else if ((o = av_opt_find(&sc, opt, NULL, 0,
383 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) {
384 // XXX we only support sws_flags, not arbitrary sws options
385 int ret = av_opt_set(sws_opts, opt, arg, 0);
387 av_log(NULL, AV_LOG_ERROR, "Error setting option %s.\n", opt);
394 av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);
395 return AVERROR_OPTION_NOT_FOUND;
398 int opt_loglevel(const char *opt, const char *arg)
400 const struct { const char *name; int level; } log_levels[] = {
401 { "quiet" , AV_LOG_QUIET },
402 { "panic" , AV_LOG_PANIC },
403 { "fatal" , AV_LOG_FATAL },
404 { "error" , AV_LOG_ERROR },
405 { "warning", AV_LOG_WARNING },
406 { "info" , AV_LOG_INFO },
407 { "verbose", AV_LOG_VERBOSE },
408 { "debug" , AV_LOG_DEBUG },
414 for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
415 if (!strcmp(log_levels[i].name, arg)) {
416 av_log_set_level(log_levels[i].level);
421 level = strtol(arg, &tail, 10);
423 av_log(NULL, AV_LOG_FATAL, "Invalid loglevel \"%s\". "
424 "Possible levels are numbers or:\n", arg);
425 for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
426 av_log(NULL, AV_LOG_FATAL, "\"%s\"\n", log_levels[i].name);
429 av_log_set_level(level);
433 int opt_timelimit(const char *opt, const char *arg)
436 int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
437 struct rlimit rl = { lim, lim + 1 };
438 if (setrlimit(RLIMIT_CPU, &rl))
441 av_log(NULL, AV_LOG_WARNING, "-%s not implemented on this OS\n", opt);
446 void print_error(const char *filename, int err)
449 const char *errbuf_ptr = errbuf;
451 if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
452 errbuf_ptr = strerror(AVUNERROR(err));
453 av_log(NULL, AV_LOG_ERROR, "%s: %s\n", filename, errbuf_ptr);
456 static int warned_cfg = 0;
459 #define SHOW_VERSION 2
460 #define SHOW_CONFIG 4
462 #define PRINT_LIB_INFO(libname, LIBNAME, flags, level) \
463 if (CONFIG_##LIBNAME) { \
464 const char *indent = flags & INDENT? " " : ""; \
465 if (flags & SHOW_VERSION) { \
466 unsigned int version = libname##_version(); \
467 av_log(NULL, level, \
468 "%slib%-10s %2d.%3d.%2d / %2d.%3d.%2d\n", \
470 LIB##LIBNAME##_VERSION_MAJOR, \
471 LIB##LIBNAME##_VERSION_MINOR, \
472 LIB##LIBNAME##_VERSION_MICRO, \
473 version >> 16, version >> 8 & 0xff, version & 0xff); \
475 if (flags & SHOW_CONFIG) { \
476 const char *cfg = libname##_configuration(); \
477 if (strcmp(LIBAV_CONFIGURATION, cfg)) { \
479 av_log(NULL, level, \
480 "%sWARNING: library configuration mismatch\n", \
484 av_log(NULL, level, "%s%-11s configuration: %s\n", \
485 indent, #libname, cfg); \
490 static void print_all_libs_info(int flags, int level)
492 PRINT_LIB_INFO(avutil, AVUTIL, flags, level);
493 PRINT_LIB_INFO(avcodec, AVCODEC, flags, level);
494 PRINT_LIB_INFO(avformat, AVFORMAT, flags, level);
495 PRINT_LIB_INFO(avdevice, AVDEVICE, flags, level);
496 PRINT_LIB_INFO(avfilter, AVFILTER, flags, level);
497 PRINT_LIB_INFO(avresample, AVRESAMPLE, flags, level);
498 PRINT_LIB_INFO(swscale, SWSCALE, flags, level);
501 void show_banner(void)
503 av_log(NULL, AV_LOG_INFO,
504 "%s version " LIBAV_VERSION ", Copyright (c) %d-%d the Libav developers\n",
505 program_name, program_birth_year, this_year);
506 av_log(NULL, AV_LOG_INFO, " built on %s %s with %s %s\n",
507 __DATE__, __TIME__, CC_TYPE, CC_VERSION);
508 av_log(NULL, AV_LOG_VERBOSE, " configuration: " LIBAV_CONFIGURATION "\n");
509 print_all_libs_info(INDENT|SHOW_CONFIG, AV_LOG_VERBOSE);
510 print_all_libs_info(INDENT|SHOW_VERSION, AV_LOG_VERBOSE);
513 void show_version(void) {
514 av_log_set_callback(log_callback_help);
515 printf("%s " LIBAV_VERSION "\n", program_name);
516 print_all_libs_info(SHOW_VERSION, AV_LOG_INFO);
519 void show_license(void)
523 "This version of %s has nonfree parts compiled in.\n"
524 "Therefore it is not legally redistributable.\n",
527 "%s is free software; you can redistribute it and/or modify\n"
528 "it under the terms of the GNU General Public License as published by\n"
529 "the Free Software Foundation; either version 3 of the License, or\n"
530 "(at your option) any later version.\n"
532 "%s is distributed in the hope that it will be useful,\n"
533 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
534 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
535 "GNU General Public License for more details.\n"
537 "You should have received a copy of the GNU General Public License\n"
538 "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
539 program_name, program_name, program_name
541 "%s is free software; you can redistribute it and/or modify\n"
542 "it under the terms of the GNU General Public License as published by\n"
543 "the Free Software Foundation; either version 2 of the License, or\n"
544 "(at your option) any later version.\n"
546 "%s is distributed in the hope that it will be useful,\n"
547 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
548 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
549 "GNU General Public License for more details.\n"
551 "You should have received a copy of the GNU General Public License\n"
552 "along with %s; if not, write to the Free Software\n"
553 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
554 program_name, program_name, program_name
556 "%s is free software; you can redistribute it and/or modify\n"
557 "it under the terms of the GNU Lesser General Public License as published by\n"
558 "the Free Software Foundation; either version 3 of the License, or\n"
559 "(at your option) any later version.\n"
561 "%s is distributed in the hope that it will be useful,\n"
562 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
563 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
564 "GNU Lesser General Public License for more details.\n"
566 "You should have received a copy of the GNU Lesser General Public License\n"
567 "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
568 program_name, program_name, program_name
570 "%s is free software; you can redistribute it and/or\n"
571 "modify it under the terms of the GNU Lesser General Public\n"
572 "License as published by the Free Software Foundation; either\n"
573 "version 2.1 of the License, or (at your option) any later version.\n"
575 "%s is distributed in the hope that it will be useful,\n"
576 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
577 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
578 "Lesser General Public License for more details.\n"
580 "You should have received a copy of the GNU Lesser General Public\n"
581 "License along with %s; if not, write to the Free Software\n"
582 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
583 program_name, program_name, program_name
588 void show_formats(void)
590 AVInputFormat *ifmt = NULL;
591 AVOutputFormat *ofmt = NULL;
592 const char *last_name;
594 printf("File formats:\n"
595 " D. = Demuxing supported\n"
596 " .E = Muxing supported\n"
602 const char *name = NULL;
603 const char *long_name = NULL;
605 while ((ofmt = av_oformat_next(ofmt))) {
606 if ((name == NULL || strcmp(ofmt->name, name) < 0) &&
607 strcmp(ofmt->name, last_name) > 0) {
609 long_name = ofmt->long_name;
613 while ((ifmt = av_iformat_next(ifmt))) {
614 if ((name == NULL || strcmp(ifmt->name, name) < 0) &&
615 strcmp(ifmt->name, last_name) > 0) {
617 long_name = ifmt->long_name;
620 if (name && strcmp(ifmt->name, name) == 0)
627 printf(" %s%s %-15s %s\n",
631 long_name ? long_name:" ");
635 void show_codecs(void)
637 AVCodec *p = NULL, *p2;
638 const char *last_name;
640 " D..... = Decoding supported\n"
641 " .E.... = Encoding supported\n"
642 " ..V... = Video codec\n"
643 " ..A... = Audio codec\n"
644 " ..S... = Subtitle codec\n"
645 " ...S.. = Supports draw_horiz_band\n"
646 " ....D. = Supports direct rendering method 1\n"
647 " .....T = Supports weird frame truncation\n"
654 const char *type_str;
657 while ((p = av_codec_next(p))) {
658 if ((p2 == NULL || strcmp(p->name, p2->name) < 0) &&
659 strcmp(p->name, last_name) > 0) {
661 decode = encode = cap = 0;
663 if (p2 && strcmp(p->name, p2->name) == 0) {
664 if (av_codec_is_decoder(p))
666 if (av_codec_is_encoder(p))
668 cap |= p->capabilities;
673 last_name = p2->name;
676 case AVMEDIA_TYPE_VIDEO:
679 case AVMEDIA_TYPE_AUDIO:
682 case AVMEDIA_TYPE_SUBTITLE:
689 printf(" %s%s%s%s%s%s %-15s %s",
690 decode ? "D" : (/* p2->decoder ? "d" : */ " "),
693 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S" : " ",
694 cap & CODEC_CAP_DR1 ? "D" : " ",
695 cap & CODEC_CAP_TRUNCATED ? "T" : " ",
697 p2->long_name ? p2->long_name : "");
699 if (p2->decoder && decode == 0)
700 printf(" use %s for decoding", p2->decoder->name);
705 printf("Note, the names of encoders and decoders do not always match, so there are\n"
706 "several cases where the above table shows encoder only or decoder only entries\n"
707 "even though both encoding and decoding are supported. For example, the h263\n"
708 "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
714 AVBitStreamFilter *bsf = NULL;
716 printf("Bitstream filters:\n");
717 while ((bsf = av_bitstream_filter_next(bsf)))
718 printf("%s\n", bsf->name);
722 void show_protocols(void)
727 printf("Supported file protocols:\n"
729 while ((name = avio_enum_protocols(&opaque, 0)))
730 printf("%s\n", name);
732 while ((name = avio_enum_protocols(&opaque, 1)))
733 printf("%s\n", name);
736 void show_filters(void)
738 AVFilter av_unused(**filter) = NULL;
740 printf("Filters:\n");
742 while ((filter = av_filter_next(filter)) && *filter)
743 printf("%-16s %s\n", (*filter)->name, (*filter)->description);
747 void show_pix_fmts(void)
749 enum PixelFormat pix_fmt;
751 printf("Pixel formats:\n"
752 "I.... = Supported Input format for conversion\n"
753 ".O... = Supported Output format for conversion\n"
754 "..H.. = Hardware accelerated format\n"
755 "...P. = Paletted format\n"
756 "....B = Bitstream format\n"
757 "FLAGS NAME NB_COMPONENTS BITS_PER_PIXEL\n"
761 # define sws_isSupportedInput(x) 0
762 # define sws_isSupportedOutput(x) 0
765 for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {
766 const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[pix_fmt];
767 printf("%c%c%c%c%c %-16s %d %2d\n",
768 sws_isSupportedInput (pix_fmt) ? 'I' : '.',
769 sws_isSupportedOutput(pix_fmt) ? 'O' : '.',
770 pix_desc->flags & PIX_FMT_HWACCEL ? 'H' : '.',
771 pix_desc->flags & PIX_FMT_PAL ? 'P' : '.',
772 pix_desc->flags & PIX_FMT_BITSTREAM ? 'B' : '.',
774 pix_desc->nb_components,
775 av_get_bits_per_pixel(pix_desc));
779 int show_sample_fmts(const char *opt, const char *arg)
783 for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
784 printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
791 int yesno = (toupper(c) == 'Y');
793 while (c != '\n' && c != EOF)
799 int cmdutils_read_file(const char *filename, char **bufptr, size_t *size)
802 FILE *f = fopen(filename, "rb");
805 av_log(NULL, AV_LOG_ERROR, "Cannot read file '%s': %s\n", filename,
807 return AVERROR(errno);
809 fseek(f, 0, SEEK_END);
811 fseek(f, 0, SEEK_SET);
812 *bufptr = av_malloc(*size + 1);
814 av_log(NULL, AV_LOG_ERROR, "Could not allocate file buffer\n");
816 return AVERROR(ENOMEM);
818 ret = fread(*bufptr, 1, *size, f);
822 av_log(NULL, AV_LOG_ERROR, "Error while reading file '%s': %s\n",
823 filename, strerror(errno));
824 ret = AVERROR(errno);
829 (*bufptr)[*size++] = '\0';
836 void init_pts_correction(PtsCorrectionContext *ctx)
838 ctx->num_faulty_pts = ctx->num_faulty_dts = 0;
839 ctx->last_pts = ctx->last_dts = INT64_MIN;
842 int64_t guess_correct_pts(PtsCorrectionContext *ctx, int64_t reordered_pts,
845 int64_t pts = AV_NOPTS_VALUE;
847 if (dts != AV_NOPTS_VALUE) {
848 ctx->num_faulty_dts += dts <= ctx->last_dts;
851 if (reordered_pts != AV_NOPTS_VALUE) {
852 ctx->num_faulty_pts += reordered_pts <= ctx->last_pts;
853 ctx->last_pts = reordered_pts;
855 if ((ctx->num_faulty_pts<=ctx->num_faulty_dts || dts == AV_NOPTS_VALUE)
856 && reordered_pts != AV_NOPTS_VALUE)
864 FILE *get_preset_file(char *filename, size_t filename_size,
865 const char *preset_name, int is_path,
866 const char *codec_name)
870 const char *base[3] = { getenv("AVCONV_DATADIR"),
875 av_strlcpy(filename, preset_name, filename_size);
876 f = fopen(filename, "r");
878 for (i = 0; i < 3 && !f; i++) {
881 snprintf(filename, filename_size, "%s%s/%s.avpreset", base[i],
882 i != 1 ? "" : "/.avconv", preset_name);
883 f = fopen(filename, "r");
884 if (!f && codec_name) {
885 snprintf(filename, filename_size,
886 "%s%s/%s-%s.avpreset",
887 base[i], i != 1 ? "" : "/.avconv", codec_name,
889 f = fopen(filename, "r");
897 int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
899 if (*spec <= '9' && *spec >= '0') /* opt:index */
900 return strtol(spec, NULL, 0) == st->index;
901 else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
902 *spec == 't') { /* opt:[vasdt] */
903 enum AVMediaType type;
906 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
907 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
908 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
909 case 'd': type = AVMEDIA_TYPE_DATA; break;
910 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
911 default: av_assert0(0);
913 if (type != st->codec->codec_type)
915 if (*spec++ == ':') { /* possibly followed by :index */
916 int i, index = strtol(spec, NULL, 0);
917 for (i = 0; i < s->nb_streams; i++)
918 if (s->streams[i]->codec->codec_type == type && index-- == 0)
919 return i == st->index;
923 } else if (*spec == 'p' && *(spec + 1) == ':') {
927 prog_id = strtol(spec, &endptr, 0);
928 for (i = 0; i < s->nb_programs; i++) {
929 if (s->programs[i]->id != prog_id)
932 if (*endptr++ == ':') {
933 int stream_idx = strtol(endptr, NULL, 0);
934 return stream_idx >= 0 &&
935 stream_idx < s->programs[i]->nb_stream_indexes &&
936 st->index == s->programs[i]->stream_index[stream_idx];
939 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
940 if (st->index == s->programs[i]->stream_index[j])
944 } else if (!*spec) /* empty specifier, matches everything */
947 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
948 return AVERROR(EINVAL);
951 AVDictionary *filter_codec_opts(AVDictionary *opts, enum CodecID codec_id,
952 AVFormatContext *s, AVStream *st, AVCodec *codec)
954 AVDictionary *ret = NULL;
955 AVDictionaryEntry *t = NULL;
956 int flags = s->oformat ? AV_OPT_FLAG_ENCODING_PARAM
957 : AV_OPT_FLAG_DECODING_PARAM;
959 const AVClass *cc = avcodec_get_class();
962 codec = s->oformat ? avcodec_find_encoder(codec_id)
963 : avcodec_find_decoder(codec_id);
967 switch (codec->type) {
968 case AVMEDIA_TYPE_VIDEO:
970 flags |= AV_OPT_FLAG_VIDEO_PARAM;
972 case AVMEDIA_TYPE_AUDIO:
974 flags |= AV_OPT_FLAG_AUDIO_PARAM;
976 case AVMEDIA_TYPE_SUBTITLE:
978 flags |= AV_OPT_FLAG_SUBTITLE_PARAM;
982 while (t = av_dict_get(opts, "", t, AV_DICT_IGNORE_SUFFIX)) {
983 char *p = strchr(t->key, ':');
985 /* check stream specification in opt name */
987 switch (check_stream_specifier(s, st, p + 1)) {
988 case 1: *p = 0; break;
990 default: return NULL;
993 if (av_opt_find(&cc, t->key, NULL, flags, AV_OPT_SEARCH_FAKE_OBJ) ||
994 (codec && codec->priv_class &&
995 av_opt_find(&codec->priv_class, t->key, NULL, flags,
996 AV_OPT_SEARCH_FAKE_OBJ)))
997 av_dict_set(&ret, t->key, t->value, 0);
998 else if (t->key[0] == prefix &&
999 av_opt_find(&cc, t->key + 1, NULL, flags,
1000 AV_OPT_SEARCH_FAKE_OBJ))
1001 av_dict_set(&ret, t->key + 1, t->value, 0);
1009 AVDictionary **setup_find_stream_info_opts(AVFormatContext *s,
1010 AVDictionary *codec_opts)
1013 AVDictionary **opts;
1017 opts = av_mallocz(s->nb_streams * sizeof(*opts));
1019 av_log(NULL, AV_LOG_ERROR,
1020 "Could not alloc memory for stream options.\n");
1023 for (i = 0; i < s->nb_streams; i++)
1024 opts[i] = filter_codec_opts(codec_opts, s->streams[i]->codec->codec_id,
1025 s, s->streams[i], NULL);
1029 void *grow_array(void *array, int elem_size, int *size, int new_size)
1031 if (new_size >= INT_MAX / elem_size) {
1032 av_log(NULL, AV_LOG_ERROR, "Array too big.\n");
1035 if (*size < new_size) {
1036 uint8_t *tmp = av_realloc(array, new_size*elem_size);
1038 av_log(NULL, AV_LOG_ERROR, "Could not alloc buffer.\n");
1041 memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
1048 static int alloc_buffer(FrameBuffer **pool, AVCodecContext *s, FrameBuffer **pbuf)
1050 FrameBuffer *buf = av_mallocz(sizeof(*buf));
1052 const int pixel_size = av_pix_fmt_descriptors[s->pix_fmt].comp[0].step_minus1+1;
1053 int h_chroma_shift, v_chroma_shift;
1054 int edge = 32; // XXX should be avcodec_get_edge_width(), but that fails on svq1
1055 int w = s->width, h = s->height;
1058 return AVERROR(ENOMEM);
1060 if (!(s->flags & CODEC_FLAG_EMU_EDGE)) {
1065 avcodec_align_dimensions(s, &w, &h);
1066 if ((ret = av_image_alloc(buf->base, buf->linesize, w, h,
1067 s->pix_fmt, 32)) < 0) {
1071 /* XXX this shouldn't be needed, but some tests break without this line
1072 * those decoders are buggy and need to be fixed.
1073 * the following tests fail:
1074 * cdgraphics, ansi, aasc, fraps-v1, qtrle-1bit
1076 memset(buf->base[0], 128, ret);
1078 avcodec_get_chroma_sub_sample(s->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1079 for (i = 0; i < FF_ARRAY_ELEMS(buf->data); i++) {
1080 const int h_shift = i==0 ? 0 : h_chroma_shift;
1081 const int v_shift = i==0 ? 0 : v_chroma_shift;
1082 if (s->flags & CODEC_FLAG_EMU_EDGE)
1083 buf->data[i] = buf->base[i];
1085 buf->data[i] = buf->base[i] +
1086 FFALIGN((buf->linesize[i]*edge >> v_shift) +
1087 (pixel_size*edge >> h_shift), 32);
1091 buf->pix_fmt = s->pix_fmt;
1098 int codec_get_buffer(AVCodecContext *s, AVFrame *frame)
1100 FrameBuffer **pool = s->opaque;
1104 if (!*pool && (ret = alloc_buffer(pool, s, pool)) < 0)
1110 if (buf->w != s->width || buf->h != s->height || buf->pix_fmt != s->pix_fmt) {
1111 av_freep(&buf->base[0]);
1113 if ((ret = alloc_buffer(pool, s, &buf)) < 0)
1118 frame->opaque = buf;
1119 frame->type = FF_BUFFER_TYPE_USER;
1120 frame->extended_data = frame->data;
1121 frame->pkt_pts = s->pkt ? s->pkt->pts : AV_NOPTS_VALUE;
1122 frame->width = buf->w;
1123 frame->height = buf->h;
1124 frame->format = buf->pix_fmt;
1125 frame->sample_aspect_ratio = s->sample_aspect_ratio;
1127 for (i = 0; i < FF_ARRAY_ELEMS(buf->data); i++) {
1128 frame->base[i] = buf->base[i]; // XXX h264.c uses base though it shouldn't
1129 frame->data[i] = buf->data[i];
1130 frame->linesize[i] = buf->linesize[i];
1136 static void unref_buffer(FrameBuffer *buf)
1138 FrameBuffer **pool = buf->pool;
1140 av_assert0(buf->refcount);
1142 if (!buf->refcount) {
1148 void codec_release_buffer(AVCodecContext *s, AVFrame *frame)
1150 FrameBuffer *buf = frame->opaque;
1153 for (i = 0; i < FF_ARRAY_ELEMS(frame->data); i++)
1154 frame->data[i] = NULL;
1159 void filter_release_buffer(AVFilterBuffer *fb)
1161 FrameBuffer *buf = fb->priv;
1166 void free_buffer_pool(FrameBuffer **pool)
1168 FrameBuffer *buf = *pool;
1171 av_freep(&buf->base[0]);