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);
93 void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
95 vfprintf(stdout, fmt, vl);
98 double parse_number_or_die(const char *context, const char *numstr, int type, double min, double max)
102 double d = av_strtod(numstr, &tail);
104 error= "Expected number for %s but found: %s\n";
105 else if (d < min || d > max)
106 error= "The value for %s was %s which is not within %f - %f\n";
107 else if(type == OPT_INT64 && (int64_t)d != d)
108 error= "Expected int64 for %s but found %s\n";
111 fprintf(stderr, error, context, numstr, min, max);
115 int64_t parse_time_or_die(const char *context, const char *timestr, int is_duration)
118 if (av_parse_time(&us, timestr, is_duration) < 0) {
119 fprintf(stderr, "Invalid %s specification for %s: %s\n",
120 is_duration ? "duration" : "date", context, timestr);
126 void show_help_options(const OptionDef *options, const char *msg, int mask, int value)
132 for(po = options; po->name != NULL; po++) {
134 if ((po->flags & mask) == value) {
139 av_strlcpy(buf, po->name, sizeof(buf));
140 if (po->flags & HAS_ARG) {
141 av_strlcat(buf, " ", sizeof(buf));
142 av_strlcat(buf, po->argname, sizeof(buf));
144 printf("-%-17s %s\n", buf, po->help);
149 static const OptionDef* find_option(const OptionDef *po, const char *name){
150 while (po->name != NULL) {
151 if (!strcmp(name, po->name))
158 void parse_options(int argc, char **argv, const OptionDef *options,
159 void (* parse_arg_function)(const char*))
161 const char *opt, *arg;
162 int optindex, handleoptions=1;
167 while (optindex < argc) {
168 opt = argv[optindex++];
170 if (handleoptions && opt[0] == '-' && opt[1] != '\0') {
172 if (opt[1] == '-' && opt[2] == '\0') {
177 po= find_option(options, opt);
178 if (!po->name && opt[0] == 'n' && opt[1] == 'o') {
179 /* handle 'no' bool option */
180 po = find_option(options, opt + 2);
181 if (!(po->name && (po->flags & OPT_BOOL)))
186 po= find_option(options, "default");
189 fprintf(stderr, "%s: unrecognized option '%s'\n", argv[0], opt);
193 if (po->flags & HAS_ARG) {
194 arg = argv[optindex++];
196 fprintf(stderr, "%s: missing argument for option '%s'\n", argv[0], opt);
200 if (po->flags & OPT_STRING) {
202 str = av_strdup(arg);
203 *po->u.str_arg = str;
204 } else if (po->flags & OPT_BOOL) {
205 *po->u.int_arg = bool_val;
206 } else if (po->flags & OPT_INT) {
207 *po->u.int_arg = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
208 } else if (po->flags & OPT_INT64) {
209 *po->u.int64_arg = parse_number_or_die(opt, arg, OPT_INT64, INT64_MIN, INT64_MAX);
210 } else if (po->flags & OPT_FLOAT) {
211 *po->u.float_arg = parse_number_or_die(opt, arg, OPT_FLOAT, -INFINITY, INFINITY);
212 } else if (po->flags & OPT_FUNC2) {
213 if (po->u.func2_arg(opt, arg) < 0) {
214 fprintf(stderr, "%s: failed to set value '%s' for option '%s'\n", argv[0], arg, opt);
220 if(po->flags & OPT_EXIT)
223 if (parse_arg_function)
224 parse_arg_function(opt);
229 int opt_default(const char *opt, const char *arg){
232 const AVOption *o= NULL;
233 int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
235 for(type=0; *avcodec_opts && type<AVMEDIA_TYPE_NB && ret>= 0; type++){
236 const AVOption *o2 = av_find_opt(avcodec_opts[0], opt, NULL, opt_types[type], opt_types[type]);
238 ret = av_set_string3(avcodec_opts[type], opt, arg, 1, &o);
240 if(!o && avformat_opts)
241 ret = av_set_string3(avformat_opts, opt, arg, 1, &o);
243 ret = av_set_string3(sws_opts, opt, arg, 1, &o);
245 if (opt[0] == 'a' && avcodec_opts[AVMEDIA_TYPE_AUDIO])
246 ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_AUDIO], opt+1, arg, 1, &o);
247 else if(opt[0] == 'v' && avcodec_opts[AVMEDIA_TYPE_VIDEO])
248 ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_VIDEO], opt+1, arg, 1, &o);
249 else if(opt[0] == 's' && avcodec_opts[AVMEDIA_TYPE_SUBTITLE])
250 ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], opt+1, arg, 1, &o);
253 fprintf(stderr, "Invalid value '%s' for option '%s'\n", arg, opt);
258 AVOutputFormat *oformat = NULL;
259 while ((p=av_codec_next(p))){
260 AVClass *c= p->priv_class;
261 if(c && av_find_opt(&c, opt, NULL, 0, 0))
265 while ((oformat = av_oformat_next(oformat))) {
266 const AVClass *c = oformat->priv_class;
267 if (c && av_find_opt(&c, opt, NULL, 0, 0))
272 fprintf(stderr, "Unrecognized option '%s'\n", opt);
277 // 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));
279 //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
280 opt_values= av_realloc(opt_values, sizeof(void*)*(opt_name_count+1));
281 opt_values[opt_name_count]= o ? NULL : av_strdup(arg);
282 opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
283 opt_names[opt_name_count++]= o ? o->name : av_strdup(opt);
285 if ((*avcodec_opts && avcodec_opts[0]->debug) || (avformat_opts && avformat_opts->debug))
286 av_log_set_level(AV_LOG_DEBUG);
290 int opt_loglevel(const char *opt, const char *arg)
292 const struct { const char *name; int level; } log_levels[] = {
293 { "quiet" , AV_LOG_QUIET },
294 { "panic" , AV_LOG_PANIC },
295 { "fatal" , AV_LOG_FATAL },
296 { "error" , AV_LOG_ERROR },
297 { "warning", AV_LOG_WARNING },
298 { "info" , AV_LOG_INFO },
299 { "verbose", AV_LOG_VERBOSE },
300 { "debug" , AV_LOG_DEBUG },
306 for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
307 if (!strcmp(log_levels[i].name, arg)) {
308 av_log_set_level(log_levels[i].level);
313 level = strtol(arg, &tail, 10);
315 fprintf(stderr, "Invalid loglevel \"%s\". "
316 "Possible levels are numbers or:\n", arg);
317 for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
318 fprintf(stderr, "\"%s\"\n", log_levels[i].name);
321 av_log_set_level(level);
325 int opt_timelimit(const char *opt, const char *arg)
328 int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
329 struct rlimit rl = { lim, lim + 1 };
330 if (setrlimit(RLIMIT_CPU, &rl))
333 fprintf(stderr, "Warning: -%s not implemented on this OS\n", opt);
338 void set_context_opts(void *ctx, void *opts_ctx, int flags, AVCodec *codec)
342 if(!strcmp("AVCodecContext", (*(AVClass**)ctx)->class_name)){
343 AVCodecContext *avctx= ctx;
344 if(codec && codec->priv_class && avctx->priv_data){
345 priv_ctx= avctx->priv_data;
347 } else if (!strcmp("AVFormatContext", (*(AVClass**)ctx)->class_name)) {
348 AVFormatContext *avctx = ctx;
349 if (avctx->oformat && avctx->oformat->priv_class) {
350 priv_ctx = avctx->priv_data;
354 for(i=0; i<opt_name_count; i++){
357 const char *str= av_get_string(opts_ctx, opt_names[i], &opt, buf, sizeof(buf));
358 /* if an option with name opt_names[i] is present in opts_ctx then str is non-NULL */
359 if(str && ((opt->flags & flags) == flags))
360 av_set_string3(ctx, opt_names[i], str, 1, NULL);
361 /* We need to use a differnt system to pass options to the private context because
362 it is not known which codec and thus context kind that will be when parsing options
363 we thus use opt_values directly instead of opts_ctx */
364 if(!str && priv_ctx && av_get_string(priv_ctx, opt_names[i], &opt, buf, sizeof(buf))){
365 av_set_string3(priv_ctx, opt_names[i], opt_values[i], 1, NULL);
370 void print_error(const char *filename, int err)
373 const char *errbuf_ptr = errbuf;
375 if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
376 errbuf_ptr = strerror(AVUNERROR(err));
377 fprintf(stderr, "%s: %s\n", filename, errbuf_ptr);
380 static int warned_cfg = 0;
383 #define SHOW_VERSION 2
384 #define SHOW_CONFIG 4
386 #define PRINT_LIB_INFO(outstream,libname,LIBNAME,flags) \
387 if (CONFIG_##LIBNAME) { \
388 const char *indent = flags & INDENT? " " : ""; \
389 if (flags & SHOW_VERSION) { \
390 unsigned int version = libname##_version(); \
391 fprintf(outstream, "%slib%-9s %2d.%3d.%2d / %2d.%3d.%2d\n", \
393 LIB##LIBNAME##_VERSION_MAJOR, \
394 LIB##LIBNAME##_VERSION_MINOR, \
395 LIB##LIBNAME##_VERSION_MICRO, \
396 version >> 16, version >> 8 & 0xff, version & 0xff); \
398 if (flags & SHOW_CONFIG) { \
399 const char *cfg = libname##_configuration(); \
400 if (strcmp(LIBAV_CONFIGURATION, cfg)) { \
403 "%sWARNING: library configuration mismatch\n", \
407 fprintf(stderr, "%s%-11s configuration: %s\n", \
408 indent, #libname, cfg); \
413 static void print_all_libs_info(FILE* outstream, int flags)
415 PRINT_LIB_INFO(outstream, avutil, AVUTIL, flags);
416 PRINT_LIB_INFO(outstream, avcodec, AVCODEC, flags);
417 PRINT_LIB_INFO(outstream, avformat, AVFORMAT, flags);
418 PRINT_LIB_INFO(outstream, avdevice, AVDEVICE, flags);
419 PRINT_LIB_INFO(outstream, avfilter, AVFILTER, flags);
420 PRINT_LIB_INFO(outstream, swscale, SWSCALE, flags);
421 PRINT_LIB_INFO(outstream, postproc, POSTPROC, flags);
424 void show_banner(void)
426 fprintf(stderr, "%s version " LIBAV_VERSION ", Copyright (c) %d-%d the Libav developers\n",
427 program_name, program_birth_year, this_year);
428 fprintf(stderr, " built on %s %s with %s %s\n",
429 __DATE__, __TIME__, CC_TYPE, CC_VERSION);
430 fprintf(stderr, " configuration: " LIBAV_CONFIGURATION "\n");
431 print_all_libs_info(stderr, INDENT|SHOW_CONFIG);
432 print_all_libs_info(stderr, INDENT|SHOW_VERSION);
435 void show_version(void) {
436 printf("%s " LIBAV_VERSION "\n", program_name);
437 print_all_libs_info(stdout, SHOW_VERSION);
440 void show_license(void)
444 "This version of %s has nonfree parts compiled in.\n"
445 "Therefore it is not legally redistributable.\n",
448 "%s is free software; you can redistribute it and/or modify\n"
449 "it under the terms of the GNU General Public License as published by\n"
450 "the Free Software Foundation; either version 3 of the License, or\n"
451 "(at your option) any later version.\n"
453 "%s is distributed in the hope that it will be useful,\n"
454 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
455 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
456 "GNU General Public License for more details.\n"
458 "You should have received a copy of the GNU General Public License\n"
459 "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
460 program_name, program_name, program_name
462 "%s is free software; you can redistribute it and/or modify\n"
463 "it under the terms of the GNU General Public License as published by\n"
464 "the Free Software Foundation; either version 2 of the License, or\n"
465 "(at your option) any later version.\n"
467 "%s is distributed in the hope that it will be useful,\n"
468 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
469 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
470 "GNU General Public License for more details.\n"
472 "You should have received a copy of the GNU General Public License\n"
473 "along with %s; if not, write to the Free Software\n"
474 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
475 program_name, program_name, program_name
477 "%s is free software; you can redistribute it and/or modify\n"
478 "it under the terms of the GNU Lesser General Public License as published by\n"
479 "the Free Software Foundation; either version 3 of the License, or\n"
480 "(at your option) any later version.\n"
482 "%s is distributed in the hope that it will be useful,\n"
483 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
484 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
485 "GNU Lesser General Public License for more details.\n"
487 "You should have received a copy of the GNU Lesser General Public License\n"
488 "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
489 program_name, program_name, program_name
491 "%s is free software; you can redistribute it and/or\n"
492 "modify it under the terms of the GNU Lesser General Public\n"
493 "License as published by the Free Software Foundation; either\n"
494 "version 2.1 of the License, or (at your option) any later version.\n"
496 "%s is distributed in the hope that it will be useful,\n"
497 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
498 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
499 "Lesser General Public License for more details.\n"
501 "You should have received a copy of the GNU Lesser General Public\n"
502 "License along with %s; if not, write to the Free Software\n"
503 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
504 program_name, program_name, program_name
509 void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
513 for (i=-1; i < nb_fmts; i++) {
514 get_fmt_string (fmt_str, sizeof(fmt_str), i);
515 fprintf(stdout, "%s\n", fmt_str);
519 void show_formats(void)
521 AVInputFormat *ifmt=NULL;
522 AVOutputFormat *ofmt=NULL;
523 const char *last_name;
527 " D. = Demuxing supported\n"
528 " .E = Muxing supported\n"
534 const char *name=NULL;
535 const char *long_name=NULL;
537 while((ofmt= av_oformat_next(ofmt))) {
538 if((name == NULL || strcmp(ofmt->name, name)<0) &&
539 strcmp(ofmt->name, last_name)>0){
541 long_name= ofmt->long_name;
545 while((ifmt= av_iformat_next(ifmt))) {
546 if((name == NULL || strcmp(ifmt->name, name)<0) &&
547 strcmp(ifmt->name, last_name)>0){
549 long_name= ifmt->long_name;
552 if(name && strcmp(ifmt->name, name)==0)
564 long_name ? long_name:" ");
568 void show_codecs(void)
570 AVCodec *p=NULL, *p2;
571 const char *last_name;
574 " D..... = Decoding supported\n"
575 " .E.... = Encoding supported\n"
576 " ..V... = Video codec\n"
577 " ..A... = Audio codec\n"
578 " ..S... = Subtitle codec\n"
579 " ...S.. = Supports draw_horiz_band\n"
580 " ....D. = Supports direct rendering method 1\n"
581 " .....T = Supports weird frame truncation\n"
588 const char *type_str;
591 while((p= av_codec_next(p))) {
592 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
593 strcmp(p->name, last_name)>0){
595 decode= encode= cap=0;
597 if(p2 && strcmp(p->name, p2->name)==0){
598 if(p->decode) decode=1;
599 if(p->encode) encode=1;
600 cap |= p->capabilities;
608 case AVMEDIA_TYPE_VIDEO:
611 case AVMEDIA_TYPE_AUDIO:
614 case AVMEDIA_TYPE_SUBTITLE:
622 " %s%s%s%s%s%s %-15s %s",
623 decode ? "D": (/*p2->decoder ? "d":*/" "),
626 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
627 cap & CODEC_CAP_DR1 ? "D":" ",
628 cap & CODEC_CAP_TRUNCATED ? "T":" ",
630 p2->long_name ? p2->long_name : "");
631 /* if(p2->decoder && decode==0)
632 printf(" use %s for decoding", p2->decoder->name);*/
637 "Note, the names of encoders and decoders do not always match, so there are\n"
638 "several cases where the above table shows encoder only or decoder only entries\n"
639 "even though both encoding and decoding are supported. For example, the h263\n"
640 "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
646 AVBitStreamFilter *bsf=NULL;
648 printf("Bitstream filters:\n");
649 while((bsf = av_bitstream_filter_next(bsf)))
650 printf("%s\n", bsf->name);
654 void show_protocols(void)
659 printf("Supported file protocols:\n"
661 while ((name = avio_enum_protocols(&opaque, 0)))
662 printf("%s\n", name);
664 while ((name = avio_enum_protocols(&opaque, 1)))
665 printf("%s\n", name);
668 void show_filters(void)
670 AVFilter av_unused(**filter) = NULL;
672 printf("Filters:\n");
674 while ((filter = av_filter_next(filter)) && *filter)
675 printf("%-16s %s\n", (*filter)->name, (*filter)->description);
679 void show_pix_fmts(void)
681 enum PixelFormat pix_fmt;
685 "I.... = Supported Input format for conversion\n"
686 ".O... = Supported Output format for conversion\n"
687 "..H.. = Hardware accelerated format\n"
688 "...P. = Paletted format\n"
689 "....B = Bitstream format\n"
690 "FLAGS NAME NB_COMPONENTS BITS_PER_PIXEL\n"
694 # define sws_isSupportedInput(x) 0
695 # define sws_isSupportedOutput(x) 0
698 for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {
699 const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[pix_fmt];
700 printf("%c%c%c%c%c %-16s %d %2d\n",
701 sws_isSupportedInput (pix_fmt) ? 'I' : '.',
702 sws_isSupportedOutput(pix_fmt) ? 'O' : '.',
703 pix_desc->flags & PIX_FMT_HWACCEL ? 'H' : '.',
704 pix_desc->flags & PIX_FMT_PAL ? 'P' : '.',
705 pix_desc->flags & PIX_FMT_BITSTREAM ? 'B' : '.',
707 pix_desc->nb_components,
708 av_get_bits_per_pixel(pix_desc));
715 int yesno = (toupper(c) == 'Y');
717 while (c != '\n' && c != EOF)
723 int read_file(const char *filename, char **bufptr, size_t *size)
725 FILE *f = fopen(filename, "rb");
728 fprintf(stderr, "Cannot read file '%s': %s\n", filename, strerror(errno));
729 return AVERROR(errno);
731 fseek(f, 0, SEEK_END);
733 fseek(f, 0, SEEK_SET);
734 *bufptr = av_malloc(*size + 1);
736 fprintf(stderr, "Could not allocate file buffer\n");
738 return AVERROR(ENOMEM);
740 fread(*bufptr, 1, *size, f);
741 (*bufptr)[*size++] = '\0';
747 void init_pts_correction(PtsCorrectionContext *ctx)
749 ctx->num_faulty_pts = ctx->num_faulty_dts = 0;
750 ctx->last_pts = ctx->last_dts = INT64_MIN;
753 int64_t guess_correct_pts(PtsCorrectionContext *ctx, int64_t reordered_pts, int64_t dts)
755 int64_t pts = AV_NOPTS_VALUE;
757 if (dts != AV_NOPTS_VALUE) {
758 ctx->num_faulty_dts += dts <= ctx->last_dts;
761 if (reordered_pts != AV_NOPTS_VALUE) {
762 ctx->num_faulty_pts += reordered_pts <= ctx->last_pts;
763 ctx->last_pts = reordered_pts;
765 if ((ctx->num_faulty_pts<=ctx->num_faulty_dts || dts == AV_NOPTS_VALUE)
766 && reordered_pts != AV_NOPTS_VALUE)
774 FILE *get_preset_file(char *filename, size_t filename_size,
775 const char *preset_name, int is_path, const char *codec_name)
779 const char *base[3]= { getenv("FFMPEG_DATADIR"),
785 av_strlcpy(filename, preset_name, filename_size);
786 f = fopen(filename, "r");
788 for (i = 0; i < 3 && !f; i++) {
791 snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", preset_name);
792 f = fopen(filename, "r");
793 if (!f && codec_name) {
794 snprintf(filename, filename_size,
795 "%s%s/%s-%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", codec_name, preset_name);
796 f = fopen(filename, "r");
806 static int ffsink_init(AVFilterContext *ctx, const char *args, void *opaque)
808 FFSinkContext *priv = ctx->priv;
811 return AVERROR(EINVAL);
812 *priv = *(FFSinkContext *)opaque;
817 static void null_end_frame(AVFilterLink *inlink) { }
819 static int ffsink_query_formats(AVFilterContext *ctx)
821 FFSinkContext *priv = ctx->priv;
822 enum PixelFormat pix_fmts[] = { priv->pix_fmt, PIX_FMT_NONE };
824 avfilter_set_common_formats(ctx, avfilter_make_format_list(pix_fmts));
830 .priv_size = sizeof(FFSinkContext),
833 .query_formats = ffsink_query_formats,
835 .inputs = (AVFilterPad[]) {{ .name = "default",
836 .type = AVMEDIA_TYPE_VIDEO,
837 .end_frame = null_end_frame,
838 .min_perms = AV_PERM_READ, },
840 .outputs = (AVFilterPad[]) {{ .name = NULL }},
843 int get_filtered_video_frame(AVFilterContext *ctx, AVFrame *frame,
844 AVFilterBufferRef **picref_ptr, AVRational *tb)
847 AVFilterBufferRef *picref;
849 if ((ret = avfilter_request_frame(ctx->inputs[0])) < 0)
851 if (!(picref = ctx->inputs[0]->cur_buf))
852 return AVERROR(ENOENT);
853 *picref_ptr = picref;
854 ctx->inputs[0]->cur_buf = NULL;
855 *tb = ctx->inputs[0]->time_base;
857 memcpy(frame->data, picref->data, sizeof(frame->data));
858 memcpy(frame->linesize, picref->linesize, sizeof(frame->linesize));
859 frame->interlaced_frame = picref->video->interlaced;
860 frame->top_field_first = picref->video->top_field_first;
865 #endif /* CONFIG_AVFILTER */