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 "libswscale/swscale.h"
37 #include "libpostproc/postprocess.h"
39 #include "libavutil/avstring.h"
40 #include "libavutil/mathematics.h"
41 #include "libavutil/parseutils.h"
42 #include "libavutil/pixdesc.h"
43 #include "libavutil/eval.h"
44 #include "libavutil/dict.h"
45 #include "libavutil/opt.h"
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 = 2011;
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);
327 * Return index of option opt in argv or 0 if not found.
329 static int locate_option(int argc, char **argv, const OptionDef *options,
335 for (i = 1; i < argc; i++) {
336 const char *cur_opt = argv[i];
338 if (*cur_opt++ != '-')
341 po = find_option(options, cur_opt);
342 if (!po->name && cur_opt[0] == 'n' && cur_opt[1] == 'o')
343 po = find_option(options, cur_opt + 2);
345 if ((!po->name && !strcmp(cur_opt, optname)) ||
346 (po->name && !strcmp(optname, po->name)))
349 if (!po || po->flags & HAS_ARG)
355 void parse_loglevel(int argc, char **argv, const OptionDef *options)
357 int idx = locate_option(argc, argv, options, "loglevel");
359 idx = locate_option(argc, argv, options, "v");
360 if (idx && argv[idx + 1])
361 opt_loglevel("loglevel", argv[idx + 1]);
364 #define FLAGS (o->type == AV_OPT_TYPE_FLAGS) ? AV_DICT_APPEND : 0
365 int opt_default(const char *opt, const char *arg)
368 char opt_stripped[128];
370 const AVClass *cc = avcodec_get_class(), *fc = avformat_get_class(), *sc = sws_get_class();
372 if (!(p = strchr(opt, ':')))
373 p = opt + strlen(opt);
374 av_strlcpy(opt_stripped, opt, FFMIN(sizeof(opt_stripped), p - opt + 1));
376 if ((o = av_opt_find(&cc, opt_stripped, NULL, 0,
377 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)) ||
378 ((opt[0] == 'v' || opt[0] == 'a' || opt[0] == 's') &&
379 (o = av_opt_find(&cc, opt + 1, NULL, 0, AV_OPT_SEARCH_FAKE_OBJ))))
380 av_dict_set(&codec_opts, opt, arg, FLAGS);
381 else if ((o = av_opt_find(&fc, opt, NULL, 0,
382 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)))
383 av_dict_set(&format_opts, opt, arg, FLAGS);
384 else if ((o = av_opt_find(&sc, opt, NULL, 0,
385 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) {
386 // XXX we only support sws_flags, not arbitrary sws options
387 int ret = av_opt_set(sws_opts, opt, arg, 0);
389 av_log(NULL, AV_LOG_ERROR, "Error setting option %s.\n", opt);
396 av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);
397 return AVERROR_OPTION_NOT_FOUND;
400 int opt_loglevel(const char *opt, const char *arg)
402 const struct { const char *name; int level; } log_levels[] = {
403 { "quiet" , AV_LOG_QUIET },
404 { "panic" , AV_LOG_PANIC },
405 { "fatal" , AV_LOG_FATAL },
406 { "error" , AV_LOG_ERROR },
407 { "warning", AV_LOG_WARNING },
408 { "info" , AV_LOG_INFO },
409 { "verbose", AV_LOG_VERBOSE },
410 { "debug" , AV_LOG_DEBUG },
416 for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
417 if (!strcmp(log_levels[i].name, arg)) {
418 av_log_set_level(log_levels[i].level);
423 level = strtol(arg, &tail, 10);
425 av_log(NULL, AV_LOG_FATAL, "Invalid loglevel \"%s\". "
426 "Possible levels are numbers or:\n", arg);
427 for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
428 av_log(NULL, AV_LOG_FATAL, "\"%s\"\n", log_levels[i].name);
431 av_log_set_level(level);
435 int opt_timelimit(const char *opt, const char *arg)
438 int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
439 struct rlimit rl = { lim, lim + 1 };
440 if (setrlimit(RLIMIT_CPU, &rl))
443 av_log(NULL, AV_LOG_WARNING, "-%s not implemented on this OS\n", opt);
448 void print_error(const char *filename, int err)
451 const char *errbuf_ptr = errbuf;
453 if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
454 errbuf_ptr = strerror(AVUNERROR(err));
455 av_log(NULL, AV_LOG_ERROR, "%s: %s\n", filename, errbuf_ptr);
458 static int warned_cfg = 0;
461 #define SHOW_VERSION 2
462 #define SHOW_CONFIG 4
464 #define PRINT_LIB_INFO(libname, LIBNAME, flags, level) \
465 if (CONFIG_##LIBNAME) { \
466 const char *indent = flags & INDENT? " " : ""; \
467 if (flags & SHOW_VERSION) { \
468 unsigned int version = libname##_version(); \
469 av_log(NULL, level, "%slib%-9s %2d.%3d.%2d / %2d.%3d.%2d\n",\
471 LIB##LIBNAME##_VERSION_MAJOR, \
472 LIB##LIBNAME##_VERSION_MINOR, \
473 LIB##LIBNAME##_VERSION_MICRO, \
474 version >> 16, version >> 8 & 0xff, version & 0xff); \
476 if (flags & SHOW_CONFIG) { \
477 const char *cfg = libname##_configuration(); \
478 if (strcmp(LIBAV_CONFIGURATION, cfg)) { \
480 av_log(NULL, level, \
481 "%sWARNING: library configuration mismatch\n", \
485 av_log(NULL, level, "%s%-11s configuration: %s\n", \
486 indent, #libname, cfg); \
491 static void print_all_libs_info(int flags, int level)
493 PRINT_LIB_INFO(avutil, AVUTIL, flags, level);
494 PRINT_LIB_INFO(avcodec, AVCODEC, flags, level);
495 PRINT_LIB_INFO(avformat, AVFORMAT, flags, level);
496 PRINT_LIB_INFO(avdevice, AVDEVICE, flags, level);
497 PRINT_LIB_INFO(avfilter, AVFILTER, flags, level);
498 PRINT_LIB_INFO(swscale, SWSCALE, flags, level);
500 PRINT_LIB_INFO(postproc, POSTPROC, flags, level);
504 void show_banner(void)
506 av_log(NULL, AV_LOG_INFO,
507 "%s version " LIBAV_VERSION ", Copyright (c) %d-%d the Libav developers\n",
508 program_name, program_birth_year, this_year);
509 av_log(NULL, AV_LOG_INFO, " built on %s %s with %s %s\n",
510 __DATE__, __TIME__, CC_TYPE, CC_VERSION);
511 av_log(NULL, AV_LOG_VERBOSE, " configuration: " LIBAV_CONFIGURATION "\n");
512 print_all_libs_info(INDENT|SHOW_CONFIG, AV_LOG_VERBOSE);
513 print_all_libs_info(INDENT|SHOW_VERSION, AV_LOG_VERBOSE);
516 void show_version(void) {
517 av_log_set_callback(log_callback_help);
518 printf("%s " LIBAV_VERSION "\n", program_name);
519 print_all_libs_info(SHOW_VERSION, AV_LOG_INFO);
522 void show_license(void)
526 "This version of %s has nonfree parts compiled in.\n"
527 "Therefore it is not legally redistributable.\n",
530 "%s is free software; you can redistribute it and/or modify\n"
531 "it under the terms of the GNU General Public License as published by\n"
532 "the Free Software Foundation; either version 3 of the License, or\n"
533 "(at your option) any later version.\n"
535 "%s is distributed in the hope that it will be useful,\n"
536 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
537 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
538 "GNU General Public License for more details.\n"
540 "You should have received a copy of the GNU General Public License\n"
541 "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
542 program_name, program_name, program_name
544 "%s is free software; you can redistribute it and/or modify\n"
545 "it under the terms of the GNU General Public License as published by\n"
546 "the Free Software Foundation; either version 2 of the License, or\n"
547 "(at your option) any later version.\n"
549 "%s is distributed in the hope that it will be useful,\n"
550 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
551 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
552 "GNU General Public License for more details.\n"
554 "You should have received a copy of the GNU General Public License\n"
555 "along with %s; if not, write to the Free Software\n"
556 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
557 program_name, program_name, program_name
559 "%s is free software; you can redistribute it and/or modify\n"
560 "it under the terms of the GNU Lesser General Public License as published by\n"
561 "the Free Software Foundation; either version 3 of the License, or\n"
562 "(at your option) any later version.\n"
564 "%s is distributed in the hope that it will be useful,\n"
565 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
566 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
567 "GNU Lesser General Public License for more details.\n"
569 "You should have received a copy of the GNU Lesser General Public License\n"
570 "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
571 program_name, program_name, program_name
573 "%s is free software; you can redistribute it and/or\n"
574 "modify it under the terms of the GNU Lesser General Public\n"
575 "License as published by the Free Software Foundation; either\n"
576 "version 2.1 of the License, or (at your option) any later version.\n"
578 "%s is distributed in the hope that it will be useful,\n"
579 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
580 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
581 "Lesser General Public License for more details.\n"
583 "You should have received a copy of the GNU Lesser General Public\n"
584 "License along with %s; if not, write to the Free Software\n"
585 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
586 program_name, program_name, program_name
591 void show_formats(void)
593 AVInputFormat *ifmt = NULL;
594 AVOutputFormat *ofmt = NULL;
595 const char *last_name;
597 printf("File formats:\n"
598 " D. = Demuxing supported\n"
599 " .E = Muxing supported\n"
605 const char *name = NULL;
606 const char *long_name = NULL;
608 while ((ofmt = av_oformat_next(ofmt))) {
609 if ((name == NULL || strcmp(ofmt->name, name) < 0) &&
610 strcmp(ofmt->name, last_name) > 0) {
612 long_name = ofmt->long_name;
616 while ((ifmt = av_iformat_next(ifmt))) {
617 if ((name == NULL || strcmp(ifmt->name, name) < 0) &&
618 strcmp(ifmt->name, last_name) > 0) {
620 long_name = ifmt->long_name;
623 if (name && strcmp(ifmt->name, name) == 0)
630 printf(" %s%s %-15s %s\n",
634 long_name ? long_name:" ");
638 void show_codecs(void)
640 AVCodec *p = NULL, *p2;
641 const char *last_name;
643 " D..... = Decoding supported\n"
644 " .E.... = Encoding supported\n"
645 " ..V... = Video codec\n"
646 " ..A... = Audio codec\n"
647 " ..S... = Subtitle codec\n"
648 " ...S.. = Supports draw_horiz_band\n"
649 " ....D. = Supports direct rendering method 1\n"
650 " .....T = Supports weird frame truncation\n"
657 const char *type_str;
660 while ((p = av_codec_next(p))) {
661 if ((p2 == NULL || strcmp(p->name, p2->name) < 0) &&
662 strcmp(p->name, last_name) > 0) {
664 decode = encode = cap = 0;
666 if (p2 && strcmp(p->name, p2->name) == 0) {
671 cap |= p->capabilities;
676 last_name = p2->name;
679 case AVMEDIA_TYPE_VIDEO:
682 case AVMEDIA_TYPE_AUDIO:
685 case AVMEDIA_TYPE_SUBTITLE:
692 printf(" %s%s%s%s%s%s %-15s %s",
693 decode ? "D" : (/* p2->decoder ? "d" : */ " "),
696 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S" : " ",
697 cap & CODEC_CAP_DR1 ? "D" : " ",
698 cap & CODEC_CAP_TRUNCATED ? "T" : " ",
700 p2->long_name ? p2->long_name : "");
702 if (p2->decoder && decode == 0)
703 printf(" use %s for decoding", p2->decoder->name);
708 printf("Note, the names of encoders and decoders do not always match, so there are\n"
709 "several cases where the above table shows encoder only or decoder only entries\n"
710 "even though both encoding and decoding are supported. For example, the h263\n"
711 "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
717 AVBitStreamFilter *bsf = NULL;
719 printf("Bitstream filters:\n");
720 while ((bsf = av_bitstream_filter_next(bsf)))
721 printf("%s\n", bsf->name);
725 void show_protocols(void)
730 printf("Supported file protocols:\n"
732 while ((name = avio_enum_protocols(&opaque, 0)))
733 printf("%s\n", name);
735 while ((name = avio_enum_protocols(&opaque, 1)))
736 printf("%s\n", name);
739 void show_filters(void)
741 AVFilter av_unused(**filter) = NULL;
743 printf("Filters:\n");
745 while ((filter = av_filter_next(filter)) && *filter)
746 printf("%-16s %s\n", (*filter)->name, (*filter)->description);
750 void show_pix_fmts(void)
752 enum PixelFormat pix_fmt;
754 printf("Pixel formats:\n"
755 "I.... = Supported Input format for conversion\n"
756 ".O... = Supported Output format for conversion\n"
757 "..H.. = Hardware accelerated format\n"
758 "...P. = Paletted format\n"
759 "....B = Bitstream format\n"
760 "FLAGS NAME NB_COMPONENTS BITS_PER_PIXEL\n"
764 # define sws_isSupportedInput(x) 0
765 # define sws_isSupportedOutput(x) 0
768 for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {
769 const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[pix_fmt];
770 printf("%c%c%c%c%c %-16s %d %2d\n",
771 sws_isSupportedInput (pix_fmt) ? 'I' : '.',
772 sws_isSupportedOutput(pix_fmt) ? 'O' : '.',
773 pix_desc->flags & PIX_FMT_HWACCEL ? 'H' : '.',
774 pix_desc->flags & PIX_FMT_PAL ? 'P' : '.',
775 pix_desc->flags & PIX_FMT_BITSTREAM ? 'B' : '.',
777 pix_desc->nb_components,
778 av_get_bits_per_pixel(pix_desc));
782 int show_sample_fmts(const char *opt, const char *arg)
786 for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
787 printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
794 int yesno = (toupper(c) == 'Y');
796 while (c != '\n' && c != EOF)
802 int cmdutils_read_file(const char *filename, char **bufptr, size_t *size)
805 FILE *f = fopen(filename, "rb");
808 av_log(NULL, AV_LOG_ERROR, "Cannot read file '%s': %s\n", filename,
810 return AVERROR(errno);
812 fseek(f, 0, SEEK_END);
814 fseek(f, 0, SEEK_SET);
815 *bufptr = av_malloc(*size + 1);
817 av_log(NULL, AV_LOG_ERROR, "Could not allocate file buffer\n");
819 return AVERROR(ENOMEM);
821 ret = fread(*bufptr, 1, *size, f);
825 av_log(NULL, AV_LOG_ERROR, "Error while reading file '%s': %s\n",
826 filename, strerror(errno));
827 ret = AVERROR(errno);
832 (*bufptr)[*size++] = '\0';
839 void init_pts_correction(PtsCorrectionContext *ctx)
841 ctx->num_faulty_pts = ctx->num_faulty_dts = 0;
842 ctx->last_pts = ctx->last_dts = INT64_MIN;
845 int64_t guess_correct_pts(PtsCorrectionContext *ctx, int64_t reordered_pts,
848 int64_t pts = AV_NOPTS_VALUE;
850 if (dts != AV_NOPTS_VALUE) {
851 ctx->num_faulty_dts += dts <= ctx->last_dts;
854 if (reordered_pts != AV_NOPTS_VALUE) {
855 ctx->num_faulty_pts += reordered_pts <= ctx->last_pts;
856 ctx->last_pts = reordered_pts;
858 if ((ctx->num_faulty_pts<=ctx->num_faulty_dts || dts == AV_NOPTS_VALUE)
859 && reordered_pts != AV_NOPTS_VALUE)
867 FILE *get_preset_file(char *filename, size_t filename_size,
868 const char *preset_name, int is_path,
869 const char *codec_name)
873 const char *base[3] = { getenv("AVCONV_DATADIR"),
878 av_strlcpy(filename, preset_name, filename_size);
879 f = fopen(filename, "r");
881 for (i = 0; i < 3 && !f; i++) {
884 snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i],
885 i != 1 ? "" : "/.avconv", preset_name);
886 f = fopen(filename, "r");
887 if (!f && codec_name) {
888 snprintf(filename, filename_size,
889 "%s%s/%s-%s.ffpreset",
890 base[i], i != 1 ? "" : "/.avconv", codec_name,
892 f = fopen(filename, "r");
900 int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
902 if (*spec <= '9' && *spec >= '0') /* opt:index */
903 return strtol(spec, NULL, 0) == st->index;
904 else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
905 *spec == 't') { /* opt:[vasdt] */
906 enum AVMediaType type;
909 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
910 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
911 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
912 case 'd': type = AVMEDIA_TYPE_DATA; break;
913 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
915 if (type != st->codec->codec_type)
917 if (*spec++ == ':') { /* possibly followed by :index */
918 int i, index = strtol(spec, NULL, 0);
919 for (i = 0; i < s->nb_streams; i++)
920 if (s->streams[i]->codec->codec_type == type && index-- == 0)
921 return i == st->index;
925 } else if (*spec == 'p' && *(spec + 1) == ':') {
929 prog_id = strtol(spec, &endptr, 0);
930 for (i = 0; i < s->nb_programs; i++) {
931 if (s->programs[i]->id != prog_id)
934 if (*endptr++ == ':') {
935 int stream_idx = strtol(endptr, NULL, 0);
936 return stream_idx >= 0 &&
937 stream_idx < s->programs[i]->nb_stream_indexes &&
938 st->index == s->programs[i]->stream_index[stream_idx];
941 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
942 if (st->index == s->programs[i]->stream_index[j])
946 } else if (!*spec) /* empty specifier, matches everything */
949 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
950 return AVERROR(EINVAL);
953 AVDictionary *filter_codec_opts(AVDictionary *opts, enum CodecID codec_id,
954 AVFormatContext *s, AVStream *st)
956 AVDictionary *ret = NULL;
957 AVDictionaryEntry *t = NULL;
958 AVCodec *codec = s->oformat ? avcodec_find_encoder(codec_id)
959 : avcodec_find_decoder(codec_id);
960 int flags = s->oformat ? AV_OPT_FLAG_ENCODING_PARAM
961 : AV_OPT_FLAG_DECODING_PARAM;
963 const AVClass *cc = avcodec_get_class();
968 switch (codec->type) {
969 case AVMEDIA_TYPE_VIDEO:
971 flags |= AV_OPT_FLAG_VIDEO_PARAM;
973 case AVMEDIA_TYPE_AUDIO:
975 flags |= AV_OPT_FLAG_AUDIO_PARAM;
977 case AVMEDIA_TYPE_SUBTITLE:
979 flags |= AV_OPT_FLAG_SUBTITLE_PARAM;
983 while (t = av_dict_get(opts, "", t, AV_DICT_IGNORE_SUFFIX)) {
984 char *p = strchr(t->key, ':');
986 /* check stream specification in opt name */
988 switch (check_stream_specifier(s, st, p + 1)) {
989 case 1: *p = 0; break;
991 default: return NULL;
994 if (av_opt_find(&cc, t->key, NULL, flags, AV_OPT_SEARCH_FAKE_OBJ) ||
995 (codec && codec->priv_class &&
996 av_opt_find(&codec->priv_class, t->key, NULL, flags,
997 AV_OPT_SEARCH_FAKE_OBJ)))
998 av_dict_set(&ret, t->key, t->value, 0);
999 else if (t->key[0] == prefix &&
1000 av_opt_find(&cc, t->key + 1, NULL, flags,
1001 AV_OPT_SEARCH_FAKE_OBJ))
1002 av_dict_set(&ret, t->key + 1, t->value, 0);
1010 AVDictionary **setup_find_stream_info_opts(AVFormatContext *s,
1011 AVDictionary *codec_opts)
1014 AVDictionary **opts;
1018 opts = av_mallocz(s->nb_streams * sizeof(*opts));
1020 av_log(NULL, AV_LOG_ERROR,
1021 "Could not alloc memory for stream options.\n");
1024 for (i = 0; i < s->nb_streams; i++)
1025 opts[i] = filter_codec_opts(codec_opts, s->streams[i]->codec->codec_id,
1032 static int sink_init(AVFilterContext *ctx, const char *args, void *opaque)
1034 SinkContext *priv = ctx->priv;
1037 return AVERROR(EINVAL);
1038 *priv = *(SinkContext *)opaque;
1043 static void null_end_frame(AVFilterLink *inlink) { }
1045 static int sink_query_formats(AVFilterContext *ctx)
1047 SinkContext *priv = ctx->priv;
1048 enum PixelFormat pix_fmts[] = { priv->pix_fmt, PIX_FMT_NONE };
1050 avfilter_set_common_formats(ctx, avfilter_make_format_list(pix_fmts));
1056 .priv_size = sizeof(SinkContext),
1059 .query_formats = sink_query_formats,
1061 .inputs = (AVFilterPad[]) {{ .name = "default",
1062 .type = AVMEDIA_TYPE_VIDEO,
1063 .end_frame = null_end_frame,
1064 .min_perms = AV_PERM_READ, },
1066 .outputs = (AVFilterPad[]) {{ .name = NULL }},
1069 int get_filtered_video_frame(AVFilterContext *ctx, AVFrame *frame,
1070 AVFilterBufferRef **picref_ptr, AVRational *tb)
1073 AVFilterBufferRef *picref;
1075 if ((ret = avfilter_request_frame(ctx->inputs[0])) < 0)
1077 if (!(picref = ctx->inputs[0]->cur_buf))
1078 return AVERROR(ENOENT);
1079 *picref_ptr = picref;
1080 ctx->inputs[0]->cur_buf = NULL;
1081 *tb = ctx->inputs[0]->time_base;
1083 memcpy(frame->data, picref->data, sizeof(frame->data));
1084 memcpy(frame->linesize, picref->linesize, sizeof(frame->linesize));
1085 frame->interlaced_frame = picref->video->interlaced;
1086 frame->top_field_first = picref->video->top_field_first;
1087 frame->key_frame = picref->video->key_frame;
1088 frame->pict_type = picref->video->pict_type;
1089 frame->sample_aspect_ratio = picref->video->pixel_aspect;
1094 #endif /* CONFIG_AVFILTER */
1096 void *grow_array(void *array, int elem_size, int *size, int new_size)
1098 if (new_size >= INT_MAX / elem_size) {
1099 av_log(NULL, AV_LOG_ERROR, "Array too big.\n");
1102 if (*size < new_size) {
1103 uint8_t *tmp = av_realloc(array, new_size*elem_size);
1105 av_log(NULL, AV_LOG_ERROR, "Could not alloc buffer.\n");
1108 memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);