mpegimdc.c

Application (fix point) for playing MP3 data on embedded systems. mp3play is designed to be able to

     prev[5-2] = WIN_MULT( in3, 11-2 );

     ts[(12+0)*SBLIMIT] += WIN_MULT( in0, 0 );
     ts[(17-0)*SBLIMIT] += WIN_MULT( in0, 5-0 );
     ts[(12+2)*SBLIMIT] += WIN_MULT( in4, 2 );
     ts[(17-2)*SBLIMIT] += WIN_MULT( in4, 5-2 );
  }

  in++;

  {
     IMDCT_TYPE in0,in1,in2,in3,in4,in5;
     prev[12]=prev[13]=prev[14]=prev[15]=prev[16]=prev[17]=(MPEGIMDCT_BLOCK_TYPE)0;

     DCT12_PART1

     {
       IMDCT_TYPE tmp0,tmp1 = (in0 - in4);
       {
         IMDCT_TYPE tmp2 = T12_MULT( (in1 - in5), 1 );
         tmp0 = tmp1 + tmp2;
         tmp1 -= tmp2;
       }
       prev[11-1] = WIN_MULT( tmp0, 11-1 );
       prev[6 +1] = WIN_MULT( tmp0, 6+1 );
       prev[0+1] += WIN_MULT( tmp1, 1 );
       prev[5-1] += WIN_MULT( tmp1, 5-1 );
     }

     DCT12_PART2

     prev[11-0] = WIN_MULT( in2, 11-0 );
     prev[6 +0] = WIN_MULT( in2, 6+0 );
     prev[6 +2] = WIN_MULT( in3, 6+2 );
     prev[11-2] = WIN_MULT( in3, 11-2 );

     prev[0+0] += WIN_MULT( in0, 0 );
     prev[5-0] += WIN_MULT( in0, 5-0 );
     prev[0+2] += WIN_MULT( in4, 2 );
     prev[5-2] += WIN_MULT( in4, 5-2 );
  }
}

int MPEGIMDCT_hybrid( MPEGIMDCT *mpegimdct, MPEGAUD_FRACT_TYPE *in,
                      MPEGAUD_FRACT_TYPE *out, INT16 block_type, BOOL mixed,
                      INT16 ch, INT16 sb_max )
