mpadecl3.cpp

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

}
//=========================================================================
IN_OUT CMpaDecoderL3::L3audio_decode_MPEG2(unsigned char *bs, unsigned char *pcm)
{
int sync;
IN_OUT in_out;
int side_bytes;
int nbytes;

iframe++;

bitget_init(&bitdat, bs);          /* initialize bit getter */
/* test sync */
in_out.in_bytes = 0;     /* assume fail */
in_out.out_bytes = 0;
sync = bitget(&bitdat, 12);

//if( sync != 0xFFF ) return in_out;       /* sync fail */
mpeg25_flag = 0;
if( sync != 0xFFF ) {
    mpeg25_flag = 1;       /* mpeg 2.5 sync */
    if( sync != 0xFFE ) return in_out;  /* sync fail */
}
/*-----------*/


/*-- unpack side info --*/
side_bytes = unpack_side_MPEG2(igr);
if( framebytes <= 0 ) return in_out;  // fail bad sr or br index

padframebytes = framebytes+pad;

in_out.in_bytes = padframebytes;

buf_ptr0 = buf_ptr1 - side_info.main_data_begin;   /* decode start point */
if( buf_ptr1 > BUF_TRIGGER ) {          /* shift buffer */
    memmove(buf, buf+buf_ptr0, side_info.main_data_begin);
    buf_ptr0 = 0;
    buf_ptr1 = side_info.main_data_begin;
}
nbytes = padframebytes - side_bytes - crcbytes;
memmove(buf+buf_ptr1, bs+side_bytes+crcbytes, nbytes);
buf_ptr1 += nbytes;
/*-----------------------*/

if( buf_ptr0 >= 0 ) {
    main_pos_bit = buf_ptr0 << 3;
    unpack_main(buf, igr);
    Xform(pcm, igr);
    in_out.out_bytes = outbytes;
}
else {
    memset(pcm, zero_level_pcm, outbytes);  /* fill out skipped frames */
    in_out.out_bytes = outbytes;
}

igr = igr^1;
return in_out;
}
/*====================================================================*/
int CMpaDecoderL3::unpack_side_MPEG1()
{
int prot;
int br_index;
int igr, ch;
int side_bytes;

/* decode partial header plus initial side info */
/* at entry bit getter points at id, sync skipped by caller */

id = bitget(&bitdat, 1);   /* id */
bitget(&bitdat, 2);        /* skip layer */
prot = bitget(&bitdat, 1);     /* bitget prot bit */
br_index = bitget(&bitdat, 4);
sr_index = bitget(&bitdat, 2);
pad = bitget(&bitdat, 1);
bitget(&bitdat, 1);            /* skip to mode */
side_info.mode = bitget(&bitdat, 2);        /* mode */
side_info.mode_ext = bitget(&bitdat, 2);    /* mode ext */

if( side_info.mode != 1 ) side_info.mode_ext = 0;

/* adjust global gain in ms mode to avoid having to mult by 1/sqrt(2) */
ms_mode = side_info.mode_ext >> 1;
is_mode = side_info.mode_ext & 1;


crcbytes = 0;
if( prot ) bitget(&bitdat, 4);    /* skip to data */
else {
    bitget(&bitdat, 20);          /* skip crc */
    crcbytes = 2;
}

if( br_index > 0 )      /* framebytes fixed for free format */
    framebytes =
        2880 * mp_br_table_L3[id][br_index]/mp_sr20_table_L3[id][sr_index];

side_info.main_data_begin = bitget(&bitdat, 9);
if( side_info.mode == 3 ) {
    side_info.private_bits  = bitget(&bitdat, 5);
    nchan = 1;
    stereo_flag = 0;
    side_bytes = (4+17);   /*-- with header --*/
}
else {                      
    side_info.private_bits  = bitget(&bitdat, 3);
    nchan = 2;
    stereo_flag = 1;
    side_bytes = (4+32);   /*-- with header --*/
}
for(ch=0;ch<nchan;ch++) side_info.scfsi[ch] = bitget(&bitdat, 4);
/* this always 0 (both igr) for short blocks */


for(igr=0;igr<2;igr++) {
for(ch=0;ch<nchan;ch++) {
    side_info.gr[igr][ch].part2_3_length   = bitget(&bitdat, 12);
    side_info.gr[igr][ch].big_values       = bitget(&bitdat, 9);
    side_info.gr[igr][ch].global_gain      = bitget(&bitdat, 8) + gain_adjust;
    if( ms_mode ) side_info.gr[igr][ch].global_gain -= 2;
    side_info.gr[igr][ch].scalefac_compress      = bitget(&bitdat, 4);
    side_info.gr[igr][ch].window_switching_flag  = bitget(&bitdat, 1);
    if( side_info.gr[igr][ch].window_switching_flag ) {
        side_info.gr[igr][ch].block_type          = bitget(&bitdat, 2);
        side_info.gr[igr][ch].mixed_block_flag    = bitget(&bitdat, 1);
        side_info.gr[igr][ch].table_select[0]     = bitget(&bitdat, 5);
        side_info.gr[igr][ch].table_select[1]     = bitget(&bitdat, 5);
        side_info.gr[igr][ch].subblock_gain[0]    = bitget(&bitdat, 3);
        side_info.gr[igr][ch].subblock_gain[1]    = bitget(&bitdat, 3);
        side_info.gr[igr][ch].subblock_gain[2]    = bitget(&bitdat, 3);
        /* region count set in terms of long block cb's/bands */
        /* r1 set so r0+r1+1 = 21 (lookup produces 576 bands ) */
        /* if(window_switching_flag) always 36 samples in region0 */
        side_info.gr[igr][ch].region0_count = (8-1);    /* 36 samples */
        side_info.gr[igr][ch].region1_count = 20-(8-1);
    }
    else {
        side_info.gr[igr][ch].mixed_block_flag    = 0;
        side_info.gr[igr][ch].block_type          = 0;
        side_info.gr[igr][ch].table_select[0]     = bitget(&bitdat, 5);
        side_info.gr[igr][ch].table_select[1]     = bitget(&bitdat, 5);
        side_info.gr[igr][ch].table_select[2]     = bitget(&bitdat, 5);
        side_info.gr[igr][ch].region0_count       = bitget(&bitdat, 4);
        side_info.gr[igr][ch].region1_count       = bitget(&bitdat, 3);
    }
    side_info.gr[igr][ch].preflag             = bitget(&bitdat, 1);
    side_info.gr[igr][ch].scalefac_scale      = bitget(&bitdat, 1);
    side_info.gr[igr][ch].count1table_select  = bitget(&bitdat, 1);
}
}    


/* return  bytes in header + side info */
return side_bytes;
}
/*====================================================================*/
int CMpaDecoderL3::unpack_side_MPEG2(int igr)
{
int prot;
int br_index;
int ch;
int side_bytes;

/* decode partial header plus initial side info */
/* at entry bit getter points at id, sync skipped by caller */

id = bitget(&bitdat, 1);   /* id */
bitget(&bitdat, 2);        /* skip layer */
prot = bitget(&bitdat, 1);     /* bitget prot bit */
br_index = bitget(&bitdat, 4);
sr_index = bitget(&bitdat, 2);
pad = bitget(&bitdat, 1);
bitget(&bitdat, 1);            /* skip to mode */
side_info.mode = bitget(&bitdat, 2);        /* mode */
side_info.mode_ext = bitget(&bitdat, 2);    /* mode ext */

if( side_info.mode != 1 ) side_info.mode_ext = 0;

/* adjust global gain in ms mode to avoid having to mult by 1/sqrt(2) */
ms_mode = side_info.mode_ext >> 1;
is_mode = side_info.mode_ext & 1;

crcbytes = 0;
if( prot ) bitget(&bitdat, 4);    /* skip to data */
else {
    bitget(&bitdat, 20);          /* skip crc */
    crcbytes = 2;
}

if( br_index > 0 )  {       /* framebytes fixed for free format */
  if( mpeg25_flag == 0 ) {
    framebytes =
        1440 * mp_br_table_L3[id][br_index]/mp_sr20_table_L3[id][sr_index];
  }
  else {
    framebytes =
        2880 * mp_br_table_L3[id][br_index]/mp_sr20_table_L3[id][sr_index];
    //if( sr_index == 2 ) return 0;  // fail mpeg25 8khz
  }
}
side_info.main_data_begin = bitget(&bitdat, 8);
if( side_info.mode == 3 ) {
    side_info.private_bits  = bitget(&bitdat, 1);
    nchan = 1;
    stereo_flag = 0;
    side_bytes = (4+9);   /*-- with header --*/
}
else {                      
    side_info.private_bits  = bitget(&bitdat, 2);
    nchan = 2;
    stereo_flag = 1;
    side_bytes = (4+17);   /*-- with header --*/
}
side_info.scfsi[1] = side_info.scfsi[0] = 0;


for(ch=0;ch<nchan;ch++) {
    side_info.gr[igr][ch].part2_3_length   = bitget(&bitdat, 12);
    side_info.gr[igr][ch].big_values       = bitget(&bitdat, 9);
    side_info.gr[igr][ch].global_gain      = bitget(&bitdat, 8) + gain_adjust;
    if( ms_mode ) side_info.gr[igr][ch].global_gain -= 2;
    side_info.gr[igr][ch].scalefac_compress      = bitget(&bitdat, 9);
    side_info.gr[igr][ch].window_switching_flag  = bitget(&bitdat, 1);
    if( side_info.gr[igr][ch].window_switching_flag ) {
        side_info.gr[igr][ch].block_type          = bitget(&bitdat, 2);
        side_info.gr[igr][ch].mixed_block_flag    = bitget(&bitdat, 1);
        side_info.gr[igr][ch].table_select[0]     = bitget(&bitdat, 5);
        side_info.gr[igr][ch].table_select[1]     = bitget(&bitdat, 5);
        side_info.gr[igr][ch].subblock_gain[0]    = bitget(&bitdat, 3);
        side_info.gr[igr][ch].subblock_gain[1]    = bitget(&bitdat, 3);
        side_info.gr[igr][ch].subblock_gain[2]    = bitget(&bitdat, 3);
        /* region count set in terms of long block cb's/bands  */
        /* r1 set so r0+r1+1 = 21 (lookup produces 576 bands ) */
        /* bt=1 or 3       54 samples */
        /* bt=2 mixed=0    36 samples */
        /* bt=2 mixed=1    54 (8 long sf) samples? or maybe 36 */
        /* region0 discussion says 54 but this would mix long */
        /* and short in region0 if scale factors switch */
        /* at band 36 (6 long scale factors) */
        if( (side_info.gr[igr][ch].block_type == 2) ) {
            side_info.gr[igr][ch].region0_count = (6-1); /* 36 samples */
            side_info.gr[igr][ch].region1_count = 20-(6-1);
        }
        else {  /* long block type 1 or 3 */
            side_info.gr[igr][ch].region0_count = (8-1); /* 54 samples */
            side_info.gr[igr][ch].region1_count = 20-(8-1);
        }
    }
    else {
        side_info.gr[igr][ch].mixed_block_flag    = 0;
        side_info.gr[igr][ch].block_type          = 0;
        side_info.gr[igr][ch].table_select[0]     = bitget(&bitdat, 5);
        side_info.gr[igr][ch].table_select[1]     = bitget(&bitdat, 5);
        side_info.gr[igr][ch].table_select[2]     = bitget(&bitdat, 5);
        side_info.gr[igr][ch].region0_count       = bitget(&bitdat, 4);
        side_info.gr[igr][ch].region1_count       = bitget(&bitdat, 3);
    }
    side_info.gr[igr][ch].preflag             = 0;
    side_info.gr[igr][ch].scalefac_scale      = bitget(&bitdat, 1);
    side_info.gr[igr][ch].count1table_select  = bitget(&bitdat, 1);
}

/* return  bytes in header + side info */
return side_bytes;
}
/*====================================================================*/
void CMpaDecoderL3::unpack_main(unsigned char *buf, int igr)
{
int ch;
int bit0;
int n1, n2, n3, n4, nn2, nn3;
int nn4;
int qbits;
int m0;

for(ch=0;ch<nchan;ch++) {
    bitget_init(&bitdat, buf + (main_pos_bit >> 3));
    bit0 = (main_pos_bit & 7);
    if( bit0 ) bitget(&bitdat, bit0);
    main_pos_bit +=  side_info.gr[igr][ch].part2_3_length;
    bitget_init_end(&bitdat, buf + ((main_pos_bit+39) >> 3));
    /*-- scale factors --*/
    if( id ) 
        unpack_sf_sub_MPEG1(&sf[igr][ch], 
            &side_info.gr[igr][ch], side_info.scfsi[ch],  igr, &bitdat);
    else 
        unpack_sf_sub_MPEG2(&sf[igr][ch], 
            &side_info.gr[igr][ch], is_mode & ch, &is_sf_info, &bitdat);
    /*--- huff data ---*/
    n1 = sfBandIndex[0][side_info.gr[igr][ch].region0_count];
    n2 = sfBandIndex[0][side_info.gr[igr][ch].region0_count
                        + side_info.gr[igr][ch].region1_count+1];
    n3 =  side_info.gr[igr][ch].big_values;
    n3 = n3 + n3;

    
    if( n3 > band_limit ) n3 = band_limit;
    if( n2 > n3 ) n2 = n3;
    if( n1 > n3 ) n1 = n3;
    nn3 = n3 - n2;
    nn2 = n2 - n1;
    unpack_huff(sample[ch][igr],     n1, side_info.gr[igr][ch].table_select[0], &bitdat);
    unpack_huff(sample[ch][igr]+n1, nn2, side_info.gr[igr][ch].table_select[1], &bitdat);
    unpack_huff(sample[ch][igr]+n2, nn3, side_info.gr[igr][ch].table_select[2], &bitdat);
    qbits = side_info.gr[igr][ch].part2_3_length - (bitget_bits_used(&bitdat)-bit0);
    nn4 = unpack_huff_quad(sample[ch][igr]+n3, band_limit - n3, qbits, 
            side_info.gr[igr][ch].count1table_select, &bitdat);
    n4 = n3 + nn4;
    nsamp[igr][ch] = n4;
    //limit n4 or allow deqaunt to sf band 22
    if( side_info.gr[igr][ch].block_type == 2 ) n4 = min(n4,band_limit12);
    else  n4 = min(n4,band_limit21);
    if( n4 < 576 ) memset(sample[ch][igr]+n4, 0, sizeof(SAMPLE)*(576-n4));
    if(  bitget_overrun(&bitdat) ) { // bad data overrun
        memset(sample[ch][igr], 0, sizeof(SAMPLE)*(576));
    }
}


/*--- dequant ---*/
for(ch=0;ch<nchan;ch++) {
    dequant(sample[ch][igr], 
        &nsamp[igr][ch],    /* nsamp updated for shorts */
        &sf[igr][ch], &side_info.gr[igr][ch], 
        &cb_info[igr][ch], ncbl_mixed, nBand, re_buf);
}


/*--- ms stereo processing  ---*/
if( ms_mode ) {
    if( is_mode == 0 ) {
        m0 = nsamp[igr][0];    /* process to longer of left/right */
        if( m0 < nsamp[igr][1] ) m0 = nsamp[igr][1];
    }
    else {  /* process to last cb in right */
        m0  = sfBandIndex[cb_info[igr][1].cbtype][cb_info[igr][1].cbmax];
    }
    ms_process(sample[0][igr], m0);    
}

/*--- is stereo processing  ---*/
if( is_mode ) {
    if( id ) 
        is_process_MPEG1(sample[0][igr], &sf[igr][1], 
            cb_info[igr], nsamp[igr][0], ms_mode, nBand, sfBandIndex);
    else
        is_process_MPEG2(sample[0][igr], &sf[igr][1], 
            cb_info[igr], &is_sf_info,
            nsamp[igr][0], ms_mode, nBand, sfBandIndex);
}

/*-- adjust ms and is modes to max of left/right */
if( side_info.mode_ext ) {
    if(nsamp[igr][0] < nsamp[igr][1]) nsamp[igr][0] = nsamp[igr][1];
    else  nsamp[igr][1] = nsamp[igr][0];
}

/*--- antialias ---*/
for(ch=0;ch<nchan;ch++) {
    if( cb_info[igr][ch].ncbl == 0 ) continue; /* have no long blocks */
    if( side_info.gr[igr][ch].mixed_block_flag ) n1 = 1; /* 1 -> 36 samples */
    else n1 = (nsamp[igr][ch]+7)/18;
    if( n1 > 31 ) n1 = 31;
    antialias(sample[ch][igr], n1);
    n1 = 18*n1+8;       /* update number of samples */
    if( n1 > nsamp[igr][ch] ) nsamp[igr][ch] = n1;
}


//Xform(pcm, igr);


/*-- done --*/
}
/*====================================================================*/
void CMpaDecoderL3::Xform(unsigned char *pcm, int igr)
{
    switch(iXform) {
    default:
    case 0:
        Xform_mono(pcm, igr);
        break;
    case 1:
        Xform_dual(pcm,igr);
        break;
    case 2:
        Xform_dual_mono(pcm,igr);
        break;
    case 3:
        Xform_mono(pcm,igr);
        break;
    case 4:
        Xform_dual_right(pcm,igr);
        break;
    }
}    
/*====================================================================*/
void CMpaDecoderL3::Xform_mono(unsigned char *pcm, int igr)
{
int igr_prev, n1, n2;

/*--- hybrid + sbt ---*/
n1 = n2 = nsamp[igr][0];   /* total number bands */
if( side_info.gr[igr][0].block_type == 2 ) { /* long bands */
    n1 = 0;     
    if( side_info.gr[igr][0].mixed_block_flag ) 
                n1 = sfBandIndex[0][ncbl_mixed-1];
}
if( n1 > band_limit ) n1 = band_limit;
if( n2 > band_limit ) n2 = band_limit;
igr_prev = igr^1;

nsamp[igr][0] = hybrid(sample[0][igr], sample[0][igr_prev], 
     yout, side_info.gr[igr][0].block_type, n1, n2, nsamp[igr_prev][0], band_limit_nsb);
FreqInvert(yout, nsamp[igr][0]);
sbt_L3(yout, pcm, 0, vbuf, vb_ptr);

}
/*--------------------------------------------------------------------*/
void CMpaDecoderL3::Xform_dual_right(unsigned char *pcm, int igr)
{
int igr_prev, n1, n2;

/*--- hybrid + sbt ---*/