Merge from branches/mdctexp - faster ifft+imdct in codec lib

git-svn-id: svn://svn.rockbox.org/rockbox/trunk@24712 a1c6a512-1295-4272-9138-f99709370657

4 files changed, 121 insertions, 116 deletions

diff --git a/apps/codecs/liba52/a52_internal.h b/apps/codecs/liba52/a52_internal.h
index 0db16a8bcf..1e3b4a7edf 100644
--- a/apps/codecs/liba52/a52_internal.h
+++ b/apps/codecs/liba52/a52_internal.h
@@ -111,13 +111,13 @@ int a52_downmix_init (int input, int flags, level_t * level,
                       level_t clev, level_t slev);
 int a52_downmix_coeff (level_t * coeff, int acmod, int output, level_t level,
                        level_t clev, level_t slev);
-void a52_downmix (sample_t * samples, int acmod, int output, sample_t bias,
+void a52_downmix (sample_t * samples, int acmod, int output, 
                   level_t clev, level_t slev);
 void a52_upmix (sample_t * samples, int acmod, int output);
 
 void a52_imdct_init (uint32_t mm_accel);
-void a52_imdct_256 (sample_t * data, sample_t * delay, sample_t bias);
-void a52_imdct_512 (sample_t * data, sample_t * delay, sample_t bias);
+void a52_imdct_256 (sample_t * data, sample_t * delay);
+void a52_imdct_512 (sample_t * data, sample_t * delay);
 
 #define ROUND(x) ((int)((x) + ((x) > 0 ? 0.5 : -0.5)))
 
@@ -210,6 +210,6 @@ typedef int16_t quantizer_t;
 
 #define MUL_C(a,b) MUL_L (a, LEVEL (b))
 #define DIV(a,b) ((((int64_t)LEVEL (a)) << 26) / (b))
-#define BIAS(x) ((x) + (bias*0))
+#define BIAS(x) ((x))
 
 #endif
diff --git a/apps/codecs/liba52/downmix.c b/apps/codecs/liba52/downmix.c
index 7bbf3793f0..2e8567bceb 100644
--- a/apps/codecs/liba52/downmix.c
+++ b/apps/codecs/liba52/downmix.c
@@ -329,7 +329,7 @@ int a52_downmix_coeff (level_t * coeff, int acmod, int output, level_t level,
     return -1;  /* NOTREACHED */
 }
 
-static void mix2to1 (sample_t * dest, sample_t * src, sample_t bias)
+static void mix2to1 (sample_t * dest, sample_t * src)
 {
     int i;
 
@@ -337,7 +337,7 @@ static void mix2to1 (sample_t * dest, sample_t * src, sample_t bias)
         dest[i] += BIAS (src[i]);
 }
 
-static void mix3to1 (sample_t * samples, sample_t bias)
+static void mix3to1 (sample_t * samples)
 {
     int i;
 
@@ -345,7 +345,7 @@ static void mix3to1 (sample_t * samples, sample_t bias)
         samples[i] += BIAS (samples[i + 256] + samples[i + 512]);
 }
 
-static void mix4to1 (sample_t * samples, sample_t bias)
+static void mix4to1 (sample_t * samples)
 {
     int i;
 
@@ -354,7 +354,7 @@ static void mix4to1 (sample_t * samples, sample_t bias)
                             samples[i + 768]);
 }
 
-static void mix5to1 (sample_t * samples, sample_t bias)
+static void mix5to1 (sample_t * samples)
 {
     int i;
 
@@ -363,7 +363,7 @@ static void mix5to1 (sample_t * samples, sample_t bias)
                             samples[i + 768] + samples[i + 1024]);
 }
 
-static void mix3to2 (sample_t * samples, sample_t bias)
+static void mix3to2 (sample_t * samples)
 {
     int i;
     sample_t common;
@@ -375,7 +375,7 @@ static void mix3to2 (sample_t * samples, sample_t bias)
     }
 }
 
-static void mix21to2 (sample_t * left, sample_t * right, sample_t bias)
+static void mix21to2 (sample_t * left, sample_t * right)
 {
     int i;
     sample_t common;
@@ -387,7 +387,7 @@ static void mix21to2 (sample_t * left, sample_t * right, sample_t bias)
     }
 }
 
