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 "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 int (* parse_arg_function)(const char *opt, const char *arg))
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 ? arg : "[null]", opt);
276 if(po->flags & OPT_EXIT)
279 if (parse_arg_function) {
280 if (parse_arg_function(NULL, opt) < 0)
287 #define FLAGS (o->type == FF_OPT_TYPE_FLAGS) ? AV_DICT_APPEND : 0
288 int opt_default(const char *opt, const char *arg)
291 if ((o = av_opt_find(avcodec_opts[0], opt, NULL, 0, AV_OPT_SEARCH_CHILDREN)) ||
292 ((opt[0] == 'v' || opt[0] == 'a' || opt[0] == 's') &&
293 (o = av_opt_find(avcodec_opts[0], opt+1, NULL, 0, 0))))
294 av_dict_set(&codec_opts, opt, arg, FLAGS);
295 else if ((o = av_opt_find(avformat_opts, opt, NULL, 0, AV_OPT_SEARCH_CHILDREN)))
296 av_dict_set(&format_opts, opt, arg, FLAGS);
297 else if ((o = av_opt_find(sws_opts, opt, NULL, 0, AV_OPT_SEARCH_CHILDREN))) {
298 // XXX we only support sws_flags, not arbitrary sws options
299 int ret = av_set_string3(sws_opts, opt, arg, 1, NULL);
301 av_log(NULL, AV_LOG_ERROR, "Error setting option %s.\n", opt);
308 fprintf(stderr, "Unrecognized option '%s'\n", opt);
309 return AVERROR_OPTION_NOT_FOUND;
312 int opt_loglevel(const char *opt, const char *arg)
314 const struct { const char *name; int level; } log_levels[] = {
315 { "quiet" , AV_LOG_QUIET },
316 { "panic" , AV_LOG_PANIC },
317 { "fatal" , AV_LOG_FATAL },
318 { "error" , AV_LOG_ERROR },
319 { "warning", AV_LOG_WARNING },
320 { "info" , AV_LOG_INFO },
321 { "verbose", AV_LOG_VERBOSE },
322 { "debug" , AV_LOG_DEBUG },
328 for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
329 if (!strcmp(log_levels[i].name, arg)) {
330 av_log_set_level(log_levels[i].level);
335 level = strtol(arg, &tail, 10);
337 fprintf(stderr, "Invalid loglevel \"%s\". "
338 "Possible levels are numbers or:\n", arg);
339 for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
340 fprintf(stderr, "\"%s\"\n", log_levels[i].name);
343 av_log_set_level(level);
347 int opt_timelimit(const char *opt, const char *arg)
350 int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
351 struct rlimit rl = { lim, lim + 1 };
352 if (setrlimit(RLIMIT_CPU, &rl))
355 fprintf(stderr, "Warning: -%s not implemented on this OS\n", opt);
360 void print_error(const char *filename, int err)
363 const char *errbuf_ptr = errbuf;
365 if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
366 errbuf_ptr = strerror(AVUNERROR(err));
367 fprintf(stderr, "%s: %s\n", filename, errbuf_ptr);
370 static int warned_cfg = 0;
373 #define SHOW_VERSION 2
374 #define SHOW_CONFIG 4
376 #define PRINT_LIB_INFO(outstream,libname,LIBNAME,flags) \
377 if (CONFIG_##LIBNAME) { \
378 const char *indent = flags & INDENT? " " : ""; \
379 if (flags & SHOW_VERSION) { \
380 unsigned int version = libname##_version(); \
381 fprintf(outstream, "%slib%-9s %2d.%3d.%2d / %2d.%3d.%2d\n", \
383 LIB##LIBNAME##_VERSION_MAJOR, \
384 LIB##LIBNAME##_VERSION_MINOR, \
385 LIB##LIBNAME##_VERSION_MICRO, \
386 version >> 16, version >> 8 & 0xff, version & 0xff); \
388 if (flags & SHOW_CONFIG) { \
389 const char *cfg = libname##_configuration(); \
390 if (strcmp(FFMPEG_CONFIGURATION, cfg)) { \
393 "%sWARNING: library configuration mismatch\n", \
397 fprintf(stderr, "%s%-11s configuration: %s\n", \
398 indent, #libname, cfg); \
403 static void print_all_libs_info(FILE* outstream, int flags)
405 PRINT_LIB_INFO(outstream, avutil, AVUTIL, flags);
406 PRINT_LIB_INFO(outstream, avcodec, AVCODEC, flags);
407 PRINT_LIB_INFO(outstream, avformat, AVFORMAT, flags);
408 PRINT_LIB_INFO(outstream, avdevice, AVDEVICE, flags);
409 PRINT_LIB_INFO(outstream, avfilter, AVFILTER, flags);
410 PRINT_LIB_INFO(outstream, swscale, SWSCALE, flags);
411 PRINT_LIB_INFO(outstream, postproc, POSTPROC, flags);
414 void show_banner(void)
416 fprintf(stderr, "%s version " FFMPEG_VERSION ", Copyright (c) %d-%d the FFmpeg developers\n",
417 program_name, program_birth_year, this_year);
418 fprintf(stderr, " built on %s %s with %s %s\n",
419 __DATE__, __TIME__, CC_TYPE, CC_VERSION);
420 fprintf(stderr, " configuration: " FFMPEG_CONFIGURATION "\n");
421 print_all_libs_info(stderr, INDENT|SHOW_CONFIG);
422 print_all_libs_info(stderr, INDENT|SHOW_VERSION);
425 int opt_version(const char *opt, const char *arg) {
426 printf("%s " FFMPEG_VERSION "\n", program_name);
427 print_all_libs_info(stdout, SHOW_VERSION);
431 int opt_license(const char *opt, const char *arg)
435 "This version of %s has nonfree parts compiled in.\n"
436 "Therefore it is not legally redistributable.\n",
439 "%s is free software; you can redistribute it and/or modify\n"
440 "it under the terms of the GNU General Public License as published by\n"
441 "the Free Software Foundation; either version 3 of the License, or\n"
442 "(at your option) any later version.\n"
444 "%s is distributed in the hope that it will be useful,\n"
445 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
446 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
447 "GNU General Public License for more details.\n"
449 "You should have received a copy of the GNU General Public License\n"
450 "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
451 program_name, program_name, program_name
453 "%s is free software; you can redistribute it and/or modify\n"
454 "it under the terms of the GNU General Public License as published by\n"
455 "the Free Software Foundation; either version 2 of the License, or\n"
456 "(at your option) any later version.\n"
458 "%s is distributed in the hope that it will be useful,\n"
459 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
460 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
461 "GNU General Public License for more details.\n"
463 "You should have received a copy of the GNU General Public License\n"
464 "along with %s; if not, write to the Free Software\n"
465 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
466 program_name, program_name, program_name
468 "%s is free software; you can redistribute it and/or modify\n"
469 "it under the terms of the GNU Lesser General Public License as published by\n"
470 "the Free Software Foundation; either version 3 of the License, or\n"
471 "(at your option) any later version.\n"
473 "%s is distributed in the hope that it will be useful,\n"
474 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
475 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
476 "GNU Lesser General Public License for more details.\n"
478 "You should have received a copy of the GNU Lesser General Public License\n"
479 "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
480 program_name, program_name, program_name
482 "%s is free software; you can redistribute it and/or\n"
483 "modify it under the terms of the GNU Lesser General Public\n"
484 "License as published by the Free Software Foundation; either\n"
485 "version 2.1 of the License, or (at your option) any later version.\n"
487 "%s is distributed in the hope that it will be useful,\n"
488 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
489 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
490 "Lesser General Public License for more details.\n"
492 "You should have received a copy of the GNU Lesser General Public\n"
493 "License along with %s; if not, write to the Free Software\n"
494 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
495 program_name, program_name, program_name
501 int opt_formats(const char *opt, const char *arg)
503 AVInputFormat *ifmt=NULL;
504 AVOutputFormat *ofmt=NULL;
505 const char *last_name;
509 " D. = Demuxing supported\n"
510 " .E = Muxing supported\n"
516 const char *name=NULL;
517 const char *long_name=NULL;
519 while((ofmt= av_oformat_next(ofmt))) {
520 if((name == NULL || strcmp(ofmt->name, name)<0) &&
521 strcmp(ofmt->name, last_name)>0){
523 long_name= ofmt->long_name;
527 while((ifmt= av_iformat_next(ifmt))) {
528 if((name == NULL || strcmp(ifmt->name, name)<0) &&
529 strcmp(ifmt->name, last_name)>0){
531 long_name= ifmt->long_name;
534 if(name && strcmp(ifmt->name, name)==0)
546 long_name ? long_name:" ");
551 int opt_codecs(const char *opt, const char *arg)
553 AVCodec *p=NULL, *p2;
554 const char *last_name;
557 " D..... = Decoding supported\n"
558 " .E.... = Encoding supported\n"
559 " ..V... = Video codec\n"
560 " ..A... = Audio codec\n"
561 " ..S... = Subtitle codec\n"
562 " ...S.. = Supports draw_horiz_band\n"
563 " ....D. = Supports direct rendering method 1\n"
564 " .....T = Supports weird frame truncation\n"
571 const char *type_str;
574 while((p= av_codec_next(p))) {
575 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
576 strcmp(p->name, last_name)>0){
578 decode= encode= cap=0;
580 if(p2 && strcmp(p->name, p2->name)==0){
581 if(p->decode) decode=1;
582 if(p->encode) encode=1;
583 cap |= p->capabilities;
591 case AVMEDIA_TYPE_VIDEO:
594 case AVMEDIA_TYPE_AUDIO:
597 case AVMEDIA_TYPE_SUBTITLE:
605 " %s%s%s%s%s%s %-15s %s",
606 decode ? "D": (/*p2->decoder ? "d":*/" "),
609 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
610 cap & CODEC_CAP_DR1 ? "D":" ",
611 cap & CODEC_CAP_TRUNCATED ? "T":" ",
613 p2->long_name ? p2->long_name : "");
614 /* if(p2->decoder && decode==0)
615 printf(" use %s for decoding", p2->decoder->name);*/
620 "Note, the names of encoders and decoders do not always match, so there are\n"
621 "several cases where the above table shows encoder only or decoder only entries\n"
622 "even though both encoding and decoding are supported. For example, the h263\n"
623 "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
628 int opt_bsfs(const char *opt, const char *arg)
630 AVBitStreamFilter *bsf=NULL;
632 printf("Bitstream filters:\n");
633 while((bsf = av_bitstream_filter_next(bsf)))
634 printf("%s\n", bsf->name);
639 int opt_protocols(const char *opt, const char *arg)
641 URLProtocol *up=NULL;
643 printf("Supported file protocols:\n"
644 "I.. = Input supported\n"
645 ".O. = Output supported\n"
646 "..S = Seek supported\n"
649 while((up = av_protocol_next(up)))
650 printf("%c%c%c %s\n",
651 up->url_read ? 'I' : '.',
652 up->url_write ? 'O' : '.',
653 up->url_seek ? 'S' : '.',
658 int opt_filters(const char *opt, const char *arg)
660 AVFilter av_unused(**filter) = NULL;
662 printf("Filters:\n");
664 while ((filter = av_filter_next(filter)) && *filter)
665 printf("%-16s %s\n", (*filter)->name, (*filter)->description);
670 int opt_pix_fmts(const char *opt, const char *arg)
672 enum PixelFormat pix_fmt;
676 "I.... = Supported Input format for conversion\n"
677 ".O... = Supported Output format for conversion\n"
678 "..H.. = Hardware accelerated format\n"
679 "...P. = Paletted format\n"
680 "....B = Bitstream format\n"
681 "FLAGS NAME NB_COMPONENTS BITS_PER_PIXEL\n"
685 # define sws_isSupportedInput(x) 0
686 # define sws_isSupportedOutput(x) 0
689 for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {
690 const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[pix_fmt];
691 printf("%c%c%c%c%c %-16s %d %2d\n",
692 sws_isSupportedInput (pix_fmt) ? 'I' : '.',
693 sws_isSupportedOutput(pix_fmt) ? 'O' : '.',
694 pix_desc->flags & PIX_FMT_HWACCEL ? 'H' : '.',
695 pix_desc->flags & PIX_FMT_PAL ? 'P' : '.',
696 pix_desc->flags & PIX_FMT_BITSTREAM ? 'B' : '.',
698 pix_desc->nb_components,
699 av_get_bits_per_pixel(pix_desc));
707 int yesno = (toupper(c) == 'Y');
709 while (c != '\n' && c != EOF)
715 int read_file(const char *filename, char **bufptr, size_t *size)
717 FILE *f = fopen(filename, "rb");
720 fprintf(stderr, "Cannot read file '%s': %s\n", filename, strerror(errno));
721 return AVERROR(errno);
723 fseek(f, 0, SEEK_END);
725 fseek(f, 0, SEEK_SET);
726 *bufptr = av_malloc(*size + 1);
728 fprintf(stderr, "Could not allocate file buffer\n");
730 return AVERROR(ENOMEM);
732 fread(*bufptr, 1, *size, f);
733 (*bufptr)[*size++] = '\0';
739 FILE *get_preset_file(char *filename, size_t filename_size,
740 const char *preset_name, int is_path, const char *codec_name)
744 const char *base[3]= { getenv("FFMPEG_DATADIR"),
750 av_strlcpy(filename, preset_name, filename_size);
751 f = fopen(filename, "r");
754 char datadir[MAX_PATH], *ls;
757 if (GetModuleFileNameA(GetModuleHandleA(NULL), datadir, sizeof(datadir) - 1))
759 for (ls = datadir; ls < datadir + strlen(datadir); ls++)
760 if (*ls == '\\') *ls = '/';
762 if (ls = strrchr(datadir, '/'))
765 strncat(datadir, "/ffpresets", sizeof(datadir) - 1 - strlen(datadir));
770 for (i = 0; i < 3 && !f; i++) {
773 snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", preset_name);
774 f = fopen(filename, "r");
775 if (!f && codec_name) {
776 snprintf(filename, filename_size,
777 "%s%s/%s-%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", codec_name, preset_name);
778 f = fopen(filename, "r");
786 AVDictionary *filter_codec_opts(AVDictionary *opts, enum CodecID codec_id, int encoder)
788 AVDictionary *ret = NULL;
789 AVDictionaryEntry *t = NULL;
790 AVCodec *codec = encoder ? avcodec_find_encoder(codec_id) : avcodec_find_decoder(codec_id);
791 int flags = encoder ? AV_OPT_FLAG_ENCODING_PARAM : AV_OPT_FLAG_DECODING_PARAM;
797 switch (codec->type) {
798 case AVMEDIA_TYPE_VIDEO: prefix = 'v'; flags |= AV_OPT_FLAG_VIDEO_PARAM; break;
799 case AVMEDIA_TYPE_AUDIO: prefix = 'a'; flags |= AV_OPT_FLAG_AUDIO_PARAM; break;
800 case AVMEDIA_TYPE_SUBTITLE: prefix = 's'; flags |= AV_OPT_FLAG_SUBTITLE_PARAM; break;
803 while (t = av_dict_get(opts, "", t, AV_DICT_IGNORE_SUFFIX)) {
804 if (av_opt_find(avcodec_opts[0], t->key, NULL, flags, 0) ||
805 (codec && codec->priv_class && av_opt_find(&codec->priv_class, t->key, NULL, flags, 0)))
806 av_dict_set(&ret, t->key, t->value, 0);
807 else if (t->key[0] == prefix && av_opt_find(avcodec_opts[0], t->key+1, NULL, flags, 0))
808 av_dict_set(&ret, t->key+1, t->value, 0);
813 AVDictionary **setup_find_stream_info_opts(AVFormatContext *s, AVDictionary *codec_opts)
820 opts = av_mallocz(s->nb_streams * sizeof(*opts));
822 av_log(NULL, AV_LOG_ERROR, "Could not alloc memory for stream options.\n");
825 for (i = 0; i < s->nb_streams; i++)
826 opts[i] = filter_codec_opts(codec_opts, s->streams[i]->codec->codec_id, 0);