/**
* Add all refs from a to ret and destroy a.
- * ret->refs must have enough spare room left for this.
*/
-#define MERGE_REF_NO_ALLOC(ret, a, fmts) \
+#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)))) \
+ { fail_statement } \
+ ret->refs = tmp; \
+ \
for (i = 0; i < a->refcount; i ++) { \
ret->refs[ret->refcount] = a->refs[i]; \
*ret->refs[ret->refcount++] = ret; \
av_freep(&a); \
} while (0)
-#define MERGE_REF(ret, a, fmts, type, fail) \
-do { \
- type ***tmp; \
- \
- if (!(tmp = av_realloc_array(ret->refs, ret->refcount + a->refcount, \
- sizeof(*tmp)))) \
- goto fail; \
- ret->refs = tmp; \
- MERGE_REF_NO_ALLOC(ret, a, fmts); \
-} 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); \
- type ***tmp; \
- \
- if (!(ret = av_mallocz(sizeof(*ret)))) \
- goto fail; \
+ int i, j, k = 0, skip = 0; \
\
- 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; \
- \
- tmp = av_realloc_array(NULL, a->refcount + b->refcount, sizeof(*tmp)); \
- if (!tmp) \
- goto fail; \
- ret->refs = tmp; \
- \
- MERGE_REF_NO_ALLOC(ret, a, fmts); \
- MERGE_REF_NO_ALLOC(ret, b, fmts); \
+ /* 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_assert1(!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_assert1(!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;
+ if (!ret_nb) {
+ av_free(channel_layouts);
+ return 0;
+ }
- ret->refs = av_realloc_array(NULL, a->refcount + b->refcount,
- sizeof(*ret->refs));
- if (!ret->refs)
- goto fail;
- MERGE_REF_NO_ALLOC(ret, a, channel_layouts);
- MERGE_REF_NO_ALLOC(ret, b, channel_layouts);
- return ret;
+ if (a->refcount > b->refcount)
+ FFSWAP(AVFilterChannelLayouts *, a, b);
-fail:
- if (ret) {
- av_assert1(!ret->refs);
- av_freep(&ret->channel_layouts);
- av_freep(&ret);
- }
- return NULL;
+ 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)
projects / ffmpeg / blobdiff