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"
36 #include "libpostproc/postprocess.h"
37 #include "libavutil/avstring.h"
38 #include "libavutil/parseutils.h"
39 #include "libavutil/pixdesc.h"
40 #include "libavutil/eval.h"
41 #include "libavutil/dict.h"
42 #include "libavutil/opt.h"
46 #include "libavformat/network.h"
48 #if HAVE_SYS_RESOURCE_H
49 #include <sys/resource.h>
52 struct SwsContext *sws_opts;
53 AVDictionary *format_opts, *codec_opts;
55 static const int this_year = 2011;
60 sws_opts = sws_getContext(16, 16, 0, 16, 16, 0, SWS_BICUBIC, NULL, NULL, NULL);
64 void uninit_opts(void)
67 sws_freeContext(sws_opts);
70 av_dict_free(&format_opts);
71 av_dict_free(&codec_opts);
74 void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
76 vfprintf(stdout, fmt, vl);
79 double parse_number_or_die(const char *context, const char *numstr, int type, double min, double max)
83 double d = av_strtod(numstr, &tail);
85 error= "Expected number for %s but found: %s\n";
86 else if (d < min || d > max)
87 error= "The value for %s was %s which is not within %f - %f\n";
88 else if(type == OPT_INT64 && (int64_t)d != d)
89 error= "Expected int64 for %s but found %s\n";
90 else if (type == OPT_INT && (int)d != d)
91 error= "Expected int for %s but found %s\n";
94 av_log(NULL, AV_LOG_FATAL, error, context, numstr, min, max);
99 int64_t parse_time_or_die(const char *context, const char *timestr, int is_duration)
102 if (av_parse_time(&us, timestr, is_duration) < 0) {
103 av_log(NULL, AV_LOG_FATAL, "Invalid %s specification for %s: %s\n",
104 is_duration ? "duration" : "date", context, timestr);
110 void show_help_options(const OptionDef *options, const char *msg, int mask, int value)
116 for(po = options; po->name != NULL; po++) {
118 if ((po->flags & mask) == value) {
123 av_strlcpy(buf, po->name, sizeof(buf));
124 if (po->flags & HAS_ARG) {
125 av_strlcat(buf, " ", sizeof(buf));
126 av_strlcat(buf, po->argname, sizeof(buf));
128 printf("-%-17s %s\n", buf, po->help);
133 static const OptionDef* find_option(const OptionDef *po, const char *name){
134 const char *p = strchr(name, ':');
135 int len = p ? p - name : strlen(name);
137 while (po->name != NULL) {
138 if (!strncmp(name, po->name, len) && strlen(po->name) == len)
145 #if defined(_WIN32) && !defined(__MINGW32CE__)
147 /* Will be leaked on exit */
148 static char** win32_argv_utf8 = NULL;
149 static int win32_argc = 0;
152 * Prepare command line arguments for executable.
153 * For Windows - perform wide-char to UTF-8 conversion.
154 * Input arguments should be main() function arguments.
155 * @param argc_ptr Arguments number (including executable)
156 * @param argv_ptr Arguments list.
158 static void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
162 int i, buffsize = 0, offset = 0;
164 if (win32_argv_utf8) {
165 *argc_ptr = win32_argc;
166 *argv_ptr = win32_argv_utf8;
171 argv_w = CommandLineToArgvW(GetCommandLineW(), &win32_argc);
172 if (win32_argc <= 0 || !argv_w)
175 /* determine the UTF-8 buffer size (including NULL-termination symbols) */
176 for (i = 0; i < win32_argc; i++)
177 buffsize += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
178 NULL, 0, NULL, NULL);
180 win32_argv_utf8 = av_mallocz(sizeof(char*) * (win32_argc + 1) + buffsize);
181 argstr_flat = (char*)win32_argv_utf8 + sizeof(char*) * (win32_argc + 1);
182 if (win32_argv_utf8 == NULL) {
187 for (i = 0; i < win32_argc; i++) {
188 win32_argv_utf8[i] = &argstr_flat[offset];
189 offset += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
190 &argstr_flat[offset],
191 buffsize - offset, NULL, NULL);
193 win32_argv_utf8[i] = NULL;
196 *argc_ptr = win32_argc;
197 *argv_ptr = win32_argv_utf8;
200 static inline void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
204 #endif /* WIN32 && !__MINGW32CE__ */
206 int parse_option(void *optctx, const char *opt, const char *arg, const OptionDef *options)
213 po = find_option(options, opt);
214 if (!po->name && opt[0] == 'n' && opt[1] == 'o') {
215 /* handle 'no' bool option */
216 po = find_option(options, opt + 2);
217 if (!(po->name && (po->flags & OPT_BOOL)))
222 po = find_option(options, "default");
225 av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);
226 return AVERROR(EINVAL);
228 if (po->flags & HAS_ARG && !arg) {
229 av_log(NULL, AV_LOG_ERROR, "Missing argument for option '%s'\n", opt);
230 return AVERROR(EINVAL);
233 /* new-style options contain an offset into optctx, old-style address of
235 dst = po->flags & (OPT_OFFSET|OPT_SPEC) ? (uint8_t*)optctx + po->u.off : po->u.dst_ptr;
237 if (po->flags & OPT_SPEC) {
238 SpecifierOpt **so = dst;
239 char *p = strchr(opt, ':');
241 dstcount = (int*)(so + 1);
242 *so = grow_array(*so, sizeof(**so), dstcount, *dstcount + 1);
243 (*so)[*dstcount - 1].specifier = av_strdup(p ? p + 1 : "");
244 dst = &(*so)[*dstcount - 1].u;
247 if (po->flags & OPT_STRING) {
249 str = av_strdup(arg);
251 } else if (po->flags & OPT_BOOL) {
252 *(int*)dst = bool_val;
253 } else if (po->flags & OPT_INT) {
254 *(int*)dst = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
255 } else if (po->flags & OPT_INT64) {
256 *(int64_t*)dst = parse_number_or_die(opt, arg, OPT_INT64, INT64_MIN, INT64_MAX);
257 } else if (po->flags & OPT_TIME) {
258 *(int64_t*)dst = parse_time_or_die(opt, arg, 1);
259 } else if (po->flags & OPT_FLOAT) {
260 *(float*)dst = parse_number_or_die(opt, arg, OPT_FLOAT, -INFINITY, INFINITY);
261 } else if (po->flags & OPT_DOUBLE) {
262 *(double*)dst = parse_number_or_die(opt, arg, OPT_DOUBLE, -INFINITY, INFINITY);
263 } else if (po->u.func_arg) {
264 int ret = po->flags & OPT_FUNC2 ? po->u.func2_arg(optctx, opt, arg) :
265 po->u.func_arg(opt, arg);
267 av_log(NULL, AV_LOG_ERROR, "Failed to set value '%s' for option '%s'\n", arg, opt);
271 if (po->flags & OPT_EXIT)
273 return !!(po->flags & HAS_ARG);
276 void parse_options(void *optctx, int argc, char **argv, const OptionDef *options,
277 void (* parse_arg_function)(void *, const char*))
280 int optindex, handleoptions = 1, ret;
282 /* perform system-dependent conversions for arguments list */
283 prepare_app_arguments(&argc, &argv);
287 while (optindex < argc) {
288 opt = argv[optindex++];
290 if (handleoptions && opt[0] == '-' && opt[1] != '\0') {
291 if (opt[1] == '-' && opt[2] == '\0') {
297 if ((ret = parse_option(optctx, opt, argv[optindex], options)) < 0)
301 if (parse_arg_function)
302 parse_arg_function(optctx, opt);
308 * Return index of option opt in argv or 0 if not found.
310 static int locate_option(int argc, char **argv, const OptionDef *options, const char *optname)
315 for (i = 1; i < argc; i++) {
316 const char *cur_opt = argv[i];
318 if (*cur_opt++ != '-')
321 po = find_option(options, cur_opt);
322 if (!po->name && cur_opt[0] == 'n' && cur_opt[1] == 'o')
323 po = find_option(options, cur_opt + 2);
325 if ((!po->name && !strcmp(cur_opt, optname)) ||
326 (po->name && !strcmp(optname, po->name)))
329 if (!po || po->flags & HAS_ARG)
335 void parse_loglevel(int argc, char **argv, const OptionDef *options)
337 int idx = locate_option(argc, argv, options, "loglevel");
338 if (idx && argv[idx + 1])
339 opt_loglevel("loglevel", argv[idx + 1]);
342 #define FLAGS (o->type == FF_OPT_TYPE_FLAGS) ? AV_DICT_APPEND : 0
343 int opt_default(const char *opt, const char *arg)
346 char opt_stripped[128];
348 const AVClass *cc = avcodec_get_class(), *fc = avformat_get_class(), *sc = sws_get_class();
350 if (!(p = strchr(opt, ':')))
351 p = opt + strlen(opt);
352 av_strlcpy(opt_stripped, opt, FFMIN(sizeof(opt_stripped), p - opt + 1));
354 if ((o = av_opt_find(&cc, opt_stripped, NULL, 0, AV_OPT_SEARCH_CHILDREN|AV_OPT_SEARCH_FAKE_OBJ)) ||
355 ((opt[0] == 'v' || opt[0] == 'a' || opt[0] == 's') &&
356 (o = av_opt_find(&cc, opt+1, NULL, 0, AV_OPT_SEARCH_FAKE_OBJ))))
357 av_dict_set(&codec_opts, opt, arg, FLAGS);
358 else if ((o = av_opt_find(&fc, opt, NULL, 0, AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)))
359 av_dict_set(&format_opts, opt, arg, FLAGS);
360 else if ((o = av_opt_find(&sc, opt, NULL, 0, AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) {
361 // XXX we only support sws_flags, not arbitrary sws options
362 int ret = av_set_string3(sws_opts, opt, arg, 1, NULL);
364 av_log(NULL, AV_LOG_ERROR, "Error setting option %s.\n", opt);
371 av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);
372 return AVERROR_OPTION_NOT_FOUND;
375 int opt_loglevel(const char *opt, const char *arg)
377 const struct { const char *name; int level; } log_levels[] = {
378 { "quiet" , AV_LOG_QUIET },
379 { "panic" , AV_LOG_PANIC },
380 { "fatal" , AV_LOG_FATAL },
381 { "error" , AV_LOG_ERROR },
382 { "warning", AV_LOG_WARNING },
383 { "info" , AV_LOG_INFO },
384 { "verbose", AV_LOG_VERBOSE },
385 { "debug" , AV_LOG_DEBUG },
391 for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
392 if (!strcmp(log_levels[i].name, arg)) {
393 av_log_set_level(log_levels[i].level);
398 level = strtol(arg, &tail, 10);
400 av_log(NULL, AV_LOG_FATAL, "Invalid loglevel \"%s\". "
401 "Possible levels are numbers or:\n", arg);
402 for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
403 av_log(NULL, AV_LOG_FATAL, "\"%s\"\n", log_levels[i].name);
406 av_log_set_level(level);
410 int opt_timelimit(const char *opt, const char *arg)
413 int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
414 struct rlimit rl = { lim, lim + 1 };
415 if (setrlimit(RLIMIT_CPU, &rl))
418 av_log(NULL, AV_LOG_WARNING, "-%s not implemented on this OS\n", opt);
423 void print_error(const char *filename, int err)
426 const char *errbuf_ptr = errbuf;
428 if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
429 errbuf_ptr = strerror(AVUNERROR(err));
430 av_log(NULL, AV_LOG_ERROR, "%s: %s\n", filename, errbuf_ptr);
433 static int warned_cfg = 0;
436 #define SHOW_VERSION 2
437 #define SHOW_CONFIG 4
439 #define PRINT_LIB_INFO(libname, LIBNAME, flags, level) \
440 if (CONFIG_##LIBNAME) { \
441 const char *indent = flags & INDENT? " " : ""; \
442 if (flags & SHOW_VERSION) { \
443 unsigned int version = libname##_version(); \
444 av_log(NULL, level, "%slib%-9s %2d.%3d.%2d / %2d.%3d.%2d\n",\
446 LIB##LIBNAME##_VERSION_MAJOR, \
447 LIB##LIBNAME##_VERSION_MINOR, \
448 LIB##LIBNAME##_VERSION_MICRO, \
449 version >> 16, version >> 8 & 0xff, version & 0xff); \
451 if (flags & SHOW_CONFIG) { \
452 const char *cfg = libname##_configuration(); \
453 if (strcmp(LIBAV_CONFIGURATION, cfg)) { \
455 av_log(NULL, level, \
456 "%sWARNING: library configuration mismatch\n", \
460 av_log(NULL, level, "%s%-11s configuration: %s\n", \
461 indent, #libname, cfg); \
466 static void print_all_libs_info(int flags, int level)
468 PRINT_LIB_INFO(avutil, AVUTIL, flags, level);
469 PRINT_LIB_INFO(avcodec, AVCODEC, flags, level);
470 PRINT_LIB_INFO(avformat, AVFORMAT, flags, level);
471 PRINT_LIB_INFO(avdevice, AVDEVICE, flags, level);
472 PRINT_LIB_INFO(avfilter, AVFILTER, flags, level);
473 PRINT_LIB_INFO(swscale, SWSCALE, flags, level);
474 PRINT_LIB_INFO(postproc, POSTPROC, flags, level);
477 void show_banner(void)
479 av_log(NULL, AV_LOG_INFO, "%s version " LIBAV_VERSION ", Copyright (c) %d-%d the Libav developers\n",
480 program_name, program_birth_year, this_year);
481 av_log(NULL, AV_LOG_INFO, " built on %s %s with %s %s\n",
482 __DATE__, __TIME__, CC_TYPE, CC_VERSION);
483 av_log(NULL, AV_LOG_VERBOSE, " configuration: " LIBAV_CONFIGURATION "\n");
484 print_all_libs_info(INDENT|SHOW_CONFIG, AV_LOG_VERBOSE);
485 print_all_libs_info(INDENT|SHOW_VERSION, AV_LOG_VERBOSE);
488 void show_version(void) {
489 av_log_set_callback(log_callback_help);
490 printf("%s " LIBAV_VERSION "\n", program_name);
491 print_all_libs_info(SHOW_VERSION, AV_LOG_INFO);
494 void show_license(void)
498 "This version of %s has nonfree parts compiled in.\n"
499 "Therefore it is not legally redistributable.\n",
502 "%s is free software; you can redistribute it and/or modify\n"
503 "it under the terms of the GNU General Public License as published by\n"
504 "the Free Software Foundation; either version 3 of the License, or\n"
505 "(at your option) any later version.\n"
507 "%s is distributed in the hope that it will be useful,\n"
508 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
509 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
510 "GNU General Public License for more details.\n"
512 "You should have received a copy of the GNU General Public License\n"
513 "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
514 program_name, program_name, program_name
516 "%s is free software; you can redistribute it and/or modify\n"
517 "it under the terms of the GNU General Public License as published by\n"
518 "the Free Software Foundation; either version 2 of the License, or\n"
519 "(at your option) any later version.\n"
521 "%s is distributed in the hope that it will be useful,\n"
522 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
523 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
524 "GNU General Public License for more details.\n"
526 "You should have received a copy of the GNU General Public License\n"
527 "along with %s; if not, write to the Free Software\n"
528 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
529 program_name, program_name, program_name
531 "%s is free software; you can redistribute it and/or modify\n"
532 "it under the terms of the GNU Lesser General Public License as published by\n"
533 "the Free Software Foundation; either version 3 of the License, or\n"
534 "(at your option) any later version.\n"
536 "%s is distributed in the hope that it will be useful,\n"
537 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
538 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
539 "GNU Lesser General Public License for more details.\n"
541 "You should have received a copy of the GNU Lesser General Public License\n"
542 "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
543 program_name, program_name, program_name
545 "%s is free software; you can redistribute it and/or\n"
546 "modify it under the terms of the GNU Lesser General Public\n"
547 "License as published by the Free Software Foundation; either\n"
548 "version 2.1 of the License, or (at your option) any later version.\n"
550 "%s is distributed in the hope that it will be useful,\n"
551 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
552 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
553 "Lesser General Public License for more details.\n"
555 "You should have received a copy of the GNU Lesser General Public\n"
556 "License along with %s; if not, write to the Free Software\n"
557 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
558 program_name, program_name, program_name
563 void show_formats(void)
565 AVInputFormat *ifmt=NULL;
566 AVOutputFormat *ofmt=NULL;
567 const char *last_name;
571 " D. = Demuxing supported\n"
572 " .E = Muxing supported\n"
578 const char *name=NULL;
579 const char *long_name=NULL;
581 while((ofmt= av_oformat_next(ofmt))) {
582 if((name == NULL || strcmp(ofmt->name, name)<0) &&
583 strcmp(ofmt->name, last_name)>0){
585 long_name= ofmt->long_name;
589 while((ifmt= av_iformat_next(ifmt))) {
590 if((name == NULL || strcmp(ifmt->name, name)<0) &&
591 strcmp(ifmt->name, last_name)>0){
593 long_name= ifmt->long_name;
596 if(name && strcmp(ifmt->name, name)==0)
608 long_name ? long_name:" ");
612 void show_codecs(void)
614 AVCodec *p=NULL, *p2;
615 const char *last_name;
618 " D..... = Decoding supported\n"
619 " .E.... = Encoding supported\n"
620 " ..V... = Video codec\n"
621 " ..A... = Audio codec\n"
622 " ..S... = Subtitle codec\n"
623 " ...S.. = Supports draw_horiz_band\n"
624 " ....D. = Supports direct rendering method 1\n"
625 " .....T = Supports weird frame truncation\n"
632 const char *type_str;
635 while((p= av_codec_next(p))) {
636 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
637 strcmp(p->name, last_name)>0){
639 decode= encode= cap=0;
641 if(p2 && strcmp(p->name, p2->name)==0){
642 if(p->decode) decode=1;
643 if(p->encode) encode=1;
644 cap |= p->capabilities;
652 case AVMEDIA_TYPE_VIDEO:
655 case AVMEDIA_TYPE_AUDIO:
658 case AVMEDIA_TYPE_SUBTITLE:
666 " %s%s%s%s%s%s %-15s %s",
667 decode ? "D": (/*p2->decoder ? "d":*/" "),
670 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
671 cap & CODEC_CAP_DR1 ? "D":" ",
672 cap & CODEC_CAP_TRUNCATED ? "T":" ",
674 p2->long_name ? p2->long_name : "");
675 /* if(p2->decoder && decode==0)
676 printf(" use %s for decoding", p2->decoder->name);*/
681 "Note, the names of encoders and decoders do not always match, so there are\n"
682 "several cases where the above table shows encoder only or decoder only entries\n"
683 "even though both encoding and decoding are supported. For example, the h263\n"
684 "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
690 AVBitStreamFilter *bsf=NULL;
692 printf("Bitstream filters:\n");
693 while((bsf = av_bitstream_filter_next(bsf)))
694 printf("%s\n", bsf->name);
698 void show_protocols(void)
703 printf("Supported file protocols:\n"
705 while ((name = avio_enum_protocols(&opaque, 0)))
706 printf("%s\n", name);
708 while ((name = avio_enum_protocols(&opaque, 1)))
709 printf("%s\n", name);
712 void show_filters(void)
714 AVFilter av_unused(**filter) = NULL;
716 printf("Filters:\n");
718 while ((filter = av_filter_next(filter)) && *filter)
719 printf("%-16s %s\n", (*filter)->name, (*filter)->description);
723 void show_pix_fmts(void)
725 enum PixelFormat pix_fmt;
729 "I.... = Supported Input format for conversion\n"
730 ".O... = Supported Output format for conversion\n"
731 "..H.. = Hardware accelerated format\n"
732 "...P. = Paletted format\n"
733 "....B = Bitstream format\n"
734 "FLAGS NAME NB_COMPONENTS BITS_PER_PIXEL\n"
738 # define sws_isSupportedInput(x) 0
739 # define sws_isSupportedOutput(x) 0
742 for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {
743 const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[pix_fmt];
744 printf("%c%c%c%c%c %-16s %d %2d\n",
745 sws_isSupportedInput (pix_fmt) ? 'I' : '.',
746 sws_isSupportedOutput(pix_fmt) ? 'O' : '.',
747 pix_desc->flags & PIX_FMT_HWACCEL ? 'H' : '.',
748 pix_desc->flags & PIX_FMT_PAL ? 'P' : '.',
749 pix_desc->flags & PIX_FMT_BITSTREAM ? 'B' : '.',
751 pix_desc->nb_components,
752 av_get_bits_per_pixel(pix_desc));
756 int show_sample_fmts(const char *opt, const char *arg)
760 for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
761 printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
768 int yesno = (toupper(c) == 'Y');
770 while (c != '\n' && c != EOF)
776 int read_file(const char *filename, char **bufptr, size_t *size)
778 FILE *f = fopen(filename, "rb");
781 av_log(NULL, AV_LOG_ERROR, "Cannot read file '%s': %s\n", filename, strerror(errno));
782 return AVERROR(errno);
784 fseek(f, 0, SEEK_END);
786 fseek(f, 0, SEEK_SET);
787 *bufptr = av_malloc(*size + 1);
789 av_log(NULL, AV_LOG_ERROR, "Could not allocate file buffer\n");
791 return AVERROR(ENOMEM);
793 fread(*bufptr, 1, *size, f);
794 (*bufptr)[*size++] = '\0';
800 void init_pts_correction(PtsCorrectionContext *ctx)
802 ctx->num_faulty_pts = ctx->num_faulty_dts = 0;
803 ctx->last_pts = ctx->last_dts = INT64_MIN;
806 int64_t guess_correct_pts(PtsCorrectionContext *ctx, int64_t reordered_pts, int64_t dts)
808 int64_t pts = AV_NOPTS_VALUE;
810 if (dts != AV_NOPTS_VALUE) {
811 ctx->num_faulty_dts += dts <= ctx->last_dts;
814 if (reordered_pts != AV_NOPTS_VALUE) {
815 ctx->num_faulty_pts += reordered_pts <= ctx->last_pts;
816 ctx->last_pts = reordered_pts;
818 if ((ctx->num_faulty_pts<=ctx->num_faulty_dts || dts == AV_NOPTS_VALUE)
819 && reordered_pts != AV_NOPTS_VALUE)
827 FILE *get_preset_file(char *filename, size_t filename_size,
828 const char *preset_name, int is_path, const char *codec_name)
832 const char *base[3]= { getenv("AVCONV_DATADIR"),
838 av_strlcpy(filename, preset_name, filename_size);
839 f = fopen(filename, "r");
841 for (i = 0; i < 3 && !f; i++) {
844 snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.avconv", preset_name);
845 f = fopen(filename, "r");
846 if (!f && codec_name) {
847 snprintf(filename, filename_size,
848 "%s%s/%s-%s.ffpreset", base[i], i != 1 ? "" : "/.avconv", codec_name, preset_name);
849 f = fopen(filename, "r");
857 int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
859 if (*spec <= '9' && *spec >= '0') /* opt:index */
860 return strtol(spec, NULL, 0) == st->index;
861 else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd') { /* opt:[vasd] */
862 enum AVMediaType type;
865 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
866 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
867 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
868 case 'd': type = AVMEDIA_TYPE_DATA; break;
870 if (type != st->codec->codec_type)
872 if (*spec++ == ':') { /* possibly followed by :index */
873 int i, index = strtol(spec, NULL, 0);
874 for (i = 0; i < s->nb_streams; i++)
875 if (s->streams[i]->codec->codec_type == type && index-- == 0)
876 return i == st->index;
880 } else if (*spec == 'p' && *(spec + 1) == ':') {
884 prog_id = strtol(spec, &endptr, 0);
885 for (i = 0; i < s->nb_programs; i++) {
886 if (s->programs[i]->id != prog_id)
889 if (*endptr++ == ':') {
890 int stream_idx = strtol(endptr, NULL, 0);
891 return (stream_idx >= 0 && stream_idx < s->programs[i]->nb_stream_indexes &&
892 st->index == s->programs[i]->stream_index[stream_idx]);
895 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
896 if (st->index == s->programs[i]->stream_index[j])
900 } else if (!*spec) /* empty specifier, matches everything */
903 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
904 return AVERROR(EINVAL);
907 AVDictionary *filter_codec_opts(AVDictionary *opts, enum CodecID codec_id, AVFormatContext *s, AVStream *st)
909 AVDictionary *ret = NULL;
910 AVDictionaryEntry *t = NULL;
911 AVCodec *codec = s->oformat ? avcodec_find_encoder(codec_id) : avcodec_find_decoder(codec_id);
912 int flags = s->oformat ? AV_OPT_FLAG_ENCODING_PARAM : AV_OPT_FLAG_DECODING_PARAM;
914 const AVClass *cc = avcodec_get_class();
919 switch (codec->type) {
920 case AVMEDIA_TYPE_VIDEO: prefix = 'v'; flags |= AV_OPT_FLAG_VIDEO_PARAM; break;
921 case AVMEDIA_TYPE_AUDIO: prefix = 'a'; flags |= AV_OPT_FLAG_AUDIO_PARAM; break;
922 case AVMEDIA_TYPE_SUBTITLE: prefix = 's'; flags |= AV_OPT_FLAG_SUBTITLE_PARAM; break;
925 while (t = av_dict_get(opts, "", t, AV_DICT_IGNORE_SUFFIX)) {
926 char *p = strchr(t->key, ':');
928 /* check stream specification in opt name */
930 switch (check_stream_specifier(s, st, p + 1)) {
931 case 1: *p = 0; break;
933 default: return NULL;
936 if (av_opt_find(&cc, t->key, NULL, flags, AV_OPT_SEARCH_FAKE_OBJ) ||
937 (codec && codec->priv_class && av_opt_find(&codec->priv_class, t->key, NULL, flags, AV_OPT_SEARCH_FAKE_OBJ)))
938 av_dict_set(&ret, t->key, t->value, 0);
939 else if (t->key[0] == prefix && av_opt_find(&cc, t->key+1, NULL, flags, AV_OPT_SEARCH_FAKE_OBJ))
940 av_dict_set(&ret, t->key+1, t->value, 0);
948 AVDictionary **setup_find_stream_info_opts(AVFormatContext *s, AVDictionary *codec_opts)
955 opts = av_mallocz(s->nb_streams * sizeof(*opts));
957 av_log(NULL, AV_LOG_ERROR, "Could not alloc memory for stream options.\n");
960 for (i = 0; i < s->nb_streams; i++)
961 opts[i] = filter_codec_opts(codec_opts, s->streams[i]->codec->codec_id, s, s->streams[i]);
967 static int ffsink_init(AVFilterContext *ctx, const char *args, void *opaque)
969 FFSinkContext *priv = ctx->priv;
972 return AVERROR(EINVAL);
973 *priv = *(FFSinkContext *)opaque;
978 static void null_end_frame(AVFilterLink *inlink) { }
980 static int ffsink_query_formats(AVFilterContext *ctx)
982 FFSinkContext *priv = ctx->priv;
983 enum PixelFormat pix_fmts[] = { priv->pix_fmt, PIX_FMT_NONE };
985 avfilter_set_common_formats(ctx, avfilter_make_format_list(pix_fmts));
991 .priv_size = sizeof(FFSinkContext),
994 .query_formats = ffsink_query_formats,
996 .inputs = (AVFilterPad[]) {{ .name = "default",
997 .type = AVMEDIA_TYPE_VIDEO,
998 .end_frame = null_end_frame,
999 .min_perms = AV_PERM_READ, },
1001 .outputs = (AVFilterPad[]) {{ .name = NULL }},
1004 int get_filtered_video_frame(AVFilterContext *ctx, AVFrame *frame,
1005 AVFilterBufferRef **picref_ptr, AVRational *tb)
1008 AVFilterBufferRef *picref;
1010 if ((ret = avfilter_request_frame(ctx->inputs[0])) < 0)
1012 if (!(picref = ctx->inputs[0]->cur_buf))
1013 return AVERROR(ENOENT);
1014 *picref_ptr = picref;
1015 ctx->inputs[0]->cur_buf = NULL;
1016 *tb = ctx->inputs[0]->time_base;
1018 memcpy(frame->data, picref->data, sizeof(frame->data));
1019 memcpy(frame->linesize, picref->linesize, sizeof(frame->linesize));
1020 frame->interlaced_frame = picref->video->interlaced;
1021 frame->top_field_first = picref->video->top_field_first;
1022 frame->key_frame = picref->video->key_frame;
1023 frame->pict_type = picref->video->pict_type;
1028 #endif /* CONFIG_AVFILTER */
1030 void *grow_array(void *array, int elem_size, int *size, int new_size)
1032 if (new_size >= INT_MAX / elem_size) {
1033 av_log(NULL, AV_LOG_ERROR, "Array too big.\n");
1036 if (*size < new_size) {
1037 uint8_t *tmp = av_realloc(array, new_size*elem_size);
1039 av_log(NULL, AV_LOG_ERROR, "Could not alloc buffer.\n");
1042 memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);