The Tor Browser: media/libvorbis/lib/vorbis_mdct.c@97036ab72558 (annotated)

media/libvorbis/lib/vorbis_mdct.c@97036ab72558 (annotated)

media/libvorbis/lib/vorbis_mdct.c

Tue, 06 Jan 2015 21:39:09 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Tue, 06 Jan 2015 21:39:09 +0100
branch: TOR_BUG_9701
changeset 8: 97036ab72558
permissions: -rw-r--r--

Conditionally force memory storage according to privacy.thirdparty.isolate;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

 /********************************************************************
  *                                                                  *
  * 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 http://www.xiph.org/                  *
  *                                                                  *
  ********************************************************************
  function: normalized modified discrete cosine transform
            power of two length transform only [64 <= n ]
  last mod: $Id: mdct.c 16227 2009-07-08 06:58:46Z xiphmont $
  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
 -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       = 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]);
               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];
               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]);
               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 */
   {
     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_forward(mdct_lookup *init, DATA_TYPE *in, DATA_TYPE *out){
   int n=init->n;
   int n2=n>>1;
   int n4=n>>2;
   int n8=n>>3;
   DATA_TYPE *w=alloca(n*sizeof(*w)); /* forward needs working space */
   DATA_TYPE *w2=w+n2;
   /* rotate */
   /* 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;
   }
   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;
   }
   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;
   }
 }

The Tor Browser / annotate

media/libvorbis/lib/vorbis_mdct.c@97036ab72558 (annotated)

media/libvorbis/lib/vorbis_mdct.c