/*--------------------------------------------------------------------------
   Apply the hybrid imdct to a granule
   Return 0 if Ok
*/
{
   static BOOL init = FALSE;
   MPEGIMDCT_BLOCK_TYPE *prev;
   INT16 bt1,bt2;
   INT16 sb;

#define O( i ) out[ i*32 ]

   if( !init ) {
      int i,j;
#ifdef IMDCT_INT
#define KW ((double)(1<<(WIN_BITS-1))+0)
#define KC (double)(1<<COS_BITS)
#define KT ((double)(1<<(TFC_BITS-1))+0)
#else
#define KW 0.5
#define KC 1
#define KT 0.5
#endif

      for(i=0;i<18;i++) {
         win[0][i]    = win[1][i]    = KW * sin( M_PI / 72.0 * (double) (2*(i+0) +1) ) / cos ( M_PI * (double) (2*(i+0) +19) / 72.0 );
         win[0][i+18] = win[3][i+18] = KW * sin( M_PI / 72.0 * (double) (2*(i+18)+1) ) / cos ( M_PI * (double) (2*(i+18)+19) / 72.0 );
      }
      for(i=0;i<6;i++) {
         win[1][i+18] = KW / cos ( M_PI * (double) (2*(i+18)+19) / 72.0 );
         win[3][i+12] = KW / cos ( M_PI * (double) (2*(i+12)+19) / 72.0 );
         win[1][i+24] = KW * sin( M_PI / 24.0 * (double) (2*i+13) ) / cos ( M_PI * (double) (2*(i+24)+19) / 72.0 );
         win[1][i+30] = win[3][i] = 0.0;
         win[3][i+6 ] = KW * sin( M_PI / 24.0 * (double) (2*i+1) )  / cos ( M_PI * (double) (2*(i+6 )+19) / 72.0 );
      }

      for(i=0;i<9;i++) COS9[i] = KC * cos( M_PI / 18.0 * (double) i);

      for(i=0;i<9;i++) tfcos36[i] = KT / cos ( M_PI * (double) (i*2+1) / 36.0 );
      for(i=0;i<3;i++) tfcos12[i] = KT / cos ( M_PI * (double) (i*2+1) / 12.0 );

      COS6_1 = KC * cos( M_PI / 6.0 * (double) 1 );
      COS6_2 = KC * cos( M_PI / 6.0 * (double) 2 );

      for(i=0;i<12;i++) {
         win[2][i]  = KW * sin( M_PI / 24.0 * (double) (2*i+1) ) / cos ( M_PI * (double) (2*i+7) / 24.0 );
         for(j=0;j<6;j++) COS1[i][j] = KC * cos( M_PI / 24.0 * (double) ((2*i+7)*(2*j+1)) );
      }

      for(j=0;j<4;j++) {
         static const int len[4] = { 36,36,12,36 }; /* #3 Added const */
         for(i=0;i<len[j];i+=2) win1[j][i] = + win[j][i];
         for(i=1;i<len[j];i+=2) win1[j][i] = - win[j][i];
      }
      init = TRUE;

   }

   prev = mpegimdct->prevblk[ ch ];

   bt1 = (mixed) ? 0 : block_type;
   bt2 = block_type;

   if( bt2 == 2 ) {
      if( !bt1 ) {
         dct36( in, prev, win[0], out );
         in += SSLIMIT;
         dct36( in, prev+18, win1[0], out+1 );
         in += SSLIMIT;
      }
      else {
         dct12( in, prev, win[2], out );
         in += SSLIMIT;
         dct12( in, prev+18, win1[2], out+1 );
         in += SSLIMIT;
      }
      prev += 36; out += 2;
      for( sb=2; sb<sb_max; sb += 2,out += 2, prev += 36 ) {
         dct12( in, prev, win[2], out );
         in += SSLIMIT;
         dct12( in, prev+18, win1[2], out+1 );
         in += SSLIMIT;
      }
   }
   else {
      dct36( in, prev, win[bt1], out );
      in += SSLIMIT;
      dct36( in, prev+18, win1[bt1], out+1 );
      in += SSLIMIT;
      prev += 36; out += 2;
      for ( sb=2; sb<sb_max; sb += 2, out += 2, prev += 36 ) {
         dct36( in, prev, win[bt2], out );
         in += SSLIMIT;
         dct36( in, prev+18, win1[bt2], out+1 );
         in += SSLIMIT;
      }
   }

   for( ; sb< SBLIMIT; sb++ ) {
      O( 0 ) = *prev; *prev++ = (MPEGIMDCT_BLOCK_TYPE)0;
          O( 1 ) = *prev; *prev++ = (MPEGIMDCT_BLOCK_TYPE)0;
          O( 2 ) = *prev; *prev++ = (MPEGIMDCT_BLOCK_TYPE)0;
      O( 3 ) = *prev; *prev++ = (MPEGIMDCT_BLOCK_TYPE)0;
          O( 4 ) = *prev; *prev++ = (MPEGIMDCT_BLOCK_TYPE)0;
          O( 5 ) = *prev; *prev++ = (MPEGIMDCT_BLOCK_TYPE)0;
      O( 6 ) = *prev; *prev++ = (MPEGIMDCT_BLOCK_TYPE)0;
          O( 7 ) = *prev; *prev++ = (MPEGIMDCT_BLOCK_TYPE)0;
          O( 8 ) = *prev; *prev++ = (MPEGIMDCT_BLOCK_TYPE)0;
      O( 9 ) = *prev; *prev++ = (MPEGIMDCT_BLOCK_TYPE)0;
          O( 10 ) = *prev; *prev++ = (MPEGIMDCT_BLOCK_TYPE)0;
          O( 11 ) = *prev; *prev++ = (MPEGIMDCT_BLOCK_TYPE)0;
      O( 12 ) = *prev; *prev++ = (MPEGIMDCT_BLOCK_TYPE)0;
          O( 13 ) = *prev; *prev++ = (MPEGIMDCT_BLOCK_TYPE)0;
          O( 14 ) = *prev; *prev++ = (MPEGIMDCT_BLOCK_TYPE)0;
      O( 15 ) = *prev; *prev++ = (MPEGIMDCT_BLOCK_TYPE)0;
          O( 16 ) = *prev; *prev++ = (MPEGIMDCT_BLOCK_TYPE)0;
          O( 17 ) = *prev; *prev++ = (MPEGIMDCT_BLOCK_TYPE)0;
      out++;
   }

   return 0;
}


#else // -> NOT NEW_IMDCT


