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)))
241 po = find_option(options, "default");
244 av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);
245 return AVERROR(EINVAL);
247 if (po->flags & HAS_ARG && !arg) {
248 av_log(NULL, AV_LOG_ERROR, "Missing argument for option '%s'\n", opt);
249 return AVERROR(EINVAL);
252 /* new-style options contain an offset into optctx, old-style address of
254 dst = po->flags & (OPT_OFFSET | OPT_SPEC) ? (uint8_t *)optctx + po->u.off
257 if (po->flags & OPT_SPEC) {
258 SpecifierOpt **so = dst;
259 char *p = strchr(opt, ':');
261 dstcount = (int *)(so + 1);
262 *so = grow_array(*so, sizeof(**so), dstcount, *dstcount + 1);
263 (*so)[*dstcount - 1].specifier = av_strdup(p ? p + 1 : "");
264 dst = &(*so)[*dstcount - 1].u;
267 if (po->flags & OPT_STRING) {
269 str = av_strdup(arg);
271 } else if (po->flags & OPT_BOOL) {
272 *(int *)dst = bool_val;
273 } else if (po->flags & OPT_INT) {
274 *(int *)dst = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
275 } else if (po->flags & OPT_INT64) {
276 *(int64_t *)dst = parse_number_or_die(opt, arg, OPT_INT64, INT64_MIN, INT64_MAX);
277 } else if (po->flags & OPT_TIME) {
278 *(int64_t *)dst = parse_time_or_die(opt, arg, 1);
279 } else if (po->flags & OPT_FLOAT) {
280 *(float *)dst = parse_number_or_die(opt, arg, OPT_FLOAT, -INFINITY, INFINITY);
281 } else if (po->flags & OPT_DOUBLE) {
282 *(double *)dst = parse_number_or_die(opt, arg, OPT_DOUBLE, -INFINITY, INFINITY);
283 } else if (po->u.func_arg) {
284 int ret = po->flags & OPT_FUNC2 ? po->u.func2_arg(optctx, opt, arg)
285 : po->u.func_arg(opt, arg);
287 av_log(NULL, AV_LOG_ERROR,
288 "Failed to set value '%s' for option '%s'\n", arg, opt);
292 if (po->flags & OPT_EXIT)
294 return !!(po->flags & HAS_ARG);
297 void parse_options(void *optctx, int argc, char **argv, const OptionDef *options,
298 void (*parse_arg_function)(void *, const char*))
301 int optindex, handleoptions = 1, ret;
303 /* perform system-dependent conversions for arguments list */
304 prepare_app_arguments(&argc, &argv);
308 while (optindex < argc) {
309 opt = argv[optindex++];
311 if (handleoptions && opt[0] == '-' && opt[1] != '\0') {
312 if (opt[1] == '-' && opt[2] == '\0') {
318 if ((ret = parse_option(optctx, opt, argv[optindex], options)) < 0)
322 if (parse_arg_function)
323 parse_arg_function(optctx, opt);
329 * Return index of option opt in argv or 0 if not found.
331 static int locate_option(int argc, char **argv, const OptionDef *options,
337 for (i = 1; i < argc; i++) {
338 const char *cur_opt = argv[i];
340 if (*cur_opt++ != '-')
343 po = find_option(options, cur_opt);
344 if (!po->name && cur_opt[0] == 'n' && cur_opt[1] == 'o')
345 po = find_option(options, cur_opt + 2);
347 if ((!po->name && !strcmp(cur_opt, optname)) ||
348 (po->name && !strcmp(optname, po->name)))
351 if (!po || po->flags & HAS_ARG)
357 void parse_loglevel(int argc, char **argv, const OptionDef *options)
359 int idx = locate_option(argc, argv, options, "loglevel");
361 idx = locate_option(argc, argv, options, "v");
362 if (idx && argv[idx + 1])
363 opt_loglevel("loglevel", argv[idx + 1]);
366 #define FLAGS (o->type == AV_OPT_TYPE_FLAGS) ? AV_DICT_APPEND : 0
367 int opt_default(const char *opt, const char *arg)
370 char opt_stripped[128];
372 const AVClass *cc = avcodec_get_class(), *fc = avformat_get_class(), *sc = sws_get_class();
374 if (!(p = strchr(opt, ':')))
375 p = opt + strlen(opt);
376 av_strlcpy(opt_stripped, opt, FFMIN(sizeof(opt_stripped), p - opt + 1));
378 if ((o = av_opt_find(&cc, opt_stripped, NULL, 0,
379 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)) ||
380 ((opt[0] == 'v' || opt[0] == 'a' || opt[0] == 's') &&
381 (o = av_opt_find(&cc, opt + 1, NULL, 0, AV_OPT_SEARCH_FAKE_OBJ))))
382 av_dict_set(&codec_opts, opt, arg, FLAGS);
383 else if ((o = av_opt_find(&fc, opt, NULL, 0,
384 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)))
385 av_dict_set(&format_opts, opt, arg, FLAGS);
386 else if ((o = av_opt_find(&sc, opt, NULL, 0,
387 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) {
388 // XXX we only support sws_flags, not arbitrary sws options
389 int ret = av_opt_set(sws_opts, opt, arg, 0);
391 av_log(NULL, AV_LOG_ERROR, "Error setting option %s.\n", opt);
398 av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);
399 return AVERROR_OPTION_NOT_FOUND;
402 int opt_loglevel(const char *opt, const char *arg)
404 const struct { const char *name; int level; } log_levels[] = {
405 { "quiet" , AV_LOG_QUIET },
406 { "panic" , AV_LOG_PANIC },
407 { "fatal" , AV_LOG_FATAL },
408 { "error" , AV_LOG_ERROR },
409 { "warning", AV_LOG_WARNING },
410 { "info" , AV_LOG_INFO },
411 { "verbose", AV_LOG_VERBOSE },
412 { "debug" , AV_LOG_DEBUG },
418 for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
419 if (!strcmp(log_levels[i].name, arg)) {
420 av_log_set_level(log_levels[i].level);
425 level = strtol(arg, &tail, 10);
427 av_log(NULL, AV_LOG_FATAL, "Invalid loglevel \"%s\". "
428 "Possible levels are numbers or:\n", arg);
429 for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
430 av_log(NULL, AV_LOG_FATAL, "\"%s\"\n", log_levels[i].name);
433 av_log_set_level(level);
437 int opt_timelimit(const char *opt, const char *arg)
440 int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
441 struct rlimit rl = { lim, lim + 1 };
442 if (setrlimit(RLIMIT_CPU, &rl))
445 av_log(NULL, AV_LOG_WARNING, "-%s not implemented on this OS\n", opt);
450 void print_error(const char *filename, int err)
453 const char *errbuf_ptr = errbuf;
455 if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
456 errbuf_ptr = strerror(AVUNERROR(err));
457 av_log(NULL, AV_LOG_ERROR, "%s: %s\n", filename, errbuf_ptr);
460 static int warned_cfg = 0;
463 #define SHOW_VERSION 2
464 #define SHOW_CONFIG 4
466 #define PRINT_LIB_INFO(libname, LIBNAME, flags, level) \
467 if (CONFIG_##LIBNAME) { \
468 const char *indent = flags & INDENT? " " : ""; \
469 if (flags & SHOW_VERSION) { \
470 unsigned int version = libname##_version(); \
471 av_log(NULL, level, "%slib%-9s %2d.%3d.%2d / %2d.%3d.%2d\n",\
473 LIB##LIBNAME##_VERSION_MAJOR, \
474 LIB##LIBNAME##_VERSION_MINOR, \
475 LIB##LIBNAME##_VERSION_MICRO, \
476 version >> 16, version >> 8 & 0xff, version & 0xff); \
478 if (flags & SHOW_CONFIG) { \
479 const char *cfg = libname##_configuration(); \
480 if (strcmp(LIBAV_CONFIGURATION, cfg)) { \
482 av_log(NULL, level, \
483 "%sWARNING: library configuration mismatch\n", \
487 av_log(NULL, level, "%s%-11s configuration: %s\n", \
488 indent, #libname, cfg); \
493 static void print_all_libs_info(int flags, int level)
495 PRINT_LIB_INFO(avutil, AVUTIL, flags, level);
496 PRINT_LIB_INFO(avcodec, AVCODEC, flags, level);
497 PRINT_LIB_INFO(avformat, AVFORMAT, flags, level);
498 PRINT_LIB_INFO(avdevice, AVDEVICE, flags, level);
499 PRINT_LIB_INFO(avfilter, AVFILTER, flags, level);
500 PRINT_LIB_INFO(swscale, SWSCALE, flags, level);
502 PRINT_LIB_INFO(postproc, POSTPROC, flags, level);
506 void show_banner(void)
508 av_log(NULL, AV_LOG_INFO,
509 "%s version " LIBAV_VERSION ", Copyright (c) %d-%d the Libav developers\n",
510 program_name, program_birth_year, this_year);
511 av_log(NULL, AV_LOG_INFO, " built on %s %s with %s %s\n",
512 __DATE__, __TIME__, CC_TYPE, CC_VERSION);
513 av_log(NULL, AV_LOG_VERBOSE, " configuration: " LIBAV_CONFIGURATION "\n");
514 print_all_libs_info(INDENT|SHOW_CONFIG, AV_LOG_VERBOSE);
515 print_all_libs_info(INDENT|SHOW_VERSION, AV_LOG_VERBOSE);
518 void show_version(void) {
519 av_log_set_callback(log_callback_help);
520 printf("%s " LIBAV_VERSION "\n", program_name);
521 print_all_libs_info(SHOW_VERSION, AV_LOG_INFO);
524 void show_license(void)
528 "This version of %s has nonfree parts compiled in.\n"
529 "Therefore it is not legally redistributable.\n",
532 "%s is free software; you can redistribute it and/or modify\n"
533 "it under the terms of the GNU General Public License as published by\n"
534 "the Free Software Foundation; either version 3 of the License, or\n"
535 "(at your option) any later version.\n"
537 "%s is distributed in the hope that it will be useful,\n"
538 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
539 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
540 "GNU General Public License for more details.\n"
542 "You should have received a copy of the GNU General Public License\n"
543 "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
544 program_name, program_name, program_name
546 "%s is free software; you can redistribute it and/or modify\n"
547 "it under the terms of the GNU General Public License as published by\n"
548 "the Free Software Foundation; either version 2 of the License, or\n"
549 "(at your option) any later version.\n"
551 "%s is distributed in the hope that it will be useful,\n"
552 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
553 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
554 "GNU General Public License for more details.\n"
556 "You should have received a copy of the GNU General Public License\n"
557 "along with %s; if not, write to the Free Software\n"
558 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
559 program_name, program_name, program_name
561 "%s is free software; you can redistribute it and/or modify\n"
562 "it under the terms of the GNU Lesser General Public License as published by\n"
563 "the Free Software Foundation; either version 3 of the License, or\n"
564 "(at your option) any later version.\n"
566 "%s is distributed in the hope that it will be useful,\n"
567 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
568 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
569 "GNU Lesser General Public License for more details.\n"
571 "You should have received a copy of the GNU Lesser General Public License\n"
572 "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
573 program_name, program_name, program_name
575 "%s is free software; you can redistribute it and/or\n"
576 "modify it under the terms of the GNU Lesser General Public\n"
577 "License as published by the Free Software Foundation; either\n"
578 "version 2.1 of the License, or (at your option) any later version.\n"
580 "%s is distributed in the hope that it will be useful,\n"
581 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
582 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
583 "Lesser General Public License for more details.\n"
585 "You should have received a copy of the GNU Lesser General Public\n"
586 "License along with %s; if not, write to the Free Software\n"
587 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
588 program_name, program_name, program_name
593 void show_formats(void)
595 AVInputFormat *ifmt = NULL;
596 AVOutputFormat *ofmt = NULL;
597 const char *last_name;
599 printf("File formats:\n"
600 " D. = Demuxing supported\n"
601 " .E = Muxing supported\n"
607 const char *name = NULL;
608 const char *long_name = NULL;
610 while ((ofmt = av_oformat_next(ofmt))) {
611 if ((name == NULL || strcmp(ofmt->name, name) < 0) &&
612 strcmp(ofmt->name, last_name) > 0) {
614 long_name = ofmt->long_name;
618 while ((ifmt = av_iformat_next(ifmt))) {
619 if ((name == NULL || strcmp(ifmt->name, name) < 0) &&
620 strcmp(ifmt->name, last_name) > 0) {
622 long_name = ifmt->long_name;
625 if (name && strcmp(ifmt->name, name) == 0)
632 printf(" %s%s %-15s %s\n",
636 long_name ? long_name:" ");
640 void show_codecs(void)
642 AVCodec *p = NULL, *p2;
643 const char *last_name;
645 " D..... = Decoding supported\n"
646 " .E.... = Encoding supported\n"
647 " ..V... = Video codec\n"
648 " ..A... = Audio codec\n"
649 " ..S... = Subtitle codec\n"
650 " ...S.. = Supports draw_horiz_band\n"
651 " ....D. = Supports direct rendering method 1\n"
652 " .....T = Supports weird frame truncation\n"
659 const char *type_str;
662 while ((p = av_codec_next(p))) {
663 if ((p2 == NULL || strcmp(p->name, p2->name) < 0) &&
664 strcmp(p->name, last_name) > 0) {
666 decode = encode = cap = 0;
668 if (p2 && strcmp(p->name, p2->name) == 0) {
673 cap |= p->capabilities;
678 last_name = p2->name;
681 case AVMEDIA_TYPE_VIDEO:
684 case AVMEDIA_TYPE_AUDIO:
687 case AVMEDIA_TYPE_SUBTITLE:
694 printf(" %s%s%s%s%s%s %-15s %s",
695 decode ? "D" : (/* p2->decoder ? "d" : */ " "),
698 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S" : " ",
699 cap & CODEC_CAP_DR1 ? "D" : " ",
700 cap & CODEC_CAP_TRUNCATED ? "T" : " ",
702 p2->long_name ? p2->long_name : "");
704 if (p2->decoder && decode == 0)
705 printf(" use %s for decoding", p2->decoder->name);
710 printf("Note, the names of encoders and decoders do not always match, so there are\n"
711 "several cases where the above table shows encoder only or decoder only entries\n"
712 "even though both encoding and decoding are supported. For example, the h263\n"
713 "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
719 AVBitStreamFilter *bsf = NULL;
721 printf("Bitstream filters:\n");
722 while ((bsf = av_bitstream_filter_next(bsf)))
723 printf("%s\n", bsf->name);
727 void show_protocols(void)
732 printf("Supported file protocols:\n"
734 while ((name = avio_enum_protocols(&opaque, 0)))
735 printf("%s\n", name);
737 while ((name = avio_enum_protocols(&opaque, 1)))
738 printf("%s\n", name);
741 void show_filters(void)
743 AVFilter av_unused(**filter) = NULL;
745 printf("Filters:\n");
747 while ((filter = av_filter_next(filter)) && *filter)
748 printf("%-16s %s\n", (*filter)->name, (*filter)->description);
752 void show_pix_fmts(void)
754 enum PixelFormat pix_fmt;
756 printf("Pixel formats:\n"
757 "I.... = Supported Input format for conversion\n"
758 ".O... = Supported Output format for conversion\n"
759 "..H.. = Hardware accelerated format\n"
760 "...P. = Paletted format\n"
761 "....B = Bitstream format\n"
762 "FLAGS NAME NB_COMPONENTS BITS_PER_PIXEL\n"
766 # define sws_isSupportedInput(x) 0
767 # define sws_isSupportedOutput(x) 0
770 for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {
771 const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[pix_fmt];
772 printf("%c%c%c%c%c %-16s %d %2d\n",
773 sws_isSupportedInput (pix_fmt) ? 'I' : '.',
774 sws_isSupportedOutput(pix_fmt) ? 'O' : '.',
775 pix_desc->flags & PIX_FMT_HWACCEL ? 'H' : '.',
776 pix_desc->flags & PIX_FMT_PAL ? 'P' : '.',
777 pix_desc->flags & PIX_FMT_BITSTREAM ? 'B' : '.',
779 pix_desc->nb_components,
780 av_get_bits_per_pixel(pix_desc));
784 int show_sample_fmts(const char *opt, const char *arg)
788 for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
789 printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
796 int yesno = (toupper(c) == 'Y');
798 while (c != '\n' && c != EOF)
804 int cmdutils_read_file(const char *filename, char **bufptr, size_t *size)
807 FILE *f = fopen(filename, "rb");
810 av_log(NULL, AV_LOG_ERROR, "Cannot read file '%s': %s\n", filename,
812 return AVERROR(errno);
814 fseek(f, 0, SEEK_END);
816 fseek(f, 0, SEEK_SET);
817 *bufptr = av_malloc(*size + 1);
819 av_log(NULL, AV_LOG_ERROR, "Could not allocate file buffer\n");
821 return AVERROR(ENOMEM);
823 ret = fread(*bufptr, 1, *size, f);
827 av_log(NULL, AV_LOG_ERROR, "Error while reading file '%s': %s\n",
828 filename, strerror(errno));
829 ret = AVERROR(errno);
834 (*bufptr)[*size++] = '\0';
841 void init_pts_correction(PtsCorrectionContext *ctx)
843 ctx->num_faulty_pts = ctx->num_faulty_dts = 0;
844 ctx->last_pts = ctx->last_dts = INT64_MIN;
847 int64_t guess_correct_pts(PtsCorrectionContext *ctx, int64_t reordered_pts,
850 int64_t pts = AV_NOPTS_VALUE;
852 if (dts != AV_NOPTS_VALUE) {
853 ctx->num_faulty_dts += dts <= ctx->last_dts;
856 if (reordered_pts != AV_NOPTS_VALUE) {
857 ctx->num_faulty_pts += reordered_pts <= ctx->last_pts;
858 ctx->last_pts = reordered_pts;
860 if ((ctx->num_faulty_pts<=ctx->num_faulty_dts || dts == AV_NOPTS_VALUE)
861 && reordered_pts != AV_NOPTS_VALUE)
869 FILE *get_preset_file(char *filename, size_t filename_size,
870 const char *preset_name, int is_path,
871 const char *codec_name)
875 const char *base[3] = { getenv("AVCONV_DATADIR"),
880 av_strlcpy(filename, preset_name, filename_size);
881 f = fopen(filename, "r");
883 for (i = 0; i < 3 && !f; i++) {
886 snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i],
887 i != 1 ? "" : "/.avconv", preset_name);
888 f = fopen(filename, "r");
889 if (!f && codec_name) {
890 snprintf(filename, filename_size,
891 "%s%s/%s-%s.ffpreset",
892 base[i], i != 1 ? "" : "/.avconv", codec_name,
894 f = fopen(filename, "r");
902 int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
904 if (*spec <= '9' && *spec >= '0') /* opt:index */
905 return strtol(spec, NULL, 0) == st->index;
906 else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
907 *spec == 't') { /* opt:[vasdt] */
908 enum AVMediaType type;
911 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
912 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
913 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
914 case 'd': type = AVMEDIA_TYPE_DATA; break;
915 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
917 if (type != st->codec->codec_type)
919 if (*spec++ == ':') { /* possibly followed by :index */
920 int i, index = strtol(spec, NULL, 0);
921 for (i = 0; i < s->nb_streams; i++)
922 if (s->streams[i]->codec->codec_type == type && index-- == 0)
923 return i == st->index;
927 } else if (*spec == 'p' && *(spec + 1) == ':') {
931 prog_id = strtol(spec, &endptr, 0);
932 for (i = 0; i < s->nb_programs; i++) {
933 if (s->programs[i]->id != prog_id)
936 if (*endptr++ == ':') {
937 int stream_idx = strtol(endptr, NULL, 0);
938 return stream_idx >= 0 &&
939 stream_idx < s->programs[i]->nb_stream_indexes &&
940 st->index == s->programs[i]->stream_index[stream_idx];
943 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
944 if (st->index == s->programs[i]->stream_index[j])
948 } else if (!*spec) /* empty specifier, matches everything */
951 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
952 return AVERROR(EINVAL);
955 AVDictionary *filter_codec_opts(AVDictionary *opts, enum CodecID codec_id,
956 AVFormatContext *s, AVStream *st)
958 AVDictionary *ret = NULL;
959 AVDictionaryEntry *t = NULL;
960 AVCodec *codec = s->oformat ? avcodec_find_encoder(codec_id)
961 : avcodec_find_decoder(codec_id);
962 int flags = s->oformat ? AV_OPT_FLAG_ENCODING_PARAM
963 : AV_OPT_FLAG_DECODING_PARAM;
965 const AVClass *cc = avcodec_get_class();
970 switch (codec->type) {
971 case AVMEDIA_TYPE_VIDEO:
973 flags |= AV_OPT_FLAG_VIDEO_PARAM;
975 case AVMEDIA_TYPE_AUDIO:
977 flags |= AV_OPT_FLAG_AUDIO_PARAM;
979 case AVMEDIA_TYPE_SUBTITLE:
981 flags |= AV_OPT_FLAG_SUBTITLE_PARAM;
985 while (t = av_dict_get(opts, "", t, AV_DICT_IGNORE_SUFFIX)) {
986 char *p = strchr(t->key, ':');
988 /* check stream specification in opt name */
990 switch (check_stream_specifier(s, st, p + 1)) {
991 case 1: *p = 0; break;
993 default: return NULL;
996 if (av_opt_find(&cc, t->key, NULL, flags, AV_OPT_SEARCH_FAKE_OBJ) ||
997 (codec && codec->priv_class &&
998 av_opt_find(&codec->priv_class, t->key, NULL, flags,
999 AV_OPT_SEARCH_FAKE_OBJ)))
1000 av_dict_set(&ret, t->key, t->value, 0);
1001 else if (t->key[0] == prefix &&
1002 av_opt_find(&cc, t->key + 1, NULL, flags,
1003 AV_OPT_SEARCH_FAKE_OBJ))
1004 av_dict_set(&ret, t->key + 1, t->value, 0);
1012 AVDictionary **setup_find_stream_info_opts(AVFormatContext *s,
1013 AVDictionary *codec_opts)
1016 AVDictionary **opts;
1020 opts = av_mallocz(s->nb_streams * sizeof(*opts));
1022 av_log(NULL, AV_LOG_ERROR,
1023 "Could not alloc memory for stream options.\n");
1026 for (i = 0; i < s->nb_streams; i++)
1027 opts[i] = filter_codec_opts(codec_opts, s->streams[i]->codec->codec_id,
1034 static int avsink_init(AVFilterContext *ctx, const char *args, void *opaque)
1036 AVSinkContext *priv = ctx->priv;
1039 return AVERROR(EINVAL);
1040 *priv = *(AVSinkContext *)opaque;
1045 static void null_end_frame(AVFilterLink *inlink) { }
1047 static int avsink_query_formats(AVFilterContext *ctx)
1049 AVSinkContext *priv = ctx->priv;
1050 enum PixelFormat pix_fmts[] = { priv->pix_fmt, PIX_FMT_NONE };
1052 avfilter_set_common_formats(ctx, avfilter_make_format_list(pix_fmts));
1058 .priv_size = sizeof(AVSinkContext),
1059 .init = avsink_init,
1061 .query_formats = avsink_query_formats,
1063 .inputs = (AVFilterPad[]) {{ .name = "default",
1064 .type = AVMEDIA_TYPE_VIDEO,
1065 .end_frame = null_end_frame,
1066 .min_perms = AV_PERM_READ, },
1068 .outputs = (AVFilterPad[]) {{ .name = NULL }},
1071 int get_filtered_video_frame(AVFilterContext *ctx, AVFrame *frame,
1072 AVFilterBufferRef **picref_ptr, AVRational *tb)
1075 AVFilterBufferRef *picref;
1077 if ((ret = avfilter_request_frame(ctx->inputs[0])) < 0)
1079 if (!(picref = ctx->inputs[0]->cur_buf))
1080 return AVERROR(ENOENT);
1081 *picref_ptr = picref;
1082 ctx->inputs[0]->cur_buf = NULL;
1083 *tb = ctx->inputs[0]->time_base;
1085 memcpy(frame->data, picref->data, sizeof(frame->data));
1086 memcpy(frame->linesize, picref->linesize, sizeof(frame->linesize));
1087 frame->interlaced_frame = picref->video->interlaced;
1088 frame->top_field_first = picref->video->top_field_first;
1089 frame->key_frame = picref->video->key_frame;
1090 frame->pict_type = picref->video->pict_type;
1091 frame->sample_aspect_ratio = picref->video->pixel_aspect;
1096 #endif /* CONFIG_AVFILTER */
1098 void *grow_array(void *array, int elem_size, int *size, int new_size)
1100 if (new_size >= INT_MAX / elem_size) {
1101 av_log(NULL, AV_LOG_ERROR, "Array too big.\n");
1104 if (*size < new_size) {
1105 uint8_t *tmp = av_realloc(array, new_size*elem_size);
1107 av_log(NULL, AV_LOG_ERROR, "Could not alloc buffer.\n");
1110 memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);