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/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 = 2011;
61 sws_opts = sws_getContext(16, 16, 0, 16, 16, 0, SWS_BICUBIC, NULL, NULL, NULL);
65 void uninit_opts(void)
68 sws_freeContext(sws_opts);
71 av_dict_free(&format_opts);
72 av_dict_free(&codec_opts);
75 void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
77 vfprintf(stdout, fmt, vl);
80 double parse_number_or_die(const char *context, const char *numstr, int type, double min, double max)
84 double d = av_strtod(numstr, &tail);
86 error= "Expected number for %s but found: %s\n";
87 else if (d < min || d > max)
88 error= "The value for %s was %s which is not within %f - %f\n";
89 else if(type == OPT_INT64 && (int64_t)d != d)
90 error= "Expected int64 for %s but found %s\n";
91 else if (type == OPT_INT && (int)d != d)
92 error= "Expected int for %s but found %s\n";
95 av_log(NULL, AV_LOG_FATAL, error, context, numstr, min, max);
100 int64_t parse_time_or_die(const char *context, const char *timestr, int is_duration)
103 if (av_parse_time(&us, timestr, is_duration) < 0) {
104 av_log(NULL, AV_LOG_FATAL, "Invalid %s specification for %s: %s\n",
105 is_duration ? "duration" : "date", context, timestr);
111 void show_help_options(const OptionDef *options, const char *msg, int mask, int value)
117 for(po = options; po->name != NULL; po++) {
119 if ((po->flags & mask) == value) {
124 av_strlcpy(buf, po->name, sizeof(buf));
125 if (po->flags & HAS_ARG) {
126 av_strlcat(buf, " ", sizeof(buf));
127 av_strlcat(buf, po->argname, sizeof(buf));
129 printf("-%-17s %s\n", buf, po->help);
134 void show_help_children(const AVClass *class, int flags)
136 const AVClass *child = NULL;
137 av_opt_show2(&class, NULL, flags, 0);
140 while (child = av_opt_child_class_next(class, child))
141 show_help_children(child, flags);
144 static const OptionDef* find_option(const OptionDef *po, const char *name){
145 const char *p = strchr(name, ':');
146 int len = p ? p - name : strlen(name);
148 while (po->name != NULL) {
149 if (!strncmp(name, po->name, len) && strlen(po->name) == len)
156 #if defined(_WIN32) && !defined(__MINGW32CE__)
158 /* Will be leaked on exit */
159 static char** win32_argv_utf8 = NULL;
160 static int win32_argc = 0;
163 * Prepare command line arguments for executable.
164 * For Windows - perform wide-char to UTF-8 conversion.
165 * Input arguments should be main() function arguments.
166 * @param argc_ptr Arguments number (including executable)
167 * @param argv_ptr Arguments list.
169 static void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
173 int i, buffsize = 0, offset = 0;
175 if (win32_argv_utf8) {
176 *argc_ptr = win32_argc;
177 *argv_ptr = win32_argv_utf8;
182 argv_w = CommandLineToArgvW(GetCommandLineW(), &win32_argc);
183 if (win32_argc <= 0 || !argv_w)
186 /* determine the UTF-8 buffer size (including NULL-termination symbols) */
187 for (i = 0; i < win32_argc; i++)
188 buffsize += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
189 NULL, 0, NULL, NULL);
191 win32_argv_utf8 = av_mallocz(sizeof(char*) * (win32_argc + 1) + buffsize);
192 argstr_flat = (char*)win32_argv_utf8 + sizeof(char*) * (win32_argc + 1);
193 if (win32_argv_utf8 == NULL) {
198 for (i = 0; i < win32_argc; i++) {
199 win32_argv_utf8[i] = &argstr_flat[offset];
200 offset += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
201 &argstr_flat[offset],
202 buffsize - offset, NULL, NULL);
204 win32_argv_utf8[i] = NULL;
207 *argc_ptr = win32_argc;
208 *argv_ptr = win32_argv_utf8;
211 static inline void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
215 #endif /* WIN32 && !__MINGW32CE__ */
217 int parse_option(void *optctx, const char *opt, const char *arg, const OptionDef *options)
224 po = find_option(options, opt);
225 if (!po->name && opt[0] == 'n' && opt[1] == 'o') {
226 /* handle 'no' bool option */
227 po = find_option(options, opt + 2);
228 if (!(po->name && (po->flags & OPT_BOOL)))
233 po = find_option(options, "default");
236 av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);
237 return AVERROR(EINVAL);
239 if (po->flags & HAS_ARG && !arg) {
240 av_log(NULL, AV_LOG_ERROR, "Missing argument for option '%s'\n", opt);
241 return AVERROR(EINVAL);
244 /* new-style options contain an offset into optctx, old-style address of
246 dst = po->flags & (OPT_OFFSET|OPT_SPEC) ? (uint8_t*)optctx + po->u.off : po->u.dst_ptr;
248 if (po->flags & OPT_SPEC) {
249 SpecifierOpt **so = dst;
250 char *p = strchr(opt, ':');
252 dstcount = (int*)(so + 1);
253 *so = grow_array(*so, sizeof(**so), dstcount, *dstcount + 1);
254 (*so)[*dstcount - 1].specifier = av_strdup(p ? p + 1 : "");
255 dst = &(*so)[*dstcount - 1].u;
258 if (po->flags & OPT_STRING) {
260 str = av_strdup(arg);
262 } else if (po->flags & OPT_BOOL) {
263 *(int*)dst = bool_val;
264 } else if (po->flags & OPT_INT) {
265 *(int*)dst = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
266 } else if (po->flags & OPT_INT64) {
267 *(int64_t*)dst = parse_number_or_die(opt, arg, OPT_INT64, INT64_MIN, INT64_MAX);
268 } else if (po->flags & OPT_TIME) {
269 *(int64_t*)dst = parse_time_or_die(opt, arg, 1);
270 } else if (po->flags & OPT_FLOAT) {
271 *(float*)dst = parse_number_or_die(opt, arg, OPT_FLOAT, -INFINITY, INFINITY);
272 } else if (po->flags & OPT_DOUBLE) {
273 *(double*)dst = parse_number_or_die(opt, arg, OPT_DOUBLE, -INFINITY, INFINITY);
274 } else if (po->u.func_arg) {
275 int ret = po->flags & OPT_FUNC2 ? po->u.func2_arg(optctx, opt, arg) :
276 po->u.func_arg(opt, arg);
278 av_log(NULL, AV_LOG_ERROR, "Failed to set value '%s' for option '%s'\n", arg, opt);
282 if (po->flags & OPT_EXIT)
284 return !!(po->flags & HAS_ARG);
287 void parse_options(void *optctx, int argc, char **argv, const OptionDef *options,
288 void (* parse_arg_function)(void *, const char*))
291 int optindex, handleoptions = 1, ret;
293 /* perform system-dependent conversions for arguments list */
294 prepare_app_arguments(&argc, &argv);
298 while (optindex < argc) {
299 opt = argv[optindex++];
301 if (handleoptions && opt[0] == '-' && opt[1] != '\0') {
302 if (opt[1] == '-' && opt[2] == '\0') {
308 if ((ret = parse_option(optctx, opt, argv[optindex], options)) < 0)
312 if (parse_arg_function)
313 parse_arg_function(optctx, opt);
319 * Return index of option opt in argv or 0 if not found.
321 static int locate_option(int argc, char **argv, const OptionDef *options, const char *optname)
326 for (i = 1; i < argc; i++) {
327 const char *cur_opt = argv[i];
329 if (*cur_opt++ != '-')
332 po = find_option(options, cur_opt);
333 if (!po->name && cur_opt[0] == 'n' && cur_opt[1] == 'o')
334 po = find_option(options, cur_opt + 2);
336 if ((!po->name && !strcmp(cur_opt, optname)) ||
337 (po->name && !strcmp(optname, po->name)))
340 if (!po || po->flags & HAS_ARG)
346 void parse_loglevel(int argc, char **argv, const OptionDef *options)
348 int idx = locate_option(argc, argv, options, "loglevel");
350 idx = locate_option(argc, argv, options, "v");
351 if (idx && argv[idx + 1])
352 opt_loglevel("loglevel", argv[idx + 1]);
355 #define FLAGS (o->type == AV_OPT_TYPE_FLAGS) ? AV_DICT_APPEND : 0
356 int opt_default(const char *opt, const char *arg)
359 char opt_stripped[128];
361 const AVClass *cc = avcodec_get_class(), *fc = avformat_get_class(), *sc = sws_get_class();
363 if (!(p = strchr(opt, ':')))
364 p = opt + strlen(opt);
365 av_strlcpy(opt_stripped, opt, FFMIN(sizeof(opt_stripped), p - opt + 1));
367 if ((o = av_opt_find(&cc, opt_stripped, NULL, 0, AV_OPT_SEARCH_CHILDREN|AV_OPT_SEARCH_FAKE_OBJ)) ||
368 ((opt[0] == 'v' || opt[0] == 'a' || opt[0] == 's') &&
369 (o = av_opt_find(&cc, opt+1, NULL, 0, AV_OPT_SEARCH_FAKE_OBJ))))
370 av_dict_set(&codec_opts, opt, arg, FLAGS);
371 else if ((o = av_opt_find(&fc, opt, NULL, 0, AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)))
372 av_dict_set(&format_opts, opt, arg, FLAGS);
373 else if ((o = av_opt_find(&sc, opt, NULL, 0, AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) {
374 // XXX we only support sws_flags, not arbitrary sws options
375 int ret = av_opt_set(sws_opts, opt, arg, 0);
377 av_log(NULL, AV_LOG_ERROR, "Error setting option %s.\n", opt);
384 av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);
385 return AVERROR_OPTION_NOT_FOUND;
388 int opt_loglevel(const char *opt, const char *arg)
390 const struct { const char *name; int level; } log_levels[] = {
391 { "quiet" , AV_LOG_QUIET },
392 { "panic" , AV_LOG_PANIC },
393 { "fatal" , AV_LOG_FATAL },
394 { "error" , AV_LOG_ERROR },
395 { "warning", AV_LOG_WARNING },
396 { "info" , AV_LOG_INFO },
397 { "verbose", AV_LOG_VERBOSE },
398 { "debug" , AV_LOG_DEBUG },
404 for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
405 if (!strcmp(log_levels[i].name, arg)) {
406 av_log_set_level(log_levels[i].level);
411 level = strtol(arg, &tail, 10);
413 av_log(NULL, AV_LOG_FATAL, "Invalid loglevel \"%s\". "
414 "Possible levels are numbers or:\n", arg);
415 for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
416 av_log(NULL, AV_LOG_FATAL, "\"%s\"\n", log_levels[i].name);
419 av_log_set_level(level);
423 int opt_timelimit(const char *opt, const char *arg)
426 int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
427 struct rlimit rl = { lim, lim + 1 };
428 if (setrlimit(RLIMIT_CPU, &rl))
431 av_log(NULL, AV_LOG_WARNING, "-%s not implemented on this OS\n", opt);
436 void print_error(const char *filename, int err)
439 const char *errbuf_ptr = errbuf;
441 if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
442 errbuf_ptr = strerror(AVUNERROR(err));
443 av_log(NULL, AV_LOG_ERROR, "%s: %s\n", filename, errbuf_ptr);
446 static int warned_cfg = 0;
449 #define SHOW_VERSION 2
450 #define SHOW_CONFIG 4
452 #define PRINT_LIB_INFO(libname, LIBNAME, flags, level) \
453 if (CONFIG_##LIBNAME) { \
454 const char *indent = flags & INDENT? " " : ""; \
455 if (flags & SHOW_VERSION) { \
456 unsigned int version = libname##_version(); \
457 av_log(NULL, level, "%slib%-9s %2d.%3d.%2d / %2d.%3d.%2d\n",\
459 LIB##LIBNAME##_VERSION_MAJOR, \
460 LIB##LIBNAME##_VERSION_MINOR, \
461 LIB##LIBNAME##_VERSION_MICRO, \
462 version >> 16, version >> 8 & 0xff, version & 0xff); \
464 if (flags & SHOW_CONFIG) { \
465 const char *cfg = libname##_configuration(); \
466 if (strcmp(LIBAV_CONFIGURATION, cfg)) { \
468 av_log(NULL, level, \
469 "%sWARNING: library configuration mismatch\n", \
473 av_log(NULL, level, "%s%-11s configuration: %s\n", \
474 indent, #libname, cfg); \
479 static void print_all_libs_info(int flags, int level)
481 PRINT_LIB_INFO(avutil, AVUTIL, flags, level);
482 PRINT_LIB_INFO(avcodec, AVCODEC, flags, level);
483 PRINT_LIB_INFO(avformat, AVFORMAT, flags, level);
484 PRINT_LIB_INFO(avdevice, AVDEVICE, flags, level);
485 PRINT_LIB_INFO(avfilter, AVFILTER, flags, level);
486 PRINT_LIB_INFO(swscale, SWSCALE, flags, level);
487 PRINT_LIB_INFO(postproc, POSTPROC, flags, level);
490 void show_banner(void)
492 av_log(NULL, AV_LOG_INFO, "%s version " LIBAV_VERSION ", Copyright (c) %d-%d the Libav developers\n",
493 program_name, program_birth_year, this_year);
494 av_log(NULL, AV_LOG_INFO, " built on %s %s with %s %s\n",
495 __DATE__, __TIME__, CC_TYPE, CC_VERSION);
496 av_log(NULL, AV_LOG_VERBOSE, " configuration: " LIBAV_CONFIGURATION "\n");
497 print_all_libs_info(INDENT|SHOW_CONFIG, AV_LOG_VERBOSE);
498 print_all_libs_info(INDENT|SHOW_VERSION, AV_LOG_VERBOSE);
501 void show_version(void) {
502 av_log_set_callback(log_callback_help);
503 printf("%s " LIBAV_VERSION "\n", program_name);
504 print_all_libs_info(SHOW_VERSION, AV_LOG_INFO);
507 void show_license(void)
511 "This version of %s has nonfree parts compiled in.\n"
512 "Therefore it is not legally redistributable.\n",
515 "%s is free software; you can redistribute it and/or modify\n"
516 "it under the terms of the GNU General Public License as published by\n"
517 "the Free Software Foundation; either version 3 of the License, or\n"
518 "(at your option) any later version.\n"
520 "%s is distributed in the hope that it will be useful,\n"
521 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
522 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
523 "GNU General Public License for more details.\n"
525 "You should have received a copy of the GNU General Public License\n"
526 "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
527 program_name, program_name, program_name
529 "%s is free software; you can redistribute it and/or modify\n"
530 "it under the terms of the GNU General Public License as published by\n"
531 "the Free Software Foundation; either version 2 of the License, or\n"
532 "(at your option) any later version.\n"
534 "%s is distributed in the hope that it will be useful,\n"
535 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
536 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
537 "GNU General Public License for more details.\n"
539 "You should have received a copy of the GNU General Public License\n"
540 "along with %s; if not, write to the Free Software\n"
541 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\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 Lesser General Public License as published by\n"
546 "the Free Software Foundation; either version 3 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 Lesser General Public License for more details.\n"
554 "You should have received a copy of the GNU Lesser General Public License\n"
555 "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
556 program_name, program_name, program_name
558 "%s is free software; you can redistribute it and/or\n"
559 "modify it under the terms of the GNU Lesser General Public\n"
560 "License as published by the Free Software Foundation; either\n"
561 "version 2.1 of the License, or (at your option) any later version.\n"
563 "%s is distributed in the hope that it will be useful,\n"
564 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
565 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
566 "Lesser General Public License for more details.\n"
568 "You should have received a copy of the GNU Lesser General Public\n"
569 "License along with %s; if not, write to the Free Software\n"
570 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
571 program_name, program_name, program_name
576 void show_formats(void)
578 AVInputFormat *ifmt=NULL;
579 AVOutputFormat *ofmt=NULL;
580 const char *last_name;
584 " D. = Demuxing supported\n"
585 " .E = Muxing supported\n"
591 const char *name=NULL;
592 const char *long_name=NULL;
594 while((ofmt= av_oformat_next(ofmt))) {
595 if((name == NULL || strcmp(ofmt->name, name)<0) &&
596 strcmp(ofmt->name, last_name)>0){
598 long_name= ofmt->long_name;
602 while((ifmt= av_iformat_next(ifmt))) {
603 if((name == NULL || strcmp(ifmt->name, name)<0) &&
604 strcmp(ifmt->name, last_name)>0){
606 long_name= ifmt->long_name;
609 if(name && strcmp(ifmt->name, name)==0)
621 long_name ? long_name:" ");
625 void show_codecs(void)
627 AVCodec *p=NULL, *p2;
628 const char *last_name;
631 " D..... = Decoding supported\n"
632 " .E.... = Encoding supported\n"
633 " ..V... = Video codec\n"
634 " ..A... = Audio codec\n"
635 " ..S... = Subtitle codec\n"
636 " ...S.. = Supports draw_horiz_band\n"
637 " ....D. = Supports direct rendering method 1\n"
638 " .....T = Supports weird frame truncation\n"
645 const char *type_str;
648 while((p= av_codec_next(p))) {
649 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
650 strcmp(p->name, last_name)>0){
652 decode= encode= cap=0;
654 if(p2 && strcmp(p->name, p2->name)==0){
655 if(p->decode) decode=1;
656 if(p->encode) encode=1;
657 cap |= p->capabilities;
665 case AVMEDIA_TYPE_VIDEO:
668 case AVMEDIA_TYPE_AUDIO:
671 case AVMEDIA_TYPE_SUBTITLE:
679 " %s%s%s%s%s%s %-15s %s",
680 decode ? "D": (/*p2->decoder ? "d":*/" "),
683 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
684 cap & CODEC_CAP_DR1 ? "D":" ",
685 cap & CODEC_CAP_TRUNCATED ? "T":" ",
687 p2->long_name ? p2->long_name : "");
688 /* if(p2->decoder && decode==0)
689 printf(" use %s for decoding", p2->decoder->name);*/
694 "Note, the names of encoders and decoders do not always match, so there are\n"
695 "several cases where the above table shows encoder only or decoder only entries\n"
696 "even though both encoding and decoding are supported. For example, the h263\n"
697 "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
703 AVBitStreamFilter *bsf=NULL;
705 printf("Bitstream filters:\n");
706 while((bsf = av_bitstream_filter_next(bsf)))
707 printf("%s\n", bsf->name);
711 void show_protocols(void)
716 printf("Supported file protocols:\n"
718 while ((name = avio_enum_protocols(&opaque, 0)))
719 printf("%s\n", name);
721 while ((name = avio_enum_protocols(&opaque, 1)))
722 printf("%s\n", name);
725 void show_filters(void)
727 AVFilter av_unused(**filter) = NULL;
729 printf("Filters:\n");
731 while ((filter = av_filter_next(filter)) && *filter)
732 printf("%-16s %s\n", (*filter)->name, (*filter)->description);
736 void show_pix_fmts(void)
738 enum PixelFormat pix_fmt;
742 "I.... = Supported Input format for conversion\n"
743 ".O... = Supported Output format for conversion\n"
744 "..H.. = Hardware accelerated format\n"
745 "...P. = Paletted format\n"
746 "....B = Bitstream format\n"
747 "FLAGS NAME NB_COMPONENTS BITS_PER_PIXEL\n"
751 # define sws_isSupportedInput(x) 0
752 # define sws_isSupportedOutput(x) 0
755 for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {
756 const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[pix_fmt];
757 printf("%c%c%c%c%c %-16s %d %2d\n",
758 sws_isSupportedInput (pix_fmt) ? 'I' : '.',
759 sws_isSupportedOutput(pix_fmt) ? 'O' : '.',
760 pix_desc->flags & PIX_FMT_HWACCEL ? 'H' : '.',
761 pix_desc->flags & PIX_FMT_PAL ? 'P' : '.',
762 pix_desc->flags & PIX_FMT_BITSTREAM ? 'B' : '.',
764 pix_desc->nb_components,
765 av_get_bits_per_pixel(pix_desc));
769 int show_sample_fmts(const char *opt, const char *arg)
773 for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
774 printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
781 int yesno = (toupper(c) == 'Y');
783 while (c != '\n' && c != EOF)
789 int cmdutils_read_file(const char *filename, char **bufptr, size_t *size)
792 FILE *f = fopen(filename, "rb");
795 av_log(NULL, AV_LOG_ERROR, "Cannot read file '%s': %s\n", filename, strerror(errno));
796 return AVERROR(errno);
798 fseek(f, 0, SEEK_END);
800 fseek(f, 0, SEEK_SET);
801 *bufptr = av_malloc(*size + 1);
803 av_log(NULL, AV_LOG_ERROR, "Could not allocate file buffer\n");
805 return AVERROR(ENOMEM);
807 ret = fread(*bufptr, 1, *size, f);
811 av_log(NULL, AV_LOG_ERROR, "Error while reading file '%s': %s\n",
812 filename, strerror(errno));
813 ret = AVERROR(errno);
818 (*bufptr)[*size++] = '\0';
825 void init_pts_correction(PtsCorrectionContext *ctx)
827 ctx->num_faulty_pts = ctx->num_faulty_dts = 0;
828 ctx->last_pts = ctx->last_dts = INT64_MIN;
831 int64_t guess_correct_pts(PtsCorrectionContext *ctx, int64_t reordered_pts, int64_t dts)
833 int64_t pts = AV_NOPTS_VALUE;
835 if (dts != AV_NOPTS_VALUE) {
836 ctx->num_faulty_dts += dts <= ctx->last_dts;
839 if (reordered_pts != AV_NOPTS_VALUE) {
840 ctx->num_faulty_pts += reordered_pts <= ctx->last_pts;
841 ctx->last_pts = reordered_pts;
843 if ((ctx->num_faulty_pts<=ctx->num_faulty_dts || dts == AV_NOPTS_VALUE)
844 && reordered_pts != AV_NOPTS_VALUE)
852 FILE *get_preset_file(char *filename, size_t filename_size,
853 const char *preset_name, int is_path, const char *codec_name)
857 const char *base[3]= { getenv("AVCONV_DATADIR"),
863 av_strlcpy(filename, preset_name, filename_size);
864 f = fopen(filename, "r");
866 for (i = 0; i < 3 && !f; i++) {
869 snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.avconv", preset_name);
870 f = fopen(filename, "r");
871 if (!f && codec_name) {
872 snprintf(filename, filename_size,
873 "%s%s/%s-%s.ffpreset", base[i], i != 1 ? "" : "/.avconv", codec_name, preset_name);
874 f = fopen(filename, "r");
882 int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
884 if (*spec <= '9' && *spec >= '0') /* opt:index */
885 return strtol(spec, NULL, 0) == st->index;
886 else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' || *spec == 't') { /* opt:[vasdt] */
887 enum AVMediaType type;
890 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
891 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
892 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
893 case 'd': type = AVMEDIA_TYPE_DATA; break;
894 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
896 if (type != st->codec->codec_type)
898 if (*spec++ == ':') { /* possibly followed by :index */
899 int i, index = strtol(spec, NULL, 0);
900 for (i = 0; i < s->nb_streams; i++)
901 if (s->streams[i]->codec->codec_type == type && index-- == 0)
902 return i == st->index;
906 } else if (*spec == 'p' && *(spec + 1) == ':') {
910 prog_id = strtol(spec, &endptr, 0);
911 for (i = 0; i < s->nb_programs; i++) {
912 if (s->programs[i]->id != prog_id)
915 if (*endptr++ == ':') {
916 int stream_idx = strtol(endptr, NULL, 0);
917 return stream_idx >= 0 &&
918 stream_idx < s->programs[i]->nb_stream_indexes &&
919 st->index == s->programs[i]->stream_index[stream_idx];
922 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
923 if (st->index == s->programs[i]->stream_index[j])
927 } else if (!*spec) /* empty specifier, matches everything */
930 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
931 return AVERROR(EINVAL);
934 AVDictionary *filter_codec_opts(AVDictionary *opts, enum CodecID codec_id, AVFormatContext *s, AVStream *st)
936 AVDictionary *ret = NULL;
937 AVDictionaryEntry *t = NULL;
938 AVCodec *codec = s->oformat ? avcodec_find_encoder(codec_id) : avcodec_find_decoder(codec_id);
939 int flags = s->oformat ? AV_OPT_FLAG_ENCODING_PARAM : AV_OPT_FLAG_DECODING_PARAM;
941 const AVClass *cc = avcodec_get_class();
946 switch (codec->type) {
947 case AVMEDIA_TYPE_VIDEO: prefix = 'v'; flags |= AV_OPT_FLAG_VIDEO_PARAM; break;
948 case AVMEDIA_TYPE_AUDIO: prefix = 'a'; flags |= AV_OPT_FLAG_AUDIO_PARAM; break;
949 case AVMEDIA_TYPE_SUBTITLE: prefix = 's'; flags |= AV_OPT_FLAG_SUBTITLE_PARAM; break;
952 while (t = av_dict_get(opts, "", t, AV_DICT_IGNORE_SUFFIX)) {
953 char *p = strchr(t->key, ':');
955 /* check stream specification in opt name */
957 switch (check_stream_specifier(s, st, p + 1)) {
958 case 1: *p = 0; break;
960 default: return NULL;
963 if (av_opt_find(&cc, t->key, NULL, flags, AV_OPT_SEARCH_FAKE_OBJ) ||
964 (codec && codec->priv_class && av_opt_find(&codec->priv_class, t->key, NULL, flags, AV_OPT_SEARCH_FAKE_OBJ)))
965 av_dict_set(&ret, t->key, t->value, 0);
966 else if (t->key[0] == prefix && av_opt_find(&cc, t->key+1, NULL, flags, AV_OPT_SEARCH_FAKE_OBJ))
967 av_dict_set(&ret, t->key+1, t->value, 0);
975 AVDictionary **setup_find_stream_info_opts(AVFormatContext *s, AVDictionary *codec_opts)
982 opts = av_mallocz(s->nb_streams * sizeof(*opts));
984 av_log(NULL, AV_LOG_ERROR, "Could not alloc memory for stream options.\n");
987 for (i = 0; i < s->nb_streams; i++)
988 opts[i] = filter_codec_opts(codec_opts, s->streams[i]->codec->codec_id, s, s->streams[i]);
994 static int ffsink_init(AVFilterContext *ctx, const char *args, void *opaque)
996 FFSinkContext *priv = ctx->priv;
999 return AVERROR(EINVAL);
1000 *priv = *(FFSinkContext *)opaque;
1005 static void null_end_frame(AVFilterLink *inlink) { }
1007 static int ffsink_query_formats(AVFilterContext *ctx)
1009 FFSinkContext *priv = ctx->priv;
1010 enum PixelFormat pix_fmts[] = { priv->pix_fmt, PIX_FMT_NONE };
1012 avfilter_set_common_formats(ctx, avfilter_make_format_list(pix_fmts));
1018 .priv_size = sizeof(FFSinkContext),
1019 .init = ffsink_init,
1021 .query_formats = ffsink_query_formats,
1023 .inputs = (AVFilterPad[]) {{ .name = "default",
1024 .type = AVMEDIA_TYPE_VIDEO,
1025 .end_frame = null_end_frame,
1026 .min_perms = AV_PERM_READ, },
1028 .outputs = (AVFilterPad[]) {{ .name = NULL }},
1031 int get_filtered_video_frame(AVFilterContext *ctx, AVFrame *frame,
1032 AVFilterBufferRef **picref_ptr, AVRational *tb)
1035 AVFilterBufferRef *picref;
1037 if ((ret = avfilter_request_frame(ctx->inputs[0])) < 0)
1039 if (!(picref = ctx->inputs[0]->cur_buf))
1040 return AVERROR(ENOENT);
1041 *picref_ptr = picref;
1042 ctx->inputs[0]->cur_buf = NULL;
1043 *tb = ctx->inputs[0]->time_base;
1045 memcpy(frame->data, picref->data, sizeof(frame->data));
1046 memcpy(frame->linesize, picref->linesize, sizeof(frame->linesize));
1047 frame->interlaced_frame = picref->video->interlaced;
1048 frame->top_field_first = picref->video->top_field_first;
1049 frame->key_frame = picref->video->key_frame;
1050 frame->pict_type = picref->video->pict_type;
1051 frame->sample_aspect_ratio = picref->video->pixel_aspect;
1056 #endif /* CONFIG_AVFILTER */
1058 void *grow_array(void *array, int elem_size, int *size, int new_size)
1060 if (new_size >= INT_MAX / elem_size) {
1061 av_log(NULL, AV_LOG_ERROR, "Array too big.\n");
1064 if (*size < new_size) {
1065 uint8_t *tmp = av_realloc(array, new_size*elem_size);
1067 av_log(NULL, AV_LOG_ERROR, "Could not alloc buffer.\n");
1070 memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);