#ifndef PI
#define PI 3.14159265358979323846
#endif

#ifdef IMDCT_INT
#define IMDCT_IO_TYPE MPEGAUD_FRACT_TYPE
#define IMDCT_TYPE INT32
#define IMDCT_BITS 14
#define WIN_TYPE INT16
#define WIN_BITS 14
#define WIN_MULT( t, w ) (((t) * (w))>>WIN_BITS)
#else
#define IMDCT_IO_TYPE REAL
#define IMDCT_TYPE REAL
#define IMDCT_BITS 0
#define WIN_TYPE REAL
#define WIN_BITS 0
#define WIN_MULT( t, w ) ((t) * (w))
#endif



static int imdct_l( IMDCT_IO_TYPE *x, IMDCT_IO_TYPE *out,
                    MPEGIMDCT_BLOCK_TYPE *prev, WIN_TYPE *win )
{
   static const IMDCT_TYPE K0 = 0.9990482216 * (1<<IMDCT_BITS); /* #3 Added const */
   static const IMDCT_TYPE K1 = 0.9914448614 * (1<<IMDCT_BITS); /* #3 Added const */
   static const IMDCT_TYPE K2 = 0.9762960071 * (1<<IMDCT_BITS); /* #3 Added const */
   static const IMDCT_TYPE K3 = 0.9537169507 * (1<<IMDCT_BITS); /* #3 Added const */
   static const IMDCT_TYPE K4 = 0.9238795325 * (1<<IMDCT_BITS); /* #3 Added const */
   static const IMDCT_TYPE K5 = 0.8870108332 * (1<<IMDCT_BITS); /* #3 Added const */
   static const IMDCT_TYPE K6 = 0.8433914458 * (1<<IMDCT_BITS); /* #3 Added const */
   static const IMDCT_TYPE K7 = 0.7933533403 * (1<<IMDCT_BITS); /* #3 Added const */
   static const IMDCT_TYPE K8 = 0.7372773368 * (1<<IMDCT_BITS); /* #3 Added const */
   static const IMDCT_TYPE K9 = 0.6755902076 * (1<<IMDCT_BITS); /* #3 Added const */
   static const IMDCT_TYPE K10 = 0.6087614290 * (1<<IMDCT_BITS); /* #3 Added const */
   static const IMDCT_TYPE K11 = 0.5372996083 * (1<<IMDCT_BITS); /* #3 Added const */
   static const IMDCT_TYPE K12 = 0.4617486132 * (1<<IMDCT_BITS); /* #3 Added const */
   static const IMDCT_TYPE K13 = 0.3826834324 * (1<<IMDCT_BITS); /* #3 Added const */
   static const IMDCT_TYPE K14 = 0.3007057995 * (1<<IMDCT_BITS); /* #3 Added const */
   static const IMDCT_TYPE K15 = 0.2164396139 * (1<<IMDCT_BITS); /* #3 Added const */
   static const IMDCT_TYPE K16 = 0.1305261922 * (1<<IMDCT_BITS); /* #3 Added const */
   static const IMDCT_TYPE K17 = 0.04361938737 * (1<<IMDCT_BITS); /* #3 Added const */

   IMDCT_TYPE k1, k2;
   IMDCT_TYPE s[ 6 ];
   IMDCT_TYPE t[ 6 ];
   IMDCT_TYPE temp;
   INT16 i;
#ifdef IMDCT_INT
#define S( a ) (INT32)x[ a ] - (INT32)x[ 11-a ] - (INT32)x[ 12+a ]
//   #define M( xi, Kx ) ((INT32)x[ xi ] * (Kx))
#define M( xi, Kx ) (x[ xi ] * (Kx))
#define MT( ti, Kx ) (t[ ti ] * (Kx))
#define W( t, wi ) WIN_MULT( (t>>IMDCT_BITS), win[ wi ] )
#else
#define S( a ) x[ a ] - x[ 11-a ] - x[ 12+a ]
#define M( xi, Kx ) (REAL)(x[ xi ] * (Kx))
#define MT( ti, Kx ) (REAL)(t[ ti ] * (Kx))
#define W( t, wi ) (REAL)(t * win[ wi ])
#endif

#define O( i ) out[ i*32 ]

   k1 = M( 4, K13 ) - M( 13, K4 );
   k2 = M( 4, K4 )  + M( 13, K13 );

   s[ 0 ] = -M( 1, K7 )  + k1 + M( 7, K1 )  + M( 10, K16 ) - M( 16, K10 );
   s[ 1 ] = -M( 1, K4 )  - k1 + M( 7, K13 ) + M( 10, K4 )  + M( 16, K13 );
   s[ 2 ] = -M( 1, K1 )  - k2 - M( 7, K7 )  - M( 10, K10 ) - M( 16, K16 );

   s[ 3 ] = -M( 1, K10 ) + k2 + M( 7, K16 ) - M( 10, K1 )  + M( 16, K7 );
   s[ 4 ] = -M( 1, K13 ) + k2 - M( 7, K4 )  + M( 10, K13 ) - M( 16, K4 );
   s[ 5 ] = -M( 1, K16 ) + k1 - M( 7, K10 ) + M( 10, K7 )  + M( 16, K1 );

   t[ 0 ] = S( 0 );
   t[ 1 ] = S( 2 );
   t[ 2 ] = S( 3 );
   t[ 3 ] = S( 5 );

   // 0
   temp =   M( 0, K9 ) - M( 2, K11 ) + M( 3, K5 )   - M( 5, K3 )   - M( 6, K15 ) + M( 8, K17 )
          - M( 9, K0 ) + M( 11, K2 ) - M( 12, K14 ) + M( 14, K12 ) + M( 15, K6 ) - M( 17, K8 );
   temp += s[ 0 ];
   O( 0 ) = prev[ 0 ] + W( temp, 0 );   O( 17 ) = prev[ 17 ] -W( temp, 17 );
   // 1
   temp =   MT( 0, K10 ) - MT( 1, K16 ) + MT( 2, K1 ) - MT( 3, K7 ) + s[ 1 ];
   O( 1 ) = prev[ 1 ] + W( temp, 1 );   O( 16 ) =  prev[ 16 ] -W( temp, 16 );
   // 2
   temp =   M( 0, K11 ) + M( 2, K14 ) + M( 3, K8 )  + M( 5, K17 ) + M( 6, K5 )  - M( 8, K15 )
          + M( 9, K2 ) - M( 11, K12 ) + M( 12, K0 ) - M( 14, K9 ) + M( 15, K3 ) - M( 17, K6 );
   temp += s[ 2 ];
   O( 2 ) = prev[ 2 ] + W( temp, 2 );   O( 15 ) = prev[ 15 ] -W( temp, 15 );
   // 3
   temp =   M( 0, K12 ) + M( 2, K9 ) + M( 3, K15 )  + M( 5, K6 ) - M( 6, K17 )  + M( 8, K3 )
          - M( 9, K14 ) + M( 11, K0 ) - M( 12, K11 ) + M( 14, K2 ) - M( 15, K8 ) + M( 17, K5 );
   temp += s[ 2 ];
   O( 3 ) = prev[ 3 ] + W( temp, 3 );   O( 14 ) = prev[ 14 ] -W( temp, 14 );
   // 4
   temp =   MT( 0, K13 ) + MT( 1, K4 ) - MT( 2, K13 ) + MT( 3, K4 ) + s[ 1 ];
   O( 4 ) = prev[ 4 ] + W( temp, 4 );   O( 13 ) = prev[ 13 ]  -W( temp, 13 );
   // 5
   temp =   M( 0, K14 ) + M( 2, K0 ) - M( 3, K6 )  + M( 5, K15 ) - M( 6, K8 )  - M( 8, K5 )
          + M( 9, K12 ) - M( 11, K9 ) + M( 12, K2 ) + M( 14, K11 ) + M( 15, K17 ) + M( 17, K3 );
   temp += s[ 0 ];
   O( 5 ) = prev[ 5 ] + W( temp, 5 );   O( 12 ) = prev[ 12 ] -W( temp, 12 );
   // 6
   temp =   M( 0, K15 ) + M( 2, K5 ) - M( 3, K0 )  - M( 5, K9 ) + M( 6, K14 )  - M( 8, K11 )
          + M( 9, K6 ) + M( 11, K3 ) - M( 12, K8 ) + M( 14, K17 ) - M( 15, K12 ) - M( 17, K2 );
   temp += s[ 3 ];
   O( 6 ) = prev[ 6 ] + W( temp, 6 );   O( 11 ) = prev[ 11 ] -W( temp, 11 );
   // 7
   temp =   MT( 0, K16 ) + MT( 1, K10 ) - MT( 2, K7 ) - MT( 3, K1 ) + s[ 4 ];
   O( 7 ) = prev[ 7 ] + W( temp, 7 );   O( 10 ) = prev[ 10 ] -W( temp, 10 );
   // 8
   temp =   M( 0, K17 ) + M( 2, K15 ) - M( 3, K14 ) - M( 5, K12 ) + M( 6, K11 ) + M( 8, K9 )
          - M( 9, K8 ) - M( 11, K6 ) + M( 12, K5 ) + M( 14, K3 ) - M( 15, K2 ) - M( 17, K0 );
   temp += s[ 5 ];
   O( 8 ) = prev[ 8 ] + W( temp, 8 );   O( 9 ) = prev[ 9 ] -W( temp, 9 );

   // 9+9
   temp = - M( 0, K8 ) + M( 2, K6 ) - M( 3, K12 ) + M( 5, K14 ) + M( 6, K2 ) - M( 8, K0 )
          - M( 9, K17 ) + M( 11, K15 ) - M( 12, K3 ) + M( 14, K5 ) + M( 15, K11 ) - M( 17, K9 );
   temp -= s[ 3 ];
   prev[ 0 ] = W( temp, 18 );   prev[ 17 ] = W( temp, 35 );
   // 10+9
   temp =  - MT( 0, K7 ) + MT( 1, K1 ) + MT( 2, K16 ) - MT( 3, K10 ) - s[ 4 ];
   prev[ 1 ] = W( temp, 19 );   prev[ 16 ] = W( temp, 34 );
   // 11+9
   temp = - M( 0, K6 ) + M( 2, K3 ) + M( 3, K9 ) - M( 5, K0 ) - M( 6, K12 ) + M( 8, K2 )
          + M( 9, K15 ) - M( 11, K5 ) + M( 12, K17 ) + M( 14, K8 ) - M( 15, K14 ) - M( 17, K11 );
   temp -= s[ 5 ];
   prev[ 2 ] = W( temp, 20 );   prev[ 15 ] = W( temp, 33 );
   // 12+9
   temp = - M( 0, K5 ) + M( 2, K8 ) + M( 3, K2 ) - M( 5, K11 ) - M( 6, K0 ) + M( 8, K14 )
          + M( 9, K3 ) - M( 11, K17 ) - M( 12, K6 ) - M( 14, K15 ) + M( 15, K9 ) + M( 17, K12 );
   temp += s[ 5 ];
   prev[ 3 ] = W( temp, 21 );   prev[ 14 ] = W( temp, 32 );
   // 13+9
   temp =  - MT( 0, K4 ) + MT( 1, K13 ) + MT( 2, K4 ) + MT( 3, K13 ) + s[ 4 ];
   prev[ 4 ] = W( temp, 22 );   prev[ 13 ] = W( temp, 31 );
   // 14+9
   temp = - M( 0, K3 ) - M( 2, K17 ) + M( 3, K11 ) + M( 5, K2 ) + M( 6, K9 ) - M( 8, K12 )
          - M( 9, K5 ) - M( 11, K8 ) - M( 12, K15 ) + M( 14, K6 ) + M( 15, K0 ) + M( 17, K14 );
   temp += s[ 3 ];
   prev[ 5 ] = W( temp, 23 );   prev[ 12 ] = W( temp, 30 );
   // 15+9
   temp = - M( 0, K2 ) - M( 2, K12 ) - M( 3, K17 ) + M( 5, K8 ) + M( 6, K3 ) + M( 8, K6 )
          + M( 9, K11 ) - M( 11, K14 ) - M( 12, K9 ) - M( 14, K0 ) - M( 15, K5 ) - M( 17, K15 );
   temp += s[ 0 ];
   prev[ 6 ] = W( temp, 24 );   prev[ 11 ] = W( temp, 29 );
   // 16+9
   temp =  - MT( 0, K1 ) - MT( 1, K7 ) - MT( 2, K10 ) - MT( 3, K16 ) + s[ 1 ];
   prev[ 7 ] = W( temp, 25 );   prev[ 10 ] = W( temp, 28 );
   // 17+9
   temp = - M( 0, K0 ) - M( 2, K2 ) - M( 3, K3 ) - M( 5, K5 ) - M( 6, K6 ) - M( 8, K8 )
          - M( 9, K9 ) - M( 11, K11 ) - M( 12, K12 ) - M( 14, K14 ) - M( 15, K15 ) - M( 17, K17 );
   temp += s[ 2 ];