fft: remove inline wrappers for function pointers

This removes the rather pointless wrappers (one not even inline)
for calling the fft_calc and related function pointers.

Signed-off-by: Mans Rullgard <mans@mansr.com>
oldabi
Mans Rullgard 14 years ago
parent ec10a9ab46
commit 26f548bb59
  1. 6
      libavcodec/aacdec.c
  2. 4
      libavcodec/aacenc.c
  3. 8
      libavcodec/aacsbr.c
  4. 6
      libavcodec/ac3dec.c
  5. 2
      libavcodec/ac3enc_float.c
  6. 2
      libavcodec/atrac1.c
  7. 4
      libavcodec/atrac3.c
  8. 4
      libavcodec/avfft.c
  9. 4
      libavcodec/binkaudio.c
  10. 2
      libavcodec/cook.c
  11. 13
      libavcodec/dct.c
  12. 24
      libavcodec/fft-test.c
  13. 45
      libavcodec/fft.h
  14. 4
      libavcodec/imc.c
  15. 4
      libavcodec/mdct.c
  16. 2
      libavcodec/nellymoserdec.c
  17. 4
      libavcodec/nellymoserenc.c
  18. 2
      libavcodec/qdm2.c
  19. 8
      libavcodec/rdft.c
  20. 2
      libavcodec/synth_filter.c
  21. 3
      libavcodec/twinvq.c
  22. 6
      libavcodec/vorbis_dec.c
  23. 2
      libavcodec/vorbis_enc.c
  24. 5
      libavcodec/wmadec.c
  25. 3
      libavcodec/wmaenc.c
  26. 6
      libavcodec/wmaprodec.c
  27. 14
      libavcodec/wmavoice.c

@ -1750,7 +1750,7 @@ static void windowing_and_mdct_ltp(AACContext *ac, float *out,
ac->dsp.vector_fmul_reverse(in + 1024 + 448, in + 1024 + 448, swindow, 128); ac->dsp.vector_fmul_reverse(in + 1024 + 448, in + 1024 + 448, swindow, 128);
memset(in + 1024 + 576, 0, 448 * sizeof(float)); memset(in + 1024 + 576, 0, 448 * sizeof(float));
} }
ff_mdct_calc(&ac->mdct_ltp, out, in); ac->mdct_ltp.mdct_calc(&ac->mdct_ltp, out, in);
} }
/** /**
@ -1839,9 +1839,9 @@ static void imdct_and_windowing(AACContext *ac, SingleChannelElement *sce)
// imdct // imdct
if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) { if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
for (i = 0; i < 1024; i += 128) for (i = 0; i < 1024; i += 128)
ff_imdct_half(&ac->mdct_small, buf + i, in + i); ac->mdct_small.imdct_half(&ac->mdct_small, buf + i, in + i);
} else } else
ff_imdct_half(&ac->mdct, buf, in); ac->mdct.imdct_half(&ac->mdct, buf, in);
/* window overlapping /* window overlapping
* NOTE: To simplify the overlapping code, all 'meaningless' short to long * NOTE: To simplify the overlapping code, all 'meaningless' short to long

@ -250,7 +250,7 @@ static void apply_window_and_mdct(AVCodecContext *avctx, AACEncContext *s,
for (i = 0; i < 1024; i++) for (i = 0; i < 1024; i++)
sce->saved[i] = audio[i * chans]; sce->saved[i] = audio[i * chans];
} }
ff_mdct_calc(&s->mdct1024, sce->coeffs, output); s->mdct1024.mdct_calc(&s->mdct1024, sce->coeffs, output);
} else { } else {
for (k = 0; k < 1024; k += 128) { for (k = 0; k < 1024; k += 128) {
for (i = 448 + k; i < 448 + k + 256; i++) for (i = 448 + k; i < 448 + k + 256; i++)
@ -259,7 +259,7 @@ static void apply_window_and_mdct(AVCodecContext *avctx, AACEncContext *s,
: audio[(i-1024)*chans]; : audio[(i-1024)*chans];
s->dsp.vector_fmul (output, output, k ? swindow : pwindow, 128); s->dsp.vector_fmul (output, output, k ? swindow : pwindow, 128);
s->dsp.vector_fmul_reverse(output+128, output+128, swindow, 128); s->dsp.vector_fmul_reverse(output+128, output+128, swindow, 128);
ff_mdct_calc(&s->mdct128, sce->coeffs + k, output); s->mdct128.mdct_calc(&s->mdct128, sce->coeffs + k, output);
} }
for (i = 0; i < 1024; i++) for (i = 0; i < 1024; i++)
sce->saved[i] = audio[i * chans]; sce->saved[i] = audio[i * chans];

@ -1155,7 +1155,7 @@ static void sbr_qmf_analysis(DSPContext *dsp, FFTContext *mdct, const float *in,
} }
z[64+63] = z[32]; z[64+63] = z[32];
ff_imdct_half(mdct, z, z+64); mdct->imdct_half(mdct, z, z+64);
for (k = 0; k < 32; k++) { for (k = 0; k < 32; k++) {
W[1][i][k][0] = -z[63-k]; W[1][i][k][0] = -z[63-k];
W[1][i][k][1] = z[k]; W[1][i][k][1] = z[k];
@ -1190,7 +1190,7 @@ static void sbr_qmf_synthesis(DSPContext *dsp, FFTContext *mdct,
X[0][i][ n] = -X[0][i][n]; X[0][i][ n] = -X[0][i][n];
X[0][i][32+n] = X[1][i][31-n]; X[0][i][32+n] = X[1][i][31-n];
} }
ff_imdct_half(mdct, mdct_buf[0], X[0][i]); mdct->imdct_half(mdct, mdct_buf[0], X[0][i]);
for (n = 0; n < 32; n++) { for (n = 0; n < 32; n++) {
v[ n] = mdct_buf[0][63 - 2*n]; v[ n] = mdct_buf[0][63 - 2*n];
v[63 - n] = -mdct_buf[0][62 - 2*n]; v[63 - n] = -mdct_buf[0][62 - 2*n];
@ -1199,8 +1199,8 @@ static void sbr_qmf_synthesis(DSPContext *dsp, FFTContext *mdct,
for (n = 1; n < 64; n+=2) { for (n = 1; n < 64; n+=2) {
X[1][i][n] = -X[1][i][n]; X[1][i][n] = -X[1][i][n];
} }
ff_imdct_half(mdct, mdct_buf[0], X[0][i]); mdct->imdct_half(mdct, mdct_buf[0], X[0][i]);
ff_imdct_half(mdct, mdct_buf[1], X[1][i]); mdct->imdct_half(mdct, mdct_buf[1], X[1][i]);
for (n = 0; n < 64; n++) { for (n = 0; n < 64; n++) {
v[ n] = -mdct_buf[0][63 - n] + mdct_buf[1][ n ]; v[ n] = -mdct_buf[0][63 - n] + mdct_buf[1][ n ];
v[127 - n] = mdct_buf[0][63 - n] + mdct_buf[1][ n ]; v[127 - n] = mdct_buf[0][63 - n] + mdct_buf[1][ n ];

@ -628,13 +628,13 @@ static inline void do_imdct(AC3DecodeContext *s, int channels)
float *x = s->tmp_output+128; float *x = s->tmp_output+128;
for(i=0; i<128; i++) for(i=0; i<128; i++)
x[i] = s->transform_coeffs[ch][2*i]; x[i] = s->transform_coeffs[ch][2*i];
ff_imdct_half(&s->imdct_256, s->tmp_output, x); s->imdct_256.imdct_half(&s->imdct_256, s->tmp_output, x);
s->dsp.vector_fmul_window(s->output[ch-1], s->delay[ch-1], s->tmp_output, s->window, 128); s->dsp.vector_fmul_window(s->output[ch-1], s->delay[ch-1], s->tmp_output, s->window, 128);
for(i=0; i<128; i++) for(i=0; i<128; i++)
x[i] = s->transform_coeffs[ch][2*i+1]; x[i] = s->transform_coeffs[ch][2*i+1];
ff_imdct_half(&s->imdct_256, s->delay[ch-1], x); s->imdct_256.imdct_half(&s->imdct_256, s->delay[ch-1], x);
} else { } else {
ff_imdct_half(&s->imdct_512, s->tmp_output, s->transform_coeffs[ch]); s->imdct_512.imdct_half(&s->imdct_512, s->tmp_output, s->transform_coeffs[ch]);
s->dsp.vector_fmul_window(s->output[ch-1], s->delay[ch-1], s->tmp_output, s->window, 128); s->dsp.vector_fmul_window(s->output[ch-1], s->delay[ch-1], s->tmp_output, s->window, 128);
memcpy(s->delay[ch-1], s->tmp_output+128, 128*sizeof(float)); memcpy(s->delay[ch-1], s->tmp_output+128, 128*sizeof(float));
} }

@ -74,7 +74,7 @@ static av_cold int mdct_init(AVCodecContext *avctx, AC3MDCTContext *mdct,
*/ */
static void mdct512(AC3MDCTContext *mdct, float *out, float *in) static void mdct512(AC3MDCTContext *mdct, float *out, float *in)
{ {
ff_mdct_calc(&mdct->fft, out, in); mdct->fft.mdct_calc(&mdct->fft, out, in);
} }

