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/opt.h"
45 #include "libavformat/network.h"
47 #if HAVE_SYS_RESOURCE_H
48 #include <sys/resource.h>
51 const char **opt_names;
52 const char **opt_values;
53 static int opt_name_count;
54 AVCodecContext *avcodec_opts[AVMEDIA_TYPE_NB];
55 AVFormatContext *avformat_opts;
56 struct SwsContext *sws_opts;
58 static const int this_year = 2011;
63 for (i = 0; i < AVMEDIA_TYPE_NB; i++)
64 avcodec_opts[i] = avcodec_alloc_context2(i);
65 avformat_opts = avformat_alloc_context();
67 sws_opts = sws_getContext(16, 16, 0, 16, 16, 0, SWS_BICUBIC, NULL, NULL, NULL);
71 void uninit_opts(void)
74 for (i = 0; i < AVMEDIA_TYPE_NB; i++)
75 av_freep(&avcodec_opts[i]);
76 av_freep(&avformat_opts->key);
77 av_freep(&avformat_opts);
81 for (i = 0; i < opt_name_count; i++) {
82 //opt_values are only stored for codec-specific options in which case
83 //both the name and value are dup'd
85 av_freep(&opt_names[i]);
86 av_freep(&opt_values[i]);
90 av_freep(&opt_values);
94 void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
96 vfprintf(stdout, fmt, vl);
99 double parse_number_or_die(const char *context, const char *numstr, int type, double min, double max)
103 double d = av_strtod(numstr, &tail);
105 error= "Expected number for %s but found: %s\n";
106 else if (d < min || d > max)
107 error= "The value for %s was %s which is not within %f - %f\n";
108 else if(type == OPT_INT64 && (int64_t)d != d)
109 error= "Expected int64 for %s but found %s\n";
110 else if (type == OPT_INT && (int)d != d)
111 error= "Expected int for %s but found %s\n";
114 fprintf(stderr, error, context, numstr, min, max);
118 int64_t parse_time_or_die(const char *context, const char *timestr, int is_duration)
121 if (av_parse_time(&us, timestr, is_duration) < 0) {
122 fprintf(stderr, "Invalid %s specification for %s: %s\n",
123 is_duration ? "duration" : "date", context, timestr);
129 void show_help_options(const OptionDef *options, const char *msg, int mask, int value)
135 for(po = options; po->name != NULL; po++) {
137 if ((po->flags & mask) == value) {
142 av_strlcpy(buf, po->name, sizeof(buf));
143 if (po->flags & HAS_ARG) {
144 av_strlcat(buf, " ", sizeof(buf));
145 av_strlcat(buf, po->argname, sizeof(buf));
147 printf("-%-17s %s\n", buf, po->help);
152 static const OptionDef* find_option(const OptionDef *po, const char *name){
153 while (po->name != NULL) {
154 if (!strcmp(name, po->name))
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 void parse_options(int argc, char **argv, const OptionDef *options,
223 void (* parse_arg_function)(const char*))
225 const char *opt, *arg;
226 int optindex, handleoptions=1;
229 /* perform system-dependent conversions for arguments list */
230 prepare_app_arguments(&argc, &argv);
234 while (optindex < argc) {
235 opt = argv[optindex++];
237 if (handleoptions && opt[0] == '-' && opt[1] != '\0') {
239 if (opt[1] == '-' && opt[2] == '\0') {
244 po= find_option(options, opt);
245 if (!po->name && opt[0] == 'n' && opt[1] == 'o') {
246 /* handle 'no' bool option */
247 po = find_option(options, opt + 2);
248 if (!(po->name && (po->flags & OPT_BOOL)))
253 po= find_option(options, "default");
256 fprintf(stderr, "%s: unrecognized option '%s'\n", argv[0], opt);
260 if (po->flags & HAS_ARG) {
261 arg = argv[optindex++];
263 fprintf(stderr, "%s: missing argument for option '%s'\n", argv[0], opt);
267 if (po->flags & OPT_STRING) {
269 str = av_strdup(arg);
270 *po->u.str_arg = str;
271 } else if (po->flags & OPT_BOOL) {
272 *po->u.int_arg = bool_val;
273 } else if (po->flags & OPT_INT) {
274 *po->u.int_arg = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
275 } else if (po->flags & OPT_INT64) {
276 *po->u.int64_arg = parse_number_or_die(opt, arg, OPT_INT64, INT64_MIN, INT64_MAX);
277 } else if (po->flags & OPT_FLOAT) {
278 *po->u.float_arg = parse_number_or_die(opt, arg, OPT_FLOAT, -INFINITY, INFINITY);
279 } else if (po->flags & OPT_FUNC2) {
280 if (po->u.func2_arg(opt, arg) < 0) {
281 fprintf(stderr, "%s: failed to set value '%s' for option '%s'\n", argv[0], arg, opt);
287 if(po->flags & OPT_EXIT)
290 if (parse_arg_function)
291 parse_arg_function(opt);
296 int opt_default(const char *opt, const char *arg){
299 const AVOption *o= NULL;
300 int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
302 for(type=0; *avcodec_opts && type<AVMEDIA_TYPE_NB && ret>= 0; type++){
303 const AVOption *o2 = av_find_opt(avcodec_opts[0], opt, NULL, opt_types[type], opt_types[type]);
305 ret = av_set_string3(avcodec_opts[type], opt, arg, 1, &o);
307 if(!o && avformat_opts)
308 ret = av_set_string3(avformat_opts, opt, arg, 1, &o);
310 ret = av_set_string3(sws_opts, opt, arg, 1, &o);
312 if (opt[0] == 'a' && avcodec_opts[AVMEDIA_TYPE_AUDIO])
313 ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_AUDIO], opt+1, arg, 1, &o);
314 else if(opt[0] == 'v' && avcodec_opts[AVMEDIA_TYPE_VIDEO])
315 ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_VIDEO], opt+1, arg, 1, &o);
316 else if(opt[0] == 's' && avcodec_opts[AVMEDIA_TYPE_SUBTITLE])
317 ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], opt+1, arg, 1, &o);
320 fprintf(stderr, "Invalid value '%s' for option '%s'\n", arg, opt);
325 AVOutputFormat *oformat = NULL;
326 while ((p=av_codec_next(p))){
327 AVClass *c= p->priv_class;
328 if(c && av_find_opt(&c, opt, NULL, 0, 0))
332 while ((oformat = av_oformat_next(oformat))) {
333 const AVClass *c = oformat->priv_class;
334 if (c && av_find_opt(&c, opt, NULL, 0, 0))
339 fprintf(stderr, "Unrecognized option '%s'\n", opt);
344 // av_log(NULL, AV_LOG_ERROR, "%s:%s: %f 0x%0X\n", opt, arg, av_get_double(avcodec_opts, opt, NULL), (int)av_get_int(avcodec_opts, opt, NULL));
346 //FIXME we should always use avcodec_opts, ... for storing options so there will not be any need to keep track of what i set over this
347 opt_values= av_realloc(opt_values, sizeof(void*)*(opt_name_count+1));
348 opt_values[opt_name_count]= o ? NULL : av_strdup(arg);
349 opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
350 opt_names[opt_name_count++]= o ? o->name : av_strdup(opt);
352 if ((*avcodec_opts && avcodec_opts[0]->debug) || (avformat_opts && avformat_opts->debug))
353 av_log_set_level(AV_LOG_DEBUG);
357 int opt_loglevel(const char *opt, const char *arg)
359 const struct { const char *name; int level; } log_levels[] = {
360 { "quiet" , AV_LOG_QUIET },
361 { "panic" , AV_LOG_PANIC },
362 { "fatal" , AV_LOG_FATAL },
363 { "error" , AV_LOG_ERROR },
364 { "warning", AV_LOG_WARNING },
365 { "info" , AV_LOG_INFO },
366 { "verbose", AV_LOG_VERBOSE },
367 { "debug" , AV_LOG_DEBUG },
373 for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
374 if (!strcmp(log_levels[i].name, arg)) {
375 av_log_set_level(log_levels[i].level);
380 level = strtol(arg, &tail, 10);
382 fprintf(stderr, "Invalid loglevel \"%s\". "
383 "Possible levels are numbers or:\n", arg);
384 for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
385 fprintf(stderr, "\"%s\"\n", log_levels[i].name);
388 av_log_set_level(level);
392 int opt_timelimit(const char *opt, const char *arg)
395 int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
396 struct rlimit rl = { lim, lim + 1 };
397 if (setrlimit(RLIMIT_CPU, &rl))
400 fprintf(stderr, "Warning: -%s not implemented on this OS\n", opt);
405 void set_context_opts(void *ctx, void *opts_ctx, int flags, AVCodec *codec)
409 if(!strcmp("AVCodecContext", (*(AVClass**)ctx)->class_name)){
410 AVCodecContext *avctx= ctx;
411 if(codec && codec->priv_class && avctx->priv_data){
412 priv_ctx= avctx->priv_data;
414 } else if (!strcmp("AVFormatContext", (*(AVClass**)ctx)->class_name)) {
415 AVFormatContext *avctx = ctx;
416 if (avctx->oformat && avctx->oformat->priv_class) {
417 priv_ctx = avctx->priv_data;
421 for(i=0; i<opt_name_count; i++){
424 const char *str= av_get_string(opts_ctx, opt_names[i], &opt, buf, sizeof(buf));
425 /* if an option with name opt_names[i] is present in opts_ctx then str is non-NULL */
426 if(str && ((opt->flags & flags) == flags))
427 av_set_string3(ctx, opt_names[i], str, 1, NULL);
428 /* We need to use a differnt system to pass options to the private context because
429 it is not known which codec and thus context kind that will be when parsing options
430 we thus use opt_values directly instead of opts_ctx */
431 if(!str && priv_ctx && av_get_string(priv_ctx, opt_names[i], &opt, buf, sizeof(buf))){
432 av_set_string3(priv_ctx, opt_names[i], opt_values[i], 1, NULL);
437 void print_error(const char *filename, int err)
440 const char *errbuf_ptr = errbuf;
442 if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
443 errbuf_ptr = strerror(AVUNERROR(err));
444 fprintf(stderr, "%s: %s\n", filename, errbuf_ptr);
447 static int warned_cfg = 0;
450 #define SHOW_VERSION 2
451 #define SHOW_CONFIG 4
453 #define PRINT_LIB_INFO(outstream,libname,LIBNAME,flags) \
454 if (CONFIG_##LIBNAME) { \
455 const char *indent = flags & INDENT? " " : ""; \
456 if (flags & SHOW_VERSION) { \
457 unsigned int version = libname##_version(); \
458 fprintf(outstream, "%slib%-9s %2d.%3d.%2d / %2d.%3d.%2d\n", \
460 LIB##LIBNAME##_VERSION_MAJOR, \
461 LIB##LIBNAME##_VERSION_MINOR, \
462 LIB##LIBNAME##_VERSION_MICRO, \
463 version >> 16, version >> 8 & 0xff, version & 0xff); \
465 if (flags & SHOW_CONFIG) { \
466 const char *cfg = libname##_configuration(); \
467 if (strcmp(LIBAV_CONFIGURATION, cfg)) { \
470 "%sWARNING: library configuration mismatch\n", \
474 fprintf(stderr, "%s%-11s configuration: %s\n", \
475 indent, #libname, cfg); \
480 static void print_all_libs_info(FILE* outstream, int flags)
482 PRINT_LIB_INFO(outstream, avutil, AVUTIL, flags);
483 PRINT_LIB_INFO(outstream, avcodec, AVCODEC, flags);
484 PRINT_LIB_INFO(outstream, avformat, AVFORMAT, flags);
485 PRINT_LIB_INFO(outstream, avdevice, AVDEVICE, flags);
486 PRINT_LIB_INFO(outstream, avfilter, AVFILTER, flags);
487 PRINT_LIB_INFO(outstream, swscale, SWSCALE, flags);
488 PRINT_LIB_INFO(outstream, postproc, POSTPROC, flags);
491 void show_banner(void)
493 fprintf(stderr, "%s version " LIBAV_VERSION ", Copyright (c) %d-%d the Libav developers\n",
494 program_name, program_birth_year, this_year);
495 fprintf(stderr, " built on %s %s with %s %s\n",
496 __DATE__, __TIME__, CC_TYPE, CC_VERSION);
497 fprintf(stderr, " configuration: " LIBAV_CONFIGURATION "\n");
498 print_all_libs_info(stderr, INDENT|SHOW_CONFIG);
499 print_all_libs_info(stderr, INDENT|SHOW_VERSION);
502 void show_version(void) {
503 printf("%s " LIBAV_VERSION "\n", program_name);
504 print_all_libs_info(stdout, SHOW_VERSION);
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));
772 int yesno = (toupper(c) == 'Y');
774 while (c != '\n' && c != EOF)
780 int read_file(const char *filename, char **bufptr, size_t *size)
782 FILE *f = fopen(filename, "rb");
785 fprintf(stderr, "Cannot read file '%s': %s\n", filename, strerror(errno));
786 return AVERROR(errno);
788 fseek(f, 0, SEEK_END);
790 fseek(f, 0, SEEK_SET);
791 *bufptr = av_malloc(*size + 1);
793 fprintf(stderr, "Could not allocate file buffer\n");
795 return AVERROR(ENOMEM);
797 fread(*bufptr, 1, *size, f);
798 (*bufptr)[*size++] = '\0';
804 void init_pts_correction(PtsCorrectionContext *ctx)
806 ctx->num_faulty_pts = ctx->num_faulty_dts = 0;
807 ctx->last_pts = ctx->last_dts = INT64_MIN;
810 int64_t guess_correct_pts(PtsCorrectionContext *ctx, int64_t reordered_pts, int64_t dts)
812 int64_t pts = AV_NOPTS_VALUE;
814 if (dts != AV_NOPTS_VALUE) {
815 ctx->num_faulty_dts += dts <= ctx->last_dts;
818 if (reordered_pts != AV_NOPTS_VALUE) {
819 ctx->num_faulty_pts += reordered_pts <= ctx->last_pts;
820 ctx->last_pts = reordered_pts;
822 if ((ctx->num_faulty_pts<=ctx->num_faulty_dts || dts == AV_NOPTS_VALUE)
823 && reordered_pts != AV_NOPTS_VALUE)
831 FILE *get_preset_file(char *filename, size_t filename_size,
832 const char *preset_name, int is_path, const char *codec_name)
836 const char *base[3]= { getenv("FFMPEG_DATADIR"),
842 av_strlcpy(filename, preset_name, filename_size);
843 f = fopen(filename, "r");
845 for (i = 0; i < 3 && !f; i++) {
848 snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", preset_name);
849 f = fopen(filename, "r");
850 if (!f && codec_name) {
851 snprintf(filename, filename_size,
852 "%s%s/%s-%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", codec_name, preset_name);
853 f = fopen(filename, "r");
863 static int ffsink_init(AVFilterContext *ctx, const char *args, void *opaque)
865 FFSinkContext *priv = ctx->priv;
868 return AVERROR(EINVAL);
869 *priv = *(FFSinkContext *)opaque;
874 static void null_end_frame(AVFilterLink *inlink) { }
876 static int ffsink_query_formats(AVFilterContext *ctx)
878 FFSinkContext *priv = ctx->priv;
879 enum PixelFormat pix_fmts[] = { priv->pix_fmt, PIX_FMT_NONE };
881 avfilter_set_common_formats(ctx, avfilter_make_format_list(pix_fmts));
887 .priv_size = sizeof(FFSinkContext),
890 .query_formats = ffsink_query_formats,
892 .inputs = (AVFilterPad[]) {{ .name = "default",
893 .type = AVMEDIA_TYPE_VIDEO,
894 .end_frame = null_end_frame,
895 .min_perms = AV_PERM_READ, },
897 .outputs = (AVFilterPad[]) {{ .name = NULL }},
900 int get_filtered_video_frame(AVFilterContext *ctx, AVFrame *frame,
901 AVFilterBufferRef **picref_ptr, AVRational *tb)
904 AVFilterBufferRef *picref;
906 if ((ret = avfilter_request_frame(ctx->inputs[0])) < 0)
908 if (!(picref = ctx->inputs[0]->cur_buf))
909 return AVERROR(ENOENT);
910 *picref_ptr = picref;
911 ctx->inputs[0]->cur_buf = NULL;
912 *tb = ctx->inputs[0]->time_base;
914 memcpy(frame->data, picref->data, sizeof(frame->data));
915 memcpy(frame->linesize, picref->linesize, sizeof(frame->linesize));
916 frame->interlaced_frame = picref->video->interlaced;
917 frame->top_field_first = picref->video->top_field_first;
918 frame->key_frame = picref->video->key_frame;
919 frame->pict_type = picref->video->pict_type;
924 #endif /* CONFIG_AVFILTER */