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 "libavresample/avresample.h"
36 #include "libswscale/swscale.h"
37 #include "libavutil/avassert.h"
38 #include "libavutil/avstring.h"
39 #include "libavutil/mathematics.h"
40 #include "libavutil/imgutils.h"
41 #include "libavutil/parseutils.h"
42 #include "libavutil/pixdesc.h"
43 #include "libavutil/eval.h"
44 #include "libavutil/dict.h"
45 #include "libavutil/opt.h"
49 #include "libavformat/network.h"
51 #if HAVE_SYS_RESOURCE_H
53 #include <sys/resource.h>
56 struct SwsContext
*sws_opts
;
57 AVDictionary
*format_opts
, *codec_opts
;
59 static const int this_year
= 2012;
64 sws_opts
= sws_getContext(16, 16, 0, 16, 16, 0, SWS_BICUBIC
,
69 void uninit_opts(void)
72 sws_freeContext(sws_opts
);
75 av_dict_free(&format_opts
);
76 av_dict_free(&codec_opts
);
79 void log_callback_help(void *ptr
, int level
, const char *fmt
, va_list vl
)
81 vfprintf(stdout
, fmt
, vl
);
84 double parse_number_or_die(const char *context
, const char *numstr
, int type
,
85 double min
, double max
)
89 double d
= av_strtod(numstr
, &tail
);
91 error
= "Expected number for %s but found: %s\n";
92 else if (d
< min
|| d
> max
)
93 error
= "The value for %s was %s which is not within %f - %f\n";
94 else if (type
== OPT_INT64
&& (int64_t)d
!= d
)
95 error
= "Expected int64 for %s but found %s\n";
96 else if (type
== OPT_INT
&& (int)d
!= d
)
97 error
= "Expected int for %s but found %s\n";
100 av_log(NULL
, AV_LOG_FATAL
, error
, context
, numstr
, min
, max
);
105 int64_t parse_time_or_die(const char *context
, const char *timestr
,
109 if (av_parse_time(&us
, timestr
, is_duration
) < 0) {
110 av_log(NULL
, AV_LOG_FATAL
, "Invalid %s specification for %s: %s\n",
111 is_duration
? "duration" : "date", context
, timestr
);
117 void show_help_options(const OptionDef
*options
, const char *msg
, int req_flags
,
118 int rej_flags
, int alt_flags
)
124 for (po
= options
; po
->name
!= NULL
; po
++) {
127 if (((po
->flags
& req_flags
) != req_flags
) ||
128 (alt_flags
&& !(po
->flags
& alt_flags
)) ||
129 (po
->flags
& rej_flags
))
136 av_strlcpy(buf
, po
->name
, sizeof(buf
));
138 av_strlcat(buf
, " ", sizeof(buf
));
139 av_strlcat(buf
, po
->argname
, sizeof(buf
));
141 printf("-%-17s %s\n", buf
, po
->help
);
146 void show_help_children(const AVClass
*class, int flags
)
148 const AVClass
*child
= NULL
;
149 av_opt_show2(&class, NULL
, flags
, 0);
152 while (child
= av_opt_child_class_next(class, child
))
153 show_help_children(child
, flags
);
156 static const OptionDef
*find_option(const OptionDef
*po
, const char *name
)
158 const char *p
= strchr(name
, ':');
159 int len
= p
? p
- name
: strlen(name
);
161 while (po
->name
!= NULL
) {
162 if (!strncmp(name
, po
->name
, len
) && strlen(po
->name
) == len
)
169 #if HAVE_COMMANDLINETOARGVW
171 #include <shellapi.h>
172 /* Will be leaked on exit */
173 static char** win32_argv_utf8
= NULL
;
174 static int win32_argc
= 0;
177 * Prepare command line arguments for executable.
178 * For Windows - perform wide-char to UTF-8 conversion.
179 * Input arguments should be main() function arguments.
180 * @param argc_ptr Arguments number (including executable)
181 * @param argv_ptr Arguments list.
183 static void prepare_app_arguments(int *argc_ptr
, char ***argv_ptr
)
187 int i
, buffsize
= 0, offset
= 0;
189 if (win32_argv_utf8
) {
190 *argc_ptr
= win32_argc
;
191 *argv_ptr
= win32_argv_utf8
;
196 argv_w
= CommandLineToArgvW(GetCommandLineW(), &win32_argc
);
197 if (win32_argc
<= 0 || !argv_w
)
200 /* determine the UTF-8 buffer size (including NULL-termination symbols) */
201 for (i
= 0; i
< win32_argc
; i
++)
202 buffsize
+= WideCharToMultiByte(CP_UTF8
, 0, argv_w
[i
], -1,
203 NULL
, 0, NULL
, NULL
);
205 win32_argv_utf8
= av_mallocz(sizeof(char *) * (win32_argc
+ 1) + buffsize
);
206 argstr_flat
= (char *)win32_argv_utf8
+ sizeof(char *) * (win32_argc
+ 1);
207 if (win32_argv_utf8
== NULL
) {
212 for (i
= 0; i
< win32_argc
; i
++) {
213 win32_argv_utf8
[i
] = &argstr_flat
[offset
];
214 offset
+= WideCharToMultiByte(CP_UTF8
, 0, argv_w
[i
], -1,
215 &argstr_flat
[offset
],
216 buffsize
- offset
, NULL
, NULL
);
218 win32_argv_utf8
[i
] = NULL
;
221 *argc_ptr
= win32_argc
;
222 *argv_ptr
= win32_argv_utf8
;
225 static inline void prepare_app_arguments(int *argc_ptr
, char ***argv_ptr
)
229 #endif /* HAVE_COMMANDLINETOARGVW */
231 static int write_option(void *optctx
, const OptionDef
*po
, const char *opt
,
234 /* new-style options contain an offset into optctx, old-style address of
236 void *dst
= po
->flags
& (OPT_OFFSET
| OPT_SPEC
) ?
237 (uint8_t *)optctx
+ po
->u
.off
: po
->u
.dst_ptr
;
240 if (po
->flags
& OPT_SPEC
) {
241 SpecifierOpt
**so
= dst
;
242 char *p
= strchr(opt
, ':');
244 dstcount
= (int *)(so
+ 1);
245 *so
= grow_array(*so
, sizeof(**so
), dstcount
, *dstcount
+ 1);
246 (*so
)[*dstcount
- 1].specifier
= av_strdup(p
? p
+ 1 : "");
247 dst
= &(*so
)[*dstcount
- 1].u
;
250 if (po
->flags
& OPT_STRING
) {
252 str
= av_strdup(arg
);
255 } else if (po
->flags
& OPT_BOOL
|| po
->flags
& OPT_INT
) {
256 *(int *)dst
= parse_number_or_die(opt
, arg
, OPT_INT64
, INT_MIN
, INT_MAX
);
257 } else if (po
->flags
& OPT_INT64
) {
258 *(int64_t *)dst
= parse_number_or_die(opt
, arg
, OPT_INT64
, INT64_MIN
, INT64_MAX
);
259 } else if (po
->flags
& OPT_TIME
) {
260 *(int64_t *)dst
= parse_time_or_die(opt
, arg
, 1);
261 } else if (po
->flags
& OPT_FLOAT
) {
262 *(float *)dst
= parse_number_or_die(opt
, arg
, OPT_FLOAT
, -INFINITY
, INFINITY
);
263 } else if (po
->flags
& OPT_DOUBLE
) {
264 *(double *)dst
= parse_number_or_die(opt
, arg
, OPT_DOUBLE
, -INFINITY
, INFINITY
);
265 } else if (po
->u
.func_arg
) {
266 int ret
= po
->u
.func_arg(optctx
, opt
, arg
);
268 av_log(NULL
, AV_LOG_ERROR
,
269 "Failed to set value '%s' for option '%s'\n", arg
, opt
);
273 if (po
->flags
& OPT_EXIT
)
279 int parse_option(void *optctx
, const char *opt
, const char *arg
,
280 const OptionDef
*options
)
285 po
= find_option(options
, opt
);
286 if (!po
->name
&& opt
[0] == 'n' && opt
[1] == 'o') {
287 /* handle 'no' bool option */
288 po
= find_option(options
, opt
+ 2);
289 if ((po
->name
&& (po
->flags
& OPT_BOOL
)))
291 } else if (po
->flags
& OPT_BOOL
)
295 po
= find_option(options
, "default");
297 av_log(NULL
, AV_LOG_ERROR
, "Unrecognized option '%s'\n", opt
);
298 return AVERROR(EINVAL
);
300 if (po
->flags
& HAS_ARG
&& !arg
) {
301 av_log(NULL
, AV_LOG_ERROR
, "Missing argument for option '%s'\n", opt
);
302 return AVERROR(EINVAL
);
305 ret
= write_option(optctx
, po
, opt
, arg
);
309 return !!(po
->flags
& HAS_ARG
);
312 void parse_options(void *optctx
, int argc
, char **argv
, const OptionDef
*options
,
313 void (*parse_arg_function
)(void *, const char*))
316 int optindex
, handleoptions
= 1, ret
;
318 /* perform system-dependent conversions for arguments list */
319 prepare_app_arguments(&argc
, &argv
);
323 while (optindex
< argc
) {
324 opt
= argv
[optindex
++];
326 if (handleoptions
&& opt
[0] == '-' && opt
[1] != '\0') {
327 if (opt
[1] == '-' && opt
[2] == '\0') {
333 if ((ret
= parse_option(optctx
, opt
, argv
[optindex
], options
)) < 0)
337 if (parse_arg_function
)
338 parse_arg_function(optctx
, opt
);
343 int parse_optgroup(void *optctx
, OptionGroup
*g
)
347 av_log(NULL
, AV_LOG_DEBUG
, "Parsing a group of options: %s %s.\n",
348 g
->group_def
->name
, g
->arg
);
350 for (i
= 0; i
< g
->nb_opts
; i
++) {
351 Option
*o
= &g
->opts
[i
];
353 av_log(NULL
, AV_LOG_DEBUG
, "Applying option %s (%s) with argument %s.\n",
354 o
->key
, o
->opt
->help
, o
->val
);
356 ret
= write_option(optctx
, o
->opt
, o
->key
, o
->val
);
361 av_log(NULL
, AV_LOG_DEBUG
, "Successfully parsed a group of options.\n");
366 int locate_option(int argc
, char **argv
, const OptionDef
*options
,
372 for (i
= 1; i
< argc
; i
++) {
373 const char *cur_opt
= argv
[i
];
375 if (*cur_opt
++ != '-')
378 po
= find_option(options
, cur_opt
);
379 if (!po
->name
&& cur_opt
[0] == 'n' && cur_opt
[1] == 'o')
380 po
= find_option(options
, cur_opt
+ 2);
382 if ((!po
->name
&& !strcmp(cur_opt
, optname
)) ||
383 (po
->name
&& !strcmp(optname
, po
->name
)))
386 if (!po
|| po
->flags
& HAS_ARG
)
392 void parse_loglevel(int argc
, char **argv
, const OptionDef
*options
)
394 int idx
= locate_option(argc
, argv
, options
, "loglevel");
396 idx
= locate_option(argc
, argv
, options
, "v");
397 if (idx
&& argv
[idx
+ 1])
398 opt_loglevel(NULL
, "loglevel", argv
[idx
+ 1]);
401 #define FLAGS (o->type == AV_OPT_TYPE_FLAGS) ? AV_DICT_APPEND : 0
402 int opt_default(void *optctx
, const char *opt
, const char *arg
)
405 char opt_stripped
[128];
407 const AVClass
*cc
= avcodec_get_class(), *fc
= avformat_get_class();
409 const AVClass
*sc
= sws_get_class();
412 if (!(p
= strchr(opt
, ':')))
413 p
= opt
+ strlen(opt
);
414 av_strlcpy(opt_stripped
, opt
, FFMIN(sizeof(opt_stripped
), p
- opt
+ 1));
416 if ((o
= av_opt_find(&cc
, opt_stripped
, NULL
, 0,
417 AV_OPT_SEARCH_CHILDREN
| AV_OPT_SEARCH_FAKE_OBJ
)) ||
418 ((opt
[0] == 'v' || opt
[0] == 'a' || opt
[0] == 's') &&
419 (o
= av_opt_find(&cc
, opt
+ 1, NULL
, 0, AV_OPT_SEARCH_FAKE_OBJ
))))
420 av_dict_set(&codec_opts
, opt
, arg
, FLAGS
);
421 else if ((o
= av_opt_find(&fc
, opt
, NULL
, 0,
422 AV_OPT_SEARCH_CHILDREN
| AV_OPT_SEARCH_FAKE_OBJ
)))
423 av_dict_set(&format_opts
, opt
, arg
, FLAGS
);
425 else if ((o
= av_opt_find(&sc
, opt
, NULL
, 0,
426 AV_OPT_SEARCH_CHILDREN
| AV_OPT_SEARCH_FAKE_OBJ
))) {
427 // XXX we only support sws_flags, not arbitrary sws options
428 int ret
= av_opt_set(sws_opts
, opt
, arg
, 0);
430 av_log(NULL
, AV_LOG_ERROR
, "Error setting option %s.\n", opt
);
438 return AVERROR_OPTION_NOT_FOUND
;
442 * Check whether given option is a group separator.
444 * @return index of the group definition that matched or -1 if none
446 static int match_group_separator(const OptionGroupDef
*groups
, const char *opt
)
448 const OptionGroupDef
*p
= groups
;
451 if (p
->sep
&& !strcmp(p
->sep
, opt
))
460 * Finish parsing an option group.
462 * @param group_idx which group definition should this group belong to
463 * @param arg argument of the group delimiting option
465 static void finish_group(OptionParseContext
*octx
, int group_idx
,
468 OptionGroupList
*l
= &octx
->groups
[group_idx
];
471 GROW_ARRAY(l
->groups
, l
->nb_groups
);
472 g
= &l
->groups
[l
->nb_groups
- 1];
474 *g
= octx
->cur_group
;
476 g
->group_def
= l
->group_def
;
478 g
->sws_opts
= sws_opts
;
480 g
->codec_opts
= codec_opts
;
481 g
->format_opts
= format_opts
;
490 memset(&octx
->cur_group
, 0, sizeof(octx
->cur_group
));
494 * Add an option instance to currently parsed group.
496 static void add_opt(OptionParseContext
*octx
, const OptionDef
*opt
,
497 const char *key
, const char *val
)
499 int global
= !(opt
->flags
& (OPT_PERFILE
| OPT_SPEC
| OPT_OFFSET
));
500 OptionGroup
*g
= global
? &octx
->global_opts
: &octx
->cur_group
;
502 GROW_ARRAY(g
->opts
, g
->nb_opts
);
503 g
->opts
[g
->nb_opts
- 1].opt
= opt
;
504 g
->opts
[g
->nb_opts
- 1].key
= key
;
505 g
->opts
[g
->nb_opts
- 1].val
= val
;
508 static void init_parse_context(OptionParseContext
*octx
,
509 const OptionGroupDef
*groups
)
511 static const OptionGroupDef global_group
= { "global" };
512 const OptionGroupDef
*g
= groups
;
515 memset(octx
, 0, sizeof(*octx
));
519 octx
->nb_groups
= g
- groups
;
520 octx
->groups
= av_mallocz(sizeof(*octx
->groups
) * octx
->nb_groups
);
524 for (i
= 0; i
< octx
->nb_groups
; i
++)
525 octx
->groups
[i
].group_def
= &groups
[i
];
527 octx
->global_opts
.group_def
= &global_group
;
528 octx
->global_opts
.arg
= "";
533 void uninit_parse_context(OptionParseContext
*octx
)
537 for (i
= 0; i
< octx
->nb_groups
; i
++) {
538 OptionGroupList
*l
= &octx
->groups
[i
];
540 for (j
= 0; j
< l
->nb_groups
; j
++) {
541 av_freep(&l
->groups
[j
].opts
);
542 av_dict_free(&l
->groups
[j
].codec_opts
);
543 av_dict_free(&l
->groups
[j
].format_opts
);
545 sws_freeContext(l
->groups
[j
].sws_opts
);
548 av_freep(&l
->groups
);
550 av_freep(&octx
->groups
);
552 av_freep(&octx
->cur_group
.opts
);
553 av_freep(&octx
->global_opts
.opts
);
558 int split_commandline(OptionParseContext
*octx
, int argc
, char *argv
[],
559 const OptionDef
*options
,
560 const OptionGroupDef
*groups
)
564 /* perform system-dependent conversions for arguments list */
565 prepare_app_arguments(&argc
, &argv
);
567 init_parse_context(octx
, groups
);
568 av_log(NULL
, AV_LOG_DEBUG
, "Splitting the commandline.\n");
570 while (optindex
< argc
) {
571 const char *opt
= argv
[optindex
++], *arg
;
575 av_log(NULL
, AV_LOG_DEBUG
, "Reading option '%s' ...", opt
);
577 /* unnamed group separators, e.g. output filename */
578 if (opt
[0] != '-' || !opt
[1]) {
579 finish_group(octx
, 0, opt
);
580 av_log(NULL
, AV_LOG_DEBUG
, " matched as %s.\n", groups
[0].name
);
585 #define GET_ARG(arg) \
587 arg = argv[optindex++]; \
589 av_log(NULL, AV_LOG_ERROR, "Missing argument for option '%s'.\n", opt);\
590 return AVERROR(EINVAL); \
594 /* named group separators, e.g. -i */
595 if ((ret
= match_group_separator(groups
, opt
)) >= 0) {
597 finish_group(octx
, ret
, arg
);
598 av_log(NULL
, AV_LOG_DEBUG
, " matched as %s with argument '%s'.\n",
599 groups
[ret
].name
, arg
);
604 po
= find_option(options
, opt
);
606 if (po
->flags
& OPT_EXIT
) {
607 /* optional argument, e.g. -h */
608 arg
= argv
[optindex
++];
609 } else if (po
->flags
& HAS_ARG
) {
615 add_opt(octx
, po
, opt
, arg
);
616 av_log(NULL
, AV_LOG_DEBUG
, " matched as option '%s' (%s) with "
617 "argument '%s'.\n", po
->name
, po
->help
, arg
);
622 if (argv
[optindex
]) {
623 ret
= opt_default(NULL
, opt
, argv
[optindex
]);
625 av_log(NULL
, AV_LOG_DEBUG
, " matched as AVOption '%s' with "
626 "argument '%s'.\n", opt
, argv
[optindex
]);
629 } else if (ret
!= AVERROR_OPTION_NOT_FOUND
) {
630 av_log(NULL
, AV_LOG_ERROR
, "Error parsing option '%s' "
631 "with argument '%s'.\n", opt
, argv
[optindex
]);
636 /* boolean -nofoo options */
637 if (opt
[0] == 'n' && opt
[1] == 'o' &&
638 (po
= find_option(options
, opt
+ 2)) &&
639 po
->name
&& po
->flags
& OPT_BOOL
) {
640 add_opt(octx
, po
, opt
, "0");
641 av_log(NULL
, AV_LOG_DEBUG
, " matched as option '%s' (%s) with "
642 "argument 0.\n", po
->name
, po
->help
);
646 av_log(NULL
, AV_LOG_ERROR
, "Unrecognized option '%s'.\n", opt
);
647 return AVERROR_OPTION_NOT_FOUND
;
650 if (octx
->cur_group
.nb_opts
|| codec_opts
|| format_opts
)
651 av_log(NULL
, AV_LOG_WARNING
, "Trailing options were found on the "
654 av_log(NULL
, AV_LOG_DEBUG
, "Finished splitting the commandline.\n");
659 int opt_loglevel(void *optctx
, const char *opt
, const char *arg
)
661 const struct { const char *name
; int level
; } log_levels
[] = {
662 { "quiet" , AV_LOG_QUIET
},
663 { "panic" , AV_LOG_PANIC
},
664 { "fatal" , AV_LOG_FATAL
},
665 { "error" , AV_LOG_ERROR
},
666 { "warning", AV_LOG_WARNING
},
667 { "info" , AV_LOG_INFO
},
668 { "verbose", AV_LOG_VERBOSE
},
669 { "debug" , AV_LOG_DEBUG
},
675 for (i
= 0; i
< FF_ARRAY_ELEMS(log_levels
); i
++) {
676 if (!strcmp(log_levels
[i
].name
, arg
)) {
677 av_log_set_level(log_levels
[i
].level
);
682 level
= strtol(arg
, &tail
, 10);
684 av_log(NULL
, AV_LOG_FATAL
, "Invalid loglevel \"%s\". "
685 "Possible levels are numbers or:\n", arg
);
686 for (i
= 0; i
< FF_ARRAY_ELEMS(log_levels
); i
++)
687 av_log(NULL
, AV_LOG_FATAL
, "\"%s\"\n", log_levels
[i
].name
);
690 av_log_set_level(level
);
694 int opt_timelimit(void *optctx
, const char *opt
, const char *arg
)
697 int lim
= parse_number_or_die(opt
, arg
, OPT_INT64
, 0, INT_MAX
);
698 struct rlimit rl
= { lim
, lim
+ 1 };
699 if (setrlimit(RLIMIT_CPU
, &rl
))
702 av_log(NULL
, AV_LOG_WARNING
, "-%s not implemented on this OS\n", opt
);
707 void print_error(const char *filename
, int err
)
710 const char *errbuf_ptr
= errbuf
;
712 if (av_strerror(err
, errbuf
, sizeof(errbuf
)) < 0)
713 errbuf_ptr
= strerror(AVUNERROR(err
));
714 av_log(NULL
, AV_LOG_ERROR
, "%s: %s\n", filename
, errbuf_ptr
);
717 static int warned_cfg
= 0;
720 #define SHOW_VERSION 2
721 #define SHOW_CONFIG 4
723 #define PRINT_LIB_INFO(libname, LIBNAME, flags, level) \
724 if (CONFIG_##LIBNAME) { \
725 const char *indent = flags & INDENT? " " : ""; \
726 if (flags & SHOW_VERSION) { \
727 unsigned int version = libname##_version(); \
728 av_log(NULL, level, \
729 "%slib%-10s %2d.%3d.%2d / %2d.%3d.%2d\n", \
731 LIB##LIBNAME##_VERSION_MAJOR, \
732 LIB##LIBNAME##_VERSION_MINOR, \
733 LIB##LIBNAME##_VERSION_MICRO, \
734 version >> 16, version >> 8 & 0xff, version & 0xff); \
736 if (flags & SHOW_CONFIG) { \
737 const char *cfg = libname##_configuration(); \
738 if (strcmp(LIBAV_CONFIGURATION, cfg)) { \
740 av_log(NULL, level, \
741 "%sWARNING: library configuration mismatch\n", \
745 av_log(NULL, level, "%s%-11s configuration: %s\n", \
746 indent, #libname, cfg); \
751 static void print_all_libs_info(int flags, int level)
753 PRINT_LIB_INFO(avutil
, AVUTIL
, flags
, level
);
754 PRINT_LIB_INFO(avcodec
, AVCODEC
, flags
, level
);
755 PRINT_LIB_INFO(avformat
, AVFORMAT
, flags
, level
);
756 PRINT_LIB_INFO(avdevice
, AVDEVICE
, flags
, level
);
757 PRINT_LIB_INFO(avfilter
, AVFILTER
, flags
, level
);
758 PRINT_LIB_INFO(avresample
, AVRESAMPLE
, flags
, level
);
759 PRINT_LIB_INFO(swscale
, SWSCALE
, flags
, level
);
762 void show_banner(void)
764 av_log(NULL
, AV_LOG_INFO
,
765 "%s version " LIBAV_VERSION
", Copyright (c) %d-%d the Libav developers\n",
766 program_name
, program_birth_year
, this_year
);
767 av_log(NULL
, AV_LOG_INFO
, " built on %s %s with %s\n",
768 __DATE__
, __TIME__
, CC_IDENT
);
769 av_log(NULL
, AV_LOG_VERBOSE
, " configuration: " LIBAV_CONFIGURATION
"\n");
770 print_all_libs_info(INDENT
|SHOW_CONFIG
, AV_LOG_VERBOSE
);
771 print_all_libs_info(INDENT
|SHOW_VERSION
, AV_LOG_VERBOSE
);
774 int show_version(void *optctx
, const char *opt
, const char *arg
)
776 av_log_set_callback(log_callback_help
);
777 printf("%s " LIBAV_VERSION
"\n", program_name
);
778 print_all_libs_info(SHOW_VERSION
, AV_LOG_INFO
);
783 int show_license(void *optctx
, const char *opt
, const char *arg
)
787 "This version of %s has nonfree parts compiled in.\n"
788 "Therefore it is not legally redistributable.\n",
791 "%s is free software; you can redistribute it and/or modify\n"
792 "it under the terms of the GNU General Public License as published by\n"
793 "the Free Software Foundation; either version 3 of the License, or\n"
794 "(at your option) any later version.\n"
796 "%s is distributed in the hope that it will be useful,\n"
797 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
798 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
799 "GNU General Public License for more details.\n"
801 "You should have received a copy of the GNU General Public License\n"
802 "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
803 program_name
, program_name
, program_name
805 "%s is free software; you can redistribute it and/or modify\n"
806 "it under the terms of the GNU General Public License as published by\n"
807 "the Free Software Foundation; either version 2 of the License, or\n"
808 "(at your option) any later version.\n"
810 "%s is distributed in the hope that it will be useful,\n"
811 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
812 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
813 "GNU General Public License for more details.\n"
815 "You should have received a copy of the GNU General Public License\n"
816 "along with %s; if not, write to the Free Software\n"
817 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
818 program_name
, program_name
, program_name
820 "%s is free software; you can redistribute it and/or modify\n"
821 "it under the terms of the GNU Lesser General Public License as published by\n"
822 "the Free Software Foundation; either version 3 of the License, or\n"
823 "(at your option) any later version.\n"
825 "%s is distributed in the hope that it will be useful,\n"
826 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
827 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
828 "GNU Lesser General Public License for more details.\n"
830 "You should have received a copy of the GNU Lesser General Public License\n"
831 "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
832 program_name
, program_name
, program_name
834 "%s is free software; you can redistribute it and/or\n"
835 "modify it under the terms of the GNU Lesser General Public\n"
836 "License as published by the Free Software Foundation; either\n"
837 "version 2.1 of the License, or (at your option) any later version.\n"
839 "%s is distributed in the hope that it will be useful,\n"
840 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
841 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
842 "Lesser General Public License for more details.\n"
844 "You should have received a copy of the GNU Lesser General Public\n"
845 "License along with %s; if not, write to the Free Software\n"
846 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
847 program_name
, program_name
, program_name
854 int show_formats(void *optctx
, const char *opt
, const char *arg
)
856 AVInputFormat
*ifmt
= NULL
;
857 AVOutputFormat
*ofmt
= NULL
;
858 const char *last_name
;
860 printf("File formats:\n"
861 " D. = Demuxing supported\n"
862 " .E = Muxing supported\n"
868 const char *name
= NULL
;
869 const char *long_name
= NULL
;
871 while ((ofmt
= av_oformat_next(ofmt
))) {
872 if ((name
== NULL
|| strcmp(ofmt
->name
, name
) < 0) &&
873 strcmp(ofmt
->name
, last_name
) > 0) {
875 long_name
= ofmt
->long_name
;
879 while ((ifmt
= av_iformat_next(ifmt
))) {
880 if ((name
== NULL
|| strcmp(ifmt
->name
, name
) < 0) &&
881 strcmp(ifmt
->name
, last_name
) > 0) {
883 long_name
= ifmt
->long_name
;
886 if (name
&& strcmp(ifmt
->name
, name
) == 0)
893 printf(" %s%s %-15s %s\n",
897 long_name
? long_name
:" ");
902 #define PRINT_CODEC_SUPPORTED(codec, field, type, list_name, term, get_name) \
903 if (codec->field) { \
904 const type *p = c->field; \
906 printf(" Supported " list_name ":"); \
907 while (*p != term) { \
909 printf(" %s", name); \
915 static void print_codec(const AVCodec *c)
917 int encoder
= av_codec_is_encoder(c
);
919 printf("%s %s [%s]:\n", encoder
? "Encoder" : "Decoder", c
->name
,
920 c
->long_name
? c
->long_name
: "");
922 if (c
->type
== AVMEDIA_TYPE_VIDEO
) {
923 printf(" Threading capabilities: ");
924 switch (c
->capabilities
& (CODEC_CAP_FRAME_THREADS
|
925 CODEC_CAP_SLICE_THREADS
)) {
926 case CODEC_CAP_FRAME_THREADS
|
927 CODEC_CAP_SLICE_THREADS
: printf("frame and slice"); break;
928 case CODEC_CAP_FRAME_THREADS
: printf("frame"); break;
929 case CODEC_CAP_SLICE_THREADS
: printf("slice"); break;
930 default: printf("no"); break;
935 if (c
->supported_framerates
) {
936 const AVRational
*fps
= c
->supported_framerates
;
938 printf(" Supported framerates:");
940 printf(" %d/%d", fps
->num
, fps
->den
);
945 PRINT_CODEC_SUPPORTED(c
, pix_fmts
, enum AVPixelFormat
, "pixel formats",
946 AV_PIX_FMT_NONE
, GET_PIX_FMT_NAME
);
947 PRINT_CODEC_SUPPORTED(c
, supported_samplerates
, int, "sample rates", 0,
948 GET_SAMPLE_RATE_NAME
);
949 PRINT_CODEC_SUPPORTED(c
, sample_fmts
, enum AVSampleFormat
, "sample formats",
950 AV_SAMPLE_FMT_NONE
, GET_SAMPLE_FMT_NAME
);
951 PRINT_CODEC_SUPPORTED(c
, channel_layouts
, uint64_t, "channel layouts",
952 0, GET_CH_LAYOUT_DESC
);
955 show_help_children(c
->priv_class
,
956 AV_OPT_FLAG_ENCODING_PARAM
|
957 AV_OPT_FLAG_DECODING_PARAM
);
961 static char get_media_type_char(enum AVMediaType type
)
964 case AVMEDIA_TYPE_VIDEO
: return 'V';
965 case AVMEDIA_TYPE_AUDIO
: return 'A';
966 case AVMEDIA_TYPE_SUBTITLE
: return 'S';
971 static const AVCodec
*next_codec_for_id(enum AVCodecID id
, const AVCodec
*prev
,
974 while ((prev
= av_codec_next(prev
))) {
975 if (prev
->id
== id
&&
976 (encoder
? av_codec_is_encoder(prev
) : av_codec_is_decoder(prev
)))
982 static void print_codecs_for_id(enum AVCodecID id
, int encoder
)
984 const AVCodec
*codec
= NULL
;
986 printf(" (%s: ", encoder
? "encoders" : "decoders");
988 while ((codec
= next_codec_for_id(id
, codec
, encoder
)))
989 printf("%s ", codec
->name
);
994 int show_codecs(void *optctx
, const char *opt
, const char *arg
)
996 const AVCodecDescriptor
*desc
= NULL
;
999 " D..... = Decoding supported\n"
1000 " .E.... = Encoding supported\n"
1001 " ..V... = Video codec\n"
1002 " ..A... = Audio codec\n"
1003 " ..S... = Subtitle codec\n"
1004 " ...I.. = Intra frame-only codec\n"
1005 " ....L. = Lossy compression\n"
1006 " .....S = Lossless compression\n"
1008 while ((desc
= avcodec_descriptor_next(desc
))) {
1009 const AVCodec
*codec
= NULL
;
1011 printf(avcodec_find_decoder(desc
->id
) ? "D" : ".");
1012 printf(avcodec_find_encoder(desc
->id
) ? "E" : ".");
1014 printf("%c", get_media_type_char(desc
->type
));
1015 printf((desc
->props
& AV_CODEC_PROP_INTRA_ONLY
) ? "I" : ".");
1016 printf((desc
->props
& AV_CODEC_PROP_LOSSY
) ? "L" : ".");
1017 printf((desc
->props
& AV_CODEC_PROP_LOSSLESS
) ? "S" : ".");
1019 printf(" %-20s %s", desc
->name
, desc
->long_name
? desc
->long_name
: "");
1021 /* print decoders/encoders when there's more than one or their
1022 * names are different from codec name */
1023 while ((codec
= next_codec_for_id(desc
->id
, codec
, 0))) {
1024 if (strcmp(codec
->name
, desc
->name
)) {
1025 print_codecs_for_id(desc
->id
, 0);
1030 while ((codec
= next_codec_for_id(desc
->id
, codec
, 1))) {
1031 if (strcmp(codec
->name
, desc
->name
)) {
1032 print_codecs_for_id(desc
->id
, 1);
1042 static void print_codecs(int encoder
)
1044 const AVCodecDescriptor
*desc
= NULL
;
1049 " S... = Subtitle\n"
1050 " .F.. = Frame-level multithreading\n"
1051 " ..S. = Slice-level multithreading\n"
1052 " ...X = Codec is experimental\n"
1054 encoder
? "Encoders" : "Decoders");
1055 while ((desc
= avcodec_descriptor_next(desc
))) {
1056 const AVCodec
*codec
= NULL
;
1058 while ((codec
= next_codec_for_id(desc
->id
, codec
, encoder
))) {
1059 printf("%c", get_media_type_char(desc
->type
));
1060 printf((codec
->capabilities
& CODEC_CAP_FRAME_THREADS
) ? "F" : ".");
1061 printf((codec
->capabilities
& CODEC_CAP_SLICE_THREADS
) ? "S" : ".");
1062 printf((codec
->capabilities
& CODEC_CAP_EXPERIMENTAL
) ? "X" : ".");
1064 printf(" %-20s %s", codec
->name
, codec
->long_name
? codec
->long_name
: "");
1065 if (strcmp(codec
->name
, desc
->name
))
1066 printf(" (codec %s)", desc
->name
);
1073 int show_decoders(void *optctx
, const char *opt
, const char *arg
)
1079 int show_encoders(void *optctx
, const char *opt
, const char *arg
)
1085 int show_bsfs(void *optctx
, const char *opt
, const char *arg
)
1087 AVBitStreamFilter
*bsf
= NULL
;
1089 printf("Bitstream filters:\n");
1090 while ((bsf
= av_bitstream_filter_next(bsf
)))
1091 printf("%s\n", bsf
->name
);
1096 int show_protocols(void *optctx
, const char *opt
, const char *arg
)
1098 void *opaque
= NULL
;
1101 printf("Supported file protocols:\n"
1103 while ((name
= avio_enum_protocols(&opaque
, 0)))
1104 printf("%s\n", name
);
1105 printf("Output:\n");
1106 while ((name
= avio_enum_protocols(&opaque
, 1)))
1107 printf("%s\n", name
);
1111 int show_filters(void *optctx
, const char *opt
, const char *arg
)
1113 AVFilter
av_unused(**filter
) = NULL
;
1115 printf("Filters:\n");
1117 while ((filter
= av_filter_next(filter
)) && *filter
)
1118 printf("%-16s %s\n", (*filter
)->name
, (*filter
)->description
);
1123 int show_pix_fmts(void *optctx
, const char *opt
, const char *arg
)
1125 const AVPixFmtDescriptor
*pix_desc
= NULL
;
1127 printf("Pixel formats:\n"
1128 "I.... = Supported Input format for conversion\n"
1129 ".O... = Supported Output format for conversion\n"
1130 "..H.. = Hardware accelerated format\n"
1131 "...P. = Paletted format\n"
1132 "....B = Bitstream format\n"
1133 "FLAGS NAME NB_COMPONENTS BITS_PER_PIXEL\n"
1137 # define sws_isSupportedInput(x) 0
1138 # define sws_isSupportedOutput(x) 0
1141 while ((pix_desc
= av_pix_fmt_desc_next(pix_desc
))) {
1142 enum AVPixelFormat pix_fmt
= av_pix_fmt_desc_get_id(pix_desc
);
1143 printf("%c%c%c%c%c %-16s %d %2d\n",
1144 sws_isSupportedInput (pix_fmt
) ? 'I' : '.',
1145 sws_isSupportedOutput(pix_fmt
) ? 'O' : '.',
1146 pix_desc
->flags
& PIX_FMT_HWACCEL
? 'H' : '.',
1147 pix_desc
->flags
& PIX_FMT_PAL
? 'P' : '.',
1148 pix_desc
->flags
& PIX_FMT_BITSTREAM
? 'B' : '.',
1150 pix_desc
->nb_components
,
1151 av_get_bits_per_pixel(pix_desc
));
1156 int show_sample_fmts(void *optctx
, const char *opt
, const char *arg
)
1160 for (i
= -1; i
< AV_SAMPLE_FMT_NB
; i
++)
1161 printf("%s\n", av_get_sample_fmt_string(fmt_str
, sizeof(fmt_str
), i
));
1165 static void show_help_codec(const char *name
, int encoder
)
1167 const AVCodecDescriptor
*desc
;
1168 const AVCodec
*codec
;
1171 av_log(NULL
, AV_LOG_ERROR
, "No codec name specified.\n");
1175 codec
= encoder
? avcodec_find_encoder_by_name(name
) :
1176 avcodec_find_decoder_by_name(name
);
1180 else if ((desc
= avcodec_descriptor_get_by_name(name
))) {
1183 while ((codec
= next_codec_for_id(desc
->id
, codec
, encoder
))) {
1189 av_log(NULL
, AV_LOG_ERROR
, "Codec '%s' is known to Libav, "
1190 "but no %s for it are available. Libav might need to be "
1191 "recompiled with additional external libraries.\n",
1192 name
, encoder
? "encoders" : "decoders");
1195 av_log(NULL
, AV_LOG_ERROR
, "Codec '%s' is not recognized by Libav.\n",
1200 static void show_help_demuxer(const char *name
)
1202 const AVInputFormat
*fmt
= av_find_input_format(name
);
1205 av_log(NULL
, AV_LOG_ERROR
, "Unknown format '%s'.\n", name
);
1209 printf("Demuxer %s [%s]:\n", fmt
->name
, fmt
->long_name
);
1211 if (fmt
->extensions
)
1212 printf(" Common extensions: %s.\n", fmt
->extensions
);
1214 if (fmt
->priv_class
)
1215 show_help_children(fmt
->priv_class
, AV_OPT_FLAG_DECODING_PARAM
);
1218 static void show_help_muxer(const char *name
)
1220 const AVCodecDescriptor
*desc
;
1221 const AVOutputFormat
*fmt
= av_guess_format(name
, NULL
, NULL
);
1224 av_log(NULL
, AV_LOG_ERROR
, "Unknown format '%s'.\n", name
);
1228 printf("Muxer %s [%s]:\n", fmt
->name
, fmt
->long_name
);
1230 if (fmt
->extensions
)
1231 printf(" Common extensions: %s.\n", fmt
->extensions
);
1233 printf(" Mime type: %s.\n", fmt
->mime_type
);
1234 if (fmt
->video_codec
!= AV_CODEC_ID_NONE
&&
1235 (desc
= avcodec_descriptor_get(fmt
->video_codec
))) {
1236 printf(" Default video codec: %s.\n", desc
->name
);
1238 if (fmt
->audio_codec
!= AV_CODEC_ID_NONE
&&
1239 (desc
= avcodec_descriptor_get(fmt
->audio_codec
))) {
1240 printf(" Default audio codec: %s.\n", desc
->name
);
1242 if (fmt
->subtitle_codec
!= AV_CODEC_ID_NONE
&&
1243 (desc
= avcodec_descriptor_get(fmt
->subtitle_codec
))) {
1244 printf(" Default subtitle codec: %s.\n", desc
->name
);
1247 if (fmt
->priv_class
)
1248 show_help_children(fmt
->priv_class
, AV_OPT_FLAG_ENCODING_PARAM
);
1251 int show_help(void *optctx
, const char *opt
, const char *arg
)
1254 av_log_set_callback(log_callback_help
);
1256 topic
= av_strdup(arg
? arg
: "");
1257 par
= strchr(topic
, '=');
1262 show_help_default(topic
, par
);
1263 } else if (!strcmp(topic
, "decoder")) {
1264 show_help_codec(par
, 0);
1265 } else if (!strcmp(topic
, "encoder")) {
1266 show_help_codec(par
, 1);
1267 } else if (!strcmp(topic
, "demuxer")) {
1268 show_help_demuxer(par
);
1269 } else if (!strcmp(topic
, "muxer")) {
1270 show_help_muxer(par
);
1272 show_help_default(topic
, par
);
1279 int read_yesno(void)
1282 int yesno
= (toupper(c
) == 'Y');
1284 while (c
!= '\n' && c
!= EOF
)
1290 int cmdutils_read_file(const char *filename
, char **bufptr
, size_t *size
)
1293 FILE *f
= fopen(filename
, "rb");
1296 av_log(NULL
, AV_LOG_ERROR
, "Cannot read file '%s': %s\n", filename
,
1298 return AVERROR(errno
);
1300 fseek(f
, 0, SEEK_END
);
1302 fseek(f
, 0, SEEK_SET
);
1303 *bufptr
= av_malloc(*size
+ 1);
1305 av_log(NULL
, AV_LOG_ERROR
, "Could not allocate file buffer\n");
1307 return AVERROR(ENOMEM
);
1309 ret
= fread(*bufptr
, 1, *size
, f
);
1313 av_log(NULL
, AV_LOG_ERROR
, "Error while reading file '%s': %s\n",
1314 filename
, strerror(errno
));
1315 ret
= AVERROR(errno
);
1320 (*bufptr
)[(*size
)++] = '\0';
1327 void init_pts_correction(PtsCorrectionContext
*ctx
)
1329 ctx
->num_faulty_pts
= ctx
->num_faulty_dts
= 0;
1330 ctx
->last_pts
= ctx
->last_dts
= INT64_MIN
;
1333 int64_t guess_correct_pts(PtsCorrectionContext
*ctx
, int64_t reordered_pts
,
1336 int64_t pts
= AV_NOPTS_VALUE
;
1338 if (dts
!= AV_NOPTS_VALUE
) {
1339 ctx
->num_faulty_dts
+= dts
<= ctx
->last_dts
;
1340 ctx
->last_dts
= dts
;
1342 if (reordered_pts
!= AV_NOPTS_VALUE
) {
1343 ctx
->num_faulty_pts
+= reordered_pts
<= ctx
->last_pts
;
1344 ctx
->last_pts
= reordered_pts
;
1346 if ((ctx
->num_faulty_pts
<=ctx
->num_faulty_dts
|| dts
== AV_NOPTS_VALUE
)
1347 && reordered_pts
!= AV_NOPTS_VALUE
)
1348 pts
= reordered_pts
;
1355 FILE *get_preset_file(char *filename
, size_t filename_size
,
1356 const char *preset_name
, int is_path
,
1357 const char *codec_name
)
1361 const char *base
[3] = { getenv("AVCONV_DATADIR"),
1366 av_strlcpy(filename
, preset_name
, filename_size
);
1367 f
= fopen(filename
, "r");
1369 for (i
= 0; i
< 3 && !f
; i
++) {
1372 snprintf(filename
, filename_size
, "%s%s/%s.avpreset", base
[i
],
1373 i
!= 1 ? "" : "/.avconv", preset_name
);
1374 f
= fopen(filename
, "r");
1375 if (!f
&& codec_name
) {
1376 snprintf(filename
, filename_size
,
1377 "%s%s/%s-%s.avpreset",
1378 base
[i
], i
!= 1 ? "" : "/.avconv", codec_name
,
1380 f
= fopen(filename
, "r");
1388 int check_stream_specifier(AVFormatContext
*s
, AVStream
*st
, const char *spec
)
1390 if (*spec
<= '9' && *spec
>= '0') /* opt:index */
1391 return strtol(spec
, NULL
, 0) == st
->index
;
1392 else if (*spec
== 'v' || *spec
== 'a' || *spec
== 's' || *spec
== 'd' ||
1393 *spec
== 't') { /* opt:[vasdt] */
1394 enum AVMediaType type
;
1397 case 'v': type
= AVMEDIA_TYPE_VIDEO
; break;
1398 case 'a': type
= AVMEDIA_TYPE_AUDIO
; break;
1399 case 's': type
= AVMEDIA_TYPE_SUBTITLE
; break;
1400 case 'd': type
= AVMEDIA_TYPE_DATA
; break;
1401 case 't': type
= AVMEDIA_TYPE_ATTACHMENT
; break;
1402 default: av_assert0(0);
1404 if (type
!= st
->codec
->codec_type
)
1406 if (*spec
++ == ':') { /* possibly followed by :index */
1407 int i
, index
= strtol(spec
, NULL
, 0);
1408 for (i
= 0; i
< s
->nb_streams
; i
++)
1409 if (s
->streams
[i
]->codec
->codec_type
== type
&& index
-- == 0)
1410 return i
== st
->index
;
1414 } else if (*spec
== 'p' && *(spec
+ 1) == ':') {
1418 prog_id
= strtol(spec
, &endptr
, 0);
1419 for (i
= 0; i
< s
->nb_programs
; i
++) {
1420 if (s
->programs
[i
]->id
!= prog_id
)
1423 if (*endptr
++ == ':') {
1424 int stream_idx
= strtol(endptr
, NULL
, 0);
1425 return stream_idx
>= 0 &&
1426 stream_idx
< s
->programs
[i
]->nb_stream_indexes
&&
1427 st
->index
== s
->programs
[i
]->stream_index
[stream_idx
];
1430 for (j
= 0; j
< s
->programs
[i
]->nb_stream_indexes
; j
++)
1431 if (st
->index
== s
->programs
[i
]->stream_index
[j
])
1435 } else if (!*spec
) /* empty specifier, matches everything */
1438 av_log(s
, AV_LOG_ERROR
, "Invalid stream specifier: %s.\n", spec
);
1439 return AVERROR(EINVAL
);
1442 AVDictionary
*filter_codec_opts(AVDictionary
*opts
, enum AVCodecID codec_id
,
1443 AVFormatContext
*s
, AVStream
*st
, AVCodec
*codec
)
1445 AVDictionary
*ret
= NULL
;
1446 AVDictionaryEntry
*t
= NULL
;
1447 int flags
= s
->oformat
? AV_OPT_FLAG_ENCODING_PARAM
1448 : AV_OPT_FLAG_DECODING_PARAM
;
1450 const AVClass
*cc
= avcodec_get_class();
1453 codec
= s
->oformat
? avcodec_find_encoder(codec_id
)
1454 : avcodec_find_decoder(codec_id
);
1458 switch (codec
->type
) {
1459 case AVMEDIA_TYPE_VIDEO
:
1461 flags
|= AV_OPT_FLAG_VIDEO_PARAM
;
1463 case AVMEDIA_TYPE_AUDIO
:
1465 flags
|= AV_OPT_FLAG_AUDIO_PARAM
;
1467 case AVMEDIA_TYPE_SUBTITLE
:
1469 flags
|= AV_OPT_FLAG_SUBTITLE_PARAM
;
1473 while (t
= av_dict_get(opts
, "", t
, AV_DICT_IGNORE_SUFFIX
)) {
1474 char *p
= strchr(t
->key
, ':');
1476 /* check stream specification in opt name */
1478 switch (check_stream_specifier(s
, st
, p
+ 1)) {
1479 case 1: *p
= 0; break;
1481 default: return NULL
;
1484 if (av_opt_find(&cc
, t
->key
, NULL
, flags
, AV_OPT_SEARCH_FAKE_OBJ
) ||
1485 (codec
&& codec
->priv_class
&&
1486 av_opt_find(&codec
->priv_class
, t
->key
, NULL
, flags
,
1487 AV_OPT_SEARCH_FAKE_OBJ
)))
1488 av_dict_set(&ret
, t
->key
, t
->value
, 0);
1489 else if (t
->key
[0] == prefix
&&
1490 av_opt_find(&cc
, t
->key
+ 1, NULL
, flags
,
1491 AV_OPT_SEARCH_FAKE_OBJ
))
1492 av_dict_set(&ret
, t
->key
+ 1, t
->value
, 0);
1500 AVDictionary
**setup_find_stream_info_opts(AVFormatContext
*s
,
1501 AVDictionary
*codec_opts
)
1504 AVDictionary
**opts
;
1508 opts
= av_mallocz(s
->nb_streams
* sizeof(*opts
));
1510 av_log(NULL
, AV_LOG_ERROR
,
1511 "Could not alloc memory for stream options.\n");
1514 for (i
= 0; i
< s
->nb_streams
; i
++)
1515 opts
[i
] = filter_codec_opts(codec_opts
, s
->streams
[i
]->codec
->codec_id
,
1516 s
, s
->streams
[i
], NULL
);
1520 void *grow_array(void *array
, int elem_size
, int *size
, int new_size
)
1522 if (new_size
>= INT_MAX
/ elem_size
) {
1523 av_log(NULL
, AV_LOG_ERROR
, "Array too big.\n");
1526 if (*size
< new_size
) {
1527 uint8_t *tmp
= av_realloc(array
, new_size
*elem_size
);
1529 av_log(NULL
, AV_LOG_ERROR
, "Could not alloc buffer.\n");
1532 memset(tmp
+ *size
*elem_size
, 0, (new_size
-*size
) * elem_size
);
1539 static int alloc_buffer(FrameBuffer
**pool
, AVCodecContext
*s
, FrameBuffer
**pbuf
)
1541 const AVPixFmtDescriptor
*desc
= av_pix_fmt_desc_get(s
->pix_fmt
);
1545 int h_chroma_shift
, v_chroma_shift
;
1546 int edge
= 32; // XXX should be avcodec_get_edge_width(), but that fails on svq1
1547 int w
= s
->width
, h
= s
->height
;
1550 return AVERROR(EINVAL
);
1551 pixel_size
= desc
->comp
[0].step_minus1
+ 1;
1553 buf
= av_mallocz(sizeof(*buf
));
1555 return AVERROR(ENOMEM
);
1557 if (!(s
->flags
& CODEC_FLAG_EMU_EDGE
)) {
1562 avcodec_align_dimensions(s
, &w
, &h
);
1563 if ((ret
= av_image_alloc(buf
->base
, buf
->linesize
, w
, h
,
1564 s
->pix_fmt
, 32)) < 0) {
1568 /* XXX this shouldn't be needed, but some tests break without this line
1569 * those decoders are buggy and need to be fixed.
1570 * the following tests fail:
1571 * cdgraphics, ansi, aasc, fraps-v1, qtrle-1bit
1573 memset(buf
->base
[0], 128, ret
);
1575 av_pix_fmt_get_chroma_sub_sample(s
->pix_fmt
,
1576 &h_chroma_shift
, &v_chroma_shift
);
1578 for (i
= 0; i
< FF_ARRAY_ELEMS(buf
->data
); i
++) {
1579 const int h_shift
= i
==0 ? 0 : h_chroma_shift
;
1580 const int v_shift
= i
==0 ? 0 : v_chroma_shift
;
1581 if (s
->flags
& CODEC_FLAG_EMU_EDGE
)
1582 buf
->data
[i
] = buf
->base
[i
];
1583 else if (buf
->base
[i
])
1584 buf
->data
[i
] = buf
->base
[i
] +
1585 FFALIGN((buf
->linesize
[i
]*edge
>> v_shift
) +
1586 (pixel_size
*edge
>> h_shift
), 32);
1590 buf
->pix_fmt
= s
->pix_fmt
;
1597 int codec_get_buffer(AVCodecContext
*s
, AVFrame
*frame
)
1599 FrameBuffer
**pool
= s
->opaque
;
1603 if (!*pool
&& (ret
= alloc_buffer(pool
, s
, pool
)) < 0)
1609 if (buf
->w
!= s
->width
|| buf
->h
!= s
->height
|| buf
->pix_fmt
!= s
->pix_fmt
) {
1610 av_freep(&buf
->base
[0]);
1612 if ((ret
= alloc_buffer(pool
, s
, &buf
)) < 0)
1617 frame
->opaque
= buf
;
1618 frame
->type
= FF_BUFFER_TYPE_USER
;
1619 frame
->extended_data
= frame
->data
;
1621 for (i
= 0; i
< FF_ARRAY_ELEMS(buf
->data
); i
++) {
1622 frame
->base
[i
] = buf
->base
[i
]; // XXX h264.c uses base though it shouldn't
1623 frame
->data
[i
] = buf
->data
[i
];
1624 frame
->linesize
[i
] = buf
->linesize
[i
];
1630 static void unref_buffer(FrameBuffer
*buf
)
1632 FrameBuffer
**pool
= buf
->pool
;
1634 av_assert0(buf
->refcount
);
1636 if (!buf
->refcount
) {
1642 void codec_release_buffer(AVCodecContext
*s
, AVFrame
*frame
)
1644 FrameBuffer
*buf
= frame
->opaque
;
1647 for (i
= 0; i
< FF_ARRAY_ELEMS(frame
->data
); i
++)
1648 frame
->data
[i
] = NULL
;
1653 void filter_release_buffer(AVFilterBuffer
*fb
)
1655 FrameBuffer
*buf
= fb
->priv
;
1660 void free_buffer_pool(FrameBuffer
**pool
)
1662 FrameBuffer
*buf
= *pool
;
1665 av_freep(&buf
->base
[0]);