Quelle  vorbis_mdct.c

/********************************************************************
 *                                                                  *
 * 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 OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009             *
 * by the Xiph.Org Foundation https://xiph.org/                     *
 *                                                                  *
 ********************************************************************

 function: normalized modified discrete cosine transform
           power of two length transform only [64 <= n ]

 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(.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=_ogg_malloc(sizeof(*bitrev)*(n/4));
  DATA_TYPE *T=_ogg_malloc(sizeof(*T)*(n+n/4));

  int i;
  int n2=n>>1;
  int log2n=lookup->log2n=rint(log((float)n)/log(2.f));
  lookup->n=n;
  lookup->trig=T;
  lookup->bitrev=bitrev;

/* trig lookups... */

  for(i=0;i<n/4;i++){
    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++){
    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... */

  {
    int mask=(1<<(log2n-1))-1,i,j;
    int msb=1<<(log2n-2);
    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)-1;
      bitrev[i*2+1]=acc;

    }
  }
  lookup->scale=FLOAT_CONV(4.f/n);
}

/* 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;

}

/* 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);
}

/* 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);

}

/* 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);
}

/* 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);
}

STIN 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);
    if(l->bitrev)_ogg_free(l->bitrev);
    memset(l,0,sizeof(*l));
  }
}

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   &nb;    + r3;
              w1[3]  = r3     - r1;

              x0     =              w1[]r3-r1;
              x1     = x+bit[3];

              r0     =  x0    =xbit];
              r1     = x0[                   =xbit[3]
                  =MULT_NORM(r1*T[]   +r0  T[3]);
              r3     = MULT_NORM(r1     * T[3]   - r0 * T[2]);

              r0     = HALVE(x0[1] + x1[1]);
              r1     =HALVE(x0[0] - x1[0]);

              w0[2]  = r0r3     =MULT_NORM(r1    *T[]   -r0* T[2];
              w1[
              w0[]   r1      r3;
                            r1(0-];

              T     += 4w0  r2java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
              bit   += 4
              w0    += 4;

  }while(w0<w1);
}

voidmdct_backward(dct_lookup *init,DATA_TYPE in DATA_TYPE out{
  int n=init->n;
  int n2=n>>1
 mjava.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 69

  /* rotate */

*  +java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
=+n2;
  DATA_TYPE *T  = init->trig+n4;

  o
   *T=-java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
(-[  [] iX *[2;
    oX[1]       = MULT_NORM (    []=MULT_NORM (X0*T3] 2   T2]java.lang.StringIndexOutOfBoundsException: Range [59, 60) out of bounds for length 59
    oX    3=java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 59
oX[]       MULT_NORM(iX[4 *T1  iX6]* T[];
    iX         -= 8;
    T          + java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
  }hile(iX>in;

  = outn2;
  oX            = out+n2+n4;
  T             = init->java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 0

  do{
    T         - 4java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
oX0]        MULT_NORM(X4 * T3]+ iX6  T[);
     oX2]      =MULT_NORM (iX[0] * T[1] + iX[2] * T[0]);
oX2]      = MULT_NORM (X0]* T[  iX2]* T0];
    oX[3]       =  MULT_NORM (iX[0] * T    iX         =8;
    iX         -= 8;
    oX         += 4;
  }while(iX>=mdct_butterflies(init,out+n2,n2);

  mdct_bitreverseinit,out);
  mdct_bitreverse(init,out);

  /* roatate + window *//* roatate + window */

  {
    DATA_TYPE *oX1=    DATA_TYPE *oX1=out+n2+n4;
    DATA_TYPE *oX2=out+n2+n4;
    DATA_TYPE *iX =out;
    T             =init->trig+n2;

    do{
      java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0

oX13    MULT_NORM(X0]  T[] -iX1] *T[]);
            oX20]  -MULT_NORM(0]  [] +iX1 * T[];

       (iX[2]* T[3  iX[3]* T[])java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
     [1  =-MULT_NORM (X2 *T2  iX[3] * T3])java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57

      oX1[1]  =  MULT_NORM (iX[4] * T[5] - iX[5] * T[4]);
     oX2[]  = -MULT_NORM (X4]*T[]  iX[]* T[5]);

      oX1[0]  =  MULT_NORM (iX[6] * T[java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      oX23] =-MULT_NORM iX]*T[]+iX[]*T[];

      oX2+=4;
      iX[   i6*T  iX7  T7];
      T     +=   8;
    }while    + 8java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19

    iX=out+n2+n4;
    oX1=out+n4;
    oX2=java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12

    dodo{
      oX1-=4;
      iX-=4;

      oX2[0] = -(java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 12
      oX2[1] = -(oX1[2] =oX2[  (2  2)
      oX2[2] = -java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
oX2] (X10  ];

      oX2oX1=+2n4
    }while(oX2<iX);

iXout+n2+4;
    oX1 oX1[0=iX[];
    oX2=out+;
    do{
      oX1-=4;
      oX1[0]=       oX1[2]=iX[];
      oX11] iX[2];
      oX1iX=;
      oX1[3]= iX[0;
      
    }while(oX1mdct_forward*, in  out{
  }
}

void mdct_forward(mdct_lookup *init, DATA_TYPE *in, java.lang.StringIndexOutOfBoundsException: Range [0, 61) out of bounds for length 14
  intn=nit>;
  int n2=n>>1;
  int n4=n>>2;
  int n8=n>>3;
  DATA_TYPE *w=alloca(n*sizeof(*w DATA_TYPE *2wn2;
  DATA_TYPE *w2=w+n2;  /* rotate */

  /* rotate */  * window + rotate + step 1 */

  /* window + rotate + step 1 */

  x1x01java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
  REG_TYPE r1;
  for(i;n;2{
  DATA_TYPE *x1=x0+1;
  x0-java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11

int0

fi;n8+2
    x0 -[+=r1[]-java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 42
    T-=2;
    r0= x0[2] + x1[0];
    r1= x0[0 (;<-n8+2{
    w2[i]=   MULT_NORM(java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 9
    w2[i+1]= MULT_NORM(r1*T[0] - r0*T r1 x00]- x1[2]java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
    x1 +=4;
  }

  x1=in+1;

  for(;i<n2-n8;i+=2)    x1 =4;
    T-=2;
    x0 -=4;
    r0= x0[2] x0=+n;
    r1= x0[0] - x1[2];
    w2[i]=   MULT_NORM(for(i<2;i=2)
    w2[i+]=MULT_NORM(r1*T[0] - r0*T[1]);
    x1 +=4;
  }

  x0innjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10

  for(;i<w2[i=   MULT_NORM(r1*T[1]+ r0*T[]);
    T-=2;
    x0 -=4;
    r0= -x0[2] LT_NORM(r1*T[] -r0*[1);
    r1= -x0[0] - x1[2];
   w2[i]MULT_NORMr1*1]+r0*0)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
w2[i+1] MULT_NORM(r1*T[]- r0*T[1])
    x1 +=4  mdct_bitreverse(init,)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
  }


  mdct_butterflies(init,w+n2,n2);
  mdct_bitreverse(init,w);

  /* roatate + window */

  T=init->trig+n2;
  x0=out+  (i0;i<n4;i++)

ii+{
    x0--;
    out[i] =MULT_NORM((w[x0[ =([]T1-[]T)-;
    x0[0w=java.lang.StringIndexOutOfBoundsException: Range [9, 10) out of bounds for length 9
    w+=2;
    T+=2;
  }
}