X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=lib%2Fmdct.c;h=f3f1ed805b592059a3e58f8f89b587116d4e5bce;hb=a79ec216cd119069c68b8f3542c6a425a74ab993;hp=a3cccedb8999b61b51000d264e468b258bd402e7;hpb=1487aec2e3af5f9d8e502f1ad5e3418fe4d47e59;p=platform%2Fupstream%2Flibvorbis.git

diff --git a/lib/mdct.c b/lib/mdct.c
index a3ccced..f3f1ed8 100644
--- a/lib/mdct.c
+++ b/lib/mdct.c
@@ -1,75 +1,75 @@
 /********************************************************************
  *                                                                  *
- * THIS FILE IS PART OF THE Ogg Vorbis SOFTWARE CODEC SOURCE CODE.  *
- * USE, DISTRIBUTION AND REPRODUCTION OF THIS SOURCE IS GOVERNED BY *
- * THE GNU PUBLIC LICENSE 2, WHICH IS INCLUDED WITH THIS SOURCE.    *
- * PLEASE READ THESE TERMS DISTRIBUTING.                            *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE.   *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS     *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING.       *
  *                                                                  *
- * THE OggSQUISH SOURCE CODE IS (C) COPYRIGHT 1994-2000             *
- * by Monty <monty@xiph.org> and The XIPHOPHORUS Company            *
- * http://www.xiph.org/                                             *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009             *
+ * by the Xiph.Org Foundation http://www.xiph.org/                  *
  *                                                                  *
  ********************************************************************
 
  function: normalized modified discrete cosine transform
-           power of two length transform only [16 <= n ]
- last mod: $Id: mdct.c,v 1.15 2000/02/09 22:04:15 xiphmont Exp $
+           power of two length transform only [64 <= n ]
 
- Algorithm adapted from _The use of multirate filter banks for coding
- of high quality digital audio_, by T. Sporer, K. Brandenburg and
- B. Edler, collection of the European Signal Processing Conference
- (EUSIPCO), Amsterdam, June 1992, Vol.1, pp 211-214 
+ Original algorithm adapted long ago from _The use of multirate filter
+ banks for coding of high quality digital audio_, by T. Sporer,
+ K. Brandenburg and B. Edler, collection of the European Signal
+ Processing Conference (EUSIPCO), Amsterdam, June 1992, Vol.1, pp
+ 211-214
 
- Note that the below code won't make much sense without the paper;
- The presented algorithm was already fairly polished, and the code
- once followed it closely.  The current code both corrects several
- typos in the paper and goes beyond the presented optimizations 
- (steps 4 through 6 are, for example, entirely eliminated).
+ The below code implements an algorithm that no longer looks much like
+ that presented in the paper, but the basic structure remains if you
+ dig deep enough to see it.
 
- This module DOES NOT INCLUDE code to generate the window function.
- Everybody has their own weird favorite including me... I happen to
- like the properties of y=sin(2PI*sin^2(x)), but others may vehemently
- disagree.
+ This module DOES NOT INCLUDE code to generate/apply the window
+ function.  Everybody has their own weird favorite including me... I
+ happen to like the properties of y=sin(.5PI*sin^2(x)), but others may
+ vehemently disagree.
 
  ********************************************************************/
 
+/* this can also be run as an integer transform by uncommenting a
+   define in mdct.h; the integerization is a first pass and although
+   it's likely stable for Vorbis, the dynamic range is constrained and
+   roundoff isn't done (so it's noisy).  Consider it functional, but
+   only a starting point.  There's no point on a machine with an FPU */
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <math.h>
+#include "vorbis/codec.h"
 #include "mdct.h"
 #include "os.h"
