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/avstring.h"
38 #include "libavutil/mathematics.h"
39 #include "libavutil/parseutils.h"
40 #include "libavutil/pixdesc.h"
41 #include "libavutil/eval.h"
42 #include "libavutil/dict.h"
43 #include "libavutil/opt.h"
47 #include "libavformat/network.h"
49 #if HAVE_SYS_RESOURCE_H
50 #include <sys/resource.h>
53 struct SwsContext *sws_opts;
54 AVDictionary *format_opts, *codec_opts;
56 static const int this_year = 2012;
61 sws_opts = sws_getContext(16, 16, 0, 16, 16, 0, SWS_BICUBIC,
66 void uninit_opts(void)
69 sws_freeContext(sws_opts);
72 av_dict_free(&format_opts);
73 av_dict_free(&codec_opts);
76 void log_callback_help(void *ptr, int level, const char *fmt, va_list vl)
78 vfprintf(stdout, fmt, vl);
81 double parse_number_or_die(const char *context, const char *numstr, int type,
82 double min, double max)
86 double d = av_strtod(numstr, &tail);
88 error = "Expected number for %s but found: %s\n";
89 else if (d < min || d > max)
90 error = "The value for %s was %s which is not within %f - %f\n";
91 else if (type == OPT_INT64 && (int64_t)d != d)
92 error = "Expected int64 for %s but found %s\n";
93 else if (type == OPT_INT && (int)d != d)
94 error = "Expected int for %s but found %s\n";
97 av_log(NULL, AV_LOG_FATAL, error, context, numstr, min, max);
102 int64_t parse_time_or_die(const char *context, const char *timestr,
106 if (av_parse_time(&us, timestr, is_duration) < 0) {
107 av_log(NULL, AV_LOG_FATAL, "Invalid %s specification for %s: %s\n",
108 is_duration ? "duration" : "date", context, timestr);
114 void show_help_options(const OptionDef *options, const char *msg, int mask,
121 for (po = options; po->name != NULL; po++) {
123 if ((po->flags & mask) == value) {
128 av_strlcpy(buf, po->name, sizeof(buf));
129 if (po->flags & HAS_ARG) {
130 av_strlcat(buf, " ", sizeof(buf));
131 av_strlcat(buf, po->argname, sizeof(buf));
133 printf("-%-17s %s\n", buf, po->help);
138 void show_help_children(const AVClass *class, int flags)
140 const AVClass *child = NULL;
141 av_opt_show2(&class, NULL, flags, 0);
144 while (child = av_opt_child_class_next(class, child))
145 show_help_children(child, flags);
148 static const OptionDef *find_option(const OptionDef *po, const char *name)
150 const char *p = strchr(name, ':');
151 int len = p ? p - name : strlen(name);
153 while (po->name != NULL) {
154 if (!strncmp(name, po->name, len) && strlen(po->name) == len)
161 #if defined(_WIN32) && !defined(__MINGW32CE__)
163 /* Will be leaked on exit */
164 static char** win32_argv_utf8 = NULL;
165 static int win32_argc = 0;
168 * Prepare command line arguments for executable.
169 * For Windows - perform wide-char to UTF-8 conversion.
170 * Input arguments should be main() function arguments.
171 * @param argc_ptr Arguments number (including executable)
172 * @param argv_ptr Arguments list.
174 static void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
178 int i, buffsize = 0, offset = 0;
180 if (win32_argv_utf8) {
181 *argc_ptr = win32_argc;
182 *argv_ptr = win32_argv_utf8;
187 argv_w = CommandLineToArgvW(GetCommandLineW(), &win32_argc);
188 if (win32_argc <= 0 || !argv_w)
191 /* determine the UTF-8 buffer size (including NULL-termination symbols) */
192 for (i = 0; i < win32_argc; i++)
193 buffsize += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
194 NULL, 0, NULL, NULL);
196 win32_argv_utf8 = av_mallocz(sizeof(char *) * (win32_argc + 1) + buffsize);
197 argstr_flat = (char *)win32_argv_utf8 + sizeof(char *) * (win32_argc + 1);
198 if (win32_argv_utf8 == NULL) {
203 for (i = 0; i < win32_argc; i++) {
204 win32_argv_utf8[i] = &argstr_flat[offset];
205 offset += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
206 &argstr_flat[offset],
207 buffsize - offset, NULL, NULL);
209 win32_argv_utf8[i] = NULL;
212 *argc_ptr = win32_argc;
213 *argv_ptr = win32_argv_utf8;
216 static inline void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
220 #endif /* WIN32 && !__MINGW32CE__ */
222 int parse_option(void *optctx, const char *opt, const char *arg,
223 const OptionDef *options)
230 po = find_option(options, opt);
231 if (!po->name && opt[0] == 'n' && opt[1] == 'o') {
232 /* handle 'no' bool option */
233 po = find_option(options, opt + 2);
234 if ((po->name && (po->flags & OPT_BOOL)))
238 po = find_option(options, "default");
240 av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);
241 return AVERROR(EINVAL);
243 if (po->flags & HAS_ARG && !arg) {
244 av_log(NULL, AV_LOG_ERROR, "Missing argument for option '%s'\n", opt);
245 return AVERROR(EINVAL);
248 /* new-style options contain an offset into optctx, old-style address of
250 dst = po->flags & (OPT_OFFSET | OPT_SPEC) ? (uint8_t *)optctx + po->u.off
253 if (po->flags & OPT_SPEC) {
254 SpecifierOpt **so = dst;
255 char *p = strchr(opt, ':');
257 dstcount = (int *)(so + 1);
258 *so = grow_array(*so, sizeof(**so), dstcount, *dstcount + 1);
259 (*so)[*dstcount - 1].specifier = av_strdup(p ? p + 1 : "");
260 dst = &(*so)[*dstcount - 1].u;
263 if (po->flags & OPT_STRING) {
265 str = av_strdup(arg);
267 } else if (po->flags & OPT_BOOL) {
268 *(int *)dst = bool_val;
269 } else if (po->flags & OPT_INT) {
270 *(int *)dst = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
271 } else if (po->flags & OPT_INT64) {
272 *(int64_t *)dst = parse_number_or_die(opt, arg, OPT_INT64, INT64_MIN, INT64_MAX);
273 } else if (po->flags & OPT_TIME) {
274 *(int64_t *)dst = parse_time_or_die(opt, arg, 1);
275 } else if (po->flags & OPT_FLOAT) {
276 *(float *)dst = parse_number_or_die(opt, arg, OPT_FLOAT, -INFINITY, INFINITY);
277 } else if (po->flags & OPT_DOUBLE) {
278 *(double *)dst = parse_number_or_die(opt, arg, OPT_DOUBLE, -INFINITY, INFINITY);
279 } else if (po->u.func_arg) {
280 int ret = po->flags & OPT_FUNC2 ? po->u.func2_arg(optctx, opt, arg)
281 : po->u.func_arg(opt, arg);
283 av_log(NULL, AV_LOG_ERROR,
284 "Failed to set value '%s' for option '%s'\n", arg, opt);
288 if (po->flags & OPT_EXIT)
290 return !!(po->flags & HAS_ARG);
293 void parse_options(void *optctx, int argc, char **argv, const OptionDef *options,
294 void (*parse_arg_function)(void *, const char*))
297 int optindex, handleoptions = 1, ret;
299 /* perform system-dependent conversions for arguments list */
300 prepare_app_arguments(&argc, &argv);
304 while (optindex < argc) {
305 opt = argv[optindex++];
307 if (handleoptions && opt[0] == '-' && opt[1] != '\0') {
308 if (opt[1] == '-' && opt[2] == '\0') {
314 if ((ret = parse_option(optctx, opt, argv[optindex], options)) < 0)
318 if (parse_arg_function)
319 parse_arg_function(optctx, opt);
324 int locate_option(int argc, char **argv, const OptionDef *options,
330 for (i = 1; i < argc; i++) {
331 const char *cur_opt = argv[i];
333 if (*cur_opt++ != '-')
336 po = find_option(options, cur_opt);
337 if (!po->name && cur_opt[0] == 'n' && cur_opt[1] == 'o')
338 po = find_option(options, cur_opt + 2);
340 if ((!po->name && !strcmp(cur_opt, optname)) ||
341 (po->name && !strcmp(optname, po->name)))
344 if (!po || po->flags & HAS_ARG)
350 void parse_loglevel(int argc, char **argv, const OptionDef *options)
352 int idx = locate_option(argc, argv, options, "loglevel");
354 idx = locate_option(argc, argv, options, "v");
355 if (idx && argv[idx + 1])
356 opt_loglevel("loglevel", argv[idx + 1]);
359 #define FLAGS (o->type == AV_OPT_TYPE_FLAGS) ? AV_DICT_APPEND : 0
360 int opt_default(const char *opt, const char *arg)
363 char opt_stripped[128];
365 const AVClass *cc = avcodec_get_class(), *fc = avformat_get_class(), *sc = sws_get_class();
367 if (!(p = strchr(opt, ':')))
368 p = opt + strlen(opt);
369 av_strlcpy(opt_stripped, opt, FFMIN(sizeof(opt_stripped), p - opt + 1));
371 if ((o = av_opt_find(&cc, opt_stripped, NULL, 0,
372 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)) ||
373 ((opt[0] == 'v' || opt[0] == 'a' || opt[0] == 's') &&
374 (o = av_opt_find(&cc, opt + 1, NULL, 0, AV_OPT_SEARCH_FAKE_OBJ))))
375 av_dict_set(&codec_opts, opt, arg, FLAGS);
376 else if ((o = av_opt_find(&fc, opt, NULL, 0,
377 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)))
378 av_dict_set(&format_opts, opt, arg, FLAGS);
379 else if ((o = av_opt_find(&sc, opt, NULL, 0,
380 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) {
381 // XXX we only support sws_flags, not arbitrary sws options
382 int ret = av_opt_set(sws_opts, opt, arg, 0);
384 av_log(NULL, AV_LOG_ERROR, "Error setting option %s.\n", opt);
391 av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);
392 return AVERROR_OPTION_NOT_FOUND;
395 int opt_loglevel(const char *opt, const char *arg)
397 const struct { const char *name; int level; } log_levels[] = {
398 { "quiet" , AV_LOG_QUIET },
399 { "panic" , AV_LOG_PANIC },
400 { "fatal" , AV_LOG_FATAL },
401 { "error" , AV_LOG_ERROR },
402 { "warning", AV_LOG_WARNING },
403 { "info" , AV_LOG_INFO },
404 { "verbose", AV_LOG_VERBOSE },
405 { "debug" , AV_LOG_DEBUG },
411 for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
412 if (!strcmp(log_levels[i].name, arg)) {
413 av_log_set_level(log_levels[i].level);
418 level = strtol(arg, &tail, 10);
420 av_log(NULL, AV_LOG_FATAL, "Invalid loglevel \"%s\". "
421 "Possible levels are numbers or:\n", arg);
422 for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
423 av_log(NULL, AV_LOG_FATAL, "\"%s\"\n", log_levels[i].name);
426 av_log_set_level(level);
430 int opt_timelimit(const char *opt, const char *arg)
433 int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
434 struct rlimit rl = { lim, lim + 1 };
435 if (setrlimit(RLIMIT_CPU, &rl))
438 av_log(NULL, AV_LOG_WARNING, "-%s not implemented on this OS\n", opt);
443 void print_error(const char *filename, int err)
446 const char *errbuf_ptr = errbuf;
448 if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
449 errbuf_ptr = strerror(AVUNERROR(err));
450 av_log(NULL, AV_LOG_ERROR, "%s: %s\n", filename, errbuf_ptr);
453 static int warned_cfg = 0;
456 #define SHOW_VERSION 2
457 #define SHOW_CONFIG 4
459 #define PRINT_LIB_INFO(libname, LIBNAME, flags, level) \
460 if (CONFIG_##LIBNAME) { \
461 const char *indent = flags & INDENT? " " : ""; \
462 if (flags & SHOW_VERSION) { \
463 unsigned int version = libname##_version(); \
464 av_log(NULL, level, \
465 "%slib%-10s %2d.%3d.%2d / %2d.%3d.%2d\n", \
467 LIB##LIBNAME##_VERSION_MAJOR, \
468 LIB##LIBNAME##_VERSION_MINOR, \
469 LIB##LIBNAME##_VERSION_MICRO, \
470 version >> 16, version >> 8 & 0xff, version & 0xff); \
472 if (flags & SHOW_CONFIG) { \
473 const char *cfg = libname##_configuration(); \
474 if (strcmp(LIBAV_CONFIGURATION, cfg)) { \
476 av_log(NULL, level, \
477 "%sWARNING: library configuration mismatch\n", \
481 av_log(NULL, level, "%s%-11s configuration: %s\n", \
482 indent, #libname, cfg); \
487 static void print_all_libs_info(int flags, int level)
489 PRINT_LIB_INFO(avutil, AVUTIL, flags, level);
490 PRINT_LIB_INFO(avcodec, AVCODEC, flags, level);
491 PRINT_LIB_INFO(avformat, AVFORMAT, flags, level);
492 PRINT_LIB_INFO(avdevice, AVDEVICE, flags, level);
493 PRINT_LIB_INFO(avfilter, AVFILTER, flags, level);
494 PRINT_LIB_INFO(avresample, AVRESAMPLE, flags, level);
495 PRINT_LIB_INFO(swscale, SWSCALE, flags, level);
498 void show_banner(void)
500 av_log(NULL, AV_LOG_INFO,
501 "%s version " LIBAV_VERSION ", Copyright (c) %d-%d the Libav developers\n",
502 program_name, program_birth_year, this_year);
503 av_log(NULL, AV_LOG_INFO, " built on %s %s with %s %s\n",
504 __DATE__, __TIME__, CC_TYPE, CC_VERSION);
505 av_log(NULL, AV_LOG_VERBOSE, " configuration: " LIBAV_CONFIGURATION "\n");
506 print_all_libs_info(INDENT|SHOW_CONFIG, AV_LOG_VERBOSE);
507 print_all_libs_info(INDENT|SHOW_VERSION, AV_LOG_VERBOSE);
510 void show_version(void) {
511 av_log_set_callback(log_callback_help);
512 printf("%s " LIBAV_VERSION "\n", program_name);
513 print_all_libs_info(SHOW_VERSION, AV_LOG_INFO);
516 void show_license(void)
520 "This version of %s has nonfree parts compiled in.\n"
521 "Therefore it is not legally redistributable.\n",
524 "%s is free software; you can redistribute it and/or modify\n"
525 "it under the terms of the GNU General Public License as published by\n"
526 "the Free Software Foundation; either version 3 of the License, or\n"
527 "(at your option) any later version.\n"
529 "%s is distributed in the hope that it will be useful,\n"
530 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
531 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
532 "GNU General Public License for more details.\n"
534 "You should have received a copy of the GNU General Public License\n"
535 "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
536 program_name, program_name, program_name
538 "%s is free software; you can redistribute it and/or modify\n"
539 "it under the terms of the GNU General Public License as published by\n"
540 "the Free Software Foundation; either version 2 of the License, or\n"
541 "(at your option) any later version.\n"
543 "%s is distributed in the hope that it will be useful,\n"
544 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
545 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
546 "GNU General Public License for more details.\n"
548 "You should have received a copy of the GNU General Public License\n"
549 "along with %s; if not, write to the Free Software\n"
550 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
551 program_name, program_name, program_name
553 "%s is free software; you can redistribute it and/or modify\n"
554 "it under the terms of the GNU Lesser General Public License as published by\n"
555 "the Free Software Foundation; either version 3 of the License, or\n"
556 "(at your option) any later version.\n"
558 "%s is distributed in the hope that it will be useful,\n"
559 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
560 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
561 "GNU Lesser General Public License for more details.\n"
563 "You should have received a copy of the GNU Lesser General Public License\n"
564 "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
565 program_name, program_name, program_name
567 "%s is free software; you can redistribute it and/or\n"
568 "modify it under the terms of the GNU Lesser General Public\n"
569 "License as published by the Free Software Foundation; either\n"
570 "version 2.1 of the License, or (at your option) any later version.\n"
572 "%s is distributed in the hope that it will be useful,\n"
573 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
574 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
575 "Lesser General Public License for more details.\n"
577 "You should have received a copy of the GNU Lesser General Public\n"
578 "License along with %s; if not, write to the Free Software\n"
579 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
580 program_name, program_name, program_name
585 void show_formats(void)
587 AVInputFormat *ifmt = NULL;
588 AVOutputFormat *ofmt = NULL;
589 const char *last_name;
591 printf("File formats:\n"
592 " D. = Demuxing supported\n"
593 " .E = Muxing supported\n"
599 const char *name = NULL;
600 const char *long_name = NULL;
602 while ((ofmt = av_oformat_next(ofmt))) {
603 if ((name == NULL || strcmp(ofmt->name, name) < 0) &&
604 strcmp(ofmt->name, last_name) > 0) {
606 long_name = ofmt->long_name;
610 while ((ifmt = av_iformat_next(ifmt))) {
611 if ((name == NULL || strcmp(ifmt->name, name) < 0) &&
612 strcmp(ifmt->name, last_name) > 0) {
614 long_name = ifmt->long_name;
617 if (name && strcmp(ifmt->name, name) == 0)
624 printf(" %s%s %-15s %s\n",
628 long_name ? long_name:" ");
632 void show_codecs(void)
634 AVCodec *p = NULL, *p2;
635 const char *last_name;
637 " D..... = Decoding supported\n"
638 " .E.... = Encoding supported\n"
639 " ..V... = Video codec\n"
640 " ..A... = Audio codec\n"
641 " ..S... = Subtitle codec\n"
642 " ...S.. = Supports draw_horiz_band\n"
643 " ....D. = Supports direct rendering method 1\n"
644 " .....T = Supports weird frame truncation\n"
651 const char *type_str;
654 while ((p = av_codec_next(p))) {
655 if ((p2 == NULL || strcmp(p->name, p2->name) < 0) &&
656 strcmp(p->name, last_name) > 0) {
658 decode = encode = cap = 0;
660 if (p2 && strcmp(p->name, p2->name) == 0) {
661 if (av_codec_is_decoder(p))
663 if (av_codec_is_encoder(p))
665 cap |= p->capabilities;
670 last_name = p2->name;
673 case AVMEDIA_TYPE_VIDEO:
676 case AVMEDIA_TYPE_AUDIO:
679 case AVMEDIA_TYPE_SUBTITLE:
686 printf(" %s%s%s%s%s%s %-15s %s",
687 decode ? "D" : (/* p2->decoder ? "d" : */ " "),
690 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S" : " ",
691 cap & CODEC_CAP_DR1 ? "D" : " ",
692 cap & CODEC_CAP_TRUNCATED ? "T" : " ",
694 p2->long_name ? p2->long_name : "");
696 if (p2->decoder && decode == 0)
697 printf(" use %s for decoding", p2->decoder->name);
702 printf("Note, the names of encoders and decoders do not always match, so there are\n"
703 "several cases where the above table shows encoder only or decoder only entries\n"
704 "even though both encoding and decoding are supported. For example, the h263\n"
705 "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
711 AVBitStreamFilter *bsf = NULL;
713 printf("Bitstream filters:\n");
714 while ((bsf = av_bitstream_filter_next(bsf)))
715 printf("%s\n", bsf->name);
719 void show_protocols(void)
724 printf("Supported file protocols:\n"
726 while ((name = avio_enum_protocols(&opaque, 0)))
727 printf("%s\n", name);
729 while ((name = avio_enum_protocols(&opaque, 1)))
730 printf("%s\n", name);
733 void show_filters(void)
735 AVFilter av_unused(**filter) = NULL;
737 printf("Filters:\n");
739 while ((filter = av_filter_next(filter)) && *filter)
740 printf("%-16s %s\n", (*filter)->name, (*filter)->description);
744 void show_pix_fmts(void)
746 enum PixelFormat pix_fmt;
748 printf("Pixel formats:\n"
749 "I.... = Supported Input format for conversion\n"
750 ".O... = Supported Output format for conversion\n"
751 "..H.. = Hardware accelerated format\n"
752 "...P. = Paletted format\n"
753 "....B = Bitstream format\n"
754 "FLAGS NAME NB_COMPONENTS BITS_PER_PIXEL\n"
758 # define sws_isSupportedInput(x) 0
759 # define sws_isSupportedOutput(x) 0
762 for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {
763 const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[pix_fmt];
764 printf("%c%c%c%c%c %-16s %d %2d\n",
765 sws_isSupportedInput (pix_fmt) ? 'I' : '.',
766 sws_isSupportedOutput(pix_fmt) ? 'O' : '.',
767 pix_desc->flags & PIX_FMT_HWACCEL ? 'H' : '.',
768 pix_desc->flags & PIX_FMT_PAL ? 'P' : '.',
769 pix_desc->flags & PIX_FMT_BITSTREAM ? 'B' : '.',
771 pix_desc->nb_components,
772 av_get_bits_per_pixel(pix_desc));
776 int show_sample_fmts(const char *opt, const char *arg)
780 for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
781 printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
788 int yesno = (toupper(c) == 'Y');
790 while (c != '\n' && c != EOF)
796 int cmdutils_read_file(const char *filename, char **bufptr, size_t *size)
799 FILE *f = fopen(filename, "rb");
802 av_log(NULL, AV_LOG_ERROR, "Cannot read file '%s': %s\n", filename,
804 return AVERROR(errno);
806 fseek(f, 0, SEEK_END);
808 fseek(f, 0, SEEK_SET);
809 *bufptr = av_malloc(*size + 1);
811 av_log(NULL, AV_LOG_ERROR, "Could not allocate file buffer\n");
813 return AVERROR(ENOMEM);
815 ret = fread(*bufptr, 1, *size, f);
819 av_log(NULL, AV_LOG_ERROR, "Error while reading file '%s': %s\n",
820 filename, strerror(errno));
821 ret = AVERROR(errno);
826 (*bufptr)[*size++] = '\0';
833 void init_pts_correction(PtsCorrectionContext *ctx)
835 ctx->num_faulty_pts = ctx->num_faulty_dts = 0;
836 ctx->last_pts = ctx->last_dts = INT64_MIN;
839 int64_t guess_correct_pts(PtsCorrectionContext *ctx, int64_t reordered_pts,
842 int64_t pts = AV_NOPTS_VALUE;
844 if (dts != AV_NOPTS_VALUE) {
845 ctx->num_faulty_dts += dts <= ctx->last_dts;
848 if (reordered_pts != AV_NOPTS_VALUE) {
849 ctx->num_faulty_pts += reordered_pts <= ctx->last_pts;
850 ctx->last_pts = reordered_pts;
852 if ((ctx->num_faulty_pts<=ctx->num_faulty_dts || dts == AV_NOPTS_VALUE)
853 && reordered_pts != AV_NOPTS_VALUE)
861 FILE *get_preset_file(char *filename, size_t filename_size,
862 const char *preset_name, int is_path,
863 const char *codec_name)
867 const char *base[3] = { getenv("AVCONV_DATADIR"),
872 av_strlcpy(filename, preset_name, filename_size);
873 f = fopen(filename, "r");
875 for (i = 0; i < 3 && !f; i++) {
878 snprintf(filename, filename_size, "%s%s/%s.avpreset", base[i],
879 i != 1 ? "" : "/.avconv", preset_name);
880 f = fopen(filename, "r");
881 if (!f && codec_name) {
882 snprintf(filename, filename_size,
883 "%s%s/%s-%s.avpreset",
884 base[i], i != 1 ? "" : "/.avconv", codec_name,
886 f = fopen(filename, "r");
894 int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
896 if (*spec <= '9' && *spec >= '0') /* opt:index */
897 return strtol(spec, NULL, 0) == st->index;
898 else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
899 *spec == 't') { /* opt:[vasdt] */
900 enum AVMediaType type;
903 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
904 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
905 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
906 case 'd': type = AVMEDIA_TYPE_DATA; break;
907 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
909 if (type != st->codec->codec_type)
911 if (*spec++ == ':') { /* possibly followed by :index */
912 int i, index = strtol(spec, NULL, 0);
913 for (i = 0; i < s->nb_streams; i++)
914 if (s->streams[i]->codec->codec_type == type && index-- == 0)
915 return i == st->index;
919 } else if (*spec == 'p' && *(spec + 1) == ':') {
923 prog_id = strtol(spec, &endptr, 0);
924 for (i = 0; i < s->nb_programs; i++) {
925 if (s->programs[i]->id != prog_id)
928 if (*endptr++ == ':') {
929 int stream_idx = strtol(endptr, NULL, 0);
930 return stream_idx >= 0 &&
931 stream_idx < s->programs[i]->nb_stream_indexes &&
932 st->index == s->programs[i]->stream_index[stream_idx];
935 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
936 if (st->index == s->programs[i]->stream_index[j])
940 } else if (!*spec) /* empty specifier, matches everything */
943 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
944 return AVERROR(EINVAL);
947 AVDictionary *filter_codec_opts(AVDictionary *opts, enum CodecID codec_id,
948 AVFormatContext *s, AVStream *st)
950 AVDictionary *ret = NULL;
951 AVDictionaryEntry *t = NULL;
952 AVCodec *codec = s->oformat ? avcodec_find_encoder(codec_id)
953 : avcodec_find_decoder(codec_id);
954 int flags = s->oformat ? AV_OPT_FLAG_ENCODING_PARAM
955 : AV_OPT_FLAG_DECODING_PARAM;
957 const AVClass *cc = avcodec_get_class();
962 switch (codec->type) {
963 case AVMEDIA_TYPE_VIDEO:
965 flags |= AV_OPT_FLAG_VIDEO_PARAM;
967 case AVMEDIA_TYPE_AUDIO:
969 flags |= AV_OPT_FLAG_AUDIO_PARAM;
971 case AVMEDIA_TYPE_SUBTITLE:
973 flags |= AV_OPT_FLAG_SUBTITLE_PARAM;
977 while (t = av_dict_get(opts, "", t, AV_DICT_IGNORE_SUFFIX)) {
978 char *p = strchr(t->key, ':');
980 /* check stream specification in opt name */
982 switch (check_stream_specifier(s, st, p + 1)) {
983 case 1: *p = 0; break;
985 default: return NULL;
988 if (av_opt_find(&cc, t->key, NULL, flags, AV_OPT_SEARCH_FAKE_OBJ) ||
989 (codec && codec->priv_class &&
990 av_opt_find(&codec->priv_class, t->key, NULL, flags,
991 AV_OPT_SEARCH_FAKE_OBJ)))
992 av_dict_set(&ret, t->key, t->value, 0);
993 else if (t->key[0] == prefix &&
994 av_opt_find(&cc, t->key + 1, NULL, flags,
995 AV_OPT_SEARCH_FAKE_OBJ))
996 av_dict_set(&ret, t->key + 1, t->value, 0);
1004 AVDictionary **setup_find_stream_info_opts(AVFormatContext *s,
1005 AVDictionary *codec_opts)
1008 AVDictionary **opts;
1012 opts = av_mallocz(s->nb_streams * sizeof(*opts));
1014 av_log(NULL, AV_LOG_ERROR,
1015 "Could not alloc memory for stream options.\n");
1018 for (i = 0; i < s->nb_streams; i++)
1019 opts[i] = filter_codec_opts(codec_opts, s->streams[i]->codec->codec_id,
1026 static int sink_init(AVFilterContext *ctx, const char *args, void *opaque)
1028 SinkContext *priv = ctx->priv;
1031 return AVERROR(EINVAL);
1032 *priv = *(SinkContext *)opaque;
1037 static void null_end_frame(AVFilterLink *inlink) { }
1039 static int sink_query_formats(AVFilterContext *ctx)
1041 SinkContext *priv = ctx->priv;
1044 avfilter_set_common_formats(ctx, avfilter_make_format_list(priv->pix_fmts));
1046 avfilter_default_query_formats(ctx);
1052 .priv_size = sizeof(SinkContext),
1055 .query_formats = sink_query_formats,
1057 .inputs = (AVFilterPad[]) {{ .name = "default",
1058 .type = AVMEDIA_TYPE_VIDEO,
1059 .end_frame = null_end_frame,
1060 .min_perms = AV_PERM_READ, },
1062 .outputs = (AVFilterPad[]) {{ .name = NULL }},
1065 int get_filtered_video_frame(AVFilterContext *ctx, AVFrame *frame,
1066 AVFilterBufferRef **picref_ptr, AVRational *tb)
1069 AVFilterBufferRef *picref;
1071 if ((ret = avfilter_request_frame(ctx->inputs[0])) < 0)
1073 if (!(picref = ctx->inputs[0]->cur_buf))
1074 return AVERROR(ENOENT);
1075 *picref_ptr = picref;
1076 ctx->inputs[0]->cur_buf = NULL;
1077 *tb = ctx->inputs[0]->time_base;
1079 memcpy(frame->data, picref->data, sizeof(frame->data));
1080 memcpy(frame->linesize, picref->linesize, sizeof(frame->linesize));
1081 frame->interlaced_frame = picref->video->interlaced;
1082 frame->top_field_first = picref->video->top_field_first;
1083 frame->key_frame = picref->video->key_frame;
1084 frame->pict_type = picref->video->pict_type;
1085 frame->sample_aspect_ratio = picref->video->pixel_aspect;
1090 #endif /* CONFIG_AVFILTER */
1092 void *grow_array(void *array, int elem_size, int *size, int new_size)
1094 if (new_size >= INT_MAX / elem_size) {
1095 av_log(NULL, AV_LOG_ERROR, "Array too big.\n");
1098 if (*size < new_size) {
1099 uint8_t *tmp = av_realloc(array, new_size*elem_size);
1101 av_log(NULL, AV_LOG_ERROR, "Could not alloc buffer.\n");
1104 memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);