Mercurial > libavcodec.hg
changeset 7542:a8a8205a9081 libavcodec
split-radix FFT
c is 1.9x faster than previous c (on various x86 cpus), sse is 1.6x faster than previous sse.
| author | lorenm |
|---|---|
| date | Tue, 12 Aug 2008 00:26:58 +0000 |
| parents | 570c0c027998 |
| children | f04ff5a6fb55 |
| files | Makefile dsputil.h fft.c i386/fft_3dn.c i386/fft_3dn2.c i386/fft_mmx.asm i386/fft_sse.c |
| diffstat | 7 files changed, 779 insertions(+), 437 deletions(-) [+] |
line wrap: on
line diff
--- a/Makefile Mon Aug 11 23:54:09 2008 +0000 +++ b/Makefile Tue Aug 12 00:26:58 2008 +0000 @@ -388,6 +388,8 @@ i386/simple_idct_mmx.o \ i386/idct_mmx_xvid.o \ i386/idct_sse2_xvid.o \ + +OBJS-$(HAVE_YASM) += i386/fft_mmx.o \ i386/fft_sse.o \ i386/fft_3dn.o \ i386/fft_3dn2.o \
--- a/dsputil.h Mon Aug 11 23:54:09 2008 +0000 +++ b/dsputil.h Tue Aug 12 00:26:58 2008 +0000 @@ -639,6 +639,8 @@ uint16_t *revtab; FFTComplex *exptab; FFTComplex *exptab1; /* only used by SSE code */ + FFTComplex *tmp_buf; + void (*fft_permute)(struct FFTContext *s, FFTComplex *z); void (*fft_calc)(struct FFTContext *s, FFTComplex *z); void (*imdct_calc)(struct MDCTContext *s, FFTSample *output, const FFTSample *input, FFTSample *tmp); @@ -647,13 +649,18 @@ } FFTContext; int ff_fft_init(FFTContext *s, int nbits, int inverse); -void ff_fft_permute(FFTContext *s, FFTComplex *z); +void ff_fft_permute_c(FFTContext *s, FFTComplex *z); +void ff_fft_permute_sse(FFTContext *s, FFTComplex *z); void ff_fft_calc_c(FFTContext *s, FFTComplex *z); void ff_fft_calc_sse(FFTContext *s, FFTComplex *z); void ff_fft_calc_3dn(FFTContext *s, FFTComplex *z); void ff_fft_calc_3dn2(FFTContext *s, FFTComplex *z); void ff_fft_calc_altivec(FFTContext *s, FFTComplex *z); +static inline void ff_fft_permute(FFTContext *s, FFTComplex *z) +{ + s->fft_permute(s, z); +} static inline void ff_fft_calc(FFTContext *s, FFTComplex *z) { s->fft_calc(s, z);
--- a/fft.c Mon Aug 11 23:54:09 2008 +0000 +++ b/fft.c Tue Aug 12 00:26:58 2008 +0000 @@ -1,6 +1,8 @@ /* * FFT/IFFT transforms + * Copyright (c) 2008 Loren Merritt * Copyright (c) 2002 Fabrice Bellard. + * Partly based on libdjbfft by D. J. Bernstein * * This file is part of FFmpeg. * @@ -26,6 +28,36 @@ #include "dsputil.h" +/* cos(2*pi*x/n) for 0<=x<=n/4, followed by its reverse */ +DECLARE_ALIGNED_16(FFTSample, ff_cos_16[8]); +DECLARE_ALIGNED_16(FFTSample, ff_cos_32[16]); +DECLARE_ALIGNED_16(FFTSample, ff_cos_64[32]); +DECLARE_ALIGNED_16(FFTSample, ff_cos_128[64]); +DECLARE_ALIGNED_16(FFTSample, ff_cos_256[128]); +DECLARE_ALIGNED_16(FFTSample, ff_cos_512[256]); +DECLARE_ALIGNED_16(FFTSample, ff_cos_1024[512]); +DECLARE_ALIGNED_16(FFTSample, ff_cos_2048[1024]); +DECLARE_ALIGNED_16(FFTSample, ff_cos_4096[2048]); +DECLARE_ALIGNED_16(FFTSample, ff_cos_8192[4096]); +DECLARE_ALIGNED_16(FFTSample, ff_cos_16384[8192]); +DECLARE_ALIGNED_16(FFTSample, ff_cos_32768[16384]); +DECLARE_ALIGNED_16(FFTSample, ff_cos_65536[32768]); +static FFTSample *ff_cos_tabs[] = { + ff_cos_16, ff_cos_32, ff_cos_64, ff_cos_128, ff_cos_256, ff_cos_512, ff_cos_1024, + ff_cos_2048, ff_cos_4096, ff_cos_8192, ff_cos_16384, ff_cos_32768, ff_cos_65536, +}; + +static int split_radix_permutation(int i, int n, int inverse) +{ + int m; + if(n <= 2) return i&1; + m = n >> 1; + if(!(i&m)) return split_radix_permutation(i, m, inverse)*2; + m >>= 1; + if(inverse == !(i&m)) return split_radix_permutation(i, m, inverse)*4 + 1; + else return split_radix_permutation(i, m, inverse)*4 - 1; +} + /** * The size of the FFT is 2^nbits. If inverse is TRUE, inverse FFT is * done @@ -34,12 +66,15 @@ { int i, j, m, n; float alpha, c1, s1, s2; - int shuffle = 0; + int split_radix = 1; int av_unused has_vectors; + if (nbits < 2 || nbits > 16) + goto fail; s->nbits = nbits; n = 1 << nbits; + s->tmp_buf = NULL; s->exptab = av_malloc((n / 2) * sizeof(FFTComplex)); if (!s->exptab) goto fail; @@ -50,50 +85,62 @@ s2 = inverse ? 1.0 : -1.0; - for(i=0;i<(n/2);i++) { - alpha = 2 * M_PI * (float)i / (float)n; - c1 = cos(alpha); - s1 = sin(alpha) * s2; - s->exptab[i].re = c1; - s->exptab[i].im = s1; - } + s->fft_permute = ff_fft_permute_c; s->fft_calc = ff_fft_calc_c; s->imdct_calc = ff_imdct_calc; s->imdct_half = ff_imdct_half; s->exptab1 = NULL; -#ifdef HAVE_MMX +#if defined HAVE_MMX && defined HAVE_YASM has_vectors = mm_support(); - shuffle = 1; - if (has_vectors & MM_3DNOWEXT) { - /* 3DNowEx for K7/K8 */ + if (has_vectors & MM_SSE) { + /* SSE for P3/P4/K8 */ + s->imdct_calc = ff_imdct_calc_sse; + s->imdct_half = ff_imdct_half_sse; + s->fft_permute = ff_fft_permute_sse; + s->fft_calc = ff_fft_calc_sse; + } else if (has_vectors & MM_3DNOWEXT) { + /* 3DNowEx for K7 */ s->imdct_calc = ff_imdct_calc_3dn2; s->imdct_half = ff_imdct_half_3dn2; s->fft_calc = ff_fft_calc_3dn2; } else if (has_vectors & MM_3DNOW) { /* 3DNow! for K6-2/3 */ s->fft_calc = ff_fft_calc_3dn; - } else if (has_vectors & MM_SSE) { - /* SSE for P3/P4 */ - s->imdct_calc = ff_imdct_calc_sse; - s->imdct_half = ff_imdct_half_sse; - s->fft_calc = ff_fft_calc_sse; - } else { - shuffle = 0; } #elif defined HAVE_ALTIVEC && !defined ALTIVEC_USE_REFERENCE_C_CODE has_vectors = mm_support(); if (has_vectors & MM_ALTIVEC) { s->fft_calc = ff_fft_calc_altivec; - shuffle = 1; + split_radix = 0; } #endif - /* compute constant table for HAVE_SSE version */ - if (shuffle) { + if (split_radix) { + for(j=4; j<=nbits; j++) { + int m = 1<<j; + double freq = 2*M_PI/m; + FFTSample *tab = ff_cos_tabs[j-4]; + for(i=0; i<=m/4; i++) + tab[i] = cos(i*freq); + for(i=1; i<m/4; i++) + tab[m/2-i] = tab[i]; + } + for(i=0; i<n; i++) + s->revtab[-split_radix_permutation(i, n, s->inverse) & (n-1)] = i; + s->tmp_buf = av_malloc(n * sizeof(FFTComplex)); + } else { int np, nblocks, np2, l; FFTComplex *q; + for(i=0; i<(n/2); i++) { + alpha = 2 * M_PI * (float)i / (float)n; + c1 = cos(alpha); + s1 = sin(alpha) * s2; + s->exptab[i].re = c1; + s->exptab[i].im = s1; + } + np = 1 << nbits; nblocks = np >> 3; np2 = np >> 1; @@ -116,7 +163,6 @@ nblocks = nblocks >> 1; } while (nblocks != 0); av_freep(&s->exptab); - } /* compute bit reverse table */ @@ -127,126 +173,35 @@ } s->revtab[i]=m; } + } + return 0; fail: av_freep(&s->revtab); av_freep(&s->exptab); av_freep(&s->exptab1); + av_freep(&s->tmp_buf); return -1; } -/* butter fly op */ -#define BF(pre, pim, qre, qim, pre1, pim1, qre1, qim1) \ -{\ - FFTSample ax, ay, bx, by;\ - bx=pre1;\ - by=pim1;\ - ax=qre1;\ - ay=qim1;\ - pre = (bx + ax);\ - pim = (by + ay);\ - qre = (bx - ax);\ - qim = (by - ay);\ -} - -#define MUL16(a,b) ((a) * (b)) - -#define CMUL(pre, pim, are, aim, bre, bim) \ -{\ - pre = (MUL16(are, bre) - MUL16(aim, bim));\ - pim = (MUL16(are, bim) + MUL16(bre, aim));\ -} - -/** - * Do a complex FFT with the parameters defined in ff_fft_init(). The - * input data must be permuted before with s->revtab table. No - * 1.0/sqrt(n) normalization is done. - */ -void ff_fft_calc_c(FFTContext *s, FFTComplex *z) -{ - int ln = s->nbits; - int j, np, np2; - int nblocks, nloops; - register FFTComplex *p, *q; - FFTComplex *exptab = s->exptab; - int l; - FFTSample tmp_re, tmp_im; - - np = 1 << ln; - - /* pass 0 */ - - p=&z[0]; - j=(np >> 1); - do { - BF(p[0].re, p[0].im, p[1].re, p[1].im, - p[0].re, p[0].im, p[1].re, p[1].im); - p+=2; - } while (--j != 0); - - /* pass 1 */ - - - p=&z[0]; - j=np >> 2; - if (s->inverse) { - do { - BF(p[0].re, p[0].im, p[2].re, p[2].im, - p[0].re, p[0].im, p[2].re, p[2].im); - BF(p[1].re, p[1].im, p[3].re, p[3].im, - p[1].re, p[1].im, -p[3].im, p[3].re); - p+=4; - } while (--j != 0); - } else { - do { - BF(p[0].re, p[0].im, p[2].re, p[2].im, - p[0].re, p[0].im, p[2].re, p[2].im); - BF(p[1].re, p[1].im, p[3].re, p[3].im, - p[1].re, p[1].im, p[3].im, -p[3].re); - p+=4; - } while (--j != 0); - } - /* pass 2 .. ln-1 */ - - nblocks = np >> 3; - nloops = 1 << 2; - np2 = np >> 1; - do { - p = z; - q = z + nloops; - for (j = 0; j < nblocks; ++j) { - BF(p->re, p->im, q->re, q->im, - p->re, p->im, q->re, q->im); - - p++; - q++; - for(l = nblocks; l < np2; l += nblocks) { - CMUL(tmp_re, tmp_im, exptab[l].re, exptab[l].im, q->re, q->im); - BF(p->re, p->im, q->re, q->im, - p->re, p->im, tmp_re, tmp_im); - p++; - q++; - } - - p += nloops; - q += nloops; - } - nblocks = nblocks >> 1; - nloops = nloops << 1; - } while (nblocks != 0); -} - /** * Do the permutation needed BEFORE calling ff_fft_calc() */ -void ff_fft_permute(FFTContext *s, FFTComplex *z) +void ff_fft_permute_c(FFTContext *s, FFTComplex *z) { int j, k, np; FFTComplex tmp; const uint16_t *revtab = s->revtab; + np = 1 << s->nbits; + + if (s->tmp_buf) { + /* TODO: handle split-radix permute in a more optimal way, probably in-place */ + for(j=0;j<np;j++) s->tmp_buf[revtab[j]] = z[j]; + memcpy(z, s->tmp_buf, np * sizeof(FFTComplex)); + return; + } /* reverse */ - np = 1 << s->nbits; for(j=0;j<np;j++) { k = revtab[j]; if (k < j) { @@ -262,5 +217,169 @@ av_freep(&s->revtab); av_freep(&s->exptab); av_freep(&s->exptab1); + av_freep(&s->tmp_buf); +} + +#define sqrthalf (float)M_SQRT1_2 + +#define BF(x,y,a,b) {\ + x = a - b;\ + y = a + b;\ +} + +#define BUTTERFLIES(a0,a1,a2,a3) {\ + BF(t3, t5, t5, t1);\ + BF(a2.re, a0.re, a0.re, t5);\ + BF(a3.im, a1.im, a1.im, t3);\ + BF(t4, t6, t2, t6);\ + BF(a3.re, a1.re, a1.re, t4);\ + BF(a2.im, a0.im, a0.im, t6);\ +} + +// force loading all the inputs before storing any. +// this is slightly slower for small data, but avoids store->load aliasing +// for addresses separated by large powers of 2. +#define BUTTERFLIES_BIG(a0,a1,a2,a3) {\ + FFTSample r0=a0.re, i0=a0.im, r1=a1.re, i1=a1.im;\ + BF(t3, t5, t5, t1);\ + BF(a2.re, a0.re, r0, t5);\ + BF(a3.im, a1.im, i1, t3);\ + BF(t4, t6, t2, t6);\ + BF(a3.re, a1.re, r1, t4);\ + BF(a2.im, a0.im, i0, t6);\ +} + +#define TRANSFORM(a0,a1,a2,a3,wre,wim) {\ + t1 = a2.re * wre + a2.im * wim;\ + t2 = a2.im * wre - a2.re * wim;\ + t5 = a3.re * wre - a3.im * wim;\ + t6 = a3.im * wre + a3.re * wim;\ + BUTTERFLIES(a0,a1,a2,a3)\ +} + +#define TRANSFORM_ZERO(a0,a1,a2,a3) {\ + t1 = a2.re;\ + t2 = a2.im;\ + t5 = a3.re;\ + t6 = a3.im;\ + BUTTERFLIES(a0,a1,a2,a3)\ +} + +/* z[0...8n-1], w[1...2n-1] */ +#define PASS(name)\ +static void name(FFTComplex *z, const FFTSample *wre, unsigned int n)\ +{\ + FFTSample t1, t2, t3, t4, t5, t6;\ + int o1 = 2*n;\ + int o2 = 4*n;\ + int o3 = 6*n;\ + const FFTSample *wim = wre+o1;\ + n--;\ +\ + TRANSFORM_ZERO(z[0],z[o1],z[o2],z[o3]);\ + TRANSFORM(z[1],z[o1+1],z[o2+1],z[o3+1],wre[1],wim[-1]);\ + do {\ + z += 2;\ + wre += 2;\ + wim -= 2;\ + TRANSFORM(z[0],z[o1],z[o2],z[o3],wre[0],wim[0]);\ + TRANSFORM(z[1],z[o1+1],z[o2+1],z[o3+1],wre[1],wim[-1]);\ + } while(--n);\ } +PASS(pass) +#undef BUTTERFLIES +#define BUTTERFLIES BUTTERFLIES_BIG +PASS(pass_big) + +#define DECL_FFT(n,n2,n4)\ +static void fft##n(FFTComplex *z)\ +{\ + fft##n2(z);\ + fft##n4(z+n4*2);\ + fft##n4(z+n4*3);\ + pass(z,ff_cos_##n,n4/2);\ +} + +static void fft4(FFTComplex *z) +{ + FFTSample t1, t2, t3, t4, t5, t6, t7, t8; + + BF(t3, t1, z[0].re, z[1].re); + BF(t8, t6, z[3].re, z[2].re); + BF(z[2].re, z[0].re, t1, t6); + BF(t4, t2, z[0].im, z[1].im); + BF(t7, t5, z[2].im, z[3].im); + BF(z[3].im, z[1].im, t4, t8); + BF(z[3].re, z[1].re, t3, t7); + BF(z[2].im, z[0].im, t2, t5); +} + +static void fft8(FFTComplex *z) +{ + FFTSample t1, t2, t3, t4, t5, t6, t7, t8; + + fft4(z); + + BF(t1, z[5].re, z[4].re, -z[5].re); + BF(t2, z[5].im, z[4].im, -z[5].im); + BF(t3, z[7].re, z[6].re, -z[7].re); + BF(t4, z[7].im, z[6].im, -z[7].im); + BF(t8, t1, t3, t1); + BF(t7, t2, t2, t4); + BF(z[4].re, z[0].re, z[0].re, t1); + BF(z[4].im, z[0].im, z[0].im, t2); + BF(z[6].re, z[2].re, z[2].re, t7); + BF(z[6].im, z[2].im, z[2].im, t8); + + TRANSFORM(z[1],z[3],z[5],z[7],sqrthalf,sqrthalf); +} + +#ifndef CONFIG_SMALL +static void fft16(FFTComplex *z) +{ + FFTSample t1, t2, t3, t4, t5, t6; + + fft8(z); + fft4(z+8); + fft4(z+12); + + TRANSFORM_ZERO(z[0],z[4],z[8],z[12]); + TRANSFORM(z[2],z[6],z[10],z[14],sqrthalf,sqrthalf); + TRANSFORM(z[1],z[5],z[9],z[13],ff_cos_16[1],ff_cos_16[3]); + TRANSFORM(z[3],z[7],z[11],z[15],ff_cos_16[3],ff_cos_16[1]); +} +#else +DECL_FFT(16,8,4) +#endif +DECL_FFT(32,16,8) +DECL_FFT(64,32,16) +DECL_FFT(128,64,32) +DECL_FFT(256,128,64) +DECL_FFT(512,256,128) +#ifndef CONFIG_SMALL +#define pass pass_big +#endif +DECL_FFT(1024,512,256) +DECL_FFT(2048,1024,512) +DECL_FFT(4096,2048,1024) +DECL_FFT(8192,4096,2048) +DECL_FFT(16384,8192,4096) +DECL_FFT(32768,16384,8192) +DECL_FFT(65536,32768,16384) + +static void (*fft_dispatch[])(FFTComplex*) = { + fft4, fft8, fft16, fft32, fft64, fft128, fft256, fft512, fft1024, + fft2048, fft4096, fft8192, fft16384, fft32768, fft65536, +}; + +/** + * Do a complex FFT with the parameters defined in ff_fft_init(). The + * input data must be permuted before with s->revtab table. No + * 1.0/sqrt(n) normalization is done. + */ +void ff_fft_calc_c(FFTContext *s, FFTComplex *z) +{ + fft_dispatch[s->nbits-2](z); +} +
--- a/i386/fft_3dn.c Mon Aug 11 23:54:09 2008 +0000 +++ b/i386/fft_3dn.c Tue Aug 12 00:26:58 2008 +0000 @@ -1,7 +1,6 @@ /* * FFT/MDCT transform with 3DNow! optimizations - * Copyright (c) 2006 Zuxy MENG Jie, Loren Merritt - * Based on fft_sse.c copyright (c) 2002 Fabrice Bellard. + * Copyright (c) 2008 Loren Merritt * * This file is part of FFmpeg. * @@ -20,109 +19,5 @@ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ -#include "libavutil/x86_cpu.h" -#include "libavcodec/dsputil.h" - -static const int p1m1[2] __attribute__((aligned(8))) = - { 0, 1 << 31 }; - -static const int m1p1[2] __attribute__((aligned(8))) = - { 1 << 31, 0 }; - -void ff_fft_calc_3dn(FFTContext *s, FFTComplex *z) -{ - int ln = s->nbits; - long j; - x86_reg i; - long nblocks, nloops; - FFTComplex *p, *cptr; - - asm volatile( - /* FEMMS is not a must here but recommended by AMD */ - "femms \n\t" - "movq %0, %%mm7 \n\t" - ::"m"(*(s->inverse ? m1p1 : p1m1)) - ); - - i = 8 << ln; - asm volatile( - "1: \n\t" - "sub $32, %0 \n\t" - "movq (%0,%1), %%mm0 \n\t" - "movq 16(%0,%1), %%mm1 \n\t" - "movq 8(%0,%1), %%mm2 \n\t" - "movq 24(%0,%1), %%mm3 \n\t" - "movq %%mm0, %%mm4 \n\t" - "movq %%mm1, %%mm5 \n\t" - "pfadd %%mm2, %%mm0 \n\t" - "pfadd %%mm3, %%mm1 \n\t" - "pfsub %%mm2, %%mm4 \n\t" - "pfsub %%mm3, %%mm5 \n\t" - "movq %%mm0, %%mm2 \n\t" - "punpckldq %%mm5, %%mm6 \n\t" - "punpckhdq %%mm6, %%mm5 \n\t" - "movq %%mm4, %%mm3 \n\t" - "pxor %%mm7, %%mm5 \n\t" - "pfadd %%mm1, %%mm0 \n\t" - "pfadd %%mm5, %%mm4 \n\t" - "pfsub %%mm1, %%mm2 \n\t" - "pfsub %%mm5, %%mm3 \n\t" - "movq %%mm0, (%0,%1) \n\t" - "movq %%mm4, 8(%0,%1) \n\t" - "movq %%mm2, 16(%0,%1) \n\t" - "movq %%mm3, 24(%0,%1) \n\t" - "jg 1b \n\t" - :"+r"(i) - :"r"(z) - ); - /* pass 2 .. ln-1 */ - - nblocks = 1 << (ln-3); - nloops = 1 << 2; - cptr = s->exptab1; - do { - p = z; - j = nblocks; - do { - i = nloops*8; - asm volatile( - "1: \n\t" - "sub $16, %0 \n\t" - "movq (%1,%0), %%mm0 \n\t" - "movq 8(%1,%0), %%mm1 \n\t" - "movq (%2,%0), %%mm2 \n\t" - "movq 8(%2,%0), %%mm3 \n\t" - "movq %%mm2, %%mm4 \n\t" - "movq %%mm3, %%mm5 \n\t" - "punpckldq %%mm2, %%mm2 \n\t" - "punpckldq %%mm3, %%mm3 \n\t" - "punpckhdq %%mm4, %%mm4 \n\t" - "punpckhdq %%mm5, %%mm5 \n\t" - "pfmul (%3,%0,2), %%mm2 \n\t" // cre*re cim*re - "pfmul 8(%3,%0,2), %%mm3 \n\t" - "pfmul 16(%3,%0,2), %%mm4 \n\t" // -cim*im cre*im - "pfmul 24(%3,%0,2), %%mm5 \n\t" - "pfadd %%mm2, %%mm4 \n\t" // cre*re-cim*im cim*re+cre*im - "pfadd %%mm3, %%mm5 \n\t" - "movq %%mm0, %%mm2 \n\t" - "movq %%mm1, %%mm3 \n\t" - "pfadd %%mm4, %%mm0 \n\t" - "pfadd %%mm5, %%mm1 \n\t" - "pfsub %%mm4, %%mm2 \n\t" - "pfsub %%mm5, %%mm3 \n\t" - "movq %%mm0, (%1,%0) \n\t" - "movq %%mm1, 8(%1,%0) \n\t" - "movq %%mm2, (%2,%0) \n\t" - "movq %%mm3, 8(%2,%0) \n\t" - "jg 1b \n\t" - :"+r"(i) - :"r"(p), "r"(p + nloops), "r"(cptr) - ); - p += nloops*2; - } while (--j); - cptr += nloops*2; - nblocks >>= 1; - nloops <<= 1; - } while (nblocks != 0); - asm volatile("femms"); -} +#define EMULATE_3DNOWEXT +#include "fft_3dn2.c"
--- a/i386/fft_3dn2.c Mon Aug 11 23:54:09 2008 +0000 +++ b/i386/fft_3dn2.c Tue Aug 12 00:26:58 2008 +0000 @@ -23,105 +23,26 @@ #include "libavutil/x86_cpu.h" #include "libavcodec/dsputil.h" -static const int p1m1[2] __attribute__((aligned(8))) = - { 0, 1 << 31 }; +#ifdef EMULATE_3DNOWEXT +#define ff_fft_calc_3dn2 ff_fft_calc_3dn +#define ff_fft_dispatch_3dn2 ff_fft_dispatch_3dn +#define ff_fft_dispatch_interleave_3dn2 ff_fft_dispatch_interleave_3dn +#define ff_imdct_calc_3dn2 ff_imdct_calc_3dn +#define ff_imdct_half_3dn2 ff_imdct_half_3dn +#endif -static const int m1p1[2] __attribute__((aligned(8))) = - { 1 << 31, 0 }; +void ff_fft_dispatch_3dn2(FFTComplex *z, int nbits); +void ff_fft_dispatch_interleave_3dn2(FFTComplex *z, int nbits); void ff_fft_calc_3dn2(FFTContext *s, FFTComplex *z) { - int ln = s->nbits; - long j; - x86_reg i; - long nblocks, nloops; - FFTComplex *p, *cptr; - - asm volatile( - /* FEMMS is not a must here but recommended by AMD */ - "femms \n\t" - "movq %0, %%mm7 \n\t" - ::"m"(*(s->inverse ? m1p1 : p1m1)) - ); - - i = 8 << ln; - asm volatile( - "1: \n\t" - "sub $32, %0 \n\t" - "movq (%0,%1), %%mm0 \n\t" - "movq 16(%0,%1), %%mm1 \n\t" - "movq 8(%0,%1), %%mm2 \n\t" - "movq 24(%0,%1), %%mm3 \n\t" - "movq %%mm0, %%mm4 \n\t" - "movq %%mm1, %%mm5 \n\t" - "pfadd %%mm2, %%mm0 \n\t" - "pfadd %%mm3, %%mm1 \n\t" - "pfsub %%mm2, %%mm4 \n\t" - "pfsub %%mm3, %%mm5 \n\t" - "movq %%mm0, %%mm2 \n\t" - "pswapd %%mm5, %%mm5 \n\t" - "movq %%mm4, %%mm3 \n\t" - "pxor %%mm7, %%mm5 \n\t" - "pfadd %%mm1, %%mm0 \n\t" - "pfadd %%mm5, %%mm4 \n\t" - "pfsub %%mm1, %%mm2 \n\t" - "pfsub %%mm5, %%mm3 \n\t" - "movq %%mm0, (%0,%1) \n\t" - "movq %%mm4, 8(%0,%1) \n\t" - "movq %%mm2, 16(%0,%1) \n\t" - "movq %%mm3, 24(%0,%1) \n\t" - "jg 1b \n\t" - :"+r"(i) - :"r"(z) - ); - /* pass 2 .. ln-1 */ - - nblocks = 1 << (ln-3); - nloops = 1 << 2; - cptr = s->exptab1; - do { - p = z; - j = nblocks; - do { - i = nloops*8; - asm volatile( - "1: \n\t" - "sub $16, %0 \n\t" - "movq (%1,%0), %%mm0 \n\t" - "movq 8(%1,%0), %%mm1 \n\t" - "movq (%2,%0), %%mm2 \n\t" - "movq 8(%2,%0), %%mm3 \n\t" - "movq (%3,%0,2), %%mm4 \n\t" - "movq 8(%3,%0,2), %%mm5 \n\t" - "pswapd %%mm4, %%mm6 \n\t" // no need for cptr[2] & cptr[3] - "pswapd %%mm5, %%mm7 \n\t" - "pfmul %%mm2, %%mm4 \n\t" // cre*re cim*im - "pfmul %%mm3, %%mm5 \n\t" - "pfmul %%mm2, %%mm6 \n\t" // cim*re cre*im - "pfmul %%mm3, %%mm7 \n\t" - "pfpnacc %%mm6, %%mm4 \n\t" // cre*re-cim*im cim*re+cre*im - "pfpnacc %%mm7, %%mm5 \n\t" - "movq %%mm0, %%mm2 \n\t" - "movq %%mm1, %%mm3 \n\t" - "pfadd %%mm4, %%mm0 \n\t" - "pfadd %%mm5, %%mm1 \n\t" - "pfsub %%mm4, %%mm2 \n\t" - "pfsub %%mm5, %%mm3 \n\t" - "movq %%mm0, (%1,%0) \n\t" - "movq %%mm1, 8(%1,%0) \n\t" - "movq %%mm2, (%2,%0) \n\t" - "movq %%mm3, 8(%2,%0) \n\t" - "jg 1b \n\t" - :"+r"(i) - :"r"(p), "r"(p + nloops), "r"(cptr) - ); - p += nloops*2; - } while (--j); - cptr += nloops*2; - nblocks >>= 1; - nloops <<= 1; - } while (nblocks != 0); + int n = 1<<s->nbits; + int i; + ff_fft_dispatch_interleave_3dn2(z, s->nbits); asm volatile("femms"); + if(n <= 8) + for(i=0; i<n; i+=2) + FFSWAP(FFTSample, z[i].im, z[i+1].re); } static void imdct_3dn2(MDCTContext *s, const FFTSample *input, FFTSample *tmp) @@ -162,7 +83,7 @@ ); } - ff_fft_calc(&s->fft, z); + ff_fft_calc_3dn2(&s->fft, z); /* post rotation + reordering */ for(k = 0; k < n4; k++) {
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/i386/fft_mmx.asm Tue Aug 12 00:26:58 2008 +0000 @@ -0,0 +1,467 @@ +;****************************************************************************** +;* FFT transform with SSE/3DNow optimizations +;* Copyright (c) 2008 Loren Merritt +;* +;* 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 +;* 51, Inc., Foundation Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA +;****************************************************************************** + +; These functions are not individually interchangeable with the C versions. +; While C takes arrays of FFTComplex, SSE/3DNow leave intermediate results +; in blocks as conventient to the vector size. +; i.e. {4x real, 4x imaginary, 4x real, ...} (or 2x respectively) + +%include "x86inc.asm" + +SECTION_RODATA + +%define M_SQRT1_2 0.70710678118654752440 +ps_root2: times 4 dd M_SQRT1_2 +ps_root2mppm: dd -M_SQRT1_2, M_SQRT1_2, M_SQRT1_2, -M_SQRT1_2 +ps_m1p1: dd 1<<31, 0 + +%assign i 16 +%rep 13 +cextern ff_cos_ %+ i +%assign i i<<1 +%endrep + +%ifdef ARCH_X86_64 + %define pointer dq +%else + %define pointer dd +%endif + +%macro IF0 1+ +%endmacro +%macro IF1 1+ + %1 +%endmacro + +section .text align=16 + +%macro T2_3DN 4 ; z0, z1, mem0, mem1 + mova %1, %3 + mova %2, %1 + pfadd %1, %4 + pfsub %2, %4 +%endmacro + +%macro T4_3DN 6 ; z0, z1, z2, z3, tmp0, tmp1 + mova %5, %3 + pfsub %3, %4 + pfadd %5, %4 ; {t6,t5} + pxor %3, [ps_m1p1 GLOBAL] ; {t8,t7} + mova %6, %1 + pswapd %3, %3 + pfadd %1, %5 ; {r0,i0} + pfsub %6, %5 ; {r2,i2} + mova %4, %2 + pfadd %2, %3 ; {r1,i1} + pfsub %4, %3 ; {r3,i3} + SWAP %3, %6 +%endmacro + +; in: %1={r0,i0,r1,i1} %2={r2,i2,r3,i3} +; out: %1={r0,r1,r2,r3} %2={i0,i1,i2,i3} +%macro T4_SSE 3 + mova %3, %1 + shufps %1, %2, 0x64 ; {r0,i0,r3,i2} + shufps %3, %2, 0xce ; {r1,i1,r2,i3} + mova %2, %1 + addps %1, %3 ; {t1,t2,t6,t5} + subps %2, %3 ; {t3,t4,t8,t7} + mova %3, %1 + shufps %1, %2, 0x44 ; {t1,t2,t3,t4} + shufps %3, %2, 0xbe ; {t6,t5,t7,t8} + mova %2, %1 + addps %1, %3 ; {r0,i0,r1,i1} + subps %2, %3 ; {r2,i2,r3,i3} + mova %3, %1 + shufps %1, %2, 0x88 ; {r0,r1,r2,r3} + shufps %3, %2, 0xdd ; {i0,i1,i2,i3} + SWAP %2, %3 +%endmacro + +%macro T8_SSE 6 ; r0,i0,r1,i1,t0,t1 + mova %5, %3 + shufps %3, %4, 0x44 ; {r4,i4,r6,i6} + shufps %5, %4, 0xee ; {r5,i5,r7,i7} + mova %6, %3 + subps %3, %5 ; {r5,i5,r7,i7} + addps %6, %5 ; {t1,t2,t3,t4} + mova %5, %3 + shufps %5, %5, 0xb1 ; {i5,r5,i7,r7} + mulps %3, [ps_root2mppm GLOBAL] ; {-r5,i5,r7,-i7} + mulps %5, [ps_root2 GLOBAL] + addps %3, %5 ; {t8,t7,ta,t9} + mova %5, %6 + shufps %6, %3, 0x36 ; {t3,t2,t9,t8} + shufps %5, %3, 0x9c ; {t1,t4,t7,ta} + mova %3, %6 + addps %6, %5 ; {t1,t2,t9,ta} + subps %3, %5 ; {t6,t5,tc,tb} + mova %5, %6 + shufps %6, %3, 0xd8 ; {t1,t9,t5,tb} + shufps %5, %3, 0x8d ; {t2,ta,t6,tc} + mova %3, %1 + mova %4, %2 + addps %1, %6 ; {r0,r1,r2,r3} + addps %2, %5 ; {i0,i1,i2,i3} + subps %3, %6 ; {r4,r5,r6,r7} + subps %4, %5 ; {i4,i5,i6,i7} +%endmacro + +; scheduled for cpu-bound sizes +%macro PASS_SMALL 3 ; (to load m4-m7), wre, wim +IF%1 mova m4, Z(4) +IF%1 mova m5, Z(5) + mova m0, %2 ; wre + mova m2, m4 + mova m1, %3 ; wim + mova m3, m5 + mulps m2, m0 ; r2*wre +IF%1 mova m6, Z(6) + mulps m3, m1 ; i2*wim +IF%1 mova m7, Z(7) + mulps m4, m1 ; r2*wim + mulps m5, m0 ; i2*wre + addps m2, m3 ; r2*wre + i2*wim + mova m3, m1 + mulps m1, m6 ; r3*wim + subps m5, m4 ; i2*wre - r2*wim + mova m4, m0 + mulps m3, m7 ; i3*wim + mulps m4, m6 ; r3*wre + mulps m0, m7 ; i3*wre + subps m4, m3 ; r3*wre - i3*wim + mova m3, Z(0) + addps m0, m1 ; i3*wre + r3*wim + mova m1, m4 + addps m4, m2 ; t5 + subps m1, m2 ; t3 + subps m3, m4 ; r2 + addps m4, Z(0) ; r0 + mova m6, Z(2) + mova Z(4), m3 + mova Z(0), m4 + mova m3, m5 + subps m5, m0 ; t4 + mova m4, m6 + subps m6, m5 ; r3 + addps m5, m4 ; r1 + mova Z(6), m6 + mova Z(2), m5 + mova m2, Z(3) + addps m3, m0 ; t6 + subps m2, m1 ; i3 + mova m7, Z(1) + addps m1, Z(3) ; i1 + mova Z(7), m2 + mova Z(3), m1 + mova m4, m7 + subps m7, m3 ; i2 + addps m3, m4 ; i0 + mova Z(5), m7 + mova Z(1), m3 +%endmacro + +; scheduled to avoid store->load aliasing +%macro PASS_BIG 1 ; (!interleave) + mova m4, Z(4) ; r2 + mova m5, Z(5) ; i2 + mova m2, m4 + mova m0, [wq] ; wre + mova m3, m5 + mova m1, [wq+o1q] ; wim + mulps m2, m0 ; r2*wre + mova m6, Z(6) ; r3 + mulps m3, m1 ; i2*wim + mova m7, Z(7) ; i3 + mulps m4, m1 ; r2*wim + mulps m5, m0 ; i2*wre + addps m2, m3 ; r2*wre + i2*wim + mova m3, m1 + mulps m1, m6 ; r3*wim + subps m5, m4 ; i2*wre - r2*wim + mova m4, m0 + mulps m3, m7 ; i3*wim + mulps m4, m6 ; r3*wre + mulps m0, m7 ; i3*wre + subps m4, m3 ; r3*wre - i3*wim + mova m3, Z(0) + addps m0, m1 ; i3*wre + r3*wim + mova m1, m4 + addps m4, m2 ; t5 + subps m1, m2 ; t3 + subps m3, m4 ; r2 + addps m4, Z(0) ; r0 + mova m6, Z(2) + mova Z(4), m3 + mova Z(0), m4 + mova m3, m5 + subps m5, m0 ; t4 + mova m4, m6 + subps m6, m5 ; r3 + addps m5, m4 ; r1 +IF%1 mova Z(6), m6 +IF%1 mova Z(2), m5 + mova m2, Z(3) + addps m3, m0 ; t6 + subps m2, m1 ; i3 + mova m7, Z(1) + addps m1, Z(3) ; i1 +IF%1 mova Z(7), m2 +IF%1 mova Z(3), m1 + mova m4, m7 + subps m7, m3 ; i2 + addps m3, m4 ; i0 +IF%1 mova Z(5), m7 +IF%1 mova Z(1), m3 +%if %1==0 + mova m4, m5 ; r1 + mova m0, m6 ; r3 + unpcklps m5, m1 + unpckhps m4, m1 + unpcklps m6, m2 + unpckhps m0, m2 + mova m1, Z(0) + mova m2, Z(4) + mova Z(2), m5 + mova Z(3), m4 + mova Z(6), m6 + mova Z(7), m0 + mova m5, m1 ; r0 + mova m4, m2 ; r2 + unpcklps m1, m3 + unpckhps m5, m3 + unpcklps m2, m7 + unpckhps m4, m7 + mova Z(0), m1 + mova Z(1), m5 + mova Z(4), m2 + mova Z(5), m4 +%endif +%endmacro + +%macro PUNPCK 3 + mova %3, %1 + punpckldq %1, %2 + punpckhdq %3, %2 +%endmacro + +INIT_XMM + +%define Z(x) [r0+mmsize*x] + +align 16 +fft4_sse: + mova m0, Z(0) + mova m1, Z(1) + T4_SSE m0, m1, m2 + mova Z(0), m0 + mova Z(1), m1 + ret + +align 16 +fft8_sse: + mova m0, Z(0) + mova m1, Z(1) + T4_SSE m0, m1, m2 + mova m2, Z(2) + mova m3, Z(3) + T8_SSE m0, m1, m2, m3, m4, m5 + mova Z(0), m0 + mova Z(1), m1 + mova Z(2), m2 + mova Z(3), m3 + ret + +align 16 +fft16_sse: + mova m0, Z(0) + mova m1, Z(1) + T4_SSE m0, m1, m2 + mova m2, Z(2) + mova m3, Z(3) + T8_SSE m0, m1, m2, m3, m4, m5 + mova m4, Z(4) + mova m5, Z(5) + mova Z(0), m0 + mova Z(1), m1 + mova Z(2), m2 + mova Z(3), m3 + T4_SSE m4, m5, m6 + mova m6, Z(6) + mova m7, Z(7) + T4_SSE m6, m7, m0 + PASS_SMALL 0, [ff_cos_16 GLOBAL], [ff_cos_16+16 GLOBAL] + ret + + +INIT_MMX + +%macro FFT48_3DN 1 +align 16 +fft4%1: + T2_3DN m0, m1, Z(0), Z(1) + mova m2, Z(2) + mova m3, Z(3) + T4_3DN m0, m1, m2, m3, m4, m5 + PUNPCK m0, m1, m4 + PUNPCK m2, m3, m5 + mova Z(0), m0 + mova Z(1), m4 + mova Z(2), m2 + mova Z(3), m5 + ret + +align 16 +fft8%1: + T2_3DN m0, m1, Z(0), Z(1) + mova m2, Z(2) + mova m3, Z(3) + T4_3DN m0, m1, m2, m3, m4, m5 + mova Z(0), m0 + mova Z(2), m2 + T2_3DN m4, m5, Z(4), Z(5) + T2_3DN m6, m7, Z(6), Z(7) + pswapd m0, m5 + pswapd m2, m7 + pxor m0, [ps_m1p1 GLOBAL] + pxor m2, [ps_m1p1 GLOBAL] + pfsub m5, m0 + pfadd m7, m2 + pfmul m5, [ps_root2 GLOBAL] + pfmul m7, [ps_root2 GLOBAL] + T4_3DN m1, m3, m5, m7, m0, m2 + mova Z(5), m5 + mova Z(7), m7 + mova m0, Z(0) + mova m2, Z(2) + T4_3DN m0, m2, m4, m6, m5, m7 + PUNPCK m0, m1, m5 + PUNPCK m2, m3, m7 + mova Z(0), m0 + mova Z(1), m5 + mova Z(2), m2 + mova Z(3), m7 + PUNPCK m4, Z(5), m5 + PUNPCK m6, Z(7), m7 + mova Z(4), m4 + mova Z(5), m5 + mova Z(6), m6 + mova Z(7), m7 + ret +%endmacro + +FFT48_3DN _3dn2 + +%macro pswapd 2 +%ifidn %1, %2 + movd [r0+12], %1 + punpckhdq %1, [r0+8] +%else + movq %1, %2 + psrlq %1, 32 + punpckldq %1, %2 +%endif +%endmacro + +FFT48_3DN _3dn + + +%define Z(x) [zq + o1q*(x&6)*((x/6)^1) + o3q*(x/6) + mmsize*(x&1)] + +%macro DECL_PASS 2+ ; name, payload +align 16 +%1: +DEFINE_ARGS z, w, n, o1, o3 + lea o3q, [nq*3] + lea o1q, [nq*8] + shl o3q, 4 +.loop: + %2 + add zq, mmsize*2 + add wq, mmsize + sub nd, mmsize/8 + jg .loop + rep ret +%endmacro + +INIT_XMM +DECL_PASS pass_sse, PASS_BIG 1 +DECL_PASS pass_interleave_sse, PASS_BIG 0 + +INIT_MMX +%define mulps pfmul +%define addps pfadd +%define subps pfsub +%define unpcklps punpckldq +%define unpckhps punpckhdq +DECL_PASS pass_3dn, PASS_SMALL 1, [wq], [wq+o1q] +DECL_PASS pass_interleave_3dn, PASS_BIG 0 +%define pass_3dn2 pass_3dn +%define pass_interleave_3dn2 pass_interleave_3dn + + +%macro DECL_FFT 2-3 ; nbits, cpu, suffix +%xdefine list_of_fft fft4%2, fft8%2 +%if %1==5 +%xdefine list_of_fft list_of_fft, fft16%2 +%endif + +%assign n 1<<%1 +%rep 17-%1 +%assign n2 n/2 +%assign n4 n/4 +%xdefine list_of_fft list_of_fft, fft %+ n %+ %3%2 + +align 16 +fft %+ n %+ %3%2: + call fft %+ n2 %+ %2 + add r0, n*4 - (n&(-2<<%1)) + call fft %+ n4 %+ %2 + add r0, n*2 - (n2&(-2<<%1)) + call fft %+ n4 %+ %2 + sub r0, n*6 + (n2&(-2<<%1)) + lea r1, [ff_cos_ %+ n GLOBAL] + mov r2d, n4/2 + jmp pass%3%2 + +%assign n n*2 +%endrep +%undef n + +align 8 +dispatch_tab%3%2: pointer list_of_fft + +; On x86_32, this function does the register saving and restoring for all of fft. +; The others pass args in registers and don't spill anything. +cglobal ff_fft_dispatch%3%2, 2,5,0, z, nbits + lea r2, [dispatch_tab%3%2 GLOBAL] + mov r2, [r2 + (nbitsq-2)*gprsize] + call r2 + RET +%endmacro ; DECL_FFT + +DECL_FFT 5, _sse +DECL_FFT 5, _sse, _interleave +DECL_FFT 4, _3dn +DECL_FFT 4, _3dn, _interleave +DECL_FFT 4, _3dn2 +DECL_FFT 4, _3dn2, _interleave +
--- a/i386/fft_sse.c Mon Aug 11 23:54:09 2008 +0000 +++ b/i386/fft_sse.c Tue Aug 12 00:26:58 2008 +0000 @@ -22,124 +22,55 @@ #include "libavutil/x86_cpu.h" #include "libavcodec/dsputil.h" -static const int p1p1p1m1[4] __attribute__((aligned(16))) = - { 0, 0, 0, 1 << 31 }; - -static const int p1p1m1p1[4] __attribute__((aligned(16))) = - { 0, 0, 1 << 31, 0 }; - -static const int p1p1m1m1[4] __attribute__((aligned(16))) = - { 0, 0, 1 << 31, 1 << 31 }; - static const int p1m1p1m1[4] __attribute__((aligned(16))) = { 0, 1 << 31, 0, 1 << 31 }; static const int m1m1m1m1[4] __attribute__((aligned(16))) = { 1 << 31, 1 << 31, 1 << 31, 1 << 31 }; -#if 0 -static void print_v4sf(const char *str, __m128 a) -{ - float *p = (float *)&a; - printf("%s: %f %f %f %f\n", - str, p[0], p[1], p[2], p[3]); -} -#endif +void ff_fft_dispatch_sse(FFTComplex *z, int nbits); +void ff_fft_dispatch_interleave_sse(FFTComplex *z, int nbits); -/* XXX: handle reverse case */ void ff_fft_calc_sse(FFTContext *s, FFTComplex *z) { - int ln = s->nbits; - x86_reg i; - long j; - long nblocks, nloops; - FFTComplex *p, *cptr; - - asm volatile( - "movaps %0, %%xmm4 \n\t" - "movaps %1, %%xmm5 \n\t" - ::"m"(*p1p1m1m1), - "m"(*(s->inverse ? p1p1m1p1 : p1p1p1m1)) - ); + int n = 1 << s->nbits; - i = 8 << ln; - asm volatile( - "1: \n\t" - "sub $32, %0 \n\t" - /* do the pass 0 butterfly */ - "movaps (%0,%1), %%xmm0 \n\t" - "movaps %%xmm0, %%xmm1 \n\t" - "shufps $0x4E, %%xmm0, %%xmm0 \n\t" - "xorps %%xmm4, %%xmm1 \n\t" - "addps %%xmm1, %%xmm0 \n\t" - "movaps 16(%0,%1), %%xmm2 \n\t" - "movaps %%xmm2, %%xmm3 \n\t" - "shufps $0x4E, %%xmm2, %%xmm2 \n\t" - "xorps %%xmm4, %%xmm3 \n\t" - "addps %%xmm3, %%xmm2 \n\t" - /* multiply third by -i */ - /* by toggling the sign bit */ - "shufps $0xB4, %%xmm2, %%xmm2 \n\t" - "xorps %%xmm5, %%xmm2 \n\t" - /* do the pass 1 butterfly */ - "movaps %%xmm0, %%xmm1 \n\t" - "addps %%xmm2, %%xmm0 \n\t" - "subps %%xmm2, %%xmm1 \n\t" - "movaps %%xmm0, (%0,%1) \n\t" - "movaps %%xmm1, 16(%0,%1) \n\t" - "jg 1b \n\t" - :"+r"(i) - :"r"(z) - ); - /* pass 2 .. ln-1 */ + ff_fft_dispatch_interleave_sse(z, s->nbits); - nblocks = 1 << (ln-3); - nloops = 1 << 2; - cptr = s->exptab1; - do { - p = z; - j = nblocks; - do { - i = nloops*8; - asm volatile( - "1: \n\t" - "sub $32, %0 \n\t" - "movaps (%2,%0), %%xmm1 \n\t" - "movaps (%1,%0), %%xmm0 \n\t" - "movaps 16(%2,%0), %%xmm5 \n\t" - "movaps 16(%1,%0), %%xmm4 \n\t" - "movaps %%xmm1, %%xmm2 \n\t" - "movaps %%xmm5, %%xmm6 \n\t" - "shufps $0xA0, %%xmm1, %%xmm1 \n\t" - "shufps $0xF5, %%xmm2, %%xmm2 \n\t" - "shufps $0xA0, %%xmm5, %%xmm5 \n\t" - "shufps $0xF5, %%xmm6, %%xmm6 \n\t" - "mulps (%3,%0,2), %%xmm1 \n\t" // cre*re cim*re - "mulps 16(%3,%0,2), %%xmm2 \n\t" // -cim*im cre*im - "mulps 32(%3,%0,2), %%xmm5 \n\t" // cre*re cim*re - "mulps 48(%3,%0,2), %%xmm6 \n\t" // -cim*im cre*im - "addps %%xmm2, %%xmm1 \n\t" - "addps %%xmm6, %%xmm5 \n\t" - "movaps %%xmm0, %%xmm3 \n\t" - "movaps %%xmm4, %%xmm7 \n\t" - "addps %%xmm1, %%xmm0 \n\t" - "subps %%xmm1, %%xmm3 \n\t" - "addps %%xmm5, %%xmm4 \n\t" - "subps %%xmm5, %%xmm7 \n\t" - "movaps %%xmm0, (%1,%0) \n\t" - "movaps %%xmm3, (%2,%0) \n\t" - "movaps %%xmm4, 16(%1,%0) \n\t" - "movaps %%xmm7, 16(%2,%0) \n\t" - "jg 1b \n\t" - :"+r"(i) - :"r"(p), "r"(p + nloops), "r"(cptr) - ); - p += nloops*2; - } while (--j); - cptr += nloops*2; - nblocks >>= 1; - nloops <<= 1; - } while (nblocks != 0); + if(n <= 16) { + x86_reg i = -8*n; + asm volatile( + "1: \n" + "movaps (%0,%1), %%xmm0 \n" + "movaps %%xmm0, %%xmm1 \n" + "unpcklps 16(%0,%1), %%xmm0 \n" + "unpckhps 16(%0,%1), %%xmm1 \n" + "movaps %%xmm0, (%0,%1) \n" + "movaps %%xmm1, 16(%0,%1) \n" + "add $32, %0 \n" + "jl 1b \n" + :"+r"(i) + :"r"(z+n) + :"memory" + ); + } +} + +void ff_fft_permute_sse(FFTContext *s, FFTComplex *z) +{ + int n = 1 << s->nbits; + int i; + for(i=0; i<n; i+=2) { + asm volatile( + "movaps %2, %%xmm0 \n" + "movlps %%xmm0, %0 \n" + "movhps %%xmm0, %1 \n" + :"=m"(s->tmp_buf[s->revtab[i]]), + "=m"(s->tmp_buf[s->revtab[i+1]]) + :"m"(z[i]) + ); + } + memcpy(z, s->tmp_buf, n*sizeof(FFTComplex)); } static void imdct_sse(MDCTContext *s, const FFTSample *input, FFTSample *tmp)