[xiph-cvs] cvs commit: vorbis/lib mdct.c mdct.h
Monty
xiphmont at xiph.org
Fri Dec 15 17:49:40 PST 2000
xiphmont 00/12/15 17:49:40
Modified: lib mdct.c mdct.h
Log:
Brand new mdct, roughly 35-40% faster on all block sizes (reduced
computation, reduced memory usage).
Monty
Revision Changes Path
1.20 +470 -267 vorbis/lib/mdct.c
Index: mdct.c
===================================================================
RCS file: /usr/local/cvsroot/vorbis/lib/mdct.c,v
retrieving revision 1.19
retrieving revision 1.20
diff -u -r1.19 -r1.20
--- mdct.c 2000/11/14 00:05:31 1.19
+++ mdct.c 2000/12/16 01:49:39 1.20
@@ -12,65 +12,64 @@
********************************************************************
function: normalized modified discrete cosine transform
- power of two length transform only [16 <= n ]
- last mod: $Id: mdct.c,v 1.19 2000/11/14 00:05:31 xiphmont Exp $
+ power of two length transform only [64 <= n ]
+ last mod: $Id: mdct.c,v 1.20 2000/12/16 01:49:39 xiphmont Exp $
- 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
-
- 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).
-
- 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.
+ 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
+
+ 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/apply 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 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=_ogg_malloc(sizeof(int)*(n/4));
- float *trig=_ogg_malloc(sizeof(float)*(n+n/4));
- float *AE=trig;
- float *AO=trig+1;
- float *BE=AE+n/2;
- float *BO=BE+1;
- float *CE=BE+n/2;
- float *CO=CE+1;
+ int *bitrev=_ogg_malloc(sizeof(int)*(n/4));
+ DATA_TYPE *T=_ogg_malloc(sizeof(DATA_TYPE)*(n+n/4));
int i;
+ int n2=n>>1;
int log2n=lookup->log2n=rint(log(n)/log(2));
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... */
@@ -82,12 +81,265 @@
int acc=0;
for(j=0;msb>>j;j++)
if((msb>>j)&i)acc|=1<<j;
- bitrev[i*2]=((~acc)&mask);
+ bitrev[i*2]=((~acc)&mask)-1;
bitrev[i*2+1]=acc;
+
}
}
+ lookup->scale=FLOAT_CONV(4./n);
+}
+
+/* 8 point butterfly (in place, 4 register) */
+static 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];
+
+ r0 = x[6] + x[2];
+ r1 = x[6] - x[2];
+ r2 = x[4] + x[0];
+ 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;
+
+}
+
+/* 16 point butterfly (in place, 4 register) */
+static 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);
+}
+
+/* 32 point butterfly (in place, 4 register) */
+static 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);
+
}
+/* N point first stage butterfly (in place, 2 register) */
+static 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);
+}
+
+/* N/stage point generic N stage butterfly (in place, 2 register) */
+static 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);
+}
+
+static void mdct_butterflies(mdct_lookup *init,
+ DATA_TYPE *x,
+ int points){
+
+ DATA_TYPE *T=init->trig;
+ int stages=init->log2n-5;
+ int i,j;
+
+ if(--stages>0){
+ mdct_butterfly_first(T,x,points);
+ }
+
+ 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);
+ }
+
+ 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);
@@ -96,270 +348,221 @@
}
}
-static float *_mdct_kernel(float *x, float *w,
- int n, int n2, int n4, int n8,
- mdct_lookup *init){
- int i;
- /* step 2 */
-
- {
- float *xA=x+n4;
- float *xB=x;
- float *w2=w+n4;
- float *A=init->trig+n2;
-
- float x0,x1;
- i=0;
- do{
- x0=*xA - *xB;
- w2[i]= *xA++ + *xB++;
- x1= *xA - *xB;
- A-=4;
- w[i++]= x0 * A[0] + x1 * A[1];
- w[i]= x1 * A[0] - x0 * A[1];
- w2[i++]= *xA++ + *xB++;
- }while(i<n4);
- }
-
- /* step 3 */
+static 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;
+
+ do{
+ DATA_TYPE *x0 = x+bit[0];
+ DATA_TYPE *x1 = x+bit[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]);
- {
- 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;
- float *A=init->trig;
- float *temp;
-
- for(r=0;r<(k0>>2);r++){
- int w1=wbase;
- int w2=w1-(k0>>1);
- float AEv= A[0],wA;
- float AOv= A[1],wB;
- int unroll=i;
- wbase-=2;
-
- k0++;
- unroll--;
- if(unroll>0){
- s=2<<unroll;
- s>>=1;
- do{
- 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;
- 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;
- 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;
- 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;
- }while(--s);
- }else{
- s=2<<i;
- do{
- 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;
- }while(--s);
- }
- k0--;
-
- A+=k1;
- }
-
- temp=w;
- w=x;
- x=temp;
- }
- }
+ w1 -= 4;
- /* step 4, 5, 6, 7 */
- {
- float *C=init->trig+n;
- int *bit=init->bitrev;
- float *x1=x;
- float *x2=x+n2-1;
- i=n8-1;
- do{
- int t1=*bit++;
- int t2=*bit++;
+ 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];
+
+ 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]);
- float wA=w[t1]-w[t2+1];
- float wB=w[t1-1]+w[t2];
- float wC=w[t1]+w[t2+1];
- float wD=w[t1-1]-w[t2];
-
- float wACE=wA* *C;
- float wBCE=wB* *C++;
- float wACO=wA* *C;
- float wBCO=wB* *C++;
+ r0 = HALVE(x0[1] + x1[1]);
+ r1 = HALVE(x0[0] - x1[0]);
- *x1++=( wC+wACO+wBCE)*.5;
- *x2--=(-wD+wBCO-wACE)*.5;
- *x1++=( wD+wBCO-wACE)*.5;
- *x2--=( wC-wACO-wBCE)*.5;
- }while(i--);
- }
- return(x);
+ 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_forward(mdct_lookup *init, float *in, float *out){
+void mdct_backward(mdct_lookup *init, DATA_TYPE *in, DATA_TYPE *out){
int n=init->n;
- float *x=alloca(sizeof(float)*(n/2));
- float *w=alloca(sizeof(float)*(n/2));
- float *xx;
int n2=n>>1;
int n4=n>>2;
- int n8=n>>3;
- int i;
- /* window + rotate + step 1 */
- {
- float tempA,tempB;
- int in1=n2+n4-4;
- int in2=in1+5;
- float *A=init->trig+n2;
+ /* rotate */
- 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];
- }
+ 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);
- in2=1;
+ mdct_butterflies(init,out+n2,n2);
+ mdct_bitreverse(init,out);
- 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];
- }
+ /* roatate + window */
+
+ {
+ DATA_TYPE *oX1=out+n2+n4;
+ DATA_TYPE *oX2=out+n2+n4;
+ DATA_TYPE *iX =out;
+ T =init->trig+n2;
- in1=n-4;
+ do{
+ oX1-=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];
- }
- }
+ oX1[3] = MULT_NORM (iX[0] * T[1] - iX[1] * T[0]);
+ oX2[0] = -MULT_NORM (iX[0] * T[0] + iX[1] * T[1]);
- xx=_mdct_kernel(x,w,n,n2,n4,n8,init);
+ oX1[2] = MULT_NORM (iX[2] * T[3] - iX[3] * T[2]);
+ oX2[1] = -MULT_NORM (iX[2] * T[2] + iX[3] * T[3]);
- /* step 8 */
+ oX1[1] = MULT_NORM (iX[4] * T[5] - iX[5] * T[4]);
+ oX2[2] = -MULT_NORM (iX[4] * T[4] + iX[5] * T[5]);
- {
- float *B=init->trig+n2;
- float *out2=out+n2;
- float 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;
+ oX1[0] = MULT_NORM (iX[6] * T[7] - iX[7] * T[6]);
+ oX2[3] = -MULT_NORM (iX[6] * T[6] + iX[7] * T[7]);
- xx+=2;
- B+=2;
- }
+ 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, float *in, float *out){
+void mdct_forward(mdct_lookup *init, DATA_TYPE *in, DATA_TYPE *out){
int n=init->n;
- float *x=alloca(sizeof(float)*(n/2));
- float *w=alloca(sizeof(float)*(n/2));
- float *xx;
int n2=n>>1;
int n4=n>>2;
int n8=n>>3;
- int i;
+ DATA_TYPE *w=alloca(n*sizeof(DATA_TYPE)); /* forward needs working space */
+ DATA_TYPE *w2=w+n2;
- /* rotate + step 1 */
- {
- float *inO=in+1;
- float *xO= x;
- float *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 */
+
+ 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;
+ }
- 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;
- }
+ 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;
+ }
+
+ x0=in+n;
+ 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;
}
- xx=_mdct_kernel(x,w,n,n2,n4,n8,init);
- /* step 8 */
+ mdct_butterflies(init,w+n2,n2);
+ mdct_bitreverse(init,w);
- {
- float *B=init->trig+n2;
- int o1=n4,o2=o1-1;
- int o3=n4+n2,o4=o3-1;
-
- for(i=0;i<n4;i++){
- float temp1= (*xx * B[1] - *(xx+1) * B[0]);
- float 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;
- }
+ /* 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;
}
}
+
1.14 +35 -5 vorbis/lib/mdct.h
Index: mdct.h
===================================================================
RCS file: /usr/local/cvsroot/vorbis/lib/mdct.h,v
retrieving revision 1.13
retrieving revision 1.14
diff -u -r1.13 -r1.14
--- mdct.h 2000/11/06 00:07:01 1.13
+++ mdct.h 2000/12/16 01:49:39 1.14
@@ -12,7 +12,7 @@
********************************************************************
function: modified discrete cosine transform prototypes
- last mod: $Id: mdct.h,v 1.13 2000/11/06 00:07:01 xiphmont Exp $
+ last mod: $Id: mdct.h,v 1.14 2000/12/16 01:49:39 xiphmont Exp $
********************************************************************/
@@ -21,19 +21,49 @@
#include "vorbis/codec.h"
+//#define MDCT_INTEGERIZED <- be warned there could be some hurt left here
+#ifdef MDCT_INTEGERIZED
+
+#define DATA_TYPE int
+#define REG_TYPE register int
+#define TRIGBITS 14
+#define cPI3_8 6270
+#define cPI2_8 11585
+#define cPI1_8 15137
+
+#define FLOAT_CONV(x) ((int)((x)*(1<<TRIGBITS)+.5))
+#define MULT_NORM(x) ((x)>>TRIGBITS)
+#define HALVE(x) ((x)>>1)
+
+#else
+
+#define DATA_TYPE float
+#define REG_TYPE float
+#define cPI3_8 .38268343236508977175F
+#define cPI2_8 .70710678118654752441F
+#define cPI1_8 .92387953251128675613F
+
+#define FLOAT_CONV(x) (x)
+#define MULT_NORM(x) (x)
+#define HALVE(x) ((x)*.5)
+
+#endif
+
+
typedef struct {
int n;
int log2n;
- float *trig;
- int *bitrev;
+ DATA_TYPE *trig;
+ int *bitrev;
+ DATA_TYPE scale;
} mdct_lookup;
extern void mdct_init(mdct_lookup *lookup,int n);
extern void mdct_clear(mdct_lookup *l);
-extern void mdct_forward(mdct_lookup *init, float *in, float *out);
-extern void mdct_backward(mdct_lookup *init, float *in, float *out);
+extern void mdct_forward(mdct_lookup *init, DATA_TYPE *in, DATA_TYPE *out);
+extern void mdct_backward(mdct_lookup *init, DATA_TYPE *in, DATA_TYPE *out);
#endif
--- >8 ----
List archives: http://www.xiph.org/archives/
Ogg project homepage: http://www.xiph.org/ogg/
To unsubscribe from this list, send a message to 'cvs-request at xiph.org'
containing only the word 'unsubscribe' in the body. No subject is needed.
Unsubscribe messages sent to the list will be ignored/filtered.
More information about the commits
mailing list