#include "opt.h"
#include "samplefmt.h"
#include "bprint.h"
+#include "version.h"
#include <float.h>
case AV_OPT_TYPE_INT:
*intnum = *(int *)dst;
return 0;
+#if FF_API_OLD_CHANNEL_LAYOUT
+FF_DISABLE_DEPRECATION_WARNINGS
case AV_OPT_TYPE_CHANNEL_LAYOUT:
+FF_ENABLE_DEPRECATION_WARNINGS
+#endif
case AV_OPT_TYPE_DURATION:
case AV_OPT_TYPE_INT64:
case AV_OPT_TYPE_UINT64:
*(int *)dst = llrint(num / den) * intnum;
break;
case AV_OPT_TYPE_DURATION:
+#if FF_API_OLD_CHANNEL_LAYOUT
+FF_DISABLE_DEPRECATION_WARNINGS
case AV_OPT_TYPE_CHANNEL_LAYOUT:
+FF_ENABLE_DEPRECATION_WARNINGS
+#endif
case AV_OPT_TYPE_INT64:{
double d = num / den;
if (intnum == 1 && d == (double)INT64_MAX) {
const char * const_names[64];
int search_flags = (o->flags & AV_OPT_FLAG_CHILD_CONSTS) ? AV_OPT_SEARCH_CHILDREN : 0;
const AVOption *o_named = av_opt_find(target_obj, i ? buf : val, o->unit, 0, search_flags);
- if (o_named && o_named->type == AV_OPT_TYPE_CONST)
+ if (o_named && o_named->type == AV_OPT_TYPE_CONST) {
d = DEFAULT_NUMVAL(o_named);
- else {
+ if (o_named->flags & AV_OPT_FLAG_DEPRECATED)
+ av_log(obj, AV_LOG_WARNING, "The \"%s\" option is deprecated: %s\n",
+ o_named->name, o_named->help);
+ } else {
if (o->unit) {
for (o_named = NULL; o_named = av_opt_next(target_obj, o_named); ) {
if (o_named->type == AV_OPT_TYPE_CONST &&
return 0;
}
+static int set_string_channel_layout(void *obj, const AVOption *o,
+ const char *val, void *dst)
+{
+ AVChannelLayout *channel_layout = dst;
+ av_channel_layout_uninit(channel_layout);
+ if (!val)
+ return 0;
+ return av_channel_layout_from_string(channel_layout, val);
+}
+
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
{
int ret = 0;
const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
if (!o || !target_obj)
return AVERROR_OPTION_NOT_FOUND;
+FF_DISABLE_DEPRECATION_WARNINGS
if (!val && (o->type != AV_OPT_TYPE_STRING &&
o->type != AV_OPT_TYPE_PIXEL_FMT && o->type != AV_OPT_TYPE_SAMPLE_FMT &&
o->type != AV_OPT_TYPE_IMAGE_SIZE &&
o->type != AV_OPT_TYPE_DURATION && o->type != AV_OPT_TYPE_COLOR &&
- o->type != AV_OPT_TYPE_CHANNEL_LAYOUT && o->type != AV_OPT_TYPE_BOOL))
+#if FF_API_OLD_CHANNEL_LAYOUT
+ o->type != AV_OPT_TYPE_CHANNEL_LAYOUT &&
+#endif
+ o->type != AV_OPT_TYPE_BOOL))
return AVERROR(EINVAL);
+FF_ENABLE_DEPRECATION_WARNINGS
if (o->flags & AV_OPT_FLAG_READONLY)
return AVERROR(EINVAL);
}
case AV_OPT_TYPE_COLOR:
return set_string_color(obj, o, val, dst);
+#if FF_API_OLD_CHANNEL_LAYOUT
+FF_DISABLE_DEPRECATION_WARNINGS
case AV_OPT_TYPE_CHANNEL_LAYOUT:
if (!val || !strcmp(val, "none")) {
*(int64_t *)dst = 0;
return ret;
}
break;
+FF_ENABLE_DEPRECATION_WARNINGS
+#endif
+ case AV_OPT_TYPE_CHLAYOUT:
+ ret = set_string_channel_layout(obj, o, val, dst);
+ if (ret < 0) {
+ av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\" as channel layout\n", val);
+ ret = AVERROR(EINVAL);
+ }
+ return ret;
case AV_OPT_TYPE_DICT:
return set_string_dict(obj, o, val, dst);
}
return set_format(obj, name, fmt, search_flags, AV_OPT_TYPE_SAMPLE_FMT, "sample", AV_SAMPLE_FMT_NB);
}
+#if FF_API_OLD_CHANNEL_LAYOUT
+FF_DISABLE_DEPRECATION_WARNINGS
int av_opt_set_channel_layout(void *obj, const char *name, int64_t cl, int search_flags)
{
void *target_obj;
*(int64_t *)(((uint8_t *)target_obj) + o->offset) = cl;
return 0;
}
+FF_ENABLE_DEPRECATION_WARNINGS
+#endif
int av_opt_set_dict_val(void *obj, const char *name, const AVDictionary *val,
int search_flags)
return 0;
}
+int av_opt_set_chlayout(void *obj, const char *name,
+ const AVChannelLayout *channel_layout,
+ int search_flags)
+{
+ void *target_obj;
+ const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
+ AVChannelLayout *dst;
+
+ if (!o || !target_obj)
+ return AVERROR_OPTION_NOT_FOUND;
+
+ dst = (AVChannelLayout*)((uint8_t*)target_obj + o->offset);
+
+ return av_channel_layout_copy(dst, channel_layout);
+}
+
static void format_duration(char *buf, size_t size, int64_t d)
{
char *e;
(int)((uint8_t *)dst)[0], (int)((uint8_t *)dst)[1],
(int)((uint8_t *)dst)[2], (int)((uint8_t *)dst)[3]);
break;
+#if FF_API_OLD_CHANNEL_LAYOUT
+FF_DISABLE_DEPRECATION_WARNINGS
case AV_OPT_TYPE_CHANNEL_LAYOUT:
+
i64 = *(int64_t *)dst;
ret = snprintf(buf, sizeof(buf), "0x%"PRIx64, i64);
break;
+FF_ENABLE_DEPRECATION_WARNINGS
+#endif
+ case AV_OPT_TYPE_CHLAYOUT:
+ ret = av_channel_layout_describe(dst, buf, sizeof(buf));
+ break;
case AV_OPT_TYPE_DICT:
if (!*(AVDictionary **)dst && (search_flags & AV_OPT_ALLOW_NULL)) {
*out_val = NULL;
if ((ret = get_number(obj, name, NULL, &num, &den, &intnum, search_flags)) < 0)
return ret;
- *out_val = num * intnum / den;
+ if (num == den)
+ *out_val = intnum;
+ else
+ *out_val = num * intnum / den;
return 0;
}
return get_format(obj, name, search_flags, out_fmt, AV_OPT_TYPE_SAMPLE_FMT, "sample");
}
+#if FF_API_OLD_CHANNEL_LAYOUT
+FF_DISABLE_DEPRECATION_WARNINGS
int av_opt_get_channel_layout(void *obj, const char *name, int search_flags, int64_t *cl)
{
void *dst, *target_obj;
*cl = *(int64_t *)dst;
return 0;
}
+FF_ENABLE_DEPRECATION_WARNINGS
+#endif
+
+int av_opt_get_chlayout(void *obj, const char *name, int search_flags, AVChannelLayout *cl)
+{
+ void *dst, *target_obj;
+ const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
+ if (!o || !target_obj)
+ return AVERROR_OPTION_NOT_FOUND;
+ if (o->type != AV_OPT_TYPE_CHLAYOUT) {
+ av_log(obj, AV_LOG_ERROR,
+ "The value for option '%s' is not a channel layout.\n", name);
+ return AVERROR(EINVAL);
+ }
+
+ dst = ((uint8_t*)target_obj) + o->offset;
+ return av_channel_layout_copy(cl, dst);
+}
int av_opt_get_dict_val(void *obj, const char *name, int search_flags, AVDictionary **out_val)
{
av_log(av_log_obj, AV_LOG_INFO, " %-15s ", opt->name);
else
av_log(av_log_obj, AV_LOG_INFO, " %s%-17s ",
- (opt->flags & AV_OPT_FLAG_FILTERING_PARAM) ? "" : "-",
+ (opt->flags & AV_OPT_FLAG_FILTERING_PARAM) ? " " : "-",
opt->name);
switch (opt->type) {
case AV_OPT_TYPE_COLOR:
av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<color>");
break;
+ case AV_OPT_TYPE_CHLAYOUT:
+#if FF_API_OLD_CHANNEL_LAYOUT
+FF_DISABLE_DEPRECATION_WARNINGS
case AV_OPT_TYPE_CHANNEL_LAYOUT:
+FF_ENABLE_DEPRECATION_WARNINGS
+#endif
av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<channel_layout>");
break;
case AV_OPT_TYPE_BOOL:
av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "");
break;
}
- av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_ENCODING_PARAM) ? 'E' : '.');
- av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_DECODING_PARAM) ? 'D' : '.');
- av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_FILTERING_PARAM)? 'F' : '.');
- av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_VIDEO_PARAM ) ? 'V' : '.');
- av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_AUDIO_PARAM ) ? 'A' : '.');
- av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_SUBTITLE_PARAM) ? 'S' : '.');
- av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_EXPORT) ? 'X' : '.');
- av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_READONLY) ? 'R' : '.');
- av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_BSF_PARAM) ? 'B' : '.');
- av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_RUNTIME_PARAM) ? 'T' : '.');
+ av_log(av_log_obj, AV_LOG_INFO, "%c%c%c%c%c%c%c%c%c%c%c",
+ (opt->flags & AV_OPT_FLAG_ENCODING_PARAM) ? 'E' : '.',
+ (opt->flags & AV_OPT_FLAG_DECODING_PARAM) ? 'D' : '.',
+ (opt->flags & AV_OPT_FLAG_FILTERING_PARAM) ? 'F' : '.',
+ (opt->flags & AV_OPT_FLAG_VIDEO_PARAM) ? 'V' : '.',
+ (opt->flags & AV_OPT_FLAG_AUDIO_PARAM) ? 'A' : '.',
+ (opt->flags & AV_OPT_FLAG_SUBTITLE_PARAM) ? 'S' : '.',
+ (opt->flags & AV_OPT_FLAG_EXPORT) ? 'X' : '.',
+ (opt->flags & AV_OPT_FLAG_READONLY) ? 'R' : '.',
+ (opt->flags & AV_OPT_FLAG_BSF_PARAM) ? 'B' : '.',
+ (opt->flags & AV_OPT_FLAG_RUNTIME_PARAM) ? 'T' : '.',
+ (opt->flags & AV_OPT_FLAG_DEPRECATED) ? 'P' : '.');
if (opt->help)
av_log(av_log_obj, AV_LOG_INFO, " %s", opt->help);
opt->type == AV_OPT_TYPE_IMAGE_SIZE ||
opt->type == AV_OPT_TYPE_STRING ||
opt->type == AV_OPT_TYPE_DICT ||
+ opt->type == AV_OPT_TYPE_CHLAYOUT ||
opt->type == AV_OPT_TYPE_VIDEO_RATE) &&
!opt->default_val.str)) {
av_log(av_log_obj, AV_LOG_INFO, " (default ");
case AV_OPT_TYPE_STRING:
case AV_OPT_TYPE_DICT:
case AV_OPT_TYPE_VIDEO_RATE:
+ case AV_OPT_TYPE_CHLAYOUT:
av_log(av_log_obj, AV_LOG_INFO, "\"%s\"", opt->default_val.str);
break;
+#if FF_API_OLD_CHANNEL_LAYOUT
+FF_DISABLE_DEPRECATION_WARNINGS
case AV_OPT_TYPE_CHANNEL_LAYOUT:
av_log(av_log_obj, AV_LOG_INFO, "0x%"PRIx64, opt->default_val.i64);
break;
+FF_ENABLE_DEPRECATION_WARNINGS
+#endif
}
av_log(av_log_obj, AV_LOG_INFO, ")");
}
case AV_OPT_TYPE_INT64:
case AV_OPT_TYPE_UINT64:
case AV_OPT_TYPE_DURATION:
+#if FF_API_OLD_CHANNEL_LAYOUT
+FF_DISABLE_DEPRECATION_WARNINGS
case AV_OPT_TYPE_CHANNEL_LAYOUT:
+FF_ENABLE_DEPRECATION_WARNINGS
+#endif
case AV_OPT_TYPE_PIXEL_FMT:
case AV_OPT_TYPE_SAMPLE_FMT:
write_number(s, opt, dst, 1, 1, opt->default_val.i64);
case AV_OPT_TYPE_BINARY:
set_string_binary(s, opt, opt->default_val.str, dst);
break;
+ case AV_OPT_TYPE_CHLAYOUT:
+ set_string_channel_layout(s, opt, opt->default_val.str, dst);
+ break;
case AV_OPT_TYPE_DICT:
set_string_dict(s, opt, opt->default_val.str, dst);
break;
av_dict_free((AVDictionary **)(((uint8_t *)obj) + o->offset));
break;
+ case AV_OPT_TYPE_CHLAYOUT:
+ av_channel_layout_uninit((AVChannelLayout *)(((uint8_t *)obj) + o->offset));
+ break;
+
default:
break;
}
int av_opt_set_dict2(void *obj, AVDictionary **options, int search_flags)
{
- AVDictionaryEntry *t = NULL;
+ const AVDictionaryEntry *t = NULL;
AVDictionary *tmp = NULL;
- int ret = 0;
+ int ret;
if (!options)
return 0;
- while ((t = av_dict_get(*options, "", t, AV_DICT_IGNORE_SUFFIX))) {
+ while ((t = av_dict_iterate(*options, t))) {
ret = av_opt_set(obj, t->key, t->value, search_flags);
if (ret == AVERROR_OPTION_NOT_FOUND)
- ret = av_dict_set(&tmp, t->key, t->value, 0);
+ ret = av_dict_set(&tmp, t->key, t->value, AV_DICT_MULTIKEY);
if (ret < 0) {
av_log(obj, AV_LOG_ERROR, "Error setting option %s to value %s.\n", t->key, t->value);
av_dict_free(&tmp);
return ret;
}
- ret = 0;
}
av_dict_free(options);
*options = tmp;
- return ret;
+ return 0;
}
int av_opt_set_dict(void *obj, AVDictionary **options)
if (search_flags & AV_OPT_SEARCH_CHILDREN) {
if (search_flags & AV_OPT_SEARCH_FAKE_OBJ) {
- const AVClass *child = NULL;
- while (child = av_opt_child_class_next(c, child))
+ void *iter = NULL;
+ const AVClass *child;
+ while (child = av_opt_child_class_iterate(c, &iter))
if (o = av_opt_find2(&child, name, unit, opt_flags, search_flags, NULL))
return o;
} else {
return NULL;
}
-const AVClass *av_opt_child_class_next(const AVClass *parent, const AVClass *prev)
+const AVClass *av_opt_child_class_iterate(const AVClass *parent, void **iter)
{
- if (parent->child_class_next)
- return parent->child_class_next(prev);
+ if (parent->child_class_iterate)
+ return parent->child_class_iterate(iter);
return NULL;
}
case AV_OPT_TYPE_FLAGS:
return sizeof(int);
case AV_OPT_TYPE_DURATION:
+#if FF_API_OLD_CHANNEL_LAYOUT
+FF_DISABLE_DEPRECATION_WARNINGS
case AV_OPT_TYPE_CHANNEL_LAYOUT:
+FF_ENABLE_DEPRECATION_WARNINGS
+#endif
case AV_OPT_TYPE_INT64:
case AV_OPT_TYPE_UINT64:
return sizeof(int64_t);
} else if (o->type == AV_OPT_TYPE_DICT) {
AVDictionary **sdict = (AVDictionary **) field_src;
AVDictionary **ddict = (AVDictionary **) field_dst;
+ int ret2;
if (*sdict != *ddict)
av_dict_free(ddict);
*ddict = NULL;
- av_dict_copy(ddict, *sdict, 0);
- if (av_dict_count(*sdict) != av_dict_count(*ddict))
- ret = AVERROR(ENOMEM);
+ ret2 = av_dict_copy(ddict, *sdict, 0);
+ if (ret2 < 0)
+ ret = ret2;
+ } else if (o->type == AV_OPT_TYPE_CHLAYOUT) {
+ if (field_dst != field_src)
+ ret = av_channel_layout_copy(field_dst, field_src);
} else {
int size = opt_size(o->type);
if (size < 0)
{
int ret;
const AVClass *c = *(AVClass**)obj;
- int (*callback)(AVOptionRanges **, void *obj, const char *key, int flags) = NULL;
-
- if (c->version > (52 << 16 | 11 << 8))
- callback = c->query_ranges;
+ int (*callback)(AVOptionRanges **, void *obj, const char *key, int flags) = c->query_ranges;
if (!callback)
callback = av_opt_query_ranges_default;
case AV_OPT_TYPE_DOUBLE:
case AV_OPT_TYPE_DURATION:
case AV_OPT_TYPE_COLOR:
+#if FF_API_OLD_CHANNEL_LAYOUT
+FF_DISABLE_DEPRECATION_WARNINGS
case AV_OPT_TYPE_CHANNEL_LAYOUT:
+FF_ENABLE_DEPRECATION_WARNINGS
+#endif
break;
case AV_OPT_TYPE_STRING:
range->component_min = 0;
case AV_OPT_TYPE_PIXEL_FMT:
case AV_OPT_TYPE_SAMPLE_FMT:
case AV_OPT_TYPE_INT:
+#if FF_API_OLD_CHANNEL_LAYOUT
+FF_DISABLE_DEPRECATION_WARNINGS
case AV_OPT_TYPE_CHANNEL_LAYOUT:
+FF_ENABLE_DEPRECATION_WARNINGS
+#endif
case AV_OPT_TYPE_DURATION:
case AV_OPT_TYPE_INT64:
case AV_OPT_TYPE_UINT64:
read_number(o, dst, NULL, NULL, &i64);
return o->default_val.i64 == i64;
+ case AV_OPT_TYPE_CHLAYOUT: {
+ AVChannelLayout ch_layout = { 0 };
+ if (o->default_val.str) {
+ if ((ret = av_channel_layout_from_string(&ch_layout, o->default_val.str)) < 0)
+ return ret;
+ }
+ return !av_channel_layout_compare((AVChannelLayout *)dst, &ch_layout);
+ }
case AV_OPT_TYPE_STRING:
str = *(char **)dst;
if (str == o->default_val.str) //2 NULLs
case AV_OPT_TYPE_DICT: {
AVDictionary *dict1 = NULL;
AVDictionary *dict2 = *(AVDictionary **)dst;
- AVDictionaryEntry *en1 = NULL;
- AVDictionaryEntry *en2 = NULL;
+ const AVDictionaryEntry *en1 = NULL;
+ const AVDictionaryEntry *en2 = NULL;
ret = av_dict_parse_string(&dict1, o->default_val.str, "=", ":", 0);
if (ret < 0) {
av_dict_free(&dict1);
return ret;
}
do {
- en1 = av_dict_get(dict1, "", en1, AV_DICT_IGNORE_SUFFIX);
- en2 = av_dict_get(dict2, "", en2, AV_DICT_IGNORE_SUFFIX);
+ en1 = av_dict_iterate(dict1, en1);
+ en2 = av_dict_iterate(dict2, en2);
} while (en1 && en2 && !strcmp(en1->key, en2->key) && !strcmp(en1->value, en2->value));
av_dict_free(&dict1);
return (!en1 && !en2);
av_freep(&buf);
}
}
- av_bprint_finalize(&bprint, buffer);
+ ret = av_bprint_finalize(&bprint, buffer);
+ if (ret < 0)
+ return ret;
return 0;
}