@ -99,7 +99,7 @@ static void at1_imdct(AT1Ctx *q, float *spec, float *out, int nbits,
for (i = 0; i < transf_size / 2; i++) for (i = 0; i < transf_size / 2; i++)
FFSWAP(float, spec[i], spec[transf_size - 1 - i]); FFSWAP(float, spec[i], spec[transf_size - 1 - i]);
} }
ff_imdct_half(mdct_context, out, spec); mdct_context->imdct_half(mdct_context, out, spec);
} }

@ -146,7 +146,7 @@ static void IMLT(ATRAC3Context *q, float *pInput, float *pOutput, int odd_band)
/** /**
* Reverse the odd bands before IMDCT, this is an effect of the QMF transform * Reverse the odd bands before IMDCT, this is an effect of the QMF transform
* or it gives better compression to do it this way. * or it gives better compression to do it this way.
* FIXME: It should be possible to handle this in ff_imdct_calc * FIXME: It should be possible to handle this in imdct_calc
* for that to happen a modification of the prerotation step of * for that to happen a modification of the prerotation step of
* all SIMD code and C code is needed. * all SIMD code and C code is needed.
* Or fix the functions before so they generate a pre reversed spectrum. * Or fix the functions before so they generate a pre reversed spectrum.
@ -156,7 +156,7 @@ static void IMLT(ATRAC3Context *q, float *pInput, float *pOutput, int odd_band)
FFSWAP(float, pInput[i], pInput[255-i]); FFSWAP(float, pInput[i], pInput[255-i]);
} }
ff_imdct_calc(&q->mdct_ctx,pOutput,pInput); q->mdct_ctx.imdct_calc(&q->mdct_ctx,pOutput,pInput);
/* Perform windowing on the output. */ /* Perform windowing on the output. */
dsp.vector_fmul(pOutput, pOutput, mdct_window, 512); dsp.vector_fmul(pOutput, pOutput, mdct_window, 512);

