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 /* Will be leaked on exit */
166 static char** win32_argv_utf8 = NULL;
167 static int win32_argc = 0;
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.
176 static void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
180 int i, buffsize = 0, offset = 0;
182 if (win32_argv_utf8) {
183 *argc_ptr = win32_argc;
184 *argv_ptr = win32_argv_utf8;
189 argv_w = CommandLineToArgvW(GetCommandLineW(), &win32_argc);
190 if (win32_argc <= 0 || !argv_w)
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);
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) {
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);
211 win32_argv_utf8[i] = NULL;
214 *argc_ptr = win32_argc;
215 *argv_ptr = win32_argv_utf8;
218 static inline void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
222 #endif /* WIN32 && !__MINGW32CE__ */
224 int parse_option(void *optctx, const char *opt, const char *arg,
225 const OptionDef *options)
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)))
240 po = find_option(options, "default");
242 av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);
243 return AVERROR(EINVAL);
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);
250 /* new-style options contain an offset into optctx, old-style address of
252 dst = po->flags & (OPT_OFFSET | OPT_SPEC) ? (uint8_t *)optctx + po->u.off
255 if (po->flags & OPT_SPEC) {
256 SpecifierOpt **so = dst;
257 char *p = strchr(opt, ':');
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;
265 if (po->flags & OPT_STRING) {
267 str = av_strdup(arg);
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);
285 av_log(NULL, AV_LOG_ERROR,
286 "Failed to set value '%s' for option '%s'\n", arg, opt);
290 if (po->flags & OPT_EXIT)
292 return !!(po->flags & HAS_ARG);
295 void parse_options(void *optctx, int argc, char **argv, const OptionDef *options,
296 void (*parse_arg_function)(void *, const char*))
299 int optindex, handleoptions = 1, ret;
301 /* perform system-dependent conversions for arguments list */
302 prepare_app_arguments(&argc, &argv);
306 while (optindex < argc) {
307 opt = argv[optindex++];
309 if (handleoptions && opt[0] == '-' && opt[1] != '\0') {
310 if (opt[1] == '-' && opt[2] == '\0') {
316 if ((ret = parse_option(optctx, opt, argv[optindex], options)) < 0)
320 if (parse_arg_function)
321 parse_arg_function(optctx, opt);
326 int locate_option(int argc, char **argv, const OptionDef *options,
332 for (i = 1; i < argc; i++) {
333 const char *cur_opt = argv[i];
335 if (*cur_opt++ != '-')
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);
342 if ((!po->name && !strcmp(cur_opt, optname)) ||
343 (po->name && !strcmp(optname, po->name)))
346 if (!po || po->flags & HAS_ARG)
352 void parse_loglevel(int argc, char **argv, const OptionDef *options)
354 int idx = locate_option(argc, argv, options, "loglevel");
356 idx = locate_option(argc, argv, options, "v");
357 if (idx && argv[idx + 1])
358 opt_loglevel("loglevel", argv[idx + 1]);
361 #define FLAGS (o->type == AV_OPT_TYPE_FLAGS) ? AV_DICT_APPEND : 0
362 int opt_default(const char *opt, const char *arg)
365 char opt_stripped[128];
367 const AVClass *cc = avcodec_get_class(), *fc = avformat_get_class(), *sc = sws_get_class();
369 if (!(p = strchr(opt, ':')))
370 p = opt + strlen(opt);
371 av_strlcpy(opt_stripped, opt, FFMIN(sizeof(opt_stripped), p - opt + 1));
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);
386 av_log(NULL, AV_LOG_ERROR, "Error setting option %s.\n", opt);
393 av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);
394 return AVERROR_OPTION_NOT_FOUND;
397 int opt_loglevel(const char *opt, const char *arg)
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 },
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);
420 level = strtol(arg, &tail, 10);
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);
428 av_log_set_level(level);
432 int opt_timelimit(const char *opt, const char *arg)
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))
440 av_log(NULL, AV_LOG_WARNING, "-%s not implemented on this OS\n", opt);
445 void print_error(const char *filename, int err)
448 const char *errbuf_ptr = errbuf;
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);
455 static int warned_cfg = 0;
458 #define SHOW_VERSION 2
459 #define SHOW_CONFIG 4
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", \
469 LIB##LIBNAME##_VERSION_MAJOR, \
470 LIB##LIBNAME##_VERSION_MINOR, \
471 LIB##LIBNAME##_VERSION_MICRO, \
472 version >> 16, version >> 8 & 0xff, version & 0xff); \
474 if (flags & SHOW_CONFIG) { \
475 const char *cfg = libname##_configuration(); \
476 if (strcmp(LIBAV_CONFIGURATION, cfg)) { \
478 av_log(NULL, level, \
479 "%sWARNING: library configuration mismatch\n", \
483 av_log(NULL, level, "%s%-11s configuration: %s\n", \
484 indent, #libname, cfg); \
489 static void print_all_libs_info(int flags, int level)
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);
500 void show_banner(void)
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);
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);
518 void show_license(void)
522 "This version of %s has nonfree parts compiled in.\n"
523 "Therefore it is not legally redistributable.\n",
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"
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"
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
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"
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"
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
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"
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"
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
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"
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"
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
587 void show_formats(void)
589 AVInputFormat *ifmt = NULL;
590 AVOutputFormat *ofmt = NULL;
591 const char *last_name;
593 printf("File formats:\n"
594 " D. = Demuxing supported\n"
595 " .E = Muxing supported\n"
601 const char *name = NULL;
602 const char *long_name = NULL;
604 while ((ofmt = av_oformat_next(ofmt))) {
605 if ((name == NULL || strcmp(ofmt->name, name) < 0) &&
606 strcmp(ofmt->name, last_name) > 0) {
608 long_name = ofmt->long_name;
612 while ((ifmt = av_iformat_next(ifmt))) {
613 if ((name == NULL || strcmp(ifmt->name, name) < 0) &&
614 strcmp(ifmt->name, last_name) > 0) {
616 long_name = ifmt->long_name;
619 if (name && strcmp(ifmt->name, name) == 0)
626 printf(" %s%s %-15s %s\n",
630 long_name ? long_name:" ");
634 void show_codecs(void)
636 AVCodec *p = NULL, *p2;
637 const char *last_name;
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"
653 const char *type_str;
656 while ((p = av_codec_next(p))) {
657 if ((p2 == NULL || strcmp(p->name, p2->name) < 0) &&
658 strcmp(p->name, last_name) > 0) {
660 decode = encode = cap = 0;
662 if (p2 && strcmp(p->name, p2->name) == 0) {
663 if (av_codec_is_decoder(p))
665 if (av_codec_is_encoder(p))
667 cap |= p->capabilities;
672 last_name = p2->name;
675 case AVMEDIA_TYPE_VIDEO:
678 case AVMEDIA_TYPE_AUDIO:
681 case AVMEDIA_TYPE_SUBTITLE:
688 printf(" %s%s%s%s%s%s %-15s %s",
689 decode ? "D" : (/* p2->decoder ? "d" : */ " "),
692 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S" : " ",
693 cap & CODEC_CAP_DR1 ? "D" : " ",
694 cap & CODEC_CAP_TRUNCATED ? "T" : " ",
696 p2->long_name ? p2->long_name : "");
698 if (p2->decoder && decode == 0)
699 printf(" use %s for decoding", p2->decoder->name);
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"
713 AVBitStreamFilter *bsf = NULL;
715 printf("Bitstream filters:\n");
716 while ((bsf = av_bitstream_filter_next(bsf)))
717 printf("%s\n", bsf->name);
721 void show_protocols(void)
726 printf("Supported file protocols:\n"
728 while ((name = avio_enum_protocols(&opaque, 0)))
729 printf("%s\n", name);
731 while ((name = avio_enum_protocols(&opaque, 1)))
732 printf("%s\n", name);
735 void show_filters(void)
737 AVFilter av_unused(**filter) = NULL;
739 printf("Filters:\n");
741 while ((filter = av_filter_next(filter)) && *filter)
742 printf("%-16s %s\n", (*filter)->name, (*filter)->description);
746 void show_pix_fmts(void)
748 enum PixelFormat pix_fmt;
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"
760 # define sws_isSupportedInput(x) 0
761 # define sws_isSupportedOutput(x) 0
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' : '.',
773 pix_desc->nb_components,
774 av_get_bits_per_pixel(pix_desc));
778 int show_sample_fmts(const char *opt, const char *arg)
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));
790 int yesno = (toupper(c) == 'Y');
792 while (c != '\n' && c != EOF)
798 int cmdutils_read_file(const char *filename, char **bufptr, size_t *size)
801 FILE *f = fopen(filename, "rb");
804 av_log(NULL, AV_LOG_ERROR, "Cannot read file '%s': %s\n", filename,
806 return AVERROR(errno);
808 fseek(f, 0, SEEK_END);
810 fseek(f, 0, SEEK_SET);
811 *bufptr = av_malloc(*size + 1);
813 av_log(NULL, AV_LOG_ERROR, "Could not allocate file buffer\n");
815 return AVERROR(ENOMEM);
817 ret = fread(*bufptr, 1, *size, f);
821 av_log(NULL, AV_LOG_ERROR, "Error while reading file '%s': %s\n",
822 filename, strerror(errno));
823 ret = AVERROR(errno);
828 (*bufptr)[*size++] = '\0';
835 void init_pts_correction(PtsCorrectionContext *ctx)
837 ctx->num_faulty_pts = ctx->num_faulty_dts = 0;
838 ctx->last_pts = ctx->last_dts = INT64_MIN;
841 int64_t guess_correct_pts(PtsCorrectionContext *ctx, int64_t reordered_pts,
844 int64_t pts = AV_NOPTS_VALUE;
846 if (dts != AV_NOPTS_VALUE) {
847 ctx->num_faulty_dts += dts <= ctx->last_dts;
850 if (reordered_pts != AV_NOPTS_VALUE) {
851 ctx->num_faulty_pts += reordered_pts <= ctx->last_pts;
852 ctx->last_pts = reordered_pts;
854 if ((ctx->num_faulty_pts<=ctx->num_faulty_dts || dts == AV_NOPTS_VALUE)
855 && reordered_pts != AV_NOPTS_VALUE)
863 FILE *get_preset_file(char *filename, size_t filename_size,
864 const char *preset_name, int is_path,
865 const char *codec_name)
869 const char *base[3] = { getenv("AVCONV_DATADIR"),
874 av_strlcpy(filename, preset_name, filename_size);
875 f = fopen(filename, "r");
877 for (i = 0; i < 3 && !f; i++) {
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,
888 f = fopen(filename, "r");
896 int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
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;
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);
912 if (type != st->codec->codec_type)
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;
922 } else if (*spec == 'p' && *(spec + 1) == ':') {
926 prog_id = strtol(spec, &endptr, 0);
927 for (i = 0; i < s->nb_programs; i++) {
928 if (s->programs[i]->id != prog_id)
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];
938 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
939 if (st->index == s->programs[i]->stream_index[j])
943 } else if (!*spec) /* empty specifier, matches everything */
946 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
947 return AVERROR(EINVAL);
950 AVDictionary *filter_codec_opts(AVDictionary *opts, enum CodecID codec_id,
951 AVFormatContext *s, AVStream *st, AVCodec *codec)
953 AVDictionary *ret = NULL;
954 AVDictionaryEntry *t = NULL;
955 int flags = s->oformat ? AV_OPT_FLAG_ENCODING_PARAM
956 : AV_OPT_FLAG_DECODING_PARAM;
958 const AVClass *cc = avcodec_get_class();
961 codec = s->oformat ? avcodec_find_encoder(codec_id)
962 : avcodec_find_decoder(codec_id);
966 switch (codec->type) {
967 case AVMEDIA_TYPE_VIDEO:
969 flags |= AV_OPT_FLAG_VIDEO_PARAM;
971 case AVMEDIA_TYPE_AUDIO:
973 flags |= AV_OPT_FLAG_AUDIO_PARAM;
975 case AVMEDIA_TYPE_SUBTITLE:
977 flags |= AV_OPT_FLAG_SUBTITLE_PARAM;
981 while (t = av_dict_get(opts, "", t, AV_DICT_IGNORE_SUFFIX)) {
982 char *p = strchr(t->key, ':');
984 /* check stream specification in opt name */
986 switch (check_stream_specifier(s, st, p + 1)) {
987 case 1: *p = 0; break;
989 default: return NULL;
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);
1008 AVDictionary **setup_find_stream_info_opts(AVFormatContext *s,
1009 AVDictionary *codec_opts)
1012 AVDictionary **opts;
1016 opts = av_mallocz(s->nb_streams * sizeof(*opts));
1018 av_log(NULL, AV_LOG_ERROR,
1019 "Could not alloc memory for stream options.\n");
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);
1028 void *grow_array(void *array, int elem_size, int *size, int new_size)
1030 if (new_size >= INT_MAX / elem_size) {
1031 av_log(NULL, AV_LOG_ERROR, "Array too big.\n");
1034 if (*size < new_size) {
1035 uint8_t *tmp = av_realloc(array, new_size*elem_size);
1037 av_log(NULL, AV_LOG_ERROR, "Could not alloc buffer.\n");
1040 memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
1047 static int alloc_buffer(FrameBuffer **pool, AVCodecContext *s, FrameBuffer **pbuf)
1049 FrameBuffer *buf = av_mallocz(sizeof(*buf));
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;
1057 return AVERROR(ENOMEM);
1059 if (!(s->flags & CODEC_FLAG_EMU_EDGE)) {
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) {
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
1075 memset(buf->base[0], 128, ret);
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];
1084 buf->data[i] = buf->base[i] +
1085 FFALIGN((buf->linesize[i]*edge >> v_shift) +
1086 (pixel_size*edge >> h_shift), 32);
1090 buf->pix_fmt = s->pix_fmt;
1097 int codec_get_buffer(AVCodecContext *s, AVFrame *frame)
1099 FrameBuffer **pool = s->opaque;
1103 if (!*pool && (ret = alloc_buffer(pool, s, pool)) < 0)
1109 if (buf->w != s->width || buf->h != s->height || buf->pix_fmt != s->pix_fmt) {
1110 av_freep(&buf->base[0]);
1112 if ((ret = alloc_buffer(pool, s, &buf)) < 0)
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;
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];
1135 static void unref_buffer(FrameBuffer *buf)
1137 FrameBuffer **pool = buf->pool;
1139 av_assert0(buf->refcount);
1141 if (!buf->refcount) {
1147 void codec_release_buffer(AVCodecContext *s, AVFrame *frame)
1149 FrameBuffer *buf = frame->opaque;
1152 for (i = 0; i < FF_ARRAY_ELEMS(frame->data); i++)
1153 frame->data[i] = NULL;
1158 void filter_release_buffer(AVFilterBuffer *fb)
1160 FrameBuffer *buf = fb->priv;
1165 void free_buffer_pool(FrameBuffer **pool)
1167 FrameBuffer *buf = *pool;
1170 av_freep(&buf->base[0]);