mpadecl2.cpp

著名的 helix realplayer 基于手机 symbian 系统的 播放器全套源代码

sbt(sample, pcm, 36, vbuf, vb_ptr);
/*-----------*/
in_out.in_bytes = framebytes + pad;
in_out.out_bytes = outbytes;

return in_out;
}
///////////////////////////////////////////////////////////////////////////////
// Private Functions
///////////////////////////////////////////////////////////////////////////////
void CMpaDecoderL2::table_init()
{
int i, j;
int code;

/*--  c_values (dequant) --*/
for(i=1;i<18;i++) look_c_value[i] = 2.0F/steps[i];

/*--  scale factor table, scale by 32768 for 16 pcm output  --*/
for(i=0;i<64;i++) sf_table[i] = (float)(32768.0*2.0*pow(2.0,-i/3.0));

/*--  grouped 3 level lookup table 5 bit token --*/
for(i=0;i<32;i++) {
   code = i;
   for(j=0;j<3;j++) {
      group3_table[i][j] = (char)(( code % 3 ) - 1);
      code /= 3;
  }
}
/*--  grouped 5 level lookup table 7 bit token --*/
for(i=0;i<128;i++) {
   code = i;
   for(j=0;j<3;j++) {
      group5_table[i][j] = (char)(( code % 5 ) - 2);
      code /= 5;
  }
}
/*--  grouped 9 level lookup table 10 bit token --*/
for(i=0;i<1024;i++) {
   code = i;
   for(j=0;j<3;j++) {
      group9_table[i][j] = (short)(( code % 9 ) - 4);
      code /= 9;
  }
}


}
/*---------------------------------------------------------*/
/*------------- bit getter --------------------------------*/
/*---------------------------------------------------------*/
void CMpaDecoderL2::load_init( unsigned char *buf)
{
bs_ptr = buf;
bits = 0;
bitbuf = 0;
}
/*------------- get n bits from bitstream -------------*/
int CMpaDecoderL2::load( int n)
{
unsigned int x;
if( bits < n ) {           /* refill bit buf if necessary */
          while( bits <= 24 ) {
             bitbuf = (bitbuf << 8) | *bs_ptr++;
             bits += 8;
          }
}
bits -= n;
x = bitbuf >> bits;
bitbuf -= x << bits;
return x;
}
/*------------- skip over n bits in bitstream -------------*/
void CMpaDecoderL2::skip( int n)
{
int k;
if( bits < n ) {
          n -= bits;
          k = n >> 3;     /*--- bytes = n/8 --*/
          bs_ptr+=k;
          n -= k << 3;
          bitbuf =  *bs_ptr++;
          bits = 8;
          }
bits -= n;
bitbuf -= (bitbuf >> bits) << bits;
}
/*--------------------------------------------------------------*/
#define mac_load_check(n)                     \
   if( bits < (n) ) {                           \
          while( bits <= 24 ) {               \
             bitbuf = (bitbuf << 8) | *bs_ptr++;  \
             bits += 8;                       \
          }                                   \
   }
/*--------------------------------------------------------------*/
#define mac_load(n)                    \
       ( bits -= n,                    \
         bitval = bitbuf >> bits,      \
         bitbuf -= bitval << bits,     \
         bitval )

static const int nbit[4] = { 4, 4, 3, 2 };

