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);
79 sws_freeContext(sws_opts);
82 for (i = 0; i < opt_name_count; i++) {
83 //opt_values are only stored for codec-specific options in which case
84 //both the name and value are dup'd
86 av_freep(&opt_names[i]);
87 av_freep(&opt_values[i]);
91 av_freep(&opt_values);
95 void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
97 vfprintf(stdout, fmt, vl);
100 double parse_number_or_die(const char *context, const char *numstr, int type, double min, double max)
104 double d = av_strtod(numstr, &tail);
106 error= "Expected number for %s but found: %s\n";
107 else if (d < min || d > max)
108 error= "The value for %s was %s which is not within %f - %f\n";
109 else if(type == OPT_INT64 && (int64_t)d != d)
110 error= "Expected int64 for %s but found %s\n";
111 else if (type == OPT_INT && (int)d != d)
112 error= "Expected int for %s but found %s\n";
115 fprintf(stderr, error, context, numstr, min, max);
119 int64_t parse_time_or_die(const char *context, const char *timestr, int is_duration)
122 if (av_parse_time(&us, timestr, is_duration) < 0) {
123 fprintf(stderr, "Invalid %s specification for %s: %s\n",
124 is_duration ? "duration" : "date", context, timestr);
130 void show_help_options(const OptionDef *options, const char *msg, int mask, int value)
136 for(po = options; po->name != NULL; po++) {
138 if ((po->flags & mask) == value) {
143 av_strlcpy(buf, po->name, sizeof(buf));
144 if (po->flags & HAS_ARG) {
145 av_strlcat(buf, " ", sizeof(buf));
146 av_strlcat(buf, po->argname, sizeof(buf));
148 printf("-%-17s %s\n", buf, po->help);
153 static const OptionDef* find_option(const OptionDef *po, const char *name){
154 while (po->name != NULL) {
155 if (!strcmp(name, po->name))
162 #if defined(_WIN32) && !defined(__MINGW32CE__)
164 /* Will be leaked on exit */
165 static char** win32_argv_utf8 = NULL;
166 static int win32_argc = 0;
169 * Prepare command line arguments for executable.
170 * For Windows - perform wide-char to UTF-8 conversion.
171 * Input arguments should be main() function arguments.
172 * @param argc_ptr Arguments number (including executable)
173 * @param argv_ptr Arguments list.
175 static void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
179 int i, buffsize = 0, offset = 0;
181 if (win32_argv_utf8) {
182 *argc_ptr = win32_argc;
183 *argv_ptr = win32_argv_utf8;
188 argv_w = CommandLineToArgvW(GetCommandLineW(), &win32_argc);
189 if (win32_argc <= 0 || !argv_w)
192 /* determine the UTF-8 buffer size (including NULL-termination symbols) */
193 for (i = 0; i < win32_argc; i++)
194 buffsize += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
195 NULL, 0, NULL, NULL);
197 win32_argv_utf8 = av_mallocz(sizeof(char*) * (win32_argc + 1) + buffsize);
198 argstr_flat = (char*)win32_argv_utf8 + sizeof(char*) * (win32_argc + 1);
199 if (win32_argv_utf8 == NULL) {
204 for (i = 0; i < win32_argc; i++) {
205 win32_argv_utf8[i] = &argstr_flat[offset];
206 offset += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
207 &argstr_flat[offset],
208 buffsize - offset, NULL, NULL);
210 win32_argv_utf8[i] = NULL;
213 *argc_ptr = win32_argc;
214 *argv_ptr = win32_argv_utf8;
217 static inline void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
221 #endif /* WIN32 && !__MINGW32CE__ */
223 void parse_options(int argc, char **argv, const OptionDef *options,
224 void (* parse_arg_function)(const char*))
226 const char *opt, *arg;
227 int optindex, handleoptions=1;
230 /* perform system-dependent conversions for arguments list */
231 prepare_app_arguments(&argc, &argv);
235 while (optindex < argc) {
236 opt = argv[optindex++];
238 if (handleoptions && opt[0] == '-' && opt[1] != '\0') {
240 if (opt[1] == '-' && opt[2] == '\0') {
245 po= find_option(options, opt);
246 if (!po->name && opt[0] == 'n' && opt[1] == 'o') {
247 /* handle 'no' bool option */
248 po = find_option(options, opt + 2);
249 if (!(po->name && (po->flags & OPT_BOOL)))
254 po= find_option(options, "default");
257 fprintf(stderr, "%s: unrecognized option '%s'\n", argv[0], opt);
261 if (po->flags & HAS_ARG) {
262 arg = argv[optindex++];
264 fprintf(stderr, "%s: missing argument for option '%s'\n", argv[0], opt);
268 if (po->flags & OPT_STRING) {
270 str = av_strdup(arg);
271 *po->u.str_arg = str;
272 } else if (po->flags & OPT_BOOL) {
273 *po->u.int_arg = bool_val;
274 } else if (po->flags & OPT_INT) {
275 *po->u.int_arg = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
276 } else if (po->flags & OPT_INT64) {
277 *po->u.int64_arg = parse_number_or_die(opt, arg, OPT_INT64, INT64_MIN, INT64_MAX);
278 } else if (po->flags & OPT_FLOAT) {
279 *po->u.float_arg = parse_number_or_die(opt, arg, OPT_FLOAT, -INFINITY, INFINITY);
281 if (po->u.func_arg(opt, arg) < 0) {
282 fprintf(stderr, "%s: failed to set value '%s' for option '%s'\n", argv[0], arg, opt);
286 if(po->flags & OPT_EXIT)
289 if (parse_arg_function)
290 parse_arg_function(opt);
295 int opt_default(const char *opt, const char *arg){
298 const AVOption *o= NULL;
299 int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
301 for(type=0; *avcodec_opts && type<AVMEDIA_TYPE_NB && ret>= 0; type++){
302 const AVOption *o2 = av_find_opt(avcodec_opts[0], opt, NULL, opt_types[type], opt_types[type]);
304 ret = av_set_string3(avcodec_opts[type], opt, arg, 1, &o);
306 if(!o && avformat_opts)
307 ret = av_set_string3(avformat_opts, opt, arg, 1, &o);
309 ret = av_set_string3(sws_opts, opt, arg, 1, &o);
311 if (opt[0] == 'a' && avcodec_opts[AVMEDIA_TYPE_AUDIO])
312 ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_AUDIO], opt+1, arg, 1, &o);
313 else if(opt[0] == 'v' && avcodec_opts[AVMEDIA_TYPE_VIDEO])
314 ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_VIDEO], opt+1, arg, 1, &o);
315 else if(opt[0] == 's' && avcodec_opts[AVMEDIA_TYPE_SUBTITLE])
316 ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], opt+1, arg, 1, &o);
319 fprintf(stderr, "Invalid value '%s' for option '%s'\n", arg, opt);
324 AVOutputFormat *oformat = NULL;
325 while ((p=av_codec_next(p))){
326 const AVClass *c = p->priv_class;
327 if(c && av_find_opt(&c, opt, NULL, 0, 0))
331 while ((oformat = av_oformat_next(oformat))) {
332 const AVClass *c = oformat->priv_class;
333 if (c && av_find_opt(&c, opt, NULL, 0, 0))
338 fprintf(stderr, "Unrecognized option '%s'\n", opt);
343 // 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));
345 //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
346 opt_values= av_realloc(opt_values, sizeof(void*)*(opt_name_count+1));
347 opt_values[opt_name_count]= o ? NULL : av_strdup(arg);
348 opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
349 opt_names[opt_name_count++]= o ? o->name : av_strdup(opt);
351 if ((*avcodec_opts && avcodec_opts[0]->debug) || (avformat_opts && avformat_opts->debug))
352 av_log_set_level(AV_LOG_DEBUG);
356 int opt_loglevel(const char *opt, const char *arg)
358 const struct { const char *name; int level; } log_levels[] = {
359 { "quiet" , AV_LOG_QUIET },
360 { "panic" , AV_LOG_PANIC },
361 { "fatal" , AV_LOG_FATAL },
362 { "error" , AV_LOG_ERROR },
363 { "warning", AV_LOG_WARNING },
364 { "info" , AV_LOG_INFO },
365 { "verbose", AV_LOG_VERBOSE },
366 { "debug" , AV_LOG_DEBUG },
372 for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
373 if (!strcmp(log_levels[i].name, arg)) {
374 av_log_set_level(log_levels[i].level);
379 level = strtol(arg, &tail, 10);
381 fprintf(stderr, "Invalid loglevel \"%s\". "
382 "Possible levels are numbers or:\n", arg);
383 for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
384 fprintf(stderr, "\"%s\"\n", log_levels[i].name);
387 av_log_set_level(level);
391 int opt_timelimit(const char *opt, const char *arg)
394 int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
395 struct rlimit rl = { lim, lim + 1 };
396 if (setrlimit(RLIMIT_CPU, &rl))
399 fprintf(stderr, "Warning: -%s not implemented on this OS\n", opt);
404 void set_context_opts(void *ctx, void *opts_ctx, int flags, AVCodec *codec)
408 if(!strcmp("AVCodecContext", (*(AVClass**)ctx)->class_name)){
409 AVCodecContext *avctx= ctx;
410 if(codec && codec->priv_class && avctx->priv_data){
411 priv_ctx= avctx->priv_data;
413 } else if (!strcmp("AVFormatContext", (*(AVClass**)ctx)->class_name)) {
414 AVFormatContext *avctx = ctx;
415 if (avctx->oformat && avctx->oformat->priv_class) {
416 priv_ctx = avctx->priv_data;
420 for(i=0; i<opt_name_count; i++){
423 const char *str= av_get_string(opts_ctx, opt_names[i], &opt, buf, sizeof(buf));
424 /* if an option with name opt_names[i] is present in opts_ctx then str is non-NULL */
425 if(str && ((opt->flags & flags) == flags))
426 av_set_string3(ctx, opt_names[i], str, 1, NULL);
427 /* We need to use a differnt system to pass options to the private context because
428 it is not known which codec and thus context kind that will be when parsing options
429 we thus use opt_values directly instead of opts_ctx */
430 if(!str && priv_ctx && av_get_string(priv_ctx, opt_names[i], &opt, buf, sizeof(buf))){
431 av_set_string3(priv_ctx, opt_names[i], opt_values[i], 1, NULL);
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 fprintf(stderr, "%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(outstream,libname,LIBNAME,flags) \
453 if (CONFIG_##LIBNAME) { \
454 const char *indent = flags & INDENT? " " : ""; \
455 if (flags & SHOW_VERSION) { \
456 unsigned int version = libname##_version(); \
457 fprintf(outstream, "%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)) { \
469 "%sWARNING: library configuration mismatch\n", \
473 fprintf(stderr, "%s%-11s configuration: %s\n", \
474 indent, #libname, cfg); \
479 static void print_all_libs_info(FILE* outstream, int flags)
481 PRINT_LIB_INFO(outstream, avutil, AVUTIL, flags);
482 PRINT_LIB_INFO(outstream, avcodec, AVCODEC, flags);
483 PRINT_LIB_INFO(outstream, avformat, AVFORMAT, flags);
484 PRINT_LIB_INFO(outstream, avdevice, AVDEVICE, flags);
485 PRINT_LIB_INFO(outstream, avfilter, AVFILTER, flags);
486 PRINT_LIB_INFO(outstream, swscale, SWSCALE, flags);
487 PRINT_LIB_INFO(outstream, postproc, POSTPROC, flags);
490 void show_banner(void)
492 fprintf(stderr, "%s version " LIBAV_VERSION ", Copyright (c) %d-%d the Libav developers\n",
493 program_name, program_birth_year, this_year);
494 fprintf(stderr, " built on %s %s with %s %s\n",
495 __DATE__, __TIME__, CC_TYPE, CC_VERSION);
496 fprintf(stderr, " configuration: " LIBAV_CONFIGURATION "\n");
497 print_all_libs_info(stderr, INDENT|SHOW_CONFIG);
498 print_all_libs_info(stderr, INDENT|SHOW_VERSION);
501 void show_version(void) {
502 printf("%s " LIBAV_VERSION "\n", program_name);
503 print_all_libs_info(stdout, SHOW_VERSION);
506 void show_license(void)
510 "This version of %s has nonfree parts compiled in.\n"
511 "Therefore it is not legally redistributable.\n",
514 "%s is free software; you can redistribute it and/or modify\n"
515 "it under the terms of the GNU General Public License as published by\n"
516 "the Free Software Foundation; either version 3 of the License, or\n"
517 "(at your option) any later version.\n"
519 "%s is distributed in the hope that it will be useful,\n"
520 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
521 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
522 "GNU General Public License for more details.\n"
524 "You should have received a copy of the GNU General Public License\n"
525 "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
526 program_name, program_name, program_name
528 "%s is free software; you can redistribute it and/or modify\n"
529 "it under the terms of the GNU General Public License as published by\n"
530 "the Free Software Foundation; either version 2 of the License, or\n"
531 "(at your option) any later version.\n"
533 "%s is distributed in the hope that it will be useful,\n"
534 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
535 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
536 "GNU General Public License for more details.\n"
538 "You should have received a copy of the GNU General Public License\n"
539 "along with %s; if not, write to the Free Software\n"
540 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
541 program_name, program_name, program_name
543 "%s is free software; you can redistribute it and/or modify\n"
544 "it under the terms of the GNU Lesser General Public License as published by\n"
545 "the Free Software Foundation; either version 3 of the License, or\n"
546 "(at your option) any later version.\n"
548 "%s is distributed in the hope that it will be useful,\n"
549 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
550 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
551 "GNU Lesser General Public License for more details.\n"
553 "You should have received a copy of the GNU Lesser General Public License\n"
554 "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
555 program_name, program_name, program_name
557 "%s is free software; you can redistribute it and/or\n"
558 "modify it under the terms of the GNU Lesser General Public\n"
559 "License as published by the Free Software Foundation; either\n"
560 "version 2.1 of the License, or (at your option) any later version.\n"
562 "%s is distributed in the hope that it will be useful,\n"
563 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
564 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
565 "Lesser General Public License for more details.\n"
567 "You should have received a copy of the GNU Lesser General Public\n"
568 "License along with %s; if not, write to the Free Software\n"
569 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
570 program_name, program_name, program_name
575 void show_formats(void)
577 AVInputFormat *ifmt=NULL;
578 AVOutputFormat *ofmt=NULL;
579 const char *last_name;
583 " D. = Demuxing supported\n"
584 " .E = Muxing supported\n"
590 const char *name=NULL;
591 const char *long_name=NULL;
593 while((ofmt= av_oformat_next(ofmt))) {
594 if((name == NULL || strcmp(ofmt->name, name)<0) &&
595 strcmp(ofmt->name, last_name)>0){
597 long_name= ofmt->long_name;
601 while((ifmt= av_iformat_next(ifmt))) {
602 if((name == NULL || strcmp(ifmt->name, name)<0) &&
603 strcmp(ifmt->name, last_name)>0){
605 long_name= ifmt->long_name;
608 if(name && strcmp(ifmt->name, name)==0)
620 long_name ? long_name:" ");
624 void show_codecs(void)
626 AVCodec *p=NULL, *p2;
627 const char *last_name;
630 " D..... = Decoding supported\n"
631 " .E.... = Encoding supported\n"
632 " ..V... = Video codec\n"
633 " ..A... = Audio codec\n"
634 " ..S... = Subtitle codec\n"
635 " ...S.. = Supports draw_horiz_band\n"
636 " ....D. = Supports direct rendering method 1\n"
637 " .....T = Supports weird frame truncation\n"
644 const char *type_str;
647 while((p= av_codec_next(p))) {
648 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
649 strcmp(p->name, last_name)>0){
651 decode= encode= cap=0;
653 if(p2 && strcmp(p->name, p2->name)==0){
654 if(p->decode) decode=1;
655 if(p->encode) encode=1;
656 cap |= p->capabilities;
664 case AVMEDIA_TYPE_VIDEO:
667 case AVMEDIA_TYPE_AUDIO:
670 case AVMEDIA_TYPE_SUBTITLE:
678 " %s%s%s%s%s%s %-15s %s",
679 decode ? "D": (/*p2->decoder ? "d":*/" "),
682 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
683 cap & CODEC_CAP_DR1 ? "D":" ",
684 cap & CODEC_CAP_TRUNCATED ? "T":" ",
686 p2->long_name ? p2->long_name : "");
687 /* if(p2->decoder && decode==0)
688 printf(" use %s for decoding", p2->decoder->name);*/
693 "Note, the names of encoders and decoders do not always match, so there are\n"
694 "several cases where the above table shows encoder only or decoder only entries\n"
695 "even though both encoding and decoding are supported. For example, the h263\n"
696 "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
702 AVBitStreamFilter *bsf=NULL;
704 printf("Bitstream filters:\n");
705 while((bsf = av_bitstream_filter_next(bsf)))
706 printf("%s\n", bsf->name);
710 void show_protocols(void)
715 printf("Supported file protocols:\n"
717 while ((name = avio_enum_protocols(&opaque, 0)))
718 printf("%s\n", name);
720 while ((name = avio_enum_protocols(&opaque, 1)))
721 printf("%s\n", name);
724 void show_filters(void)
726 AVFilter av_unused(**filter) = NULL;
728 printf("Filters:\n");
730 while ((filter = av_filter_next(filter)) && *filter)
731 printf("%-16s %s\n", (*filter)->name, (*filter)->description);
735 void show_pix_fmts(void)
737 enum PixelFormat pix_fmt;
741 "I.... = Supported Input format for conversion\n"
742 ".O... = Supported Output format for conversion\n"
743 "..H.. = Hardware accelerated format\n"
744 "...P. = Paletted format\n"
745 "....B = Bitstream format\n"
746 "FLAGS NAME NB_COMPONENTS BITS_PER_PIXEL\n"
750 # define sws_isSupportedInput(x) 0
751 # define sws_isSupportedOutput(x) 0
754 for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {
755 const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[pix_fmt];
756 printf("%c%c%c%c%c %-16s %d %2d\n",
757 sws_isSupportedInput (pix_fmt) ? 'I' : '.',
758 sws_isSupportedOutput(pix_fmt) ? 'O' : '.',
759 pix_desc->flags & PIX_FMT_HWACCEL ? 'H' : '.',
760 pix_desc->flags & PIX_FMT_PAL ? 'P' : '.',
761 pix_desc->flags & PIX_FMT_BITSTREAM ? 'B' : '.',
763 pix_desc->nb_components,
764 av_get_bits_per_pixel(pix_desc));
771 int yesno = (toupper(c) == 'Y');
773 while (c != '\n' && c != EOF)
779 int read_file(const char *filename, char **bufptr, size_t *size)
781 FILE *f = fopen(filename, "rb");
784 fprintf(stderr, "Cannot read file '%s': %s\n", filename, strerror(errno));
785 return AVERROR(errno);
787 fseek(f, 0, SEEK_END);
789 fseek(f, 0, SEEK_SET);
790 *bufptr = av_malloc(*size + 1);
792 fprintf(stderr, "Could not allocate file buffer\n");
794 return AVERROR(ENOMEM);
796 fread(*bufptr, 1, *size, f);
797 (*bufptr)[*size++] = '\0';
803 void init_pts_correction(PtsCorrectionContext *ctx)
805 ctx->num_faulty_pts = ctx->num_faulty_dts = 0;
806 ctx->last_pts = ctx->last_dts = INT64_MIN;
809 int64_t guess_correct_pts(PtsCorrectionContext *ctx, int64_t reordered_pts, int64_t dts)
811 int64_t pts = AV_NOPTS_VALUE;
813 if (dts != AV_NOPTS_VALUE) {
814 ctx->num_faulty_dts += dts <= ctx->last_dts;
817 if (reordered_pts != AV_NOPTS_VALUE) {
818 ctx->num_faulty_pts += reordered_pts <= ctx->last_pts;
819 ctx->last_pts = reordered_pts;
821 if ((ctx->num_faulty_pts<=ctx->num_faulty_dts || dts == AV_NOPTS_VALUE)
822 && reordered_pts != AV_NOPTS_VALUE)
830 FILE *get_preset_file(char *filename, size_t filename_size,
831 const char *preset_name, int is_path, const char *codec_name)
835 const char *base[3]= { getenv("FFMPEG_DATADIR"),
841 av_strlcpy(filename, preset_name, filename_size);
842 f = fopen(filename, "r");
844 for (i = 0; i < 3 && !f; i++) {
847 snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", preset_name);
848 f = fopen(filename, "r");
849 if (!f && codec_name) {
850 snprintf(filename, filename_size,
851 "%s%s/%s-%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", codec_name, preset_name);
852 f = fopen(filename, "r");
862 static int ffsink_init(AVFilterContext *ctx, const char *args, void *opaque)
864 FFSinkContext *priv = ctx->priv;
867 return AVERROR(EINVAL);
868 *priv = *(FFSinkContext *)opaque;
873 static void null_end_frame(AVFilterLink *inlink) { }
875 static int ffsink_query_formats(AVFilterContext *ctx)
877 FFSinkContext *priv = ctx->priv;
878 enum PixelFormat pix_fmts[] = { priv->pix_fmt, PIX_FMT_NONE };
880 avfilter_set_common_formats(ctx, avfilter_make_format_list(pix_fmts));
886 .priv_size = sizeof(FFSinkContext),
889 .query_formats = ffsink_query_formats,
891 .inputs = (AVFilterPad[]) {{ .name = "default",
892 .type = AVMEDIA_TYPE_VIDEO,
893 .end_frame = null_end_frame,
894 .min_perms = AV_PERM_READ, },
896 .outputs = (AVFilterPad[]) {{ .name = NULL }},
899 int get_filtered_video_frame(AVFilterContext *ctx, AVFrame *frame,
900 AVFilterBufferRef **picref_ptr, AVRational *tb)
903 AVFilterBufferRef *picref;
905 if ((ret = avfilter_request_frame(ctx->inputs[0])) < 0)
907 if (!(picref = ctx->inputs[0]->cur_buf))
908 return AVERROR(ENOENT);
909 *picref_ptr = picref;
910 ctx->inputs[0]->cur_buf = NULL;
911 *tb = ctx->inputs[0]->time_base;
913 memcpy(frame->data, picref->data, sizeof(frame->data));
914 memcpy(frame->linesize, picref->linesize, sizeof(frame->linesize));
915 frame->interlaced_frame = picref->video->interlaced;
916 frame->top_field_first = picref->video->top_field_first;
917 frame->key_frame = picref->video->key_frame;
918 frame->pict_type = picref->video->pict_type;
923 #endif /* CONFIG_AVFILTER */