#include "libavutil/common.h"
#include "libavutil/eval.h"
#include "libavutil/pixdesc.h"
-#include "libavutil/parseutils.h"
#include "avfilter.h"
#include "internal.h"
#include "formats.h"
/**
* Add all refs from a to ret and destroy a.
*/
-#define MERGE_REF(ret, a, fmts, type, fail) \
+#define MERGE_REF(ret, a, fmts, type, fail_statement) \
do { \
type ***tmp; \
int i; \
\
if (!(tmp = av_realloc_array(ret->refs, ret->refcount + a->refcount, \
sizeof(*tmp)))) \
- goto fail; \
+ { fail_statement } \
ret->refs = tmp; \
\
for (i = 0; i < a->refcount; i ++) { \
} while (0)
/**
- * Add all formats common for a and b to ret, copy the refs and destroy
- * a and b.
+ * Add all formats common to a and b to a, add b's refs to a and destroy b.
+ * If check is set, nothing is modified and it is only checked whether
+ * the formats are compatible.
+ * If empty_allowed is set and one of a,b->nb is zero, the lists are
+ * merged; otherwise, it is treated as error.
*/
-#define MERGE_FORMATS(ret, a, b, fmts, nb, type, fail) \
-do { \
- int i, j, k = 0, count = FFMIN(a->nb, b->nb); \
- \
- if (!(ret = av_mallocz(sizeof(*ret)))) \
- goto fail; \
- \
- if (count) { \
- if (!(ret->fmts = av_malloc_array(count, sizeof(*ret->fmts)))) \
- goto fail; \
- for (i = 0; i < a->nb; i++) \
- for (j = 0; j < b->nb; j++) \
- if (a->fmts[i] == b->fmts[j]) { \
- if(k >= FFMIN(a->nb, b->nb)){ \
- av_log(NULL, AV_LOG_ERROR, "Duplicate formats in %s detected\n", __FUNCTION__); \
- av_free(ret->fmts); \
- av_free(ret); \
- return NULL; \
- } \
- ret->fmts[k++] = a->fmts[i]; \
- } \
- } \
- ret->nb = k; \
- /* check that there was at least one common format */ \
- if (!ret->nb) \
- goto fail; \
- \
- MERGE_REF(ret, a, fmts, type, fail); \
- MERGE_REF(ret, b, fmts, type, fail); \
+#define MERGE_FORMATS(a, b, fmts, nb, type, check, empty_allowed) \
+do { \
+ int i, j, k = 0, skip = 0; \
+ \
+ if (empty_allowed) { \
+ if (!a->nb || !b->nb) { \
+ if (check) \
+ return 1; \
+ if (!a->nb) \
+ FFSWAP(type *, a, b); \
+ skip = 1; \
+ } \
+ } \
+ if (!skip) { \
+ for (i = 0; i < a->nb; i++) \
+ for (j = 0; j < b->nb; j++) \
+ if (a->fmts[i] == b->fmts[j]) { \
+ if (check) \
+ return 1; \
+ a->fmts[k++] = a->fmts[i]; \
+ break; \
+ } \
+ /* Check that there was at least one common format. \
+ * Notice that both a and b are unchanged if not. */ \
+ if (!k) \
+ return 0; \
+ av_assert2(!check); \
+ a->nb = k; \
+ } \
+ \
+ MERGE_REF(a, b, fmts, type, return AVERROR(ENOMEM);); \
} while (0)
-AVFilterFormats *ff_merge_formats(AVFilterFormats *a, AVFilterFormats *b,
- enum AVMediaType type)
+static int merge_formats_internal(AVFilterFormats *a, AVFilterFormats *b,
+ enum AVMediaType type, int check)
{
- AVFilterFormats *ret = NULL;
int i, j;
int alpha1=0, alpha2=0;
int chroma1=0, chroma2=0;
if (a == b)
- return a;
+ return 1;
/* Do not lose chroma or alpha in merging.
It happens if both lists have formats with chroma (resp. alpha), but
// If chroma or alpha can be lost through merging then do not merge
if (alpha2 > alpha1 || chroma2 > chroma1)
- return NULL;
+ return 0;
- MERGE_FORMATS(ret, a, b, formats, nb_formats, AVFilterFormats, fail);
+ MERGE_FORMATS(a, b, formats, nb_formats, AVFilterFormats, check, 0);
- return ret;
-fail:
- if (ret) {
- av_freep(&ret->refs);
- av_freep(&ret->formats);
- }
- av_freep(&ret);
- return NULL;
+ return 1;
}
-AVFilterFormats *ff_merge_samplerates(AVFilterFormats *a,
- AVFilterFormats *b)
+int ff_can_merge_formats(const AVFilterFormats *a, const AVFilterFormats *b,
+ enum AVMediaType type)
{
- AVFilterFormats *ret = NULL;
+ return merge_formats_internal((AVFilterFormats *)a,
+ (AVFilterFormats *)b, type, 1);
+}
- if (a == b) return a;
+int ff_merge_formats(AVFilterFormats *a, AVFilterFormats *b,
+ enum AVMediaType type)
+{
+ av_assert2(a->refcount && b->refcount);
+ return merge_formats_internal(a, b, type, 0);
+}
- if (a->nb_formats && b->nb_formats) {
- MERGE_FORMATS(ret, a, b, formats, nb_formats, AVFilterFormats, fail);
- } else if (a->nb_formats) {
- MERGE_REF(a, b, formats, AVFilterFormats, fail);
- ret = a;
- } else {
- MERGE_REF(b, a, formats, AVFilterFormats, fail);
- ret = b;
- }
+static int merge_samplerates_internal(AVFilterFormats *a,
+ AVFilterFormats *b, int check)
+{
+ if (a == b) return 1;
- return ret;
-fail:
- if (ret) {
- av_freep(&ret->refs);
- av_freep(&ret->formats);
- }
- av_freep(&ret);
- return NULL;
+ MERGE_FORMATS(a, b, formats, nb_formats, AVFilterFormats, check, 1);
+ return 1;
}
-AVFilterChannelLayouts *ff_merge_channel_layouts(AVFilterChannelLayouts *a,
- AVFilterChannelLayouts *b)
+int ff_can_merge_samplerates(const AVFilterFormats *a, const AVFilterFormats *b)
{
- AVFilterChannelLayouts *ret = NULL;
+ return merge_samplerates_internal((AVFilterFormats *)a, (AVFilterFormats *)b, 1);
+}
+
+int ff_merge_samplerates(AVFilterFormats *a, AVFilterFormats *b)
+{
+ av_assert2(a->refcount && b->refcount);
+ return merge_samplerates_internal(a, b, 0);
+}
+
+int ff_merge_channel_layouts(AVFilterChannelLayouts *a,
+ AVFilterChannelLayouts *b)
+{
+ uint64_t *channel_layouts;
unsigned a_all = a->all_layouts + a->all_counts;
unsigned b_all = b->all_layouts + b->all_counts;
int ret_max, ret_nb = 0, i, j, round;
- if (a == b) return a;
+ av_assert2(a->refcount && b->refcount);
+
+ if (a == b) return 1;
/* Put the most generic set in a, to avoid doing everything twice */
if (a_all < b_all) {
/* Not optimal: the unknown layouts of b may become known after
another merge. */
if (!j)
- return NULL;
+ return 0;
b->nb_channel_layouts = j;
}
- MERGE_REF(b, a, channel_layouts, AVFilterChannelLayouts, fail);
- return b;
+ MERGE_REF(b, a, channel_layouts, AVFilterChannelLayouts, return AVERROR(ENOMEM););
+ return 1;
}
ret_max = a->nb_channel_layouts + b->nb_channel_layouts;
- if (!(ret = av_mallocz(sizeof(*ret))) ||
- !(ret->channel_layouts = av_malloc_array(ret_max,
- sizeof(*ret->channel_layouts))))
- goto fail;
+ if (!(channel_layouts = av_malloc_array(ret_max, sizeof(*channel_layouts))))
+ return AVERROR(ENOMEM);
/* a[known] intersect b[known] */
for (i = 0; i < a->nb_channel_layouts; i++) {
continue;
for (j = 0; j < b->nb_channel_layouts; j++) {
if (a->channel_layouts[i] == b->channel_layouts[j]) {
- ret->channel_layouts[ret_nb++] = a->channel_layouts[i];
+ channel_layouts[ret_nb++] = a->channel_layouts[i];
a->channel_layouts[i] = b->channel_layouts[j] = 0;
+ break;
}
}
}
bfmt = FF_COUNT2LAYOUT(av_get_channel_layout_nb_channels(fmt));
for (j = 0; j < b->nb_channel_layouts; j++)
if (b->channel_layouts[j] == bfmt)
- ret->channel_layouts[ret_nb++] = a->channel_layouts[i];
+ channel_layouts[ret_nb++] = a->channel_layouts[i];
}
/* 1st round: swap to prepare 2nd round; 2nd round: put it back */
FFSWAP(AVFilterChannelLayouts *, a, b);
continue;
for (j = 0; j < b->nb_channel_layouts; j++)
if (a->channel_layouts[i] == b->channel_layouts[j])
- ret->channel_layouts[ret_nb++] = a->channel_layouts[i];
+ channel_layouts[ret_nb++] = a->channel_layouts[i];
}
- ret->nb_channel_layouts = ret_nb;
- if (!ret->nb_channel_layouts)
- goto fail;
- MERGE_REF(ret, a, channel_layouts, AVFilterChannelLayouts, fail);
- MERGE_REF(ret, b, channel_layouts, AVFilterChannelLayouts, fail);
- return ret;
-
-fail:
- if (ret) {
- av_freep(&ret->refs);
- av_freep(&ret->channel_layouts);
+ if (!ret_nb) {
+ av_free(channel_layouts);
+ return 0;
}
- av_freep(&ret);
- return NULL;
+
+ if (a->refcount > b->refcount)
+ FFSWAP(AVFilterChannelLayouts *, a, b);
+
+ MERGE_REF(b, a, channel_layouts, AVFilterChannelLayouts,
+ { av_free(channel_layouts); return AVERROR(ENOMEM); });
+ av_freep(&b->channel_layouts);
+ b->channel_layouts = channel_layouts;
+ b->nb_channel_layouts = ret_nb;
+ return 1;
}
int ff_fmt_is_in(int fmt, const int *fmts)
return formats;
}
-AVFilterChannelLayouts *ff_make_formatu64_list(const uint64_t *fmts)
-{
- MAKE_FORMAT_LIST(AVFilterChannelLayouts,
- channel_layouts, nb_channel_layouts);
- if (count)
- memcpy(formats->channel_layouts, fmts,
- sizeof(*formats->channel_layouts) * count);
-
- return formats;
-}
-
-AVFilterChannelLayouts *avfilter_make_format64_list(const int64_t *fmts)
+AVFilterChannelLayouts *ff_make_format64_list(const int64_t *fmts)
{
MAKE_FORMAT_LIST(AVFilterChannelLayouts,
channel_layouts, nb_channel_layouts);
#define ADD_FORMAT(f, fmt, unref_fn, type, list, nb) \
do { \
type *fmts; \
- void *oldf = *f; \
\
if (!(*f) && !(*f = av_mallocz(sizeof(**f)))) { \
- unref_fn(f); \
return AVERROR(ENOMEM); \
} \
\
sizeof(*(*f)->list)); \
if (!fmts) { \
unref_fn(f); \
- if (!oldf) \
- av_freep(f); \
return AVERROR(ENOMEM); \
} \
\
return ret;
}
-const int64_t avfilter_all_channel_layouts[] = {
-#include "all_channel_layouts.inc"
- -1
-};
-
-// AVFilterFormats *avfilter_make_all_channel_layouts(void)
-// {
-// return avfilter_make_format64_list(avfilter_all_channel_layouts);
-// }
+int ff_formats_pixdesc_filter(AVFilterFormats **rfmts, unsigned want, unsigned rej)
+{
+ unsigned nb_formats, fmt, flags;
+ AVFilterFormats *formats = NULL;
+
+ while (1) {
+ nb_formats = 0;
+ for (fmt = 0;; fmt++) {
+ const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(fmt);
+ if (!desc)
+ break;
+ flags = desc->flags;
+ if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL) &&
+ !(desc->flags & AV_PIX_FMT_FLAG_PLANAR) &&
+ (desc->log2_chroma_w || desc->log2_chroma_h))
+ flags |= FF_PIX_FMT_FLAG_SW_FLAT_SUB;
+ if ((flags & (want | rej)) != want)
+ continue;
+ if (formats)
+ formats->formats[nb_formats] = fmt;
+ nb_formats++;
+ }
+ if (formats) {
+ av_assert0(formats->nb_formats == nb_formats);
+ *rfmts = formats;
+ return 0;
+ }
+ formats = av_mallocz(sizeof(*formats));
+ if (!formats)
+ return AVERROR(ENOMEM);
+ formats->nb_formats = nb_formats;
+ if (nb_formats) {
+ formats->formats = av_malloc_array(nb_formats, sizeof(*formats->formats));
+ if (!formats->formats) {
+ av_freep(&formats);
+ return AVERROR(ENOMEM);
+ }
+ }
+ }
+}
AVFilterFormats *ff_planar_sample_fmts(void)
{
#define FORMATS_REF(f, ref, unref_fn) \
void *tmp; \
\
- if (!f || !ref) \
+ if (!f) \
return AVERROR(ENOMEM); \
\
tmp = av_realloc_array(f->refs, sizeof(*f->refs), f->refcount + 1); \
do { \
int idx = -1; \
\
- if (!*ref || !(*ref)->refs) \
+ if (!*ref) \
return; \
\
FIND_REF_INDEX(ref, idx); \
\
- if (idx >= 0) \
+ if (idx >= 0) { \
memmove((*ref)->refs + idx, (*ref)->refs + idx + 1, \
sizeof(*(*ref)->refs) * ((*ref)->refcount - idx - 1)); \
- \
- if(!--(*ref)->refcount) { \
+ --(*ref)->refcount; \
+ } \
+ if (!(*ref)->refcount) { \
av_free((*ref)->list); \
av_free((*ref)->refs); \
av_free(*ref); \
FORMATS_CHANGEREF(oldref, newref);
}
-#define SET_COMMON_FORMATS(ctx, fmts, in_fmts, out_fmts, ref_fn, unref_fn, list) \
+#define SET_COMMON_FORMATS(ctx, fmts, ref_fn, unref_fn) \
int count = 0, i; \
\
if (!fmts) \
return AVERROR(ENOMEM); \
\
for (i = 0; i < ctx->nb_inputs; i++) { \
- if (ctx->inputs[i] && !ctx->inputs[i]->out_fmts) { \
- int ret = ref_fn(fmts, &ctx->inputs[i]->out_fmts); \
+ if (ctx->inputs[i] && !ctx->inputs[i]->outcfg.fmts) { \
+ int ret = ref_fn(fmts, &ctx->inputs[i]->outcfg.fmts); \
if (ret < 0) { \
- unref_fn(&fmts); \
- av_freep(&fmts->list); \
- av_freep(&fmts); \
return ret; \
} \
count++; \
} \
} \
for (i = 0; i < ctx->nb_outputs; i++) { \
- if (ctx->outputs[i] && !ctx->outputs[i]->in_fmts) { \
- int ret = ref_fn(fmts, &ctx->outputs[i]->in_fmts); \
+ if (ctx->outputs[i] && !ctx->outputs[i]->incfg.fmts) { \
+ int ret = ref_fn(fmts, &ctx->outputs[i]->incfg.fmts); \
if (ret < 0) { \
- unref_fn(&fmts); \
- av_freep(&fmts->list); \
- av_freep(&fmts); \
return ret; \
} \
count++; \
} \
\
if (!count) { \
- av_freep(&fmts->list); \
- av_freep(&fmts->refs); \
- av_freep(&fmts); \
+ unref_fn(&fmts); \
} \
\
return 0;
int ff_set_common_channel_layouts(AVFilterContext *ctx,
- AVFilterChannelLayouts *layouts)
+ AVFilterChannelLayouts *channel_layouts)
{
- SET_COMMON_FORMATS(ctx, layouts, in_channel_layouts, out_channel_layouts,
- ff_channel_layouts_ref, ff_channel_layouts_unref, channel_layouts);
+ SET_COMMON_FORMATS(ctx, channel_layouts,
+ ff_channel_layouts_ref, ff_channel_layouts_unref);
}
int ff_set_common_samplerates(AVFilterContext *ctx,
AVFilterFormats *samplerates)
{
- SET_COMMON_FORMATS(ctx, samplerates, in_samplerates, out_samplerates,
- ff_formats_ref, ff_formats_unref, formats);
+ SET_COMMON_FORMATS(ctx, samplerates,
+ ff_formats_ref, ff_formats_unref);
}
/**
*/
int ff_set_common_formats(AVFilterContext *ctx, AVFilterFormats *formats)
{
- SET_COMMON_FORMATS(ctx, formats, in_formats, out_formats,
- ff_formats_ref, ff_formats_unref, formats);
+ SET_COMMON_FORMATS(ctx, formats,
+ ff_formats_ref, ff_formats_unref);
}
-static int default_query_formats_common(AVFilterContext *ctx,
- AVFilterChannelLayouts *(layouts)(void))
+int ff_default_query_formats(AVFilterContext *ctx)
{
int ret;
- enum AVMediaType type = ctx->inputs && ctx->inputs [0] ? ctx->inputs [0]->type :
- ctx->outputs && ctx->outputs[0] ? ctx->outputs[0]->type :
+ enum AVMediaType type = ctx->nb_inputs ? ctx->inputs [0]->type :
+ ctx->nb_outputs ? ctx->outputs[0]->type :
AVMEDIA_TYPE_VIDEO;
ret = ff_set_common_formats(ctx, ff_all_formats(type));
if (ret < 0)
return ret;
if (type == AVMEDIA_TYPE_AUDIO) {
- ret = ff_set_common_channel_layouts(ctx, layouts());
+ ret = ff_set_common_channel_layouts(ctx, ff_all_channel_counts());
if (ret < 0)
return ret;
ret = ff_set_common_samplerates(ctx, ff_all_samplerates());
return 0;
}
-int ff_default_query_formats(AVFilterContext *ctx)
-{
- return default_query_formats_common(ctx, ff_all_channel_counts);
-}
-
-int ff_query_formats_all_layouts(AVFilterContext *ctx)
-{
- return default_query_formats_common(ctx, ff_all_channel_layouts);
-}
-
/* internal functions for parsing audio format arguments */
int ff_parse_pixel_format(enum AVPixelFormat *ret, const char *arg, void *log_ctx)
return 0;
}
-int ff_parse_sample_format(int *ret, const char *arg, void *log_ctx)
-{
- char *tail;
- int sfmt = av_get_sample_fmt(arg);
- if (sfmt == AV_SAMPLE_FMT_NONE) {
- sfmt = strtol(arg, &tail, 0);
- if (*tail || av_get_bytes_per_sample(sfmt)<=0) {
- av_log(log_ctx, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
- return AVERROR(EINVAL);
- }
- }
- *ret = sfmt;
- return 0;
-}
-
-int ff_parse_time_base(AVRational *ret, const char *arg, void *log_ctx)
-{
- AVRational r;
- if(av_parse_ratio(&r, arg, INT_MAX, 0, log_ctx) < 0 ||r.num<=0 ||r.den<=0) {
- av_log(log_ctx, AV_LOG_ERROR, "Invalid time base '%s'\n", arg);
- return AVERROR(EINVAL);
- }
- *ret = r;
- return 0;
-}
-
int ff_parse_sample_rate(int *ret, const char *arg, void *log_ctx)
{
char *tail;
return 0;
}
+
+static int check_list(void *log, const char *name, const AVFilterFormats *fmts)
+{
+ unsigned i, j;
+
+ if (!fmts)
+ return 0;
+ if (!fmts->nb_formats) {
+ av_log(log, AV_LOG_ERROR, "Empty %s list\n", name);
+ return AVERROR(EINVAL);
+ }
+ for (i = 0; i < fmts->nb_formats; i++) {
+ for (j = i + 1; j < fmts->nb_formats; j++) {
+ if (fmts->formats[i] == fmts->formats[j]) {
+ av_log(log, AV_LOG_ERROR, "Duplicated %s\n", name);
+ return AVERROR(EINVAL);
+ }
+ }
+ }
+ return 0;
+}
+
+int ff_formats_check_pixel_formats(void *log, const AVFilterFormats *fmts)
+{
+ return check_list(log, "pixel format", fmts);
+}
+
+int ff_formats_check_sample_formats(void *log, const AVFilterFormats *fmts)
+{
+ return check_list(log, "sample format", fmts);
+}
+
+int ff_formats_check_sample_rates(void *log, const AVFilterFormats *fmts)
+{
+ if (!fmts || !fmts->nb_formats)
+ return 0;
+ return check_list(log, "sample rate", fmts);
+}
+
+static int layouts_compatible(uint64_t a, uint64_t b)
+{
+ return a == b ||
+ (KNOWN(a) && !KNOWN(b) && av_get_channel_layout_nb_channels(a) == FF_LAYOUT2COUNT(b)) ||
+ (KNOWN(b) && !KNOWN(a) && av_get_channel_layout_nb_channels(b) == FF_LAYOUT2COUNT(a));
+}
+
+int ff_formats_check_channel_layouts(void *log, const AVFilterChannelLayouts *fmts)
+{
+ unsigned i, j;
+
+ if (!fmts)
+ return 0;
+ if (fmts->all_layouts < fmts->all_counts) {
+ av_log(log, AV_LOG_ERROR, "Inconsistent generic list\n");
+ return AVERROR(EINVAL);
+ }
+ if (!fmts->all_layouts && !fmts->nb_channel_layouts) {
+ av_log(log, AV_LOG_ERROR, "Empty channel layout list\n");
+ return AVERROR(EINVAL);
+ }
+ for (i = 0; i < fmts->nb_channel_layouts; i++) {
+ for (j = i + 1; j < fmts->nb_channel_layouts; j++) {
+ if (layouts_compatible(fmts->channel_layouts[i], fmts->channel_layouts[j])) {
+ av_log(log, AV_LOG_ERROR, "Duplicated or redundant channel layout\n");
+ return AVERROR(EINVAL);
+ }
+ }
+ }
+ return 0;
+}
projects / ffmpeg / blobdiff