virtualenv/FFmpeg
1
0
Fork 0
mirror of https://github.com/FFmpeg/FFmpeg.git synced 2024-12-23 12:43:46 +02:00
Code Issues Releases Activity

remove mdct tmp buffer

Browse Source 
Originally committed as revision 14702 to svn://svn.ffmpeg.org/ffmpeg/trunk
This commit is contained in:
Loren Merritt 2008-08-12 00:36:36 +00:00
parent e8dd7b0c9a
commit 0a570e826d
14 changed files with 27 additions and 48 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
libavcodec/ac3dec.c
View File

@ -605,7 +605,7 @@ static void do_imdct_256(AC3DecodeContext *s, int chindex)
} }
/* run standard IMDCT */ /* run standard IMDCT */
s->imdct_256.fft.imdct_calc(&s->imdct_256, o_ptr, x, s->tmp_imdct); s->imdct_256.fft.imdct_calc(&s->imdct_256, o_ptr, x);
/* reverse the post-rotation & reordering from standard IMDCT */ /* reverse the post-rotation & reordering from standard IMDCT */
for(k=0; k<32; k++) { for(k=0; k<32; k++) {
@ -643,7 +643,7 @@ static inline void do_imdct(AC3DecodeContext *s, int channels)
do_imdct_256(s, ch); do_imdct_256(s, ch);
} else { } else {
s->imdct_512.fft.imdct_calc(&s->imdct_512, s->tmp_output, s->imdct_512.fft.imdct_calc(&s->imdct_512, s->tmp_output,
s->transform_coeffs[ch], s->tmp_imdct); s->transform_coeffs[ch]);
} }
/* For the first half of the block, apply the window, add the delay /* For the first half of the block, apply the window, add the delay
from the previous block, and send to output */ from the previous block, and send to output */

1
libavcodec/ac3dec.h
View File