@ -101,7 +101,7 @@ RDFTContext *av_rdft_init(int nbits, enum RDFTransformType trans)
void av_rdft_calc(RDFTContext *s, FFTSample *data) void av_rdft_calc(RDFTContext *s, FFTSample *data)
{ {
ff_rdft_calc(s, data); s->rdft_calc(s, data);
} }
void av_rdft_end(RDFTContext *s) void av_rdft_end(RDFTContext *s)
@ -128,7 +128,7 @@ DCTContext *av_dct_init(int nbits, enum DCTTransformType inverse)
void av_dct_calc(DCTContext *s, FFTSample *data) void av_dct_calc(DCTContext *s, FFTSample *data)
{ {
ff_dct_calc(s, data); s->dct_calc(s, data);
} }
void av_dct_end(DCTContext *s) void av_dct_end(DCTContext *s)

@ -223,11 +223,11 @@ static void decode_block(BinkAudioContext *s, short *out, int use_dct)
if (CONFIG_BINKAUDIO_DCT_DECODER && use_dct) { if (CONFIG_BINKAUDIO_DCT_DECODER && use_dct) {
coeffs[0] /= 0.5; coeffs[0] /= 0.5;
ff_dct_calc (&s->trans.dct, coeffs); s->trans.dct.dct_calc(&s->trans.dct, coeffs);
s->dsp.vector_fmul_scalar(coeffs, coeffs, s->frame_len / 2, s->frame_len); s->dsp.vector_fmul_scalar(coeffs, coeffs, s->frame_len / 2, s->frame_len);
} }
else if (CONFIG_BINKAUDIO_RDFT_DECODER) else if (CONFIG_BINKAUDIO_RDFT_DECODER)
ff_rdft_calc(&s->trans.rdft, coeffs); s->trans.rdft.rdft_calc(&s->trans.rdft, coeffs);
} }
s->fmt_conv.float_to_int16_interleave(out, (const float **)s->coeffs_ptr, s->fmt_conv.float_to_int16_interleave(out, (const float **)s->coeffs_ptr,

@ -753,7 +753,7 @@ static void imlt_gain(COOKContext *q, float *inbuffer,
int i; int i;
/* Inverse modified discrete cosine transform */ /* Inverse modified discrete cosine transform */
ff_imdct_calc(&q->mdct_ctx, q->mono_mdct_output, inbuffer); q->mdct_ctx.imdct_calc(&q->mdct_ctx, q->mono_mdct_output, inbuffer);
q->imlt_window (q, buffer1, gains_ptr, previous_buffer); q->imlt_window (q, buffer1, gains_ptr, previous_buffer);

@ -59,7 +59,7 @@ static void ff_dst_calc_I_c(DCTContext *ctx, FFTSample *data)
} }
data[n/2] *= 2; data[n/2] *= 2;
ff_rdft_calc(&ctx->rdft, data); ctx->rdft.rdft_calc(&ctx->rdft, data);
data[0] *= 0.5f; data[0] *= 0.5f;
@ -93,7 +93,7 @@ static void ff_dct_calc_I_c(DCTContext *ctx, FFTSample *data)
data[n - i] = tmp1 + s; data[n - i] = tmp1 + s;
} }
ff_rdft_calc(&ctx->rdft, data); ctx->rdft.rdft_calc(&ctx->rdft, data);
data[n] = data[1]; data[n] = data[1];
data[1] = next; data[1] = next;
@ -121,7 +121,7 @@ static void ff_dct_calc_III_c(DCTContext *ctx, FFTSample *data)
data[1] = 2 * next; data[1] = 2 * next;
ff_rdft_calc(&ctx->rdft, data); ctx->rdft.rdft_calc(&ctx->rdft, data);
for (i = 0; i < n / 2; i++) { for (i = 0; i < n / 2; i++) {
float tmp1 = data[i ] * inv_n; float tmp1 = data[i ] * inv_n;
@ -152,7 +152,7 @@ static void ff_dct_calc_II_c(DCTContext *ctx, FFTSample *data)
data[n-i-1] = tmp1 - s; data[n-i-1] = tmp1 - s;
} }
ff_rdft_calc(&ctx->rdft, data); ctx->rdft.rdft_calc(&ctx->rdft, data);
next = data[1] * 0.5; next = data[1] * 0.5;
data[1] *= -1; data[1] *= -1;
@ -176,11 +176,6 @@ static void dct32_func(DCTContext *ctx, FFTSample *data)
ctx->dct32(data, data); ctx->dct32(data, data);
} }
void ff_dct_calc(DCTContext *s, FFTSample *data)
{
s->dct_calc(s, data);
}
av_cold int ff_dct_init(DCTContext *s, int nbits, enum DCTTransformType inverse) av_cold int ff_dct_init(DCTContext *s, int nbits, enum DCTTransformType inverse)
{ {
int n = 1 << nbits; int n = 1 << nbits;

@ -327,20 +327,20 @@ int main(int argc, char **argv)
case TRANSFORM_MDCT: case TRANSFORM_MDCT:
if (do_inverse) { if (do_inverse) {
imdct_ref((float *)tab_ref, (float *)tab1, fft_nbits); imdct_ref((float *)tab_ref, (float *)tab1, fft_nbits);
ff_imdct_calc(m, tab2, (float *)tab1); m->imdct_calc(m, tab2, (float *)tab1);
err = check_diff((float *)tab_ref, tab2, fft_size, scale); err = check_diff((float *)tab_ref, tab2, fft_size, scale);
} else { } else {
mdct_ref((float *)tab_ref, (float *)tab1, fft_nbits); mdct_ref((float *)tab_ref, (float *)tab1, fft_nbits);
ff_mdct_calc(m, tab2, (float *)tab1); m->mdct_calc(m, tab2, (float *)tab1);
err = check_diff((float *)tab_ref, tab2, fft_size / 2, scale); err = check_diff((float *)tab_ref, tab2, fft_size / 2, scale);
} }
break; break;
case TRANSFORM_FFT: case TRANSFORM_FFT:
memcpy(tab, tab1, fft_size * sizeof(FFTComplex)); memcpy(tab, tab1, fft_size * sizeof(FFTComplex));
ff_fft_permute(s, tab); s->fft_permute(s, tab);
ff_fft_calc(s, tab); s->fft_calc(s, tab);
fft_ref(tab_ref, tab1, fft_nbits); fft_ref(tab_ref, tab1, fft_nbits);
err = check_diff((float *)tab_ref, (float *)tab, fft_size * 2, 1.0); err = check_diff((float *)tab_ref, (float *)tab, fft_size * 2, 1.0);
@ -357,7 +357,7 @@ int main(int argc, char **argv)
memcpy(tab2, tab1, fft_size * sizeof(FFTSample)); memcpy(tab2, tab1, fft_size * sizeof(FFTSample));
tab2[1] = tab1[fft_size_2].re; tab2[1] = tab1[fft_size_2].re;
ff_rdft_calc(r, tab2); r->rdft_calc(r, tab2);
fft_ref(tab_ref, tab1, fft_nbits); fft_ref(tab_ref, tab1, fft_nbits);
for (i = 0; i < fft_size; i++) { for (i = 0; i < fft_size; i++) {
tab[i].re = tab2[i]; tab[i].re = tab2[i];
@ -369,7 +369,7 @@ int main(int argc, char **argv)
tab2[i] = tab1[i].re; tab2[i] = tab1[i].re;
tab1[i].im = 0; tab1[i].im = 0;
} }
ff_rdft_calc(r, tab2); r->rdft_calc(r, tab2);
fft_ref(tab_ref, tab1, fft_nbits); fft_ref(tab_ref, tab1, fft_nbits);
tab_ref[0].im = tab_ref[fft_size_2].re; tab_ref[0].im = tab_ref[fft_size_2].re;
err = check_diff((float *)tab_ref, (float *)tab2, fft_size, 1.0); err = check_diff((float *)tab_ref, (float *)tab2, fft_size, 1.0);
@ -377,7 +377,7 @@ int main(int argc, char **argv)
break; break;
case TRANSFORM_DCT: case TRANSFORM_DCT:
memcpy(tab, tab1, fft_size * sizeof(FFTComplex)); memcpy(tab, tab1, fft_size * sizeof(FFTComplex));
ff_dct_calc(d, tab); d->dct_calc(d, tab);
if (do_inverse) { if (do_inverse) {
idct_ref(tab_ref, tab1, fft_nbits); idct_ref(tab_ref, tab1, fft_nbits);
} else { } else {
@ -402,22 +402,22 @@ int main(int argc, char **argv)
switch (transform) { switch (transform) {
case TRANSFORM_MDCT: case TRANSFORM_MDCT:
if (do_inverse) { if (do_inverse) {
ff_imdct_calc(m, (float *)tab, (float *)tab1); m->imdct_calc(m, (float *)tab, (float *)tab1);
} else { } else {
ff_mdct_calc(m, (float *)tab, (float *)tab1); m->mdct_calc(m, (float *)tab, (float *)tab1);
} }
break; break;
case TRANSFORM_FFT: case TRANSFORM_FFT:
memcpy(tab, tab1, fft_size * sizeof(FFTComplex)); memcpy(tab, tab1, fft_size * sizeof(FFTComplex));
ff_fft_calc(s, tab); s->fft_calc(s, tab);
break; break;
case TRANSFORM_RDFT: case TRANSFORM_RDFT:
memcpy(tab2, tab1, fft_size * sizeof(FFTSample)); memcpy(tab2, tab1, fft_size * sizeof(FFTSample));
ff_rdft_calc(r, tab2); r->rdft_calc(r, tab2);
break; break;
case TRANSFORM_DCT: case TRANSFORM_DCT:
memcpy(tab2, tab1, fft_size * sizeof(FFTSample)); memcpy(tab2, tab1, fft_size * sizeof(FFTSample));
ff_dct_calc(d, tab2); d->dct_calc(d, tab2);
break; break;
} }
} }

@ -39,7 +39,14 @@ struct FFTContext {
/* pre/post rotation tables */ /* pre/post rotation tables */
FFTSample *tcos; FFTSample *tcos;
FFTSample *tsin; FFTSample *tsin;
/**
* Do the permutation needed BEFORE calling fft_calc().
*/
void (*fft_permute)(struct FFTContext *s, FFTComplex *z); void (*fft_permute)(struct FFTContext *s, FFTComplex *z);
/**
* Do a complex FFT with the parameters defined in ff_fft_init(). The
* input data must be permuted before. No 1.0/sqrt(n) normalization is done.
*/
void (*fft_calc)(struct FFTContext *s, FFTComplex *z); void (*fft_calc)(struct FFTContext *s, FFTComplex *z);
void (*imdct_calc)(struct FFTContext *s, FFTSample *output, const FFTSample *input); void (*imdct_calc)(struct FFTContext *s, FFTSample *output, const FFTSample *input);
void (*imdct_half)(struct FFTContext *s, FFTSample *output, const FFTSample *input); void (*imdct_half)(struct FFTContext *s, FFTSample *output, const FFTSample *input);
@ -115,40 +122,8 @@ void ff_fft_init_mmx(FFTContext *s);
void ff_fft_init_arm(FFTContext *s); void ff_fft_init_arm(FFTContext *s);
void ff_dct_init_mmx(DCTContext *s); void ff_dct_init_mmx(DCTContext *s);
/**
* Do the permutation needed BEFORE calling ff_fft_calc().
*/
static inline void ff_fft_permute(FFTContext *s, FFTComplex *z)
{
s->fft_permute(s, z);
}
/**
* Do a complex FFT with the parameters defined in ff_fft_init(). The
* input data must be permuted before. No 1.0/sqrt(n) normalization is done.
*/
static inline void ff_fft_calc(FFTContext *s, FFTComplex *z)
{
s->fft_calc(s, z);
}
void ff_fft_end(FFTContext *s); void ff_fft_end(FFTContext *s);
/* MDCT computation */
static inline void ff_imdct_calc(FFTContext *s, FFTSample *output, const FFTSample *input)
{
s->imdct_calc(s, output, input);
}
static inline void ff_imdct_half(FFTContext *s, FFTSample *output, const FFTSample *input)
{
s->imdct_half(s, output, input);
}
static inline void ff_mdct_calc(FFTContext *s, FFTSample *output,
const FFTSample *input)
{
s->mdct_calc(s, output, input);
}
/** /**
* Maximum window size for ff_kbd_window_init. * Maximum window size for ff_kbd_window_init.
*/ */
@ -213,11 +188,6 @@ void ff_rdft_end(RDFTContext *s);
void ff_rdft_init_arm(RDFTContext *s); void ff_rdft_init_arm(RDFTContext *s);
static av_always_inline void ff_rdft_calc(RDFTContext *s, FFTSample *data)
{
s->rdft_calc(s, data);
}
/* Discrete Cosine Transform */ /* Discrete Cosine Transform */
struct DCTContext { struct DCTContext {
@ -239,7 +209,6 @@ struct DCTContext {
* @note the first element of the input of DST-I is ignored * @note the first element of the input of DST-I is ignored
*/ */
int ff_dct_init(DCTContext *s, int nbits, enum DCTTransformType type); int ff_dct_init(DCTContext *s, int nbits, enum DCTTransformType type);
void ff_dct_calc(DCTContext *s, FFTSample *data);
void ff_dct_end (DCTContext *s); void ff_dct_end (DCTContext *s);
#endif /* AVCODEC_FFT_H */ #endif /* AVCODEC_FFT_H */

@ -564,8 +564,8 @@ static void imc_imdct256(IMCContext *q) {
} }
/* FFT */ /* FFT */
ff_fft_permute(&q->fft, q->samples); q->fft.fft_permute(&q->fft, q->samples);
ff_fft_calc (&q->fft, q->samples); q->fft.fft_calc (&q->fft, q->samples);
/* postrotation, window and reorder */ /* postrotation, window and reorder */
for(i = 0; i < COEFFS/2; i++){ for(i = 0; i < COEFFS/2; i++){

@ -146,7 +146,7 @@ void ff_imdct_half_c(FFTContext *s, FFTSample *output, const FFTSample *input)
in1 += 2; in1 += 2;
in2 -= 2; in2 -= 2;
} }
ff_fft_calc(s, z); s->fft_calc(s, z);
/* post rotation + reordering */ /* post rotation + reordering */
for(k = 0; k < n8; k++) { for(k = 0; k < n8; k++) {
@ -213,7 +213,7 @@ void ff_mdct_calc_c(FFTContext *s, FFTSample *out, const FFTSample *input)
CMUL(x[j].re, x[j].im, re, im, -tcos[n8 + i], tsin[n8 + i]); CMUL(x[j].re, x[j].im, re, im, -tcos[n8 + i], tsin[n8 + i]);
} }
ff_fft_calc(s, x); s->fft_calc(s, x);
/* post rotation */ /* post rotation */
for(i=0;i<n8;i++) { for(i=0;i<n8;i++) {

@ -121,7 +121,7 @@ static void nelly_decode_block(NellyMoserDecodeContext *s,
memset(&aptr[NELLY_FILL_LEN], 0, memset(&aptr[NELLY_FILL_LEN], 0,
(NELLY_BUF_LEN - NELLY_FILL_LEN) * sizeof(float)); (NELLY_BUF_LEN - NELLY_FILL_LEN) * sizeof(float));
ff_imdct_calc(&s->imdct_ctx, s->imdct_out, aptr); s->imdct_ctx.imdct_calc(&s->imdct_ctx, s->imdct_out, aptr);
/* XXX: overlapping and windowing should be part of a more /* XXX: overlapping and windowing should be part of a more
generic imdct function */ generic imdct function */
overlap_and_window(s, s->state, aptr, s->imdct_out); overlap_and_window(s, s->state, aptr, s->imdct_out);

@ -116,13 +116,13 @@ static void apply_mdct(NellyMoserEncodeContext *s)
s->dsp.vector_fmul(s->in_buff, s->buf[s->bufsel], ff_sine_128, NELLY_BUF_LEN); s->dsp.vector_fmul(s->in_buff, s->buf[s->bufsel], ff_sine_128, NELLY_BUF_LEN);
s->dsp.vector_fmul_reverse(s->in_buff + NELLY_BUF_LEN, s->buf[s->bufsel] + NELLY_BUF_LEN, ff_sine_128, s->dsp.vector_fmul_reverse(s->in_buff + NELLY_BUF_LEN, s->buf[s->bufsel] + NELLY_BUF_LEN, ff_sine_128,
NELLY_BUF_LEN); NELLY_BUF_LEN);
ff_mdct_calc(&s->mdct_ctx, s->mdct_out, s->in_buff); s->mdct_ctx.mdct_calc(&s->mdct_ctx, s->mdct_out, s->in_buff);
s->dsp.vector_fmul(s->buf[s->bufsel] + NELLY_BUF_LEN, s->buf[s->bufsel] + NELLY_BUF_LEN, s->dsp.vector_fmul(s->buf[s->bufsel] + NELLY_BUF_LEN, s->buf[s->bufsel] + NELLY_BUF_LEN,
ff_sine_128, NELLY_BUF_LEN); ff_sine_128, NELLY_BUF_LEN);
s->dsp.vector_fmul_reverse(s->buf[s->bufsel] + 2 * NELLY_BUF_LEN, s->buf[1 - s->bufsel], ff_sine_128, s->dsp.vector_fmul_reverse(s->buf[s->bufsel] + 2 * NELLY_BUF_LEN, s->buf[1 - s->bufsel], ff_sine_128,
NELLY_BUF_LEN); NELLY_BUF_LEN);
ff_mdct_calc(&s->mdct_ctx, s->mdct_out + NELLY_BUF_LEN, s->buf[s->bufsel] + NELLY_BUF_LEN); s->mdct_ctx.mdct_calc(&s->mdct_ctx, s->mdct_out + NELLY_BUF_LEN, s->buf[s->bufsel] + NELLY_BUF_LEN);
} }
static av_cold int encode_init(AVCodecContext *avctx) static av_cold int encode_init(AVCodecContext *avctx)

@ -1588,7 +1588,7 @@ static void qdm2_calculate_fft (QDM2Context *q, int channel, int sub_packet)
int i; int i;
q->fft.complex[channel][0].re *= 2.0f; q->fft.complex[channel][0].re *= 2.0f;
q->fft.complex[channel][0].im = 0.0f; q->fft.complex[channel][0].im = 0.0f;
ff_rdft_calc(&q->rdft_ctx, (FFTSample *)q->fft.complex[channel]); q->rdft_ctx.rdft_calc(&q->rdft_ctx, (FFTSample *)q->fft.complex[channel]);
/* add samples to output buffer */ /* add samples to output buffer */
for (i = 0; i < ((q->fft_frame_size + 15) & ~15); i++) for (i = 0; i < ((q->fft_frame_size + 15) & ~15); i++)
q->output_buffer[q->channels * i + channel] += ((float *) q->fft.complex[channel])[i] * gain; q->output_buffer[q->channels * i + channel] += ((float *) q->fft.complex[channel])[i] * gain;

@ -65,8 +65,8 @@ static void ff_rdft_calc_c(RDFTContext* s, FFTSample* data)
const FFTSample *tsin = s->tsin; const FFTSample *tsin = s->tsin;
if (!s->inverse) { if (!s->inverse) {
ff_fft_permute(&s->fft, (FFTComplex*)data); s->fft.fft_permute(&s->fft, (FFTComplex*)data);
ff_fft_calc(&s->fft, (FFTComplex*)data); s->fft.fft_calc(&s->fft, (FFTComplex*)data);
} }
/* i=0 is a special case because of packing, the DC term is real, so we /* i=0 is a special case because of packing, the DC term is real, so we
are going to throw the N/2 term (also real) in with it. */ are going to throw the N/2 term (also real) in with it. */
@ -91,8 +91,8 @@ static void ff_rdft_calc_c(RDFTContext* s, FFTSample* data)
if (s->inverse) { if (s->inverse) {
data[0] *= k1; data[0] *= k1;
data[1] *= k1; data[1] *= k1;
ff_fft_permute(&s->fft, (FFTComplex*)data); s->fft.fft_permute(&s->fft, (FFTComplex*)data);
ff_fft_calc(&s->fft, (FFTComplex*)data); s->fft.fft_calc(&s->fft, (FFTComplex*)data);
} }
} }

@ -29,7 +29,7 @@ static void synth_filter_float(FFTContext *imdct,
float *synth_buf= synth_buf_ptr + *synth_buf_offset; float *synth_buf= synth_buf_ptr + *synth_buf_offset;
int i, j; int i, j;
ff_imdct_half(imdct, synth_buf, in); imdct->imdct_half(imdct, synth_buf, in);
for (i = 0; i < 16; i++){ for (i = 0; i < 16; i++){
float a= synth_buf2[i ]; float a= synth_buf2[i ];

@ -608,6 +608,7 @@ static void dec_lpc_spectrum_inv(TwinContext *tctx, float *lsp,
static void imdct_and_window(TwinContext *tctx, enum FrameType ftype, int wtype, static void imdct_and_window(TwinContext *tctx, enum FrameType ftype, int wtype,
float *in, float *prev, int ch) float *in, float *prev, int ch)
{ {
FFTContext *mdct = &tctx->mdct_ctx[ftype];
const ModeTab *mtab = tctx->mtab; const ModeTab *mtab = tctx->mtab;
int bsize = mtab->size / mtab->fmode[ftype].sub; int bsize = mtab->size / mtab->fmode[ftype].sub;
int size = mtab->size; int size = mtab->size;
@ -640,7 +641,7 @@ static void imdct_and_window(TwinContext *tctx, enum FrameType ftype, int wtype,
wsize = types_sizes[wtype_to_wsize[sub_wtype]]; wsize = types_sizes[wtype_to_wsize[sub_wtype]];
ff_imdct_half(&tctx->mdct_ctx[ftype], buf1 + bsize*j, in + bsize*j); mdct->imdct_half(mdct, buf1 + bsize*j, in + bsize*j);
tctx->dsp.vector_fmul_window(out2, tctx->dsp.vector_fmul_window(out2,
prev_buf + (bsize-wsize)/2, prev_buf + (bsize-wsize)/2,

@ -1448,7 +1448,7 @@ void vorbis_inverse_coupling(float *mag, float *ang, int blocksize)
static int vorbis_parse_audio_packet(vorbis_context *vc) static int vorbis_parse_audio_packet(vorbis_context *vc)
{ {
GetBitContext *gb = &vc->gb; GetBitContext *gb = &vc->gb;
FFTContext *mdct;
uint_fast8_t previous_window = vc->previous_window; uint_fast8_t previous_window = vc->previous_window;
uint_fast8_t mode_number; uint_fast8_t mode_number;
uint_fast8_t blockflag; uint_fast8_t blockflag;
@ -1552,11 +1552,13 @@ static int vorbis_parse_audio_packet(vorbis_context *vc)
// Dotproduct, MDCT // Dotproduct, MDCT
mdct = &vc->mdct[blockflag];
for (j = vc->audio_channels-1;j >= 0; j--) { for (j = vc->audio_channels-1;j >= 0; j--) {
ch_floor_ptr = vc->channel_floors + j * blocksize / 2; ch_floor_ptr = vc->channel_floors + j * blocksize / 2;
ch_res_ptr = vc->channel_residues + res_chan[j] * blocksize / 2; ch_res_ptr = vc->channel_residues + res_chan[j] * blocksize / 2;
vc->dsp.vector_fmul(ch_floor_ptr, ch_floor_ptr, ch_res_ptr, blocksize / 2); vc->dsp.vector_fmul(ch_floor_ptr, ch_floor_ptr, ch_res_ptr, blocksize / 2);
ff_imdct_half(&vc->mdct[blockflag], ch_res_ptr, ch_floor_ptr); mdct->imdct_half(mdct, ch_res_ptr, ch_floor_ptr);
} }
// Overlap/add, save data for next overlapping FPMATH // Overlap/add, save data for next overlapping FPMATH

@ -935,7 +935,7 @@ static int apply_window_and_mdct(vorbis_enc_context *venc, const signed short *a
} }
for (channel = 0; channel < venc->channels; channel++) for (channel = 0; channel < venc->channels; channel++)
ff_mdct_calc(&venc->mdct[0], venc->coeffs + channel * window_len, venc->mdct[0].mdct_calc(&venc->mdct[0], venc->coeffs + channel * window_len,
venc->samples + channel * window_len * 2); venc->samples + channel * window_len * 2);
if (samples) { if (samples) {

@ -447,6 +447,7 @@ static int wma_decode_block(WMACodecContext *s)
int coef_nb_bits, total_gain; int coef_nb_bits, total_gain;
int nb_coefs[MAX_CHANNELS]; int nb_coefs[MAX_CHANNELS];
float mdct_norm; float mdct_norm;
FFTContext *mdct;
#ifdef TRACE #ifdef TRACE
tprintf(s->avctx, "***decode_block: %d:%d\n", s->frame_count - 1, s->block_num); tprintf(s->avctx, "***decode_block: %d:%d\n", s->frame_count - 1, s->block_num);
@ -742,12 +743,14 @@ static int wma_decode_block(WMACodecContext *s)
} }
next: next:
mdct = &s->mdct_ctx[bsize];
for(ch = 0; ch < s->nb_channels; ch++) { for(ch = 0; ch < s->nb_channels; ch++) {
int n4, index; int n4, index;
n4 = s->block_len / 2; n4 = s->block_len / 2;
if(s->channel_coded[ch]){ if(s->channel_coded[ch]){
ff_imdct_calc(&s->mdct_ctx[bsize], s->output, s->coefs[ch]); mdct->imdct_calc(mdct, s->output, s->coefs[ch]);
}else if(!(s->ms_stereo && ch==1)) }else if(!(s->ms_stereo && ch==1))
memset(s->output, 0, sizeof(s->output)); memset(s->output, 0, sizeof(s->output));

@ -77,6 +77,7 @@ static int encode_init(AVCodecContext * avctx){
static void apply_window_and_mdct(AVCodecContext * avctx, const signed short * audio, int len) { static void apply_window_and_mdct(AVCodecContext * avctx, const signed short * audio, int len) {
WMACodecContext *s = avctx->priv_data; WMACodecContext *s = avctx->priv_data;
int window_index= s->frame_len_bits - s->block_len_bits; int window_index= s->frame_len_bits - s->block_len_bits;
FFTContext *mdct = &s->mdct_ctx[window_index];
int i, j, channel; int i, j, channel;
const float * win = s->windows[window_index]; const float * win = s->windows[window_index];
int window_len = 1 << s->block_len_bits; int window_len = 1 << s->block_len_bits;
@ -89,7 +90,7 @@ static void apply_window_and_mdct(AVCodecContext * avctx, const signed short * a
s->output[i+window_len] = audio[j] / n * win[window_len - i - 1]; s->output[i+window_len] = audio[j] / n * win[window_len - i - 1];
s->frame_out[channel][i] = audio[j] / n * win[i]; s->frame_out[channel][i] = audio[j] / n * win[i];
} }
ff_mdct_calc(&s->mdct_ctx[window_index], s->coefs[channel], s->output); mdct->mdct_calc(mdct, s->coefs[channel], s->output);
} }
} }

@ -1222,6 +1222,7 @@ static int decode_subframe(WMAProDecodeCtx *s)
get_bits_count(&s->gb) - s->subframe_offset); get_bits_count(&s->gb) - s->subframe_offset);
if (transmit_coeffs) { if (transmit_coeffs) {
FFTContext *mdct = &s->mdct_ctx[av_log2(subframe_len) - WMAPRO_BLOCK_MIN_BITS];
/** reconstruct the per channel data */ /** reconstruct the per channel data */
inverse_channel_transform(s); inverse_channel_transform(s);
for (i = 0; i < s->channels_for_cur_subframe; i++) { for (i = 0; i < s->channels_for_cur_subframe; i++) {
@ -1246,9 +1247,8 @@ static int decode_subframe(WMAProDecodeCtx *s)
quant, end - start); quant, end - start);
} }
/** apply imdct (ff_imdct_half == DCTIV with reverse) */ /** apply imdct (imdct_half == DCTIV with reverse) */
ff_imdct_half(&s->mdct_ctx[av_log2(subframe_len) - WMAPRO_BLOCK_MIN_BITS], mdct->imdct_half(mdct, s->channel[c].coeffs, s->tmp);
s->channel[c].coeffs, s->tmp);
} }
} }

@ -558,7 +558,7 @@ static void calc_input_response(WMAVoiceContext *s, float *lpcs,
int n, idx; int n, idx;
/* Create frequency power spectrum of speech input (i.e. RDFT of LPCs) */ /* Create frequency power spectrum of speech input (i.e. RDFT of LPCs) */
ff_rdft_calc(&s->rdft, lpcs); s->rdft.rdft_calc(&s->rdft, lpcs);
#define log_range(var, assign) do { \ #define log_range(var, assign) do { \
float tmp = log10f(assign); var = tmp; \ float tmp = log10f(assign); var = tmp; \
max = FFMAX(max, tmp); min = FFMIN(min, tmp); \ max = FFMAX(max, tmp); min = FFMIN(min, tmp); \
@ -601,8 +601,8 @@ static void calc_input_response(WMAVoiceContext *s, float *lpcs,
* is a sinus input) by doing a phase shift (in theory, H(sin())=cos()). * is a sinus input) by doing a phase shift (in theory, H(sin())=cos()).
* Hilbert_Transform(RDFT(x)) = Laplace_Transform(x), which calculates the * Hilbert_Transform(RDFT(x)) = Laplace_Transform(x), which calculates the
* "moment" of the LPCs in this filter. */ * "moment" of the LPCs in this filter. */
ff_dct_calc(&s->dct, lpcs); s->dct.dct_calc(&s->dct, lpcs);
ff_dct_calc(&s->dst, lpcs); s->dst.dct_calc(&s->dst, lpcs);
/* Split out the coefficient indexes into phase/magnitude pairs */ /* Split out the coefficient indexes into phase/magnitude pairs */
idx = 255 + av_clip(lpcs[64], -255, 255); idx = 255 + av_clip(lpcs[64], -255, 255);
@ -623,7 +623,7 @@ static void calc_input_response(WMAVoiceContext *s, float *lpcs,
coeffs[1] = last_coeff; coeffs[1] = last_coeff;
/* move into real domain */ /* move into real domain */
ff_rdft_calc(&s->irdft, coeffs); s->irdft.rdft_calc(&s->irdft, coeffs);
/* tilt correction and normalize scale */ /* tilt correction and normalize scale */
memset(&coeffs[remainder], 0, sizeof(coeffs[0]) * (128 - remainder)); memset(&coeffs[remainder], 0, sizeof(coeffs[0]) * (128 - remainder));
@ -693,8 +693,8 @@ static void wiener_denoise(WMAVoiceContext *s, int fcb_type,
/* apply coefficients (in frequency spectrum domain), i.e. complex /* apply coefficients (in frequency spectrum domain), i.e. complex
* number multiplication */ * number multiplication */
memset(&synth_pf[size], 0, sizeof(synth_pf[0]) * (128 - size)); memset(&synth_pf[size], 0, sizeof(synth_pf[0]) * (128 - size));
ff_rdft_calc(&s->rdft, synth_pf); s->rdft.rdft_calc(&s->rdft, synth_pf);
ff_rdft_calc(&s->rdft, coeffs); s->rdft.rdft_calc(&s->rdft, coeffs);
synth_pf[0] *= coeffs[0]; synth_pf[0] *= coeffs[0];
synth_pf[1] *= coeffs[1]; synth_pf[1] *= coeffs[1];
for (n = 1; n < 64; n++) { for (n = 1; n < 64; n++) {
@ -702,7 +702,7 @@ static void wiener_denoise(WMAVoiceContext *s, int fcb_type,
synth_pf[n * 2] = v1 * coeffs[n * 2] - v2 * coeffs[n * 2 + 1]; synth_pf[n * 2] = v1 * coeffs[n * 2] - v2 * coeffs[n * 2 + 1];
synth_pf[n * 2 + 1] = v2 * coeffs[n * 2] + v1 * coeffs[n * 2 + 1]; synth_pf[n * 2 + 1] = v2 * coeffs[n * 2] + v1 * coeffs[n * 2 + 1];
} }
ff_rdft_calc(&s->irdft, synth_pf); s->irdft.rdft_calc(&s->irdft, synth_pf);
} }
/* merge filter output with the history of previous runs */ /* merge filter output with the history of previous runs */

Loading…
Cancel
Save