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/dict.h"
42 #include "libavutil/opt.h"
46 #include "libavformat/network.h"
48 #if HAVE_SYS_RESOURCE_H
49 #include <sys/resource.h>
52 AVCodecContext *avcodec_opts[AVMEDIA_TYPE_NB];
53 AVFormatContext *avformat_opts;
54 struct SwsContext *sws_opts;
55 AVDictionary *format_opts, *codec_opts;
57 static const int this_year = 2011;
62 for (i = 0; i < AVMEDIA_TYPE_NB; i++)
63 avcodec_opts[i] = avcodec_alloc_context3(NULL);
64 avformat_opts = avformat_alloc_context();
66 sws_opts = sws_getContext(16, 16, 0, 16, 16, 0, SWS_BICUBIC, NULL, NULL, NULL);
70 void uninit_opts(void)
73 for (i = 0; i < AVMEDIA_TYPE_NB; i++)
74 av_freep(&avcodec_opts[i]);
75 av_freep(&avformat_opts->key);
76 av_freep(&avformat_opts);
78 sws_freeContext(sws_opts);
81 av_dict_free(&format_opts);
82 av_dict_free(&codec_opts);
85 void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
87 vfprintf(stdout, fmt, vl);
90 double parse_number_or_die(const char *context, const char *numstr, int type, double min, double max)
94 double d = av_strtod(numstr, &tail);
96 error= "Expected number for %s but found: %s\n";
97 else if (d < min || d > max)
98 error= "The value for %s was %s which is not within %f - %f\n";
99 else if(type == OPT_INT64 && (int64_t)d != d)
100 error= "Expected int64 for %s but found %s\n";
101 else if (type == OPT_INT && (int)d != d)
102 error= "Expected int for %s but found %s\n";
105 fprintf(stderr, error, context, numstr, min, max);
109 int64_t parse_time_or_die(const char *context, const char *timestr, int is_duration)
112 if (av_parse_time(&us, timestr, is_duration) < 0) {
113 fprintf(stderr, "Invalid %s specification for %s: %s\n",
114 is_duration ? "duration" : "date", context, timestr);
120 void show_help_options(const OptionDef *options, const char *msg, int mask, int value)
126 for(po = options; po->name != NULL; po++) {
128 if ((po->flags & mask) == value) {
133 av_strlcpy(buf, po->name, sizeof(buf));
134 if (po->flags & HAS_ARG) {
135 av_strlcat(buf, " ", sizeof(buf));
136 av_strlcat(buf, po->argname, sizeof(buf));
138 printf("-%-17s %s\n", buf, po->help);
143 static const OptionDef* find_option(const OptionDef *po, const char *name){
144 while (po->name != NULL) {
145 if (!strcmp(name, po->name))
152 #if defined(_WIN32) && !defined(__MINGW32CE__)
154 /* Will be leaked on exit */
155 static char** win32_argv_utf8 = NULL;
156 static int win32_argc = 0;
159 * Prepare command line arguments for executable.
160 * For Windows - perform wide-char to UTF-8 conversion.
161 * Input arguments should be main() function arguments.
162 * @param argc_ptr Arguments number (including executable)
163 * @param argv_ptr Arguments list.
165 static void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
169 int i, buffsize = 0, offset = 0;
171 if (win32_argv_utf8) {
172 *argc_ptr = win32_argc;
173 *argv_ptr = win32_argv_utf8;
178 argv_w = CommandLineToArgvW(GetCommandLineW(), &win32_argc);
179 if (win32_argc <= 0 || !argv_w)
182 /* determine the UTF-8 buffer size (including NULL-termination symbols) */
183 for (i = 0; i < win32_argc; i++)
184 buffsize += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
185 NULL, 0, NULL, NULL);
187 win32_argv_utf8 = av_mallocz(sizeof(char*) * (win32_argc + 1) + buffsize);
188 argstr_flat = (char*)win32_argv_utf8 + sizeof(char*) * (win32_argc + 1);
189 if (win32_argv_utf8 == NULL) {
194 for (i = 0; i < win32_argc; i++) {
195 win32_argv_utf8[i] = &argstr_flat[offset];
196 offset += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
197 &argstr_flat[offset],
198 buffsize - offset, NULL, NULL);
200 win32_argv_utf8[i] = NULL;
203 *argc_ptr = win32_argc;
204 *argv_ptr = win32_argv_utf8;
207 static inline void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
211 #endif /* WIN32 && !__MINGW32CE__ */
213 void parse_options(int argc, char **argv, const OptionDef *options,
214 void (* parse_arg_function)(const char*))
216 const char *opt, *arg;
217 int optindex, handleoptions=1;
220 /* perform system-dependent conversions for arguments list */
221 prepare_app_arguments(&argc, &argv);
225 while (optindex < argc) {
226 opt = argv[optindex++];
228 if (handleoptions && opt[0] == '-' && opt[1] != '\0') {
230 if (opt[1] == '-' && opt[2] == '\0') {
235 po= find_option(options, opt);
236 if (!po->name && opt[0] == 'n' && opt[1] == 'o') {
237 /* handle 'no' bool option */
238 po = find_option(options, opt + 2);
239 if (!(po->name && (po->flags & OPT_BOOL)))
244 po= find_option(options, "default");
247 fprintf(stderr, "%s: unrecognized option '%s'\n", argv[0], opt);
251 if (po->flags & HAS_ARG) {
252 arg = argv[optindex++];
254 fprintf(stderr, "%s: missing argument for option '%s'\n", argv[0], opt);
258 if (po->flags & OPT_STRING) {
260 str = av_strdup(arg);
261 *po->u.str_arg = str;
262 } else if (po->flags & OPT_BOOL) {
263 *po->u.int_arg = bool_val;
264 } else if (po->flags & OPT_INT) {
265 *po->u.int_arg = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
266 } else if (po->flags & OPT_INT64) {
267 *po->u.int64_arg = parse_number_or_die(opt, arg, OPT_INT64, INT64_MIN, INT64_MAX);
268 } else if (po->flags & OPT_FLOAT) {
269 *po->u.float_arg = parse_number_or_die(opt, arg, OPT_FLOAT, -INFINITY, INFINITY);
270 } else if (po->u.func_arg) {
271 if (po->u.func_arg(opt, arg) < 0) {
272 fprintf(stderr, "%s: failed to set value '%s' for option '%s'\n", argv[0], arg, opt);
276 if(po->flags & OPT_EXIT)
279 if (parse_arg_function)
280 parse_arg_function(opt);
285 #define FLAGS (o->type == FF_OPT_TYPE_FLAGS) ? AV_DICT_APPEND : 0
286 int opt_default(const char *opt, const char *arg)
289 if ((o = av_opt_find(avcodec_opts[0], opt, NULL, 0, AV_OPT_SEARCH_CHILDREN)) ||
290 ((opt[0] == 'v' || opt[0] == 'a' || opt[0] == 's') &&
291 (o = av_opt_find(avcodec_opts[0], opt+1, NULL, 0, 0))))
292 av_dict_set(&codec_opts, opt, arg, FLAGS);
293 else if ((o = av_opt_find(avformat_opts, opt, NULL, 0, AV_OPT_SEARCH_CHILDREN)))
294 av_dict_set(&format_opts, opt, arg, FLAGS);
295 else if ((o = av_opt_find(sws_opts, opt, NULL, 0, AV_OPT_SEARCH_CHILDREN))) {
296 // XXX we only support sws_flags, not arbitrary sws options
297 int ret = av_set_string3(sws_opts, opt, arg, 1, NULL);
299 av_log(NULL, AV_LOG_ERROR, "Error setting option %s.\n", opt);
306 fprintf(stderr, "Unrecognized option '%s'\n", opt);
307 return AVERROR_OPTION_NOT_FOUND;
310 int opt_loglevel(const char *opt, const char *arg)
312 const struct { const char *name; int level; } log_levels[] = {
313 { "quiet" , AV_LOG_QUIET },
314 { "panic" , AV_LOG_PANIC },
315 { "fatal" , AV_LOG_FATAL },
316 { "error" , AV_LOG_ERROR },
317 { "warning", AV_LOG_WARNING },
318 { "info" , AV_LOG_INFO },
319 { "verbose", AV_LOG_VERBOSE },
320 { "debug" , AV_LOG_DEBUG },
326 for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
327 if (!strcmp(log_levels[i].name, arg)) {
328 av_log_set_level(log_levels[i].level);
333 level = strtol(arg, &tail, 10);
335 fprintf(stderr, "Invalid loglevel \"%s\". "
336 "Possible levels are numbers or:\n", arg);
337 for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
338 fprintf(stderr, "\"%s\"\n", log_levels[i].name);
341 av_log_set_level(level);
345 int opt_timelimit(const char *opt, const char *arg)
348 int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
349 struct rlimit rl = { lim, lim + 1 };
350 if (setrlimit(RLIMIT_CPU, &rl))
353 fprintf(stderr, "Warning: -%s not implemented on this OS\n", opt);
358 void print_error(const char *filename, int err)
361 const char *errbuf_ptr = errbuf;
363 if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
364 errbuf_ptr = strerror(AVUNERROR(err));
365 fprintf(stderr, "%s: %s\n", filename, errbuf_ptr);
368 static int warned_cfg = 0;
371 #define SHOW_VERSION 2
372 #define SHOW_CONFIG 4
374 #define PRINT_LIB_INFO(outstream,libname,LIBNAME,flags) \
375 if (CONFIG_##LIBNAME) { \
376 const char *indent = flags & INDENT? " " : ""; \
377 if (flags & SHOW_VERSION) { \
378 unsigned int version = libname##_version(); \
379 fprintf(outstream, "%slib%-9s %2d.%3d.%2d / %2d.%3d.%2d\n", \
381 LIB##LIBNAME##_VERSION_MAJOR, \
382 LIB##LIBNAME##_VERSION_MINOR, \
383 LIB##LIBNAME##_VERSION_MICRO, \
384 version >> 16, version >> 8 & 0xff, version & 0xff); \
386 if (flags & SHOW_CONFIG) { \
387 const char *cfg = libname##_configuration(); \
388 if (strcmp(LIBAV_CONFIGURATION, cfg)) { \
391 "%sWARNING: library configuration mismatch\n", \
395 fprintf(stderr, "%s%-11s configuration: %s\n", \
396 indent, #libname, cfg); \
401 static void print_all_libs_info(FILE* outstream, int flags)
403 PRINT_LIB_INFO(outstream, avutil, AVUTIL, flags);
404 PRINT_LIB_INFO(outstream, avcodec, AVCODEC, flags);
405 PRINT_LIB_INFO(outstream, avformat, AVFORMAT, flags);
406 PRINT_LIB_INFO(outstream, avdevice, AVDEVICE, flags);
407 PRINT_LIB_INFO(outstream, avfilter, AVFILTER, flags);
408 PRINT_LIB_INFO(outstream, swscale, SWSCALE, flags);
409 PRINT_LIB_INFO(outstream, postproc, POSTPROC, flags);
412 void show_banner(void)
414 fprintf(stderr, "%s version " LIBAV_VERSION ", Copyright (c) %d-%d the Libav developers\n",
415 program_name, program_birth_year, this_year);
416 fprintf(stderr, " built on %s %s with %s %s\n",
417 __DATE__, __TIME__, CC_TYPE, CC_VERSION);
418 fprintf(stderr, " configuration: " LIBAV_CONFIGURATION "\n");
419 print_all_libs_info(stderr, INDENT|SHOW_CONFIG);
420 print_all_libs_info(stderr, INDENT|SHOW_VERSION);
423 void show_version(void) {
424 printf("%s " LIBAV_VERSION "\n", program_name);
425 print_all_libs_info(stdout, SHOW_VERSION);
428 void show_license(void)
432 "This version of %s has nonfree parts compiled in.\n"
433 "Therefore it is not legally redistributable.\n",
436 "%s is free software; you can redistribute it and/or modify\n"
437 "it under the terms of the GNU General Public License as published by\n"
438 "the Free Software Foundation; either version 3 of the License, or\n"
439 "(at your option) any later version.\n"
441 "%s is distributed in the hope that it will be useful,\n"
442 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
443 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
444 "GNU General Public License for more details.\n"
446 "You should have received a copy of the GNU General Public License\n"
447 "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
448 program_name, program_name, program_name
450 "%s is free software; you can redistribute it and/or modify\n"
451 "it under the terms of the GNU General Public License as published by\n"
452 "the Free Software Foundation; either version 2 of the License, or\n"
453 "(at your option) any later version.\n"
455 "%s is distributed in the hope that it will be useful,\n"
456 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
457 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
458 "GNU General Public License for more details.\n"
460 "You should have received a copy of the GNU General Public License\n"
461 "along with %s; if not, write to the Free Software\n"
462 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
463 program_name, program_name, program_name
465 "%s is free software; you can redistribute it and/or modify\n"
466 "it under the terms of the GNU Lesser General Public License as published by\n"
467 "the Free Software Foundation; either version 3 of the License, or\n"
468 "(at your option) any later version.\n"
470 "%s is distributed in the hope that it will be useful,\n"
471 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
472 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
473 "GNU Lesser General Public License for more details.\n"
475 "You should have received a copy of the GNU Lesser General Public License\n"
476 "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
477 program_name, program_name, program_name
479 "%s is free software; you can redistribute it and/or\n"
480 "modify it under the terms of the GNU Lesser General Public\n"
481 "License as published by the Free Software Foundation; either\n"
482 "version 2.1 of the License, or (at your option) any later version.\n"
484 "%s is distributed in the hope that it will be useful,\n"
485 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
486 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
487 "Lesser General Public License for more details.\n"
489 "You should have received a copy of the GNU Lesser General Public\n"
490 "License along with %s; if not, write to the Free Software\n"
491 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
492 program_name, program_name, program_name
497 void show_formats(void)
499 AVInputFormat *ifmt=NULL;
500 AVOutputFormat *ofmt=NULL;
501 const char *last_name;
505 " D. = Demuxing supported\n"
506 " .E = Muxing supported\n"
512 const char *name=NULL;
513 const char *long_name=NULL;
515 while((ofmt= av_oformat_next(ofmt))) {
516 if((name == NULL || strcmp(ofmt->name, name)<0) &&
517 strcmp(ofmt->name, last_name)>0){
519 long_name= ofmt->long_name;
523 while((ifmt= av_iformat_next(ifmt))) {
524 if((name == NULL || strcmp(ifmt->name, name)<0) &&
525 strcmp(ifmt->name, last_name)>0){
527 long_name= ifmt->long_name;
530 if(name && strcmp(ifmt->name, name)==0)
542 long_name ? long_name:" ");
546 void show_codecs(void)
548 AVCodec *p=NULL, *p2;
549 const char *last_name;
552 " D..... = Decoding supported\n"
553 " .E.... = Encoding supported\n"
554 " ..V... = Video codec\n"
555 " ..A... = Audio codec\n"
556 " ..S... = Subtitle codec\n"
557 " ...S.. = Supports draw_horiz_band\n"
558 " ....D. = Supports direct rendering method 1\n"
559 " .....T = Supports weird frame truncation\n"
566 const char *type_str;
569 while((p= av_codec_next(p))) {
570 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
571 strcmp(p->name, last_name)>0){
573 decode= encode= cap=0;
575 if(p2 && strcmp(p->name, p2->name)==0){
576 if(p->decode) decode=1;
577 if(p->encode) encode=1;
578 cap |= p->capabilities;
586 case AVMEDIA_TYPE_VIDEO:
589 case AVMEDIA_TYPE_AUDIO:
592 case AVMEDIA_TYPE_SUBTITLE:
600 " %s%s%s%s%s%s %-15s %s",
601 decode ? "D": (/*p2->decoder ? "d":*/" "),
604 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
605 cap & CODEC_CAP_DR1 ? "D":" ",
606 cap & CODEC_CAP_TRUNCATED ? "T":" ",
608 p2->long_name ? p2->long_name : "");
609 /* if(p2->decoder && decode==0)
610 printf(" use %s for decoding", p2->decoder->name);*/
615 "Note, the names of encoders and decoders do not always match, so there are\n"
616 "several cases where the above table shows encoder only or decoder only entries\n"
617 "even though both encoding and decoding are supported. For example, the h263\n"
618 "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
624 AVBitStreamFilter *bsf=NULL;
626 printf("Bitstream filters:\n");
627 while((bsf = av_bitstream_filter_next(bsf)))
628 printf("%s\n", bsf->name);
632 void show_protocols(void)
637 printf("Supported file protocols:\n"
639 while ((name = avio_enum_protocols(&opaque, 0)))
640 printf("%s\n", name);
642 while ((name = avio_enum_protocols(&opaque, 1)))
643 printf("%s\n", name);
646 void show_filters(void)
648 AVFilter av_unused(**filter) = NULL;
650 printf("Filters:\n");
652 while ((filter = av_filter_next(filter)) && *filter)
653 printf("%-16s %s\n", (*filter)->name, (*filter)->description);
657 void show_pix_fmts(void)
659 enum PixelFormat pix_fmt;
663 "I.... = Supported Input format for conversion\n"
664 ".O... = Supported Output format for conversion\n"
665 "..H.. = Hardware accelerated format\n"
666 "...P. = Paletted format\n"
667 "....B = Bitstream format\n"
668 "FLAGS NAME NB_COMPONENTS BITS_PER_PIXEL\n"
672 # define sws_isSupportedInput(x) 0
673 # define sws_isSupportedOutput(x) 0
676 for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {
677 const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[pix_fmt];
678 printf("%c%c%c%c%c %-16s %d %2d\n",
679 sws_isSupportedInput (pix_fmt) ? 'I' : '.',
680 sws_isSupportedOutput(pix_fmt) ? 'O' : '.',
681 pix_desc->flags & PIX_FMT_HWACCEL ? 'H' : '.',
682 pix_desc->flags & PIX_FMT_PAL ? 'P' : '.',
683 pix_desc->flags & PIX_FMT_BITSTREAM ? 'B' : '.',
685 pix_desc->nb_components,
686 av_get_bits_per_pixel(pix_desc));
693 int yesno = (toupper(c) == 'Y');
695 while (c != '\n' && c != EOF)
701 int read_file(const char *filename, char **bufptr, size_t *size)
703 FILE *f = fopen(filename, "rb");
706 fprintf(stderr, "Cannot read file '%s': %s\n", filename, strerror(errno));
707 return AVERROR(errno);
709 fseek(f, 0, SEEK_END);
711 fseek(f, 0, SEEK_SET);
712 *bufptr = av_malloc(*size + 1);
714 fprintf(stderr, "Could not allocate file buffer\n");
716 return AVERROR(ENOMEM);
718 fread(*bufptr, 1, *size, f);
719 (*bufptr)[*size++] = '\0';
725 void init_pts_correction(PtsCorrectionContext *ctx)
727 ctx->num_faulty_pts = ctx->num_faulty_dts = 0;
728 ctx->last_pts = ctx->last_dts = INT64_MIN;
731 int64_t guess_correct_pts(PtsCorrectionContext *ctx, int64_t reordered_pts, int64_t dts)
733 int64_t pts = AV_NOPTS_VALUE;
735 if (dts != AV_NOPTS_VALUE) {
736 ctx->num_faulty_dts += dts <= ctx->last_dts;
739 if (reordered_pts != AV_NOPTS_VALUE) {
740 ctx->num_faulty_pts += reordered_pts <= ctx->last_pts;
741 ctx->last_pts = reordered_pts;
743 if ((ctx->num_faulty_pts<=ctx->num_faulty_dts || dts == AV_NOPTS_VALUE)
744 && reordered_pts != AV_NOPTS_VALUE)
752 FILE *get_preset_file(char *filename, size_t filename_size,
753 const char *preset_name, int is_path, const char *codec_name)
757 const char *base[3]= { getenv("AVCONV_DATADIR"),
763 av_strlcpy(filename, preset_name, filename_size);
764 f = fopen(filename, "r");
766 for (i = 0; i < 3 && !f; i++) {
769 snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.avconv", preset_name);
770 f = fopen(filename, "r");
771 if (!f && codec_name) {
772 snprintf(filename, filename_size,
773 "%s%s/%s-%s.ffpreset", base[i], i != 1 ? "" : "/.avconv", codec_name, preset_name);
774 f = fopen(filename, "r");
782 AVDictionary *filter_codec_opts(AVDictionary *opts, enum CodecID codec_id, int encoder)
784 AVDictionary *ret = NULL;
785 AVDictionaryEntry *t = NULL;
786 AVCodec *codec = encoder ? avcodec_find_encoder(codec_id) : avcodec_find_decoder(codec_id);
787 int flags = encoder ? AV_OPT_FLAG_ENCODING_PARAM : AV_OPT_FLAG_DECODING_PARAM;
793 switch (codec->type) {
794 case AVMEDIA_TYPE_VIDEO: prefix = 'v'; flags |= AV_OPT_FLAG_VIDEO_PARAM; break;
795 case AVMEDIA_TYPE_AUDIO: prefix = 'a'; flags |= AV_OPT_FLAG_AUDIO_PARAM; break;
796 case AVMEDIA_TYPE_SUBTITLE: prefix = 's'; flags |= AV_OPT_FLAG_SUBTITLE_PARAM; break;
799 while (t = av_dict_get(opts, "", t, AV_DICT_IGNORE_SUFFIX)) {
800 if (av_opt_find(avcodec_opts[0], t->key, NULL, flags, 0) ||
801 (codec && codec->priv_class && av_opt_find(&codec->priv_class, t->key, NULL, flags, 0)))
802 av_dict_set(&ret, t->key, t->value, 0);
803 else if (t->key[0] == prefix && av_opt_find(avcodec_opts[0], t->key+1, NULL, flags, 0))
804 av_dict_set(&ret, t->key+1, t->value, 0);
809 AVDictionary **setup_find_stream_info_opts(AVFormatContext *s, AVDictionary *codec_opts)
816 opts = av_mallocz(s->nb_streams * sizeof(*opts));
818 av_log(NULL, AV_LOG_ERROR, "Could not alloc memory for stream options.\n");
821 for (i = 0; i < s->nb_streams; i++)
822 opts[i] = filter_codec_opts(codec_opts, s->streams[i]->codec->codec_id, 0);
828 static int ffsink_init(AVFilterContext *ctx, const char *args, void *opaque)
830 FFSinkContext *priv = ctx->priv;
833 return AVERROR(EINVAL);
834 *priv = *(FFSinkContext *)opaque;
839 static void null_end_frame(AVFilterLink *inlink) { }
841 static int ffsink_query_formats(AVFilterContext *ctx)
843 FFSinkContext *priv = ctx->priv;
844 enum PixelFormat pix_fmts[] = { priv->pix_fmt, PIX_FMT_NONE };
846 avfilter_set_common_formats(ctx, avfilter_make_format_list(pix_fmts));
852 .priv_size = sizeof(FFSinkContext),
855 .query_formats = ffsink_query_formats,
857 .inputs = (AVFilterPad[]) {{ .name = "default",
858 .type = AVMEDIA_TYPE_VIDEO,
859 .end_frame = null_end_frame,
860 .min_perms = AV_PERM_READ, },
862 .outputs = (AVFilterPad[]) {{ .name = NULL }},
865 int get_filtered_video_frame(AVFilterContext *ctx, AVFrame *frame,
866 AVFilterBufferRef **picref_ptr, AVRational *tb)
869 AVFilterBufferRef *picref;
871 if ((ret = avfilter_request_frame(ctx->inputs[0])) < 0)
873 if (!(picref = ctx->inputs[0]->cur_buf))
874 return AVERROR(ENOENT);
875 *picref_ptr = picref;
876 ctx->inputs[0]->cur_buf = NULL;
877 *tb = ctx->inputs[0]->time_base;
879 memcpy(frame->data, picref->data, sizeof(frame->data));
880 memcpy(frame->linesize, picref->linesize, sizeof(frame->linesize));
881 frame->interlaced_frame = picref->video->interlaced;
882 frame->top_field_first = picref->video->top_field_first;
883 frame->key_frame = picref->video->key_frame;
884 frame->pict_type = picref->video->pict_type;
889 #endif /* CONFIG_AVFILTER */