/**
* 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) \
+#define MERGE_FORMATS(a, b, fmts, nb, type, check, empty_allowed) \
do { \
- int i, j, k = 0, count = FFMIN(a->nb, b->nb); \
+ int i, j, k = 0, skip = 0; \
\
- if (!(ret = av_mallocz(sizeof(*ret)))) \
- goto fail; \
- \
- if (count) { \
- if (!(ret->fmts = av_malloc_array(count, sizeof(*ret->fmts)))) \
- goto fail; \
+ 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(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]; \
+ if (check) \
+ return 1; \
+ a->fmts[k++] = a->fmts[i]; \
+ break; \
} \
- } \
- 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); \
+ /* 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;
+}
+
+int ff_can_merge_samplerates(const AVFilterFormats *a, const AVFilterFormats *b)
+{
+ 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);
}
-AVFilterChannelLayouts *ff_merge_channel_layouts(AVFilterChannelLayouts *a,
- AVFilterChannelLayouts *b)
+int ff_merge_channel_layouts(AVFilterChannelLayouts *a,
+ AVFilterChannelLayouts *b)
{
- AVFilterChannelLayouts *ret = NULL;
+ 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)
+AVFilterChannelLayouts *ff_make_format64_list(const int64_t *fmts)
{
MAKE_FORMAT_LIST(AVFilterChannelLayouts,
channel_layouts, nb_channel_layouts);
return formats;
}
+#if LIBAVFILTER_VERSION_MAJOR < 8
AVFilterChannelLayouts *avfilter_make_format64_list(const int64_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;
+ return ff_make_format64_list(fmts);
}
+#endif
#define ADD_FORMAT(f, fmt, unref_fn, type, list, nb) \
do { \
void *oldf = *f; \
\
if (!(*f) && !(*f = av_mallocz(sizeof(**f)))) { \
- unref_fn(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)
{
do { \
int idx = -1; \
\
- if (!*ref || !(*ref)->refs) \
+ if (!ref || !*ref || !(*ref)->refs) \
return; \
\
FIND_REF_INDEX(ref, idx); \
int ret = ref_fn(fmts, &ctx->inputs[i]->out_fmts); \
if (ret < 0) { \
unref_fn(&fmts); \
- av_freep(&fmts->list); \
+ if (fmts) \
+ av_freep(&fmts->list); \
av_freep(&fmts); \
return ret; \
} \
int ret = ref_fn(fmts, &ctx->outputs[i]->in_fmts); \
if (ret < 0) { \
unref_fn(&fmts); \
- av_freep(&fmts->list); \
+ if (fmts) \
+ av_freep(&fmts->list); \
av_freep(&fmts); \
return ret; \
} \