+#include "misc.h"
 
 /* build lookups for trig functions; also pre-figure scaling and
    some window function algebra. */
 
 void mdct_init(mdct_lookup *lookup,int n){
-  int    *bitrev=malloc(sizeof(int)*(n/4));
-  double *trig=malloc(sizeof(double)*(n+n/4));
-  double *AE=trig;
-  double *AO=trig+1;
-  double *BE=AE+n/2;
-  double *BO=BE+1;
-  double *CE=BE+n/2;
-  double *CO=CE+1;
-  
+  int   *bitrev=_ogg_malloc(sizeof(*bitrev)*(n/4));
+  DATA_TYPE *T=_ogg_malloc(sizeof(*T)*(n+n/4));
+
   int i;
-  int log2n=lookup->log2n=rint(log(n)/log(2));
+  int n2=n>>1;
+  int log2n=lookup->log2n=rint(log((float)n)/log(2.f));
   lookup->n=n;
-  lookup->trig=trig;
+  lookup->trig=T;
   lookup->bitrev=bitrev;
 
-  /* trig lookups... */
+/* trig lookups... */
 
   for(i=0;i<n/4;i++){
-    AE[i*2]=cos((M_PI/n)*(4*i));
-    AO[i*2]=-sin((M_PI/n)*(4*i));
-    BE[i*2]=cos((M_PI/(2*n))*(2*i+1));
-    BO[i*2]=sin((M_PI/(2*n))*(2*i+1));
+    T[i*2]=FLOAT_CONV(cos((M_PI/n)*(4*i)));
+    T[i*2+1]=FLOAT_CONV(-sin((M_PI/n)*(4*i)));
+    T[n2+i*2]=FLOAT_CONV(cos((M_PI/(2*n))*(2*i+1)));
+    T[n2+i*2+1]=FLOAT_CONV(sin((M_PI/(2*n))*(2*i+1)));
   }
   for(i=0;i<n/8;i++){
-    CE[i*2]=cos((M_PI/n)*(4*i+2));
-    CO[i*2]=-sin((M_PI/n)*(4*i+2));
+    T[n+i*2]=FLOAT_CONV(cos((M_PI/n)*(4*i+2))*.5);
+    T[n+i*2+1]=FLOAT_CONV(-sin((M_PI/n)*(4*i+2))*.5);
   }
 
   /* bitreverse lookup... */
@@ -80,249 +80,483 @@ void mdct_init(mdct_lookup *lookup,int n){
     for(i=0;i<n/8;i++){
       int acc=0;
       for(j=0;msb>>j;j++)
-	if((msb>>j)&i)acc|=1<<j;
-      bitrev[i*2]=((~acc)&mask);
+        if((msb>>j)&i)acc|=1<<j;
+      bitrev[i*2]=((~acc)&mask)-1;
       bitrev[i*2+1]=acc;
+
     }
   }
+  lookup->scale=FLOAT_CONV(4.f/n);
 }
 
