2 * Various utilities for command line tools
3 * Copyright (c) 2000-2003 Fabrice Bellard
5 * This file is part of FFmpeg.
7 * FFmpeg 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 * FFmpeg 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 FFmpeg; 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 "libavcodec/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(FFMPEG_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 " FFMPEG_VERSION ", Copyright (c) %d-%d the FFmpeg 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: " FFMPEG_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 " FFMPEG_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)
656 URLProtocol *up=NULL;
658 printf("Supported file protocols:\n"
659 "I.. = Input supported\n"
660 ".O. = Output supported\n"
661 "..S = Seek supported\n"
664 while((up = av_protocol_next(up)))
665 printf("%c%c%c %s\n",
666 up->url_read ? 'I' : '.',
667 up->url_write ? 'O' : '.',
668 up->url_seek ? 'S' : '.',
672 void show_filters(void)
674 AVFilter av_unused(**filter) = NULL;
676 printf("Filters:\n");
678 while ((filter = av_filter_next(filter)) && *filter)
679 printf("%-16s %s\n", (*filter)->name, (*filter)->description);
683 void show_pix_fmts(void)
685 enum PixelFormat pix_fmt;
689 "I.... = Supported Input format for conversion\n"
690 ".O... = Supported Output format for conversion\n"
691 "..H.. = Hardware accelerated format\n"
692 "...P. = Paletted format\n"
693 "....B = Bitstream format\n"
694 "FLAGS NAME NB_COMPONENTS BITS_PER_PIXEL\n"
698 # define sws_isSupportedInput(x) 0
699 # define sws_isSupportedOutput(x) 0
702 for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {
703 const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[pix_fmt];
704 printf("%c%c%c%c%c %-16s %d %2d\n",
705 sws_isSupportedInput (pix_fmt) ? 'I' : '.',
706 sws_isSupportedOutput(pix_fmt) ? 'O' : '.',
707 pix_desc->flags & PIX_FMT_HWACCEL ? 'H' : '.',
708 pix_desc->flags & PIX_FMT_PAL ? 'P' : '.',
709 pix_desc->flags & PIX_FMT_BITSTREAM ? 'B' : '.',
711 pix_desc->nb_components,
712 av_get_bits_per_pixel(pix_desc));
719 int yesno = (toupper(c) == 'Y');
721 while (c != '\n' && c != EOF)
727 int read_file(const char *filename, char **bufptr, size_t *size)
729 FILE *f = fopen(filename, "rb");
732 fprintf(stderr, "Cannot read file '%s': %s\n", filename, strerror(errno));
733 return AVERROR(errno);
735 fseek(f, 0, SEEK_END);
737 fseek(f, 0, SEEK_SET);
738 *bufptr = av_malloc(*size + 1);
740 fprintf(stderr, "Could not allocate file buffer\n");
742 return AVERROR(ENOMEM);
744 fread(*bufptr, 1, *size, f);
745 (*bufptr)[*size++] = '\0';
751 FILE *get_preset_file(char *filename, size_t filename_size,
752 const char *preset_name, int is_path, const char *codec_name)
756 const char *base[3]= { getenv("FFMPEG_DATADIR"),
762 av_strlcpy(filename, preset_name, filename_size);
763 f = fopen(filename, "r");
765 for (i = 0; i < 3 && !f; i++) {
768 snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", preset_name);
769 f = fopen(filename, "r");
770 if (!f && codec_name) {
771 snprintf(filename, filename_size,
772 "%s%s/%s-%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", codec_name, preset_name);
773 f = fopen(filename, "r");
783 static int ffsink_init(AVFilterContext *ctx, const char *args, void *opaque)
785 FFSinkContext *priv = ctx->priv;
788 return AVERROR(EINVAL);
789 *priv = *(FFSinkContext *)opaque;
794 static void null_end_frame(AVFilterLink *inlink) { }
796 static int ffsink_query_formats(AVFilterContext *ctx)
798 FFSinkContext *priv = ctx->priv;
799 enum PixelFormat pix_fmts[] = { priv->pix_fmt, PIX_FMT_NONE };
801 avfilter_set_common_formats(ctx, avfilter_make_format_list(pix_fmts));
807 .priv_size = sizeof(FFSinkContext),
810 .query_formats = ffsink_query_formats,
812 .inputs = (AVFilterPad[]) {{ .name = "default",
813 .type = AVMEDIA_TYPE_VIDEO,
814 .end_frame = null_end_frame,
815 .min_perms = AV_PERM_READ, },
817 .outputs = (AVFilterPad[]) {{ .name = NULL }},
820 int get_filtered_video_frame(AVFilterContext *ctx, AVFrame *frame,
821 AVFilterBufferRef **picref_ptr, AVRational *tb)
824 AVFilterBufferRef *picref;
826 if ((ret = avfilter_request_frame(ctx->inputs[0])) < 0)
828 if (!(picref = ctx->inputs[0]->cur_buf))
829 return AVERROR(ENOENT);
830 *picref_ptr = picref;
831 ctx->inputs[0]->cur_buf = NULL;
832 *tb = ctx->inputs[0]->time_base;
834 memcpy(frame->data, picref->data, sizeof(frame->data));
835 memcpy(frame->linesize, picref->linesize, sizeof(frame->linesize));
836 frame->interlaced_frame = picref->video->interlaced;
837 frame->top_field_first = picref->video->top_field_first;
842 #endif /* CONFIG_AVFILTER */