From 26a029d407be480d791972afb5975cf62c9360a6 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Fri, 19 Apr 2024 02:47:55 +0200 Subject: Adding upstream version 124.0.1. Signed-off-by: Daniel Baumann --- media/ffvpx/libavcodec/avfft.c | 268 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 268 insertions(+) create mode 100644 media/ffvpx/libavcodec/avfft.c (limited to 'media/ffvpx/libavcodec/avfft.c') diff --git a/media/ffvpx/libavcodec/avfft.c b/media/ffvpx/libavcodec/avfft.c new file mode 100644 index 0000000000..627fd7a0be --- /dev/null +++ b/media/ffvpx/libavcodec/avfft.c @@ -0,0 +1,268 @@ +/* + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include +#include + +#include "libavutil/attributes.h" +#include "libavutil/macros.h" +#include "libavutil/mem.h" +#include "libavutil/tx.h" +#include "avfft.h" + +typedef struct AVTXWrapper { + AVTXContext *ctx; + av_tx_fn fn; + + AVTXContext *ctx2; + av_tx_fn fn2; + + ptrdiff_t stride; + int len; + int inv; + + float *tmp; + int out_of_place; +} AVTXWrapper; + +/* FFT */ + +FFTContext *av_fft_init(int nbits, int inverse) +{ + int ret; + float scale = 1.0f; + AVTXWrapper *s = av_mallocz(sizeof(*s)); + if (!s) + return NULL; + + ret = av_tx_init(&s->ctx, &s->fn, AV_TX_FLOAT_FFT, inverse, 1 << nbits, + &scale, AV_TX_INPLACE); + if (ret < 0) { + av_free(s); + return NULL; + } + + return (FFTContext *)s; +} + +void av_fft_permute(FFTContext *s, FFTComplex *z) +{ + /* Empty */ +} + +void av_fft_calc(FFTContext *s, FFTComplex *z) +{ + AVTXWrapper *w = (AVTXWrapper *)s; + w->fn(w->ctx, z, (void *)z, sizeof(AVComplexFloat)); +} + +av_cold void av_fft_end(FFTContext *s) +{ + if (s) { + AVTXWrapper *w = (AVTXWrapper *)s; + av_tx_uninit(&w->ctx); + av_tx_uninit(&w->ctx2); + av_free(w); + } +} + +FFTContext *av_mdct_init(int nbits, int inverse, double scale) +{ + int ret; + float scale_f = scale; + AVTXWrapper *s = av_mallocz(sizeof(*s)); + if (!s) + return NULL; + + ret = av_tx_init(&s->ctx, &s->fn, AV_TX_FLOAT_MDCT, inverse, 1 << (nbits - 1), &scale_f, 0); + if (ret < 0) { + av_free(s); + return NULL; + } + + if (inverse) { + ret = av_tx_init(&s->ctx2, &s->fn2, AV_TX_FLOAT_MDCT, inverse, 1 << (nbits - 1), + &scale_f, AV_TX_FULL_IMDCT); + if (ret < 0) { + av_tx_uninit(&s->ctx); + av_free(s); + return NULL; + } + } + + return (FFTContext *)s; +} + +void av_imdct_calc(FFTContext *s, FFTSample *output, const FFTSample *input) +{ + AVTXWrapper *w = (AVTXWrapper *)s; + w->fn2(w->ctx2, output, (void *)input, sizeof(float)); +} + +void av_imdct_half(FFTContext *s, FFTSample *output, const FFTSample *input) +{ + AVTXWrapper *w = (AVTXWrapper *)s; + w->fn(w->ctx, output, (void *)input, sizeof(float)); +} + +void av_mdct_calc(FFTContext *s, FFTSample *output, const FFTSample *input) +{ + AVTXWrapper *w = (AVTXWrapper *)s; + w->fn(w->ctx, output, (void *)input, sizeof(float)); +} + +av_cold void av_mdct_end(FFTContext *s) +{ + if (s) { + AVTXWrapper *w = (AVTXWrapper *)s; + av_tx_uninit(&w->ctx2); + av_tx_uninit(&w->ctx); + av_free(w); + } +} + +RDFTContext *av_rdft_init(int nbits, enum RDFTransformType trans) +{ + int ret; + float scale = trans == IDFT_C2R ? 0.5f : 1.0f; + AVTXWrapper *s; + + /* The other 2 modes are unconventional, do not form an orthogonal + * transform, have never been useful, and so they're not implemented. */ + if (trans != IDFT_C2R && trans != DFT_R2C) + return NULL; + + s = av_mallocz(sizeof(*s)); + if (!s) + return NULL; + + ret = av_tx_init(&s->ctx, &s->fn, AV_TX_FLOAT_RDFT, trans == IDFT_C2R, + 1 << nbits, &scale, 0x0); + if (ret < 0) { + av_free(s); + return NULL; + } + + s->stride = (trans == DFT_C2R) ? sizeof(float) : sizeof(AVComplexFloat); + s->len = 1 << nbits; + s->inv = trans == IDFT_C2R; + + s->tmp = av_malloc((s->len + 2)*sizeof(float)); + if (!s->tmp) { + av_tx_uninit(&s->ctx); + av_free(s); + return NULL; + } + + return (RDFTContext *)s; +} + +void av_rdft_calc(RDFTContext *s, FFTSample *data) +{ + AVTXWrapper *w = (AVTXWrapper *)s; + float *src = w->inv ? w->tmp : (float *)data; + float *dst = w->inv ? (float *)data : w->tmp; + + if (w->inv) { + memcpy(src, data, w->len*sizeof(float)); + + src[w->len] = src[1]; + src[1] = 0.0f; + } + + w->fn(w->ctx, dst, (void *)src, w->stride); + + if (!w->inv) { + dst[1] = dst[w->len]; + memcpy(data, dst, w->len*sizeof(float)); + } +} + +av_cold void av_rdft_end(RDFTContext *s) +{ + if (s) { + AVTXWrapper *w = (AVTXWrapper *)s; + av_tx_uninit(&w->ctx); + av_free(w->tmp); + av_free(w); + } +} + +DCTContext *av_dct_init(int nbits, enum DCTTransformType inverse) +{ + int ret; + const float scale_map[] = { + [DCT_II] = 0.5f, + [DCT_III] = 1.0f / (1 << nbits), + [DCT_I] = 0.5f, + [DST_I] = 2.0f, + }; + static const enum AVTXType type_map[] = { + [DCT_II] = AV_TX_FLOAT_DCT, + [DCT_III] = AV_TX_FLOAT_DCT, + [DCT_I] = AV_TX_FLOAT_DCT_I, + [DST_I] = AV_TX_FLOAT_DST_I, + }; + + AVTXWrapper *s = av_mallocz(sizeof(*s)); + if (!s) + return NULL; + + s->len = (1 << nbits); + s->out_of_place = (inverse == DCT_I) || (inverse == DST_I); + + ret = av_tx_init(&s->ctx, &s->fn, type_map[inverse], + (inverse == DCT_III), 1 << (nbits - (inverse == DCT_III)), + &scale_map[inverse], s->out_of_place ? 0 : AV_TX_INPLACE); + if (ret < 0) { + av_free(s); + return NULL; + } + + if (s->out_of_place) { + s->tmp = av_malloc((1 << (nbits + 1))*sizeof(float)); + if (!s->tmp) { + av_tx_uninit(&s->ctx); + av_free(s); + return NULL; + } + } + + return (DCTContext *)s; +} + +void av_dct_calc(DCTContext *s, FFTSample *data) +{ + AVTXWrapper *w = (AVTXWrapper *)s; + if (w->out_of_place) { + memcpy(w->tmp, data, w->len*sizeof(float)); + w->fn(w->ctx, (void *)data, w->tmp, sizeof(float)); + } else { + w->fn(w->ctx, data, (void *)data, sizeof(float)); + } +} + +av_cold void av_dct_end(DCTContext *s) +{ + if (s) { + AVTXWrapper *w = (AVTXWrapper *)s; + av_tx_uninit(&w->ctx); + av_free(w->tmp); + av_free(w); + } +} -- cgit v1.2.3