/* * 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 <stddef.h>#include <string.h> #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(AVComplexFloat) : sizeof(float);    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);    }}