/*======================================================================*/
void CMpaDecoderL2::unpack_ba()
{
int i, j, k;
int nstereo;

bit_skip = 0;
nstereo = stereo_sb;
k = 0;
for(i=0;i<4;i++) {
   for(j=0;j<nbat[i]; j++, k++) {
   mac_load_check(4);
   ballo[k] = samp_dispatch[k] = bat[i][mac_load(nbit[i])];
   if( k >= nsb_limit )  bit_skip += bat_bit_master_L2[samp_dispatch[k]];
   c_value[k] = look_c_value[samp_dispatch[k]];
   if( --nstereo < 0 ) {
       ballo[k+1] = ballo[k];
       samp_dispatch[k] += 18;  /* flag as joint */
       samp_dispatch[k+1] = samp_dispatch[k];  /* flag for sf */
       c_value[k+1] = c_value[k];
       k++;
       j++;
   }
   }
}
samp_dispatch[nsb_limit] = 37;   /* terminate the dispatcher with skip */
samp_dispatch[k] = 36;           /* terminate the dispatcher */

}
/*-------------------------------------------------------------------------*/
void CMpaDecoderL2::unpack_sfs()    /* unpack scale factor selectors */
{
int i;

for(i=0;i<max_sb;i++) {
  mac_load_check(2);
  if( ballo[i] ) sf_dispatch[i] = mac_load(2);
  else           sf_dispatch[i] = 4;           /* no allo */
}
sf_dispatch[i] = 5;    /* terminate dispatcher */
}
/*-------------------------------------------------------------------------*/
void CMpaDecoderL2::unpack_sf()    /* unpack scale factor */
{                          /* combine dequant and scale factors */
int i;
i = -1;
dispatch:   switch (sf_dispatch[++i]) {
case 0:              /* 3 factors 012 */
  mac_load_check(18);
  cs_factor[0][i] = c_value[i]*sf_table[mac_load(6)];
  cs_factor[1][i] = c_value[i]*sf_table[mac_load(6)];
  cs_factor[2][i] = c_value[i]*sf_table[mac_load(6)];
  goto dispatch;
case 1:             /* 2 factors 002 */
  mac_load_check(12);
  cs_factor[1][i] = cs_factor[0][i] = c_value[i]*sf_table[mac_load(6)];
  cs_factor[2][i] = c_value[i]*sf_table[mac_load(6)];
  goto dispatch;
case 2:             /* 1 factor 000 */
  mac_load_check(6);
  cs_factor[2][i] = cs_factor[1][i] = cs_factor[0][i] =
                                       c_value[i]*sf_table[mac_load(6)];
  goto dispatch;
case 3:             /* 2 factors 022 */
  mac_load_check(12);
  cs_factor[0][i] = c_value[i]*sf_table[mac_load(6)];
  cs_factor[2][i] = cs_factor[1][i] = c_value[i]*sf_table[mac_load(6)];
  goto dispatch;
case 4:             /* no allo */
  /*-- cs_factor[2][i] = cs_factor[1][i] = cs_factor[0][i] = 0.0;  --*/
  goto dispatch;
case 5:             /* all done */
;
} /* end switch */


}
/*-------------------------------------------------------------------------*/
#define UNPACK_N(n)                                          \
    s[k]     =  cs_factor[i][k]*(load(n)-((1 << n-1) -1));   \
    s[k+64]  =  cs_factor[i][k]*(load(n)-((1 << n-1) -1));   \
    s[k+128] =  cs_factor[i][k]*(load(n)-((1 << n-1) -1));   \
    goto dispatch;
#define UNPACK_N2(n)                                             \
    mac_load_check(3*n);                                         \
    s[k]     =  cs_factor[i][k]*(mac_load(n)-((1 << n-1) -1));   \
    s[k+64]  =  cs_factor[i][k]*(mac_load(n)-((1 << n-1) -1));   \
    s[k+128] =  cs_factor[i][k]*(mac_load(n)-((1 << n-1) -1));   \
    goto dispatch;
#define UNPACK_N3(n)                                             \
    mac_load_check(2*n);                                         \
    s[k]     =  cs_factor[i][k]*(mac_load(n)-((1 << n-1) -1));   \
    s[k+64]  =  cs_factor[i][k]*(mac_load(n)-((1 << n-1) -1));   \
    mac_load_check(n);                                           \
    s[k+128] =  cs_factor[i][k]*(mac_load(n)-((1 << n-1) -1));   \
    goto dispatch;
#define UNPACKJ_N(n)                                         \
    tmp        =  (load(n)-((1 << n-1) -1));                 \
    s[k]       =  cs_factor[i][k]*tmp;                       \
    s[k+1]     =  cs_factor[i][k+1]*tmp;                     \
    tmp        =  (load(n)-((1 << n-1) -1));                 \
    s[k+64]    =  cs_factor[i][k]*tmp;                       \
    s[k+64+1]  =  cs_factor[i][k+1]*tmp;                     \
    tmp        =  (load(n)-((1 << n-1) -1));                 \
    s[k+128]   =  cs_factor[i][k]*tmp;                       \
    s[k+128+1] =  cs_factor[i][k+1]*tmp;                     \
    k++;       /* skip right chan dispatch */                \
    goto dispatch;
