X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=libavfilter%2Fformats.c;h=78f698745ca1d7acfd331dfb275689d87bce4432;hb=06754f7bbf341062581accc27b5cce353e99fd82;hp=31ee445c494ee38fdd75b6e6517274ed70a31a6e;hpb=b2f32d60eeaf883bb7d9e1b8cc2fb9a983d08f72;p=ffmpeg diff --git a/libavfilter/formats.c b/libavfilter/formats.c index 31ee445c494..78f698745ca 100644 --- a/libavfilter/formats.c +++ b/libavfilter/formats.c @@ -34,14 +34,14 @@ /** * 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 ++) { \ @@ -55,50 +55,54 @@ do { \ } 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 @@ -122,56 +126,58 @@ AVFilterFormats *ff_merge_formats(AVFilterFormats *a, AVFilterFormats *b, // 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) { @@ -187,18 +193,16 @@ AVFilterChannelLayouts *ff_merge_channel_layouts(AVFilterChannelLayouts *a, /* 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++) { @@ -206,8 +210,9 @@ AVFilterChannelLayouts *ff_merge_channel_layouts(AVFilterChannelLayouts *a, 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; } } } @@ -221,7 +226,7 @@ AVFilterChannelLayouts *ff_merge_channel_layouts(AVFilterChannelLayouts *a, 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); @@ -232,23 +237,23 @@ AVFilterChannelLayouts *ff_merge_channel_layouts(AVFilterChannelLayouts *a, 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) @@ -289,7 +294,7 @@ AVFilterFormats *ff_make_format_list(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); @@ -300,16 +305,12 @@ AVFilterChannelLayouts *ff_make_formatu64_list(const uint64_t *fmts) 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 { \ @@ -317,7 +318,6 @@ do { \ void *oldf = *f; \ \ if (!(*f) && !(*f = av_mallocz(sizeof(**f)))) { \ - unref_fn(f); \ return AVERROR(ENOMEM); \ } \ \ @@ -369,15 +369,46 @@ AVFilterFormats *ff_all_formats(enum AVMediaType type) 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) { @@ -456,7 +487,7 @@ do { \ do { \ int idx = -1; \ \ - if (!*ref || !(*ref)->refs) \ + if (!ref || !*ref || !(*ref)->refs) \ return; \ \ FIND_REF_INDEX(ref, idx); \ @@ -518,7 +549,8 @@ void ff_formats_changeref(AVFilterFormats **oldref, AVFilterFormats **newref) 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; \ } \ @@ -530,7 +562,8 @@ void ff_formats_changeref(AVFilterFormats **oldref, AVFilterFormats **newref) 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; \ } \