@ -166,7 +166,6 @@ typedef struct {
DECLARE_ALIGNED_16(float, delay[AC3_MAX_CHANNELS][AC3_BLOCK_SIZE]); ///< delay - added to the next block DECLARE_ALIGNED_16(float, delay[AC3_MAX_CHANNELS][AC3_BLOCK_SIZE]); ///< delay - added to the next block
DECLARE_ALIGNED_16(float, window[AC3_BLOCK_SIZE]); ///< window coefficients DECLARE_ALIGNED_16(float, window[AC3_BLOCK_SIZE]); ///< window coefficients
DECLARE_ALIGNED_16(float, tmp_output[AC3_BLOCK_SIZE*2]); ///< temporary storage for output before windowing DECLARE_ALIGNED_16(float, tmp_output[AC3_BLOCK_SIZE*2]); ///< temporary storage for output before windowing
DECLARE_ALIGNED_16(float, tmp_imdct[AC3_BLOCK_SIZE]); ///< temporary storage for imdct transform
DECLARE_ALIGNED_16(float, output[AC3_MAX_CHANNELS][AC3_BLOCK_SIZE]); ///< output after imdct transform and windowing DECLARE_ALIGNED_16(float, output[AC3_MAX_CHANNELS][AC3_BLOCK_SIZE]); ///< output after imdct transform and windowing
DECLARE_ALIGNED_16(short, int_output[AC3_MAX_CHANNELS-1][AC3_BLOCK_SIZE]); ///< final 16-bit integer output DECLARE_ALIGNED_16(short, int_output[AC3_MAX_CHANNELS-1][AC3_BLOCK_SIZE]); ///< final 16-bit integer output
///@} ///@}

8
libavcodec/atrac3.c
View File

@ -108,7 +108,6 @@ typedef struct {
float outSamples[2048]; float outSamples[2048];
uint8_t* decoded_bytes_buffer; uint8_t* decoded_bytes_buffer;
float tempBuf[1070]; float tempBuf[1070];
DECLARE_ALIGNED_16(float,mdct_tmp[512]);
//@} //@}
//@{ //@{
/** extradata */ /** extradata */
@ -189,10 +188,9 @@ static void iqmf (float *inlo, float *inhi, unsigned int nIn, float *pOut, float
* @param pInput float input * @param pInput float input
* @param pOutput float output * @param pOutput float output
* @param odd_band 1 if the band is an odd band * @param odd_band 1 if the band is an odd band
* @param mdct_tmp aligned temporary buffer for the mdct
*/ */
static void IMLT(float *pInput, float *pOutput, int odd_band, float* mdct_tmp) static void IMLT(float *pInput, float *pOutput, int odd_band)
{ {
int i; int i;
@ -210,7 +208,7 @@ static void IMLT(float *pInput, float *pOutput, int odd_band, float* mdct_tmp)
FFSWAP(float, pInput[i], pInput[255-i]); FFSWAP(float, pInput[i], pInput[255-i]);
} }
mdct_ctx.fft.imdct_calc(&mdct_ctx,pOutput,pInput,mdct_tmp); mdct_ctx.fft.imdct_calc(&mdct_ctx,pOutput,pInput);
/* Perform windowing on the output. */ /* Perform windowing on the output. */
dsp.vector_fmul(pOutput,mdct_window,512); dsp.vector_fmul(pOutput,mdct_window,512);
@ -757,7 +755,7 @@ static int decodeChannelSoundUnit (ATRAC3Context *q, GetBitContext *gb, channel_
for (band=0; band<4; band++) { for (band=0; band<4; band++) {
/* Perform the IMDCT step without overlapping. */ /* Perform the IMDCT step without overlapping. */
if (band <= numBands) { if (band <= numBands) {
IMLT(&(pSnd->spectrum[band*256]), pSnd->IMDCT_buf, band&1,q->mdct_tmp); IMLT(&(pSnd->spectrum[band*256]), pSnd->IMDCT_buf, band&1);
} else } else
memset(pSnd->IMDCT_buf, 0, 512 * sizeof(float)); memset(pSnd->IMDCT_buf, 0, 512 * sizeof(float));

4
libavcodec/cook.c
View File

@ -112,7 +112,6 @@ typedef struct cook {
/* transform data */ /* transform data */
MDCTContext mdct_ctx; MDCTContext mdct_ctx;
DECLARE_ALIGNED_16(FFTSample, mdct_tmp[1024]); /* temporary storage for imlt */
float* mlt_window; float* mlt_window;
/* gain buffers */ /* gain buffers */
@ -734,8 +733,7 @@ static void imlt_gain(COOKContext *q, float *inbuffer,
int i; int i;
/* Inverse modified discrete cosine transform */ /* Inverse modified discrete cosine transform */
q->mdct_ctx.fft.imdct_calc(&q->mdct_ctx, q->mono_mdct_output, q->mdct_ctx.fft.imdct_calc(&q->mdct_ctx, q->mono_mdct_output, inbuffer);
inbuffer, q->mdct_tmp);
q->imlt_window (q, buffer1, gains_ptr, previous_buffer); q->imlt_window (q, buffer1, gains_ptr, previous_buffer);

21
libavcodec/dsputil.h
View File

@ -642,10 +642,8 @@ typedef struct FFTContext {
FFTComplex *tmp_buf; FFTComplex *tmp_buf;
void (*fft_permute)(struct FFTContext *s, FFTComplex *z); void (*fft_permute)(struct FFTContext *s, FFTComplex *z);
void (*fft_calc)(struct FFTContext *s, FFTComplex *z); void (*fft_calc)(struct FFTContext *s, FFTComplex *z);
void (*imdct_calc)(struct MDCTContext *s, FFTSample *output, void (*imdct_calc)(struct MDCTContext *s, FFTSample *output, const FFTSample *input);
const FFTSample *input, FFTSample *tmp); void (*imdct_half)(struct MDCTContext *s, FFTSample *output, const FFTSample *input);
void (*imdct_half)(struct MDCTContext *s, FFTSample *output,
const FFTSample *input);
} FFTContext; } FFTContext;
int ff_fft_init(FFTContext *s, int nbits, int inverse); int ff_fft_init(FFTContext *s, int nbits, int inverse);
@ -694,20 +692,15 @@ void ff_kbd_window_init(float *window, float alpha, int n);
void ff_sine_window_init(float *window, int n); void ff_sine_window_init(float *window, int n);
int ff_mdct_init(MDCTContext *s, int nbits, int inverse); int ff_mdct_init(MDCTContext *s, int nbits, int inverse);
void ff_imdct_calc(MDCTContext *s, FFTSample *output, void ff_imdct_calc(MDCTContext *s, FFTSample *output, const FFTSample *input);
const FFTSample *input, FFTSample *tmp);
void ff_imdct_half(MDCTContext *s, FFTSample *output, const FFTSample *input); void ff_imdct_half(MDCTContext *s, FFTSample *output, const FFTSample *input);
void ff_imdct_calc_3dn(MDCTContext *s, FFTSample *output, void ff_imdct_calc_3dn(MDCTContext *s, FFTSample *output, const FFTSample *input);
const FFTSample *input, FFTSample *tmp);
void ff_imdct_half_3dn(MDCTContext *s, FFTSample *output, const FFTSample *input); void ff_imdct_half_3dn(MDCTContext *s, FFTSample *output, const FFTSample *input);
void ff_imdct_calc_3dn2(MDCTContext *s, FFTSample *output, void ff_imdct_calc_3dn2(MDCTContext *s, FFTSample *output, const FFTSample *input);
const FFTSample *input, FFTSample *tmp);
void ff_imdct_half_3dn2(MDCTContext *s, FFTSample *output, const FFTSample *input); void ff_imdct_half_3dn2(MDCTContext *s, FFTSample *output, const FFTSample *input);
void ff_imdct_calc_sse(MDCTContext *s, FFTSample *output, void ff_imdct_calc_sse(MDCTContext *s, FFTSample *output, const FFTSample *input);
const FFTSample *input, FFTSample *tmp);
void ff_imdct_half_sse(MDCTContext *s, FFTSample *output, const FFTSample *input); void ff_imdct_half_sse(MDCTContext *s, FFTSample *output, const FFTSample *input);
void ff_mdct_calc(MDCTContext *s, FFTSample *out, void ff_mdct_calc(MDCTContext *s, FFTSample *out, const FFTSample *input);
const FFTSample *input, FFTSample *tmp);
void ff_mdct_end(MDCTContext *s); void ff_mdct_end(MDCTContext *s);
#define WRAPPER8_16(name8, name16)\ #define WRAPPER8_16(name8, name16)\

11
libavcodec/fft-test.c
View File

@ -177,7 +177,7 @@ void help(void)
int main(int argc, char **argv) int main(int argc, char **argv)
{ {
FFTComplex *tab, *tab1, *tab_ref; FFTComplex *tab, *tab1, *tab_ref;
FFTSample *tabtmp, *tab2; FFTSample *tab2;
int it, i, c; int it, i, c;
int do_speed = 0; int do_speed = 0;
int do_mdct = 0; int do_mdct = 0;
@ -214,7 +214,6 @@ int main(int argc, char **argv)
tab = av_malloc(fft_size * sizeof(FFTComplex)); tab = av_malloc(fft_size * sizeof(FFTComplex));
tab1 = av_malloc(fft_size * sizeof(FFTComplex)); tab1 = av_malloc(fft_size * sizeof(FFTComplex));
tab_ref = av_malloc(fft_size * sizeof(FFTComplex)); tab_ref = av_malloc(fft_size * sizeof(FFTComplex));
tabtmp = av_malloc(fft_size / 2 * sizeof(FFTSample));
tab2 = av_malloc(fft_size * sizeof(FFTSample)); tab2 = av_malloc(fft_size * sizeof(FFTSample));
if (do_mdct) { if (do_mdct) {
@ -246,12 +245,12 @@ int main(int argc, char **argv)
if (do_mdct) { if (do_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, tabtmp); ff_imdct_calc(m, tab2, (float *)tab1);
check_diff((float *)tab_ref, tab2, fft_size); check_diff((float *)tab_ref, tab2, fft_size);
} 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, tabtmp); ff_mdct_calc(m, tab2, (float *)tab1);
check_diff((float *)tab_ref, tab2, fft_size / 2); check_diff((float *)tab_ref, tab2, fft_size / 2);
} }
@ -278,9 +277,9 @@ int main(int argc, char **argv)
for(it=0;it<nb_its;it++) { for(it=0;it<nb_its;it++) {
if (do_mdct) { if (do_mdct) {
if (do_inverse) { if (do_inverse) {
ff_imdct_calc(m, (float *)tab, (float *)tab1, tabtmp); ff_imdct_calc(m, (float *)tab, (float *)tab1);
} else { } else {
ff_mdct_calc(m, (float *)tab, (float *)tab1, tabtmp); ff_mdct_calc(m, (float *)tab, (float *)tab1);
} }
} else { } else {
memcpy(tab, tab1, fft_size * sizeof(FFTComplex)); memcpy(tab, tab1, fft_size * sizeof(FFTComplex));

3
libavcodec/i386/fft_3dn2.c
View File

@ -142,8 +142,7 @@ void ff_imdct_half_3dn2(MDCTContext *s, FFTSample *output, const FFTSample *inpu
asm volatile("femms"); asm volatile("femms");
} }
void ff_imdct_calc_3dn2(MDCTContext *s, FFTSample *output, void ff_imdct_calc_3dn2(MDCTContext *s, FFTSample *output, const FFTSample *input)
const FFTSample *input, FFTSample *tmp)
{ {
x86_reg j, k; x86_reg j, k;
long n = 1 << s->nbits; long n = 1 << s->nbits;

3
libavcodec/i386/fft_sse.c
View File

@ -171,8 +171,7 @@ void ff_imdct_half_sse(MDCTContext *s, FFTSample *output, const FFTSample *input
); );
} }
void ff_imdct_calc_sse(MDCTContext *s, FFTSample *output, void ff_imdct_calc_sse(MDCTContext *s, FFTSample *output, const FFTSample *input)
const FFTSample *input, FFTSample *tmp)
{ {
x86_reg j, k; x86_reg j, k;
long n = 1 << s->nbits; long n = 1 << s->nbits;

8
libavcodec/mdct.c
View File

@ -150,8 +150,7 @@ void ff_imdct_half(MDCTContext *s, FFTSample *output, const FFTSample *input)
* @param input N/2 samples * @param input N/2 samples
* @param tmp N/2 samples * @param tmp N/2 samples
*/ */
void ff_imdct_calc(MDCTContext *s, FFTSample *output, void ff_imdct_calc(MDCTContext *s, FFTSample *output, const FFTSample *input)
const FFTSample *input, FFTSample *tmp)
{ {
int k; int k;
int n = 1 << s->nbits; int n = 1 << s->nbits;
@ -172,11 +171,10 @@ void ff_imdct_calc(MDCTContext *s, FFTSample *output,
* @param out N/2 samples * @param out N/2 samples
* @param tmp temporary storage of N/2 samples * @param tmp temporary storage of N/2 samples
*/ */
void ff_mdct_calc(MDCTContext *s, FFTSample *out, void ff_mdct_calc(MDCTContext *s, FFTSample *out, const FFTSample *input)
const FFTSample *input, FFTSample *tmp)
{ {
int i, j, n, n8, n4, n2, n3; int i, j, n, n8, n4, n2, n3;
FFTSample re, im, re1, im1; FFTSample re, im;
const uint16_t *revtab = s->fft.revtab; const uint16_t *revtab = s->fft.revtab;
const FFTSample *tcos = s->tcos; const FFTSample *tcos = s->tcos;
const FFTSample *tsin = s->tsin; const FFTSample *tsin = s->tsin;

4
libavcodec/nellymoserdec.c
View File

@ -50,7 +50,6 @@ typedef struct NellyMoserDecodeContext {
float scale_bias; float scale_bias;
DSPContext dsp; DSPContext dsp;
MDCTContext imdct_ctx; MDCTContext imdct_ctx;
DECLARE_ALIGNED_16(float,imdct_tmp[NELLY_BUF_LEN]);
DECLARE_ALIGNED_16(float,imdct_out[NELLY_BUF_LEN * 2]); DECLARE_ALIGNED_16(float,imdct_out[NELLY_BUF_LEN * 2]);
} NellyMoserDecodeContext; } NellyMoserDecodeContext;
@ -120,8 +119,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));
s->imdct_ctx.fft.imdct_calc(&s->imdct_ctx, s->imdct_out, s->imdct_ctx.fft.imdct_calc(&s->imdct_ctx, s->imdct_out, aptr);
aptr, s->imdct_tmp);
/* 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);

2
libavcodec/vorbis_enc.c
View File

@ -915,7 +915,7 @@ static int apply_window_and_mdct(venc_context_t * venc, signed short * audio, in
} }
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->samples + channel*window_len*2, venc->floor/*tmp*/); ff_mdct_calc(&venc->mdct[0], venc->coeffs + channel*window_len, venc->samples + channel*window_len*2);
} }
if (samples) { if (samples) {

1
libavcodec/wma.h
View File

@ -115,7 +115,6 @@ typedef struct WMACodecContext {
DECLARE_ALIGNED_16(FFTSample, output[BLOCK_MAX_SIZE * 2]); DECLARE_ALIGNED_16(FFTSample, output[BLOCK_MAX_SIZE * 2]);
MDCTContext mdct_ctx[BLOCK_NB_SIZES]; MDCTContext mdct_ctx[BLOCK_NB_SIZES];
float *windows[BLOCK_NB_SIZES]; float *windows[BLOCK_NB_SIZES];
DECLARE_ALIGNED_16(FFTSample, mdct_tmp[BLOCK_MAX_SIZE]); ///< temporary storage for imdct
/* output buffer for one frame and the last for IMDCT windowing */ /* output buffer for one frame and the last for IMDCT windowing */
DECLARE_ALIGNED_16(float, frame_out[MAX_CHANNELS][BLOCK_MAX_SIZE * 2]); DECLARE_ALIGNED_16(float, frame_out[MAX_CHANNELS][BLOCK_MAX_SIZE * 2]);
/* last frame info */ /* last frame info */

3
libavcodec/wmadec.c
View File

@ -688,8 +688,7 @@ next:
n = s->block_len; n = s->block_len;
n4 = s->block_len / 2; n4 = s->block_len / 2;
if(s->channel_coded[ch]){ if(s->channel_coded[ch]){
s->mdct_ctx[bsize].fft.imdct_calc(&s->mdct_ctx[bsize], s->mdct_ctx[bsize].fft.imdct_calc(&s->mdct_ctx[bsize], s->output, s->coefs[ch]);
s->output, s->coefs[ch], s->mdct_tmp);
}else }else
memset(s->output, 0, sizeof(s->output)); memset(s->output, 0, sizeof(s->output));

2
libavcodec/wmaenc.c
View File

@ -89,7 +89,7 @@ static void apply_window_and_mdct(AVCodecContext * avctx, signed short * audio,
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, s->mdct_tmp); ff_mdct_calc(&s->mdct_ctx[window_index], s->coefs[channel], s->output);
} }
} }