-void mdct_clear(mdct_lookup *l){
-  if(l){
-    if(l->trig)free(l->trig);
-    if(l->bitrev)free(l->bitrev);
-    memset(l,0,sizeof(mdct_lookup));
-  }
+/* 8 point butterfly (in place, 4 register) */
+STIN void mdct_butterfly_8(DATA_TYPE *x){
+  REG_TYPE r0   = x[6] + x[2];
+  REG_TYPE r1   = x[6] - x[2];
+  REG_TYPE r2   = x[4] + x[0];
+  REG_TYPE r3   = x[4] - x[0];
+
+           x[6] = r0   + r2;
+           x[4] = r0   - r2;
+
+           r0   = x[5] - x[1];
+           r2   = x[7] - x[3];
+           x[0] = r1   + r0;
+           x[2] = r1   - r0;
+
+           r0   = x[5] + x[1];
+           r1   = x[7] + x[3];
+           x[3] = r2   + r3;
+           x[1] = r2   - r3;
+           x[7] = r1   + r0;
+           x[5] = r1   - r0;
+
 }
 
-static double *_mdct_kernel(double *x, double *w,
-			    int n, int n2, int n4, int n8,
-			    mdct_lookup *init){
-  int i;
-  /* step 2 */
+/* 16 point butterfly (in place, 4 register) */
+STIN void mdct_butterfly_16(DATA_TYPE *x){
+  REG_TYPE r0     = x[1]  - x[9];
+  REG_TYPE r1     = x[0]  - x[8];
+
+           x[8]  += x[0];
+           x[9]  += x[1];
+           x[0]   = MULT_NORM((r0   + r1) * cPI2_8);
+           x[1]   = MULT_NORM((r0   - r1) * cPI2_8);
+
+           r0     = x[3]  - x[11];
+           r1     = x[10] - x[2];
+           x[10] += x[2];
+           x[11] += x[3];
+           x[2]   = r0;
+           x[3]   = r1;
+
+           r0     = x[12] - x[4];
+           r1     = x[13] - x[5];
+           x[12] += x[4];
+           x[13] += x[5];
+           x[4]   = MULT_NORM((r0   - r1) * cPI2_8);
+           x[5]   = MULT_NORM((r0   + r1) * cPI2_8);
+
+           r0     = x[14] - x[6];
+           r1     = x[15] - x[7];
+           x[14] += x[6];
+           x[15] += x[7];
+           x[6]  = r0;
+           x[7]  = r1;
+
+           mdct_butterfly_8(x);
+           mdct_butterfly_8(x+8);
+}
 
-  {
-    double *xA=x+n4;
-    double *xB=x;
-    double *w2=w+n4;
-    double *A=init->trig+n2;
+/* 32 point butterfly (in place, 4 register) */
+STIN void mdct_butterfly_32(DATA_TYPE *x){
+  REG_TYPE r0     = x[30] - x[14];
+  REG_TYPE r1     = x[31] - x[15];
+
+           x[30] +=         x[14];
+           x[31] +=         x[15];
+           x[14]  =         r0;
+           x[15]  =         r1;
+
+           r0     = x[28] - x[12];
+           r1     = x[29] - x[13];
+           x[28] +=         x[12];
+           x[29] +=         x[13];
+           x[12]  = MULT_NORM( r0 * cPI1_8  -  r1 * cPI3_8 );
+           x[13]  = MULT_NORM( r0 * cPI3_8  +  r1 * cPI1_8 );
+
+           r0     = x[26] - x[10];
+           r1     = x[27] - x[11];
+           x[26] +=         x[10];
+           x[27] +=         x[11];
+           x[10]  = MULT_NORM(( r0  - r1 ) * cPI2_8);
+           x[11]  = MULT_NORM(( r0  + r1 ) * cPI2_8);
+
+           r0     = x[24] - x[8];
+           r1     = x[25] - x[9];
+           x[24] += x[8];
+           x[25] += x[9];
+           x[8]   = MULT_NORM( r0 * cPI3_8  -  r1 * cPI1_8 );
+           x[9]   = MULT_NORM( r1 * cPI3_8  +  r0 * cPI1_8 );
+
+           r0     = x[22] - x[6];
+           r1     = x[7]  - x[23];
+           x[22] += x[6];
+           x[23] += x[7];
+           x[6]   = r1;
+           x[7]   = r0;
+
+           r0     = x[4]  - x[20];
+           r1     = x[5]  - x[21];
+           x[20] += x[4];
+           x[21] += x[5];
+           x[4]   = MULT_NORM( r1 * cPI1_8  +  r0 * cPI3_8 );
+           x[5]   = MULT_NORM( r1 * cPI3_8  -  r0 * cPI1_8 );
+
+           r0     = x[2]  - x[18];
+           r1     = x[3]  - x[19];
+           x[18] += x[2];
+           x[19] += x[3];
+           x[2]   = MULT_NORM(( r1  + r0 ) * cPI2_8);
+           x[3]   = MULT_NORM(( r1  - r0 ) * cPI2_8);
+
+           r0     = x[0]  - x[16];
+           r1     = x[1]  - x[17];
+           x[16] += x[0];
+           x[17] += x[1];
+           x[0]   = MULT_NORM( r1 * cPI3_8  +  r0 * cPI1_8 );
+           x[1]   = MULT_NORM( r1 * cPI1_8  -  r0 * cPI3_8 );
+
+           mdct_butterfly_16(x);
+           mdct_butterfly_16(x+16);
 
-    for(i=0;i<n4;){
-      double x0=*xA - *xB;
-      double x1;
-      w2[i]=    *xA++ + *xB++;
+}
 
+/* N point first stage butterfly (in place, 2 register) */
+STIN void mdct_butterfly_first(DATA_TYPE *T,
+                                        DATA_TYPE *x,
+                                        int points){
+
+  DATA_TYPE *x1        = x          + points      - 8;
+  DATA_TYPE *x2        = x          + (points>>1) - 8;
+  REG_TYPE   r0;
+  REG_TYPE   r1;
+
+  do{
+
+               r0      = x1[6]      -  x2[6];
+               r1      = x1[7]      -  x2[7];
+               x1[6]  += x2[6];
+               x1[7]  += x2[7];
+               x2[6]   = MULT_NORM(r1 * T[1]  +  r0 * T[0]);
+               x2[7]   = MULT_NORM(r1 * T[0]  -  r0 * T[1]);
+
+               r0      = x1[4]      -  x2[4];
+               r1      = x1[5]      -  x2[5];
+               x1[4]  += x2[4];
+               x1[5]  += x2[5];
+               x2[4]   = MULT_NORM(r1 * T[5]  +  r0 * T[4]);
+               x2[5]   = MULT_NORM(r1 * T[4]  -  r0 * T[5]);
+
+               r0      = x1[2]      -  x2[2];
+               r1      = x1[3]      -  x2[3];
+               x1[2]  += x2[2];
+               x1[3]  += x2[3];
+               x2[2]   = MULT_NORM(r1 * T[9]  +  r0 * T[8]);
+               x2[3]   = MULT_NORM(r1 * T[8]  -  r0 * T[9]);
+
+               r0      = x1[0]      -  x2[0];
+               r1      = x1[1]      -  x2[1];
+               x1[0]  += x2[0];
+               x1[1]  += x2[1];
+               x2[0]   = MULT_NORM(r1 * T[13] +  r0 * T[12]);
+               x2[1]   = MULT_NORM(r1 * T[12] -  r0 * T[13]);
+
+    x1-=8;
+    x2-=8;
+    T+=16;
+
+  }while(x2>=x);
+}
 
-      x1=       *xA - *xB;
-      A-=4;
+/* N/stage point generic N stage butterfly (in place, 2 register) */
+STIN void mdct_butterfly_generic(DATA_TYPE *T,
+                                          DATA_TYPE *x,
+                                          int points,
+                                          int trigint){
+
+  DATA_TYPE *x1        = x          + points      - 8;
+  DATA_TYPE *x2        = x          + (points>>1) - 8;
+  REG_TYPE   r0;
+  REG_TYPE   r1;
+
+  do{
+
+               r0      = x1[6]      -  x2[6];
+               r1      = x1[7]      -  x2[7];
+               x1[6]  += x2[6];
+               x1[7]  += x2[7];
+               x2[6]   = MULT_NORM(r1 * T[1]  +  r0 * T[0]);
+               x2[7]   = MULT_NORM(r1 * T[0]  -  r0 * T[1]);
+
+               T+=trigint;
+
+               r0      = x1[4]      -  x2[4];
+               r1      = x1[5]      -  x2[5];
+               x1[4]  += x2[4];
+               x1[5]  += x2[5];
+               x2[4]   = MULT_NORM(r1 * T[1]  +  r0 * T[0]);
+               x2[5]   = MULT_NORM(r1 * T[0]  -  r0 * T[1]);
+
+               T+=trigint;
+
+               r0      = x1[2]      -  x2[2];
+               r1      = x1[3]      -  x2[3];
+               x1[2]  += x2[2];
+               x1[3]  += x2[3];
+               x2[2]   = MULT_NORM(r1 * T[1]  +  r0 * T[0]);
+               x2[3]   = MULT_NORM(r1 * T[0]  -  r0 * T[1]);
+
+               T+=trigint;
+
+               r0      = x1[0]      -  x2[0];
+               r1      = x1[1]      -  x2[1];
+               x1[0]  += x2[0];
+               x1[1]  += x2[1];
+               x2[0]   = MULT_NORM(r1 * T[1]  +  r0 * T[0]);
+               x2[1]   = MULT_NORM(r1 * T[0]  -  r0 * T[1]);
+
+               T+=trigint;
+    x1-=8;
+    x2-=8;
+
+  }while(x2>=x);
+}
 
-      w[i++]=   x0 * A[0] + x1 * A[1];
-      w[i]=     x1 * A[0] - x0 * A[1];
+STIN void mdct_butterflies(mdct_lookup *init,
+                             DATA_TYPE *x,
+                             int points){
 
-      w2[i++]=  *xA++ + *xB++;
+  DATA_TYPE *T=init->trig;
+  int stages=init->log2n-5;
+  int i,j;
 
-    }
+  if(--stages>0){
+    mdct_butterfly_first(T,x,points);
   }
 
-  /* step 3 */
-
-  {
-    int r,s;
-    for(i=0;i<init->log2n-3;i++){
-      int k0=n>>(i+2);
-      int k1=1<<(i+3);
-      int wbase=n2-2;
-      double *A=init->trig;
-      double *temp;
-
-      for(r=0;r<(k0>>2);r++){
-        int w1=wbase;
-	int w2=w1-(k0>>1);
-	double AEv= A[0],wA;
-	double AOv= A[1],wB;
-	wbase-=2;
-
-	k0++;
-	for(s=0;s<(2<<i);s++){
-	  wB     =w[w1]   -w[w2];
-	  x[w1]  =w[w1]   +w[w2];
-
-	  wA     =w[++w1] -w[++w2];
-	  x[w1]  =w[w1]   +w[w2];
-
-	  x[w2]  =wA*AEv  - wB*AOv;
-	  x[w2-1]=wB*AEv  + wA*AOv;
-
-	  w1-=k0;
-	  w2-=k0;
-	}
-	k0--;
-
-	A+=k1;
-      }
-
-      temp=w;
-      w=x;
-      x=temp;
-    }
+  for(i=1;--stages>0;i++){
+    for(j=0;j<(1<<i);j++)
+      mdct_butterfly_generic(T,x+(points>>i)*j,points>>i,4<<i);
   }
 
-  /* step 4, 5, 6, 7 */
-  {
-    double *C=init->trig+n;
-    int *bit=init->bitrev;
-    double *x1=x;
-    double *x2=x+n2-1;
-    for(i=0;i<n8;i++){
-      int t1=*bit++;
-      int t2=*bit++;
-
-      double wA=w[t1]-w[t2+1];
-      double wB=w[t1-1]+w[t2];
-      double wC=w[t1]+w[t2+1];
-      double wD=w[t1-1]-w[t2];
-
-      double wACE=wA* *C;
-      double wBCE=wB* *C++;
-      double wACO=wA* *C;
-      double wBCO=wB* *C++;
-      
-      *x1++=( wC+wACO+wBCE)*.5;
-      *x2--=(-wD+wBCO-wACE)*.5;
-      *x1++=( wD+wBCO-wACE)*.5; 
-      *x2--=( wC-wACO-wBCE)*.5;
-    }
+  for(j=0;j<points;j+=32)
+    mdct_butterfly_32(x+j);
+
+}
+
+void mdct_clear(mdct_lookup *l){
+  if(l){
+    if(l->trig)_ogg_free(l->trig);
+    if(l->bitrev)_ogg_free(l->bitrev);
+    memset(l,0,sizeof(*l));
   }
-  return(x);
 }
 
-void mdct_forward(mdct_lookup *init, double *in, double *out){
-  int n=init->n;
-  double *x=alloca(sizeof(double)*(n/2));
-  double *w=alloca(sizeof(double)*(n/2));
-  double *xx;
-  int n2=n>>1;
-  int n4=n>>2;
-  int n8=n>>3;
-  int i;
+STIN void mdct_bitreverse(mdct_lookup *init,
+                            DATA_TYPE *x){
+  int        n       = init->n;
+  int       *bit     = init->bitrev;
+  DATA_TYPE *w0      = x;
+  DATA_TYPE *w1      = x = w0+(n>>1);
+  DATA_TYPE *T       = init->trig+n;
 
-  /* window + rotate + step 1 */
-  {
-    double tempA,tempB;
-    int in1=n2+n4-4;
-    int in2=in1+5;
-    double *A=init->trig+n2;
-
-    i=0;
-    
-    for(i=0;i<n8;i+=2){
-      A-=2;
-      tempA= in[in1+2] + in[in2];
-      tempB= in[in1] + in[in2+2];       
-      in1 -=4;in2 +=4;
-      x[i]=   tempB*A[1] + tempA*A[0];
-      x[i+1]= tempB*A[0] - tempA*A[1];
-    }
+  do{
+    DATA_TYPE *x0    = x+bit[0];
+    DATA_TYPE *x1    = x+bit[1];
 
-    in2=1;
+    REG_TYPE  r0     = x0[1]  - x1[1];
+    REG_TYPE  r1     = x0[0]  + x1[0];
+    REG_TYPE  r2     = MULT_NORM(r1     * T[0]   + r0 * T[1]);
+    REG_TYPE  r3     = MULT_NORM(r1     * T[1]   - r0 * T[0]);
 
-    for(;i<n2-n8;i+=2){
-      A-=2;
-      tempA= in[in1+2] - in[in2];
-      tempB= in[in1] - in[in2+2];       
-      in1 -=4;in2 +=4;
-      x[i]=   tempB*A[1] + tempA*A[0];
-      x[i+1]= tempB*A[0] - tempA*A[1];
-    }
-    
-    in1=n-4;
-
-    for(;i<n2;i+=2){
-      A-=2;
-      tempA= -in[in1+2] - in[in2];
-      tempB= -in[in1] - in[in2+2];       
-      in1 -=4;in2 +=4;
-      x[i]=   tempB*A[1] + tempA*A[0];
-      x[i+1]= tempB*A[0] - tempA*A[1];
-    }
-  }
+              w1    -= 4;
+
+              r0     = HALVE(x0[1] + x1[1]);
+              r1     = HALVE(x0[0] - x1[0]);
+
+              w0[0]  = r0     + r2;
+              w1[2]  = r0     - r2;
+              w0[1]  = r1     + r3;
+              w1[3]  = r3     - r1;
+
+              x0     = x+bit[2];
+              x1     = x+bit[3];
 
-  xx=_mdct_kernel(x,w,n,n2,n4,n8,init);
+              r0     = x0[1]  - x1[1];
+              r1     = x0[0]  + x1[0];
+              r2     = MULT_NORM(r1     * T[2]   + r0 * T[3]);
+              r3     = MULT_NORM(r1     * T[3]   - r0 * T[2]);
 
-  /* step 8 */
+              r0     = HALVE(x0[1] + x1[1]);
+              r1     = HALVE(x0[0] - x1[0]);
+
+              w0[2]  = r0     + r2;
+              w1[0]  = r0     - r2;
+              w0[3]  = r1     + r3;
+              w1[1]  = r3     - r1;
+
+              T     += 4;
+              bit   += 4;
+              w0    += 4;
+
+  }while(w0<w1);
+}
+
+void mdct_backward(mdct_lookup *init, DATA_TYPE *in, DATA_TYPE *out){
+  int n=init->n;
+  int n2=n>>1;
+  int n4=n>>2;
+
+  /* rotate */
+
+  DATA_TYPE *iX = in+n2-7;
+  DATA_TYPE *oX = out+n2+n4;
+  DATA_TYPE *T  = init->trig+n4;
+
+  do{
+    oX         -= 4;
+    oX[0]       = MULT_NORM(-iX[2] * T[3] - iX[0]  * T[2]);
+    oX[1]       = MULT_NORM (iX[0] * T[3] - iX[2]  * T[2]);
+    oX[2]       = MULT_NORM(-iX[6] * T[1] - iX[4]  * T[0]);
+    oX[3]       = MULT_NORM (iX[4] * T[1] - iX[6]  * T[0]);
+    iX         -= 8;
+    T          += 4;
+  }while(iX>=in);
+
+  iX            = in+n2-8;
+  oX            = out+n2+n4;
+  T             = init->trig+n4;
+
+  do{
+    T          -= 4;
+    oX[0]       =  MULT_NORM (iX[4] * T[3] + iX[6] * T[2]);
+    oX[1]       =  MULT_NORM (iX[4] * T[2] - iX[6] * T[3]);
+    oX[2]       =  MULT_NORM (iX[0] * T[1] + iX[2] * T[0]);
+    oX[3]       =  MULT_NORM (iX[0] * T[0] - iX[2] * T[1]);
+    iX         -= 8;
+    oX         += 4;
+  }while(iX>=in);
+
+  mdct_butterflies(init,out+n2,n2);
+  mdct_bitreverse(init,out);
+
+  /* roatate + window */
 
   {
-    double *B=init->trig+n2;
-    double *out2=out+n2;
-    double scale=4./n;
-    for(i=0;i<n4;i++){
-      out[i]   =(xx[0]*B[0]+xx[1]*B[1])*scale;
-      *(--out2)=(xx[0]*B[1]-xx[1]*B[0])*scale;
-
-      xx+=2;
-      B+=2;
-    }
+    DATA_TYPE *oX1=out+n2+n4;
+    DATA_TYPE *oX2=out+n2+n4;
+    DATA_TYPE *iX =out;
+    T             =init->trig+n2;
+
+    do{
+      oX1-=4;
+
+      oX1[3]  =  MULT_NORM (iX[0] * T[1] - iX[1] * T[0]);
+      oX2[0]  = -MULT_NORM (iX[0] * T[0] + iX[1] * T[1]);
+
+      oX1[2]  =  MULT_NORM (iX[2] * T[3] - iX[3] * T[2]);
+      oX2[1]  = -MULT_NORM (iX[2] * T[2] + iX[3] * T[3]);
+
+      oX1[1]  =  MULT_NORM (iX[4] * T[5] - iX[5] * T[4]);
+      oX2[2]  = -MULT_NORM (iX[4] * T[4] + iX[5] * T[5]);
+
+      oX1[0]  =  MULT_NORM (iX[6] * T[7] - iX[7] * T[6]);
+      oX2[3]  = -MULT_NORM (iX[6] * T[6] + iX[7] * T[7]);
+
+      oX2+=4;
+      iX    +=   8;
+      T     +=   8;
+    }while(iX<oX1);
+
+    iX=out+n2+n4;
+    oX1=out+n4;
+    oX2=oX1;
+
+    do{
+      oX1-=4;
+      iX-=4;
+
+      oX2[0] = -(oX1[3] = iX[3]);
+      oX2[1] = -(oX1[2] = iX[2]);
+      oX2[2] = -(oX1[1] = iX[1]);
+      oX2[3] = -(oX1[0] = iX[0]);
+
+      oX2+=4;
+    }while(oX2<iX);
+
+    iX=out+n2+n4;
+    oX1=out+n2+n4;
+    oX2=out+n2;
+    do{
+      oX1-=4;
+      oX1[0]= iX[3];
+      oX1[1]= iX[2];
+      oX1[2]= iX[1];
+      oX1[3]= iX[0];
+      iX+=4;
+    }while(oX1>oX2);
   }
 }
 
-void mdct_backward(mdct_lookup *init, double *in, double *out){
+void mdct_forward(mdct_lookup *init, DATA_TYPE *in, DATA_TYPE *out){
   int n=init->n;
-  double *x=alloca(sizeof(double)*(n/2));
-  double *w=alloca(sizeof(double)*(n/2));
-  double *xx;
   int n2=n>>1;
   int n4=n>>2;
   int n8=n>>3;
-  int i;
+  DATA_TYPE *w=alloca(n*sizeof(*w)); /* forward needs working space */
+  DATA_TYPE *w2=w+n2;
 
-  /* rotate + step 1 */
-  {
-    double *inO=in+1;
-    double  *xO= x;
-    double  *A=init->trig+n2;
-
-    for(i=0;i<n8;i++){
-      A-=2;
-      *xO++=-*(inO+2)*A[1] - *inO*A[0];
-      *xO++= *inO*A[1] - *(inO+2)*A[0];
-      inO+=4;
-    }
+  /* rotate */
 
-    inO=in+n2-4;
+  /* window + rotate + step 1 */
 
-    for(i=0;i<n8;i++){
-      A-=2;
-      *xO++=*inO*A[1] + *(inO+2)*A[0];
-      *xO++=*inO*A[0] - *(inO+2)*A[1];
-      inO-=4;
-    }
+  REG_TYPE r0;
+  REG_TYPE r1;
+  DATA_TYPE *x0=in+n2+n4;
+  DATA_TYPE *x1=x0+1;
+  DATA_TYPE *T=init->trig+n2;
+
+  int i=0;
+
+  for(i=0;i<n8;i+=2){
+    x0 -=4;
+    T-=2;
+    r0= x0[2] + x1[0];
+    r1= x0[0] + x1[2];
+    w2[i]=   MULT_NORM(r1*T[1] + r0*T[0]);
+    w2[i+1]= MULT_NORM(r1*T[0] - r0*T[1]);
+    x1 +=4;
+  }
 
+  x1=in+1;
+
+  for(;i<n2-n8;i+=2){
+    T-=2;
+    x0 -=4;
+    r0= x0[2] - x1[0];
+    r1= x0[0] - x1[2];
+    w2[i]=   MULT_NORM(r1*T[1] + r0*T[0]);
+    w2[i+1]= MULT_NORM(r1*T[0] - r0*T[1]);
+    x1 +=4;
   }
 
-  xx=_mdct_kernel(x,w,n,n2,n4,n8,init);
+  x0=in+n;
 
-  /* step 8 */
+  for(;i<n2;i+=2){
+    T-=2;
+    x0 -=4;
+    r0= -x0[2] - x1[0];
+    r1= -x0[0] - x1[2];
+    w2[i]=   MULT_NORM(r1*T[1] + r0*T[0]);
+    w2[i+1]= MULT_NORM(r1*T[0] - r0*T[1]);
+    x1 +=4;
+  }
 
-  {
-    double *B=init->trig+n2;
-    int o1=n4,o2=o1-1;
-    int o3=n4+n2,o4=o3-1;
-    
-    for(i=0;i<n4;i++){
-      double temp1= (*xx * B[1] - *(xx+1) * B[0]);
-      double temp2=-(*xx * B[0] + *(xx+1) * B[1]);
-    
-      out[o1]=-temp1;
-      out[o2]= temp1;
-      out[o3]= temp2;
-      out[o4]= temp2;
-
-      o1++;
-      o2--;
-      o3++;
-      o4--;
-      xx+=2;
-      B+=2;
-    }
+
+  mdct_butterflies(init,w+n2,n2);
+  mdct_bitreverse(init,w);
+
+  /* roatate + window */
+
+  T=init->trig+n2;
+  x0=out+n2;
+
+  for(i=0;i<n4;i++){
+    x0--;
+    out[i] =MULT_NORM((w[0]*T[0]+w[1]*T[1])*init->scale);
+    x0[0]  =MULT_NORM((w[0]*T[1]-w[1]*T[0])*init->scale);
+    w+=2;
+    T+=2;
   }
 }