-static void mix21toS (sample_t * samples, sample_t bias)
+static void mix21toS (sample_t * samples)
 {
     int i;
     sample_t surround;
@@ -399,7 +399,7 @@ static void mix21toS (sample_t * samples, sample_t bias)
     }
 }
 
-static void mix31to2 (sample_t * samples, sample_t bias)
+static void mix31to2 (sample_t * samples)
 {
     int i;
     sample_t common;
@@ -411,7 +411,7 @@ static void mix31to2 (sample_t * samples, sample_t bias)
     }
 }
 
-static void mix31toS (sample_t * samples, sample_t bias)
+static void mix31toS (sample_t * samples)
 {
     int i;
     sample_t common, surround;
@@ -424,7 +424,7 @@ static void mix31toS (sample_t * samples, sample_t bias)
     }
 }
 
-static void mix22toS (sample_t * samples, sample_t bias)
+static void mix22toS (sample_t * samples)
 {
     int i;
     sample_t surround;
@@ -436,7 +436,7 @@ static void mix22toS (sample_t * samples, sample_t bias)
     }
 }
 
-static void mix32to2 (sample_t * samples, sample_t bias)
+static void mix32to2 (sample_t * samples)
 {
     int i;
     sample_t common;
@@ -448,7 +448,7 @@ static void mix32to2 (sample_t * samples, sample_t bias)
     }
 }
 
-static void mix32toS (sample_t * samples, sample_t bias)
+static void mix32toS (sample_t * samples)
 {
     int i;
     sample_t common, surround;
@@ -461,7 +461,7 @@ static void mix32toS (sample_t * samples, sample_t bias)
     }
 }
 
-static void move2to1 (sample_t * src, sample_t * dest, sample_t bias)
+static void move2to1 (sample_t * src, sample_t * dest)
 {
     int i;
 
@@ -477,7 +477,7 @@ static void zero (sample_t * samples)
         samples[i] = 0;
 }
 