/*-------------------------------------------------------------------------*/
void CMpaDecoderL2::unpack_samp()    /* unpack samples */
{
int i, j, k;
float *s;
int n;
long tmp;

s = sample;
for(i=0;i<3;i++)  {           /* 3 groups of scale factors */
for(j=0;j<4;j++)  {
k = -1;
dispatch:   switch (samp_dispatch[++k]) {
case 0:
   s[k+128] = s[k+64] = s[k] =  0.0F;
   goto dispatch;
case 1:                     /* 3 levels grouped 5 bits */
    mac_load_check(5);
    n = mac_load(5);
    s[k]     =  cs_factor[i][k]*group3_table[n][0];
    s[k+64]  =  cs_factor[i][k]*group3_table[n][1];
    s[k+128] =  cs_factor[i][k]*group3_table[n][2];
    goto dispatch;
case 2:                     /* 5 levels grouped 7 bits */
    mac_load_check(7);
    n = mac_load(7);
    s[k]     =  cs_factor[i][k]*group5_table[n][0];
    s[k+64]  =  cs_factor[i][k]*group5_table[n][1];
    s[k+128] =  cs_factor[i][k]*group5_table[n][2];
    goto dispatch;
case 3:     UNPACK_N2(3)     /* 7 levels */
case 4:                     /* 9 levels grouped 10 bits */
    mac_load_check(10);
    n = mac_load(10);
    s[k]     =  cs_factor[i][k]*group9_table[n][0];
    s[k+64]  =  cs_factor[i][k]*group9_table[n][1];
    s[k+128] =  cs_factor[i][k]*group9_table[n][2];
    goto dispatch;
case 5:     UNPACK_N2(4)     /* 15 levels */
case 6:     UNPACK_N2(5)     /* 31 levels */
case 7:     UNPACK_N2(6)     /* 63 levels */
case 8:     UNPACK_N2(7)     /* 127 levels */
case 9:     UNPACK_N2(8)     /* 255 levels */
case 10:    UNPACK_N3(9)     /* 511 levels */
case 11:    UNPACK_N3(10)    /* 1023 levels */
case 12:    UNPACK_N3(11)    /* 2047 levels */
case 13:    UNPACK_N3(12)    /* 4095 levels */
case 14:    UNPACK_N(13)    /* 8191 levels */
case 15:    UNPACK_N(14)    /* 16383 levels */
case 16:    UNPACK_N(15)    /* 32767 levels */
case 17:    UNPACK_N(16)    /* 65535 levels */
/* -- joint ---- */
case 18+0:
    s[k+128+1] = s[k+128] = s[k+64+1] = s[k+64] = s[k+1] = s[k] =  0.0F;
    k++;       /* skip right chan dispatch */
    goto dispatch;
case 18+1:                    /* 3 levels grouped 5 bits */
    n = load(5);
    s[k]       =  cs_factor[i][k]*group3_table[n][0];
    s[k+1]     =  cs_factor[i][k+1]*group3_table[n][0];
    s[k+64]    =  cs_factor[i][k]*group3_table[n][1];
    s[k+64+1]  =  cs_factor[i][k+1]*group3_table[n][1];
    s[k+128]   =  cs_factor[i][k]*group3_table[n][2];
    s[k+128+1] =  cs_factor[i][k+1]*group3_table[n][2];
    k++;       /* skip right chan dispatch */
    goto dispatch;
case 18+2:                     /* 5 levels grouped 7 bits */
    n = load(7);
    s[k]       =  cs_factor[i][k]*group5_table[n][0];
    s[k+1]     =  cs_factor[i][k+1]*group5_table[n][0];
    s[k+64]    =  cs_factor[i][k]*group5_table[n][1];
    s[k+64+1]  =  cs_factor[i][k+1]*group5_table[n][1];
    s[k+128]   =  cs_factor[i][k]*group5_table[n][2];
    s[k+128+1] =  cs_factor[i][k+1]*group5_table[n][2];
    k++;       /* skip right chan dispatch */
    goto dispatch;
case 18+3:     UNPACKJ_N(3)     /* 7 levels */
case 18+4:                     /* 9 levels grouped 10 bits */
    n = load(10);
    s[k]      =  cs_factor[i][k]*group9_table[n][0];
    s[k+1]    =  cs_factor[i][k+1]*group9_table[n][0];
    s[k+64]   =  cs_factor[i][k]*group9_table[n][1];
    s[k+64+1] =  cs_factor[i][k+1]*group9_table[n][1];
    s[k+128]  =  cs_factor[i][k]*group9_table[n][2];
    s[k+128+1]=  cs_factor[i][k+1]*group9_table[n][2];
    k++;       /* skip right chan dispatch */
    goto dispatch;
case 18+5:     UNPACKJ_N(4)     /* 15 levels */
case 18+6:     UNPACKJ_N(5)     /* 31 levels */
case 18+7:     UNPACKJ_N(6)     /* 63 levels */
case 18+8:     UNPACKJ_N(7)     /* 127 levels */
case 18+9:     UNPACKJ_N(8)     /* 255 levels */
case 18+10:    UNPACKJ_N(9)     /* 511 levels */
case 18+11:    UNPACKJ_N(10)    /* 1023 levels */
case 18+12:    UNPACKJ_N(11)    /* 2047 levels */
case 18+13:    UNPACKJ_N(12)    /* 4095 levels */
case 18+14:    UNPACKJ_N(13)    /* 8191 levels */
case 18+15:    UNPACKJ_N(14)    /* 16383 levels */
case 18+16:    UNPACKJ_N(15)    /* 32767 levels */
case 18+17:    UNPACKJ_N(16)    /* 65535 levels */
/* -- end of dispatch -- */
case 37:
   skip(bit_skip);
case 36:
   s += 3*64;
} /* end switch */
} /* end j loop */
} /* end i loop */


}
/*-------------------------------------------------------------------------*/