-void a52_downmix (sample_t * samples, int acmod, int output, sample_t bias,
+void a52_downmix (sample_t * samples, int acmod, int output,
                   level_t clev, level_t slev)
 {
     /* avoid compiler warning */
@@ -492,7 +492,7 @@ void a52_downmix (sample_t * samples, int acmod, int output, sample_t bias,
     case CONVERT (A52_CHANNEL, A52_MONO):
     case CONVERT (A52_STEREO, A52_MONO):
     mix_2to1:
-        mix2to1 (samples, samples + 256, bias);
+        mix2to1 (samples, samples + 256);
         break;
 
     case CONVERT (A52_2F1R, A52_MONO):
@@ -500,7 +500,7 @@ void a52_downmix (sample_t * samples, int acmod, int output, sample_t bias,
             goto mix_2to1;
     case CONVERT (A52_3F, A52_MONO):
     mix_3to1:
-        mix3to1 (samples, bias);
+        mix3to1 (samples);
         break;
 
     case CONVERT (A52_3F1R, A52_MONO):
@@ -509,13 +509,13 @@ void a52_downmix (sample_t * samples, int acmod, int output, sample_t bias,
     case CONVERT (A52_2F2R, A52_MONO):
         if (slev == 0)
             goto mix_2to1;
-        mix4to1 (samples, bias);
+        mix4to1 (samples);
         break;
 
     case CONVERT (A52_3F2R, A52_MONO):
         if (slev == 0)
             goto mix_3to1;
-        mix5to1 (samples, bias);
+        mix5to1 (samples);
         break;
 
     case CONVERT (A52_MONO, A52_DOLBY):
@@ -525,79 +525,79 @@ void a52_downmix (sample_t * samples, int acmod, int output, sample_t bias,
     case CONVERT (A52_3F, A52_STEREO):
     case CONVERT (A52_3F, A52_DOLBY):
     mix_3to2:
-        mix3to2 (samples, bias);
+        mix3to2 (samples);
         break;
 
     case CONVERT (A52_2F1R, A52_STEREO):
         if (slev == 0)
             break;
-        mix21to2 (samples, samples + 256, bias);
+        mix21to2 (samples, samples + 256);
         break;
 
     case CONVERT (A52_2F1R, A52_DOLBY):
-        mix21toS (samples, bias);
+        mix21toS (samples);
         break;
 
     case CONVERT (A52_3F1R, A52_STEREO):
         if (slev == 0)
             goto mix_3to2;
-        mix31to2 (samples, bias);
+        mix31to2 (samples);
         break;
 
     case CONVERT (A52_3F1R, A52_DOLBY):
-        mix31toS (samples, bias);
+        mix31toS (samples);
         break;
 
     case CONVERT (A52_2F2R, A52_STEREO):
         if (slev == 0)
             break;
-        mix2to1 (samples, samples + 512, bias);
-        mix2to1 (samples + 256, samples + 768, bias);
+        mix2to1 (samples, samples + 512);
+        mix2to1 (samples + 256, samples + 768);
         break;
 
     case CONVERT (A52_2F2R, A52_DOLBY):
-        mix22toS (samples, bias);
+        mix22toS (samples);
         break;
 
     case CONVERT (A52_3F2R, A52_STEREO):
         if (slev == 0)
             goto mix_3to2;
-        mix32to2 (samples, bias);
+        mix32to2 (samples);
         break;
 
     case CONVERT (A52_3F2R, A52_DOLBY):
-        mix32toS (samples, bias);
+        mix32toS (samples);
         break;
 
     case CONVERT (A52_3F1R, A52_3F):
         if (slev == 0)
             break;
-        mix21to2 (samples, samples + 512, bias);
+        mix21to2 (samples, samples + 512);
         break;
 
     case CONVERT (A52_3F2R, A52_3F):
         if (slev == 0)
             break;
-        mix2to1 (samples, samples + 768, bias);
-        mix2to1 (samples + 512, samples + 1024, bias);
+        mix2to1 (samples, samples + 768);
+        mix2to1 (samples + 512, samples + 1024);
         break;
 
     case CONVERT (A52_3F1R, A52_2F1R):
-        mix3to2 (samples, bias);
+        mix3to2 (samples);
         memcpy (samples + 512, samples + 768, 256 * sizeof (sample_t));
         break;
 
     case CONVERT (A52_2F2R, A52_2F1R):
-        mix2to1 (samples + 512, samples + 768, bias);
+        mix2to1 (samples + 512, samples + 768);
         break;
 
     case CONVERT (A52_3F2R, A52_2F1R):
-        mix3to2 (samples, bias);
-        move2to1 (samples + 768, samples + 512, bias);
+        mix3to2 (samples);
+        move2to1 (samples + 768, samples + 512);
         break;
 
     case CONVERT (A52_3F2R, A52_3F1R):
-        mix2to1 (samples + 768, samples + 1024, bias);
+        mix2to1 (samples + 768, samples + 1024);
         break;
 
     case CONVERT (A52_2F1R, A52_2F2R):
@@ -605,12 +605,12 @@ void a52_downmix (sample_t * samples, int acmod, int output, sample_t bias,
         break;
 
     case CONVERT (A52_3F1R, A52_2F2R):
-        mix3to2 (samples, bias);
+        mix3to2 (samples);
         memcpy (samples + 512, samples + 768, 256 * sizeof (sample_t));
         break;
 
     case CONVERT (A52_3F2R, A52_2F2R):
-        mix3to2 (samples, bias);
+        mix3to2 (samples);
         memcpy (samples + 512, samples + 768, 256 * sizeof (sample_t));
         memcpy (samples + 768, samples + 1024, 256 * sizeof (sample_t));
         break;
diff --git a/apps/codecs/liba52/imdct.c b/apps/codecs/liba52/imdct.c
index d1035030fd..4483bd0667 100644
--- a/apps/codecs/liba52/imdct.c
+++ b/apps/codecs/liba52/imdct.c
@@ -72,6 +72,8 @@ static const uint8_t fftorder[] = {
 //static sample_t a52_imdct_window[256];
 #include "imdct_lookups.h"
 
+
+/*
 static void (* ifft128) (complex_t * buf);
 static void (* ifft64) (complex_t * buf);
 
@@ -109,7 +111,7 @@ static inline void ifft4 (complex_t * buf)
     buf[3].real = tmp5 - tmp7;
     buf[3].imag = tmp6 - tmp8;
 }
-
+*/
 /* basic radix-2 ifft butterfly */
 
 #define BUTTERFLY_0(t0,t1,W0,W1,d0,d1) do {     \
@@ -161,7 +163,7 @@ static inline void ifft4 (complex_t * buf)
 } while (0)
 
 /* split-radix ifft butterfly, specialized for wr=wi */
-
+/*
 #define BUTTERFLY_HALF(a0,a1,a2,a3,w) do {      \
     tmp5 = MUL (a2.real + a2.imag, w);          \
     tmp6 = MUL (a2.imag - a2.real, w);          \
@@ -255,93 +257,96 @@ static void ifft128_c (complex_t * buf)
     ifft32 (buf + 96);
     ifft_pass (buf, roots128, 32);
 }
-
-void a52_imdct_512 (sample_t * data, sample_t * delay, sample_t bias)
+*/
+void a52_imdct_512 (sample_t * data, sample_t * delay)
 {
     int i, k;
     sample_t t_r, t_i, a_r, a_i, b_r, b_i, w_1, w_2;
     const sample_t * window = a52_imdct_window;
-    complex_t buf[128];
+    FFTComplex buf[128];
         
     for (i = 0; i < 128; i++) {
-        k = fftorder[i];
-        t_r = pre1[i].real;
-        t_i = pre1[i].imag;
-        BUTTERFLY_0 (buf[i].real, buf[i].imag, t_r, t_i, data[k], data[255-k]);
+        k = fftorder[i];
+        t_r = pre1[i].real;
+        t_i = pre1[i].imag;
+        BUTTERFLY_0 (buf[i].re, buf[i].im, t_r, t_i, data[k], data[255-k]);
     }
 
-    ifft128 (buf);
+    //ifft128 (buf);
+    ff_fft_calc_c(7, (FFTComplex *)&buf);
 
     /* Post IFFT complex multiply plus IFFT complex conjugate*/
     /* Window and convert to real valued signal */
     for (i = 0; i < 64; i++) {
-        /* y[n] = z[n] * (xcos1[n] + j * xsin1[n]) ; */
-        t_r = post1[i].real;
-        t_i = post1[i].imag;
-        BUTTERFLY_0 (a_r, a_i, t_i, t_r, buf[i].imag, buf[i].real);
-        BUTTERFLY_0 (b_r, b_i, t_r, t_i, buf[127-i].imag, buf[127-i].real);
-
-        w_1 = window[2*i];
-        w_2 = window[255-2*i];
-        BUTTERFLY_B (data[255-2*i], data[2*i], w_2, w_1, a_r, delay[2*i]);
-        delay[2*i] = a_i;
-
-        w_1 = window[2*i+1];
-        w_2 = window[254-2*i];
-        BUTTERFLY_B (data[2*i+1], data[254-2*i], w_1, w_2, b_r, delay[2*i+1]);
-        delay[2*i+1] = b_i;
+        /* y[n] = z[n] * (xcos1[n] + j * xsin1[n]) ; */
+        t_r = post1[i].real;
+        t_i = post1[i].imag;
+        BUTTERFLY_0 (a_r, a_i, t_i, t_r, buf[i].im, buf[i].re);
+        BUTTERFLY_0 (b_r, b_i, t_r, t_i, buf[127-i].im, buf[127-i].re);
+
+        w_1 = window[2*i];
+        w_2 = window[255-2*i];
+        BUTTERFLY_B (data[255-2*i], data[2*i], w_2, w_1, a_r, delay[2*i]);
+        delay[2*i] = a_i;
+
+        w_1 = window[2*i+1];
+        w_2 = window[254-2*i];
+        BUTTERFLY_B (data[2*i+1], data[254-2*i], w_1, w_2, b_r, delay[2*i+1]);
+        delay[2*i+1] = b_i;
     }
 }
 
-void a52_imdct_256 (sample_t * data, sample_t * delay, sample_t bias)
+void a52_imdct_256 (sample_t * data, sample_t * delay)
 {
     int i, k;
     sample_t t_r, t_i, a_r, a_i, b_r, b_i, c_r, c_i, d_r, d_i, w_1, w_2;
     const sample_t * window = a52_imdct_window;
-    complex_t buf1[64], buf2[64];
+    FFTComplex buf1[64], buf2[64];
 
     /* Pre IFFT complex multiply plus IFFT cmplx conjugate */
     for (i = 0; i < 64; i++) {
-        k = fftorder[i];
-        t_r = pre2[i].real;
-        t_i = pre2[i].imag;
-        BUTTERFLY_0 (buf1[i].real, buf1[i].imag, t_r, t_i, data[k], data[254-k]);
-        BUTTERFLY_0 (buf2[i].real, buf2[i].imag, t_r, t_i, data[k+1], data[255-k]);
+        k = fftorder[i];
+        t_r = pre2[i].real;
+        t_i = pre2[i].imag;
+        BUTTERFLY_0 (buf1[i].re, buf1[i].im, t_r, t_i, data[k], data[254-k]);
+        BUTTERFLY_0 (buf2[i].re, buf2[i].im, t_r, t_i, data[k+1], data[255-k]);
     }
 
-    ifft64 (buf1);
-    ifft64 (buf2);
+    //ifft64 (buf1);
+    //ifft64 (buf2);
+    ff_fft_calc_c(6, (FFTComplex *)&buf1);
+    ff_fft_calc_c(6, (FFTComplex *)&buf2);
 
     /* Post IFFT complex multiply */
     /* Window and convert to real valued signal */
     for (i = 0; i < 32; i++) {
-        /* y1[n] = z1[n] * (xcos2[n] + j * xs in2[n]) ; */ 
-        t_r = post2[i].real;
-        t_i = post2[i].imag;
-        BUTTERFLY_0 (a_r, a_i, t_i, t_r, buf1[i].imag, buf1[i].real);
-        BUTTERFLY_0 (b_r, b_i, t_r, t_i, buf1[63-i].imag, buf1[63-i].real);
-        BUTTERFLY_0 (c_r, c_i, t_i, t_r, buf2[i].imag, buf2[i].real);
-        BUTTERFLY_0 (d_r, d_i, t_r, t_i, buf2[63-i].imag, buf2[63-i].real);
-
-        w_1 = window[2*i];
-        w_2 = window[255-2*i];
-        BUTTERFLY_B (data[255-2*i], data[2*i], w_2, w_1, a_r, delay[2*i]);
-        delay[2*i] = c_i;
-
-        w_1 = window[128+2*i];
-        w_2 = window[127-2*i];
-        BUTTERFLY_B (data[128+2*i], data[127-2*i], w_1, w_2, a_i, delay[127-2*i]);
-        delay[127-2*i] = c_r;
-
-        w_1 = window[2*i+1];
-        w_2 = window[254-2*i];
-        BUTTERFLY_B (data[254-2*i], data[2*i+1], w_2, w_1, b_i, delay[2*i+1]);
-        delay[2*i+1] = d_r;
-
-        w_1 = window[129+2*i];
-        w_2 = window[126-2*i];
-        BUTTERFLY_B (data[129+2*i], data[126-2*i], w_1, w_2, b_r, delay[126-2*i]);
-        delay[126-2*i] = d_i;
+        /* y1[n] = z1[n] * (xcos2[n] + j * xs in2[n]) ; */ 
+        t_r = post2[i].real;
+        t_i = post2[i].imag;
+        BUTTERFLY_0 (a_r, a_i, t_i, t_r, buf1[i].im, buf1[i].re);
+        BUTTERFLY_0 (b_r, b_i, t_r, t_i, buf1[63-i].im, buf1[63-i].re);
+        BUTTERFLY_0 (c_r, c_i, t_i, t_r, buf2[i].im, buf2[i].re);
+        BUTTERFLY_0 (d_r, d_i, t_r, t_i, buf2[63-i].im, buf2[63-i].re);
+
+        w_1 = window[2*i];
+        w_2 = window[255-2*i];
+        BUTTERFLY_B (data[255-2*i], data[2*i], w_2, w_1, a_r, delay[2*i]);
+        delay[2*i] = c_i;
+
+        w_1 = window[128+2*i];
+        w_2 = window[127-2*i];
+        BUTTERFLY_B (data[128+2*i], data[127-2*i], w_1, w_2, a_i, delay[127-2*i]);
+        delay[127-2*i] = c_r;
+
+        w_1 = window[2*i+1];
+        w_2 = window[254-2*i];
+        BUTTERFLY_B (data[254-2*i], data[2*i+1], w_2, w_1, b_i, delay[2*i+1]);
+        delay[2*i+1] = d_r;
+
+        w_1 = window[129+2*i];
+        w_2 = window[126-2*i];
+        BUTTERFLY_B (data[129+2*i], data[126-2*i], w_1, w_2, b_r, delay[126-2*i]);
+        delay[126-2*i] = d_i;
     }
 }
 
@@ -361,6 +366,9 @@ static double besselI0 (double x)
 void a52_imdct_init (uint32_t mm_accel)
 {
   (void)mm_accel;
+  //ff_fft_init(&s128, 7, 1);
+  //ff_fft_init(&s64, 6, 1);
+  
 /*    int i, k;
     double sum;
     double local_imdct_window[256];*/
@@ -457,7 +465,7 @@ void a52_imdct_init (uint32_t mm_accel)
     printf("static complex_t post2[32]={");
     for (i=0;i<32;i++) { printf("{%d,%d}%s",post2[i].real,post2[i].imag,(i < 31 ? "," : "")); }
     printf("};\n");
-    */
+    
 
 #ifdef LIBA52_DJBFFT
     if (mm_accel & MM_ACCEL_DJBFFT) {
@@ -474,4 +482,5 @@ void a52_imdct_init (uint32_t mm_accel)
         ifft128 = ifft128_c;
         ifft64 = ifft64_c;
     }
+    */
 }
diff --git a/apps/codecs/liba52/parse.c b/apps/codecs/liba52/parse.c
index 2a065b4fc4..f2b0ce4f6d 100644
--- a/apps/codecs/liba52/parse.c
+++ b/apps/codecs/liba52/parse.c
@@ -881,7 +881,7 @@ int a52_block (a52_state_t * state)
                        state->dynrng, 0, 7);
             for (i = 7; i < 256; i++)
                 (samples-256)[i] = 0;
-            a52_imdct_512 (samples - 256, samples + 1536 - 256, state->bias);
+            a52_imdct_512 (samples - 256, samples + 1536 - 256);
         } else {
             /* just skip the LFE coefficients */
             coeff_get (state, samples + 1280, &state->lfe_expbap, &quant,
@@ -910,11 +910,9 @@ int a52_block (a52_state_t * state)
 
             if (coeff[i]) {
                 if (blksw[i])
-                    a52_imdct_256 (samples + 256 * i, samples + 1536 + 256 * i,
-                                   bias);
+                    a52_imdct_256 (samples + 256 * i, samples + 1536 + 256 * i);
                 else 
-                    a52_imdct_512 (samples + 256 * i, samples + 1536 + 256 * i,
-                                   bias);
+                    a52_imdct_512 (samples + 256 * i, samples + 1536 + 256 * i);
             } else {
                 int j;
 
@@ -923,28 +921,26 @@ int a52_block (a52_state_t * state)
             }
         }
 
-        a52_downmix (samples, state->acmod, state->output, state->bias,
+        a52_downmix (samples, state->acmod, state->output,
                      state->clev, state->slev);
     } else {
         nfchans = nfchans_tbl[state->output & A52_CHANNEL_MASK];
 
-        a52_downmix (samples, state->acmod, state->output, 0,
+        a52_downmix (samples, state->acmod, state->output,
                      state->clev, state->slev);
 
         if (!state->downmixed) {
             state->downmixed = 1;
-            a52_downmix (samples + 1536, state->acmod, state->output, 0,
+            a52_downmix (samples + 1536, state->acmod, state->output,
                          state->clev, state->slev);
         }
 
         if (blksw[0])
             for (i = 0; i < nfchans; i++)
-                a52_imdct_256 (samples + 256 * i, samples + 1536 + 256 * i,
-                               state->bias);
+                a52_imdct_256 (samples + 256 * i, samples + 1536 + 256 * i);
         else 
             for (i = 0; i < nfchans; i++)
-                a52_imdct_512 (samples + 256 * i, samples + 1536 + 256 * i,
-                               state->bias);
+                a52_imdct_512 (samples + 256 * i, samples + 1536 + 256 * i);
     }
 
     return 0;