decode.c

ISO mp3 sources (distribution 10) Layer 1/2/3, C Source, 512 k Sources of the Mpeg 1,2 layer 1,2

   int ch, gr, i;
   int stereo = fr_ps->stereo;
   
   if(fr_ps->header->version != MPEG_PHASE2_LSF)
   {
      si->main_data_begin = getbits(bs, 9);
      if (stereo == 1)
         si->private_bits = getbits(bs,5);
         else si->private_bits = getbits(bs,3);

       for (ch=0; ch<stereo; ch++)
           for (i=0; i<4; i++)
           si->ch[ch].scfsi[i] = get1bit(bs);
 
  
        for (gr=0; gr< 2 ; gr++) {
           for (ch=0; ch<stereo; ch++) {
              si->ch[ch].gr[gr].part2_3_length = getbits(bs, 12);
              si->ch[ch].gr[gr].big_values = getbits(bs, 9);
              si->ch[ch].gr[gr].global_gain = getbits(bs, 8);
              si->ch[ch].gr[gr].scalefac_compress = getbits(bs, 4);
              si->ch[ch].gr[gr].window_switching_flag = get1bit(bs);
              if (si->ch[ch].gr[gr].window_switching_flag) {
                 si->ch[ch].gr[gr].block_type = getbits(bs, 2);
                 si->ch[ch].gr[gr].mixed_block_flag = get1bit(bs);
                 for (i=0; i<2; i++)
                    si->ch[ch].gr[gr].table_select[i] = getbits(bs, 5);
                 for (i=0; i<3; i++)
                    si->ch[ch].gr[gr].subblock_gain[i] = getbits(bs, 3);
               
            /* Set region_count parameters since they are implicit in this case. */
            
                 if (si->ch[ch].gr[gr].block_type == 0) {
                   printf("Side info bad: block_type == 0 in split block.\n");
                   exit(0);
                 }
                 else if (si->ch[ch].gr[gr].block_type == 2
                      && si->ch[ch].gr[gr].mixed_block_flag == 0)
                             si->ch[ch].gr[gr].region0_count = 8; /* MI 9; */
                 else si->ch[ch].gr[gr].region0_count = 7; /* MI 8; */
                      si->ch[ch].gr[gr].region1_count = 20 -
						si->ch[ch].gr[gr].region0_count;
             }
            else {
               for (i=0; i<3; i++)
                   si->ch[ch].gr[gr].table_select[i] = getbits(bs, 5);
               si->ch[ch].gr[gr].region0_count = getbits(bs, 4);
               si->ch[ch].gr[gr].region1_count = getbits(bs, 3);
               si->ch[ch].gr[gr].block_type = 0;
            }      
         si->ch[ch].gr[gr].preflag = get1bit(bs);
         si->ch[ch].gr[gr].scalefac_scale = get1bit(bs);
         si->ch[ch].gr[gr].count1table_select = get1bit(bs);
         }
      }
    }     
    else /* Layer 3 LSF */
    {     
        si->main_data_begin = getbits(bs, 8);
        if (stereo == 1)
                 si->private_bits = getbits(bs,1);
         else si->private_bits = getbits(bs,2);

        for (gr=0; gr< 1 ; gr++) {
           for (ch=0; ch<stereo; ch++) {
              si->ch[ch].gr[gr].part2_3_length = getbits(bs, 12);
              si->ch[ch].gr[gr].big_values = getbits(bs, 9);
              si->ch[ch].gr[gr].global_gain = getbits(bs, 8);
              si->ch[ch].gr[gr].scalefac_compress = getbits(bs, 9);
              si->ch[ch].gr[gr].window_switching_flag = get1bit(bs);
              if (si->ch[ch].gr[gr].window_switching_flag) {
                 si->ch[ch].gr[gr].block_type = getbits(bs, 2);
                 si->ch[ch].gr[gr].mixed_block_flag = get1bit(bs);
                 for (i=0; i<2; i++)
                    si->ch[ch].gr[gr].table_select[i] = getbits(bs, 5);
                 for (i=0; i<3; i++)
                    si->ch[ch].gr[gr].subblock_gain[i] = getbits(bs, 3);
               
            /* Set region_count parameters since they are implicit in this case. */
            
                 if (si->ch[ch].gr[gr].block_type == 0) {
                   printf("Side info bad: block_type == 0 in split block.\n");
                   exit(0);
                 }
                 else if (si->ch[ch].gr[gr].block_type == 2
                      && si->ch[ch].gr[gr].mixed_block_flag == 0)
                             si->ch[ch].gr[gr].region0_count = 8; /* MI 9; */
                 else si->ch[ch].gr[gr].region0_count = 7; /* MI 8; */
                      si->ch[ch].gr[gr].region1_count = 20 - si->ch[ch].gr[gr].region0_count;

              }
              else {
                for (i=0; i<3; i++)
                   si->ch[ch].gr[gr].table_select[i] = getbits(bs, 5);
               si->ch[ch].gr[gr].region0_count = getbits(bs, 4);
               si->ch[ch].gr[gr].region1_count = getbits(bs, 3);
               si->ch[ch].gr[gr].block_type = 0;
              }      

         si->ch[ch].gr[gr].scalefac_scale = get1bit(bs);
         si->ch[ch].gr[gr].count1table_select = get1bit(bs);
         }
     }
  }
}

void III_put_side_info(bs, si, fr_ps)
frame_params *fr_ps;
Bit_stream_struc *bs;
III_side_info_t *si;
{
   int ch, gr, i;
   int stereo = fr_ps->stereo;

 if(fr_ps->header->version != MPEG_PHASE2_LSF)
 {
   putbits(bs, si->main_data_begin,9);
   if (stereo == 1)
      putbits(bs, si->private_bits, 5);
      else putbits(bs, si->private_bits, 3);

   for (ch=0; ch<stereo; ch++)
      for (i=0; i<4; i++)
         put1bit(bs, si->ch[ch].scfsi[i]);

   for (gr=0; gr<2; gr++) {
      for (ch=0; ch<stereo; ch++) {
         putbits(bs, si->ch[ch].gr[gr].part2_3_length, 12);
         putbits(bs, si->ch[ch].gr[gr].big_values, 9);
         putbits(bs, si->ch[ch].gr[gr].global_gain, 8);
         putbits(bs, si->ch[ch].gr[gr].scalefac_compress, 4);
         put1bit(bs, si->ch[ch].gr[gr].window_switching_flag);
         if (si->ch[ch].gr[gr].window_switching_flag) {
            putbits(bs, si->ch[ch].gr[gr].block_type, 2);
            put1bit(bs, si->ch[ch].gr[gr].mixed_block_flag);
            for (i=0; i<2; i++)
               putbits(bs, si->ch[ch].gr[gr].table_select[i], 5);
            for (i=0; i<3; i++)
               putbits(bs, si->ch[ch].gr[gr].subblock_gain[i], 3);
            }
         else {
            for (i=0; i<3; i++)
            putbits(bs, si->ch[ch].gr[gr].table_select[i], 5);
            putbits(bs, si->ch[ch].gr[gr].region0_count, 4);
            putbits(bs, si->ch[ch].gr[gr].region1_count, 3);
            }      

         put1bit(bs, si->ch[ch].gr[gr].preflag);
         put1bit(bs, si->ch[ch].gr[gr].scalefac_scale);
         put1bit(bs, si->ch[ch].gr[gr].count1table_select);
         }
      }
 }
 else /* Layer 3 LSF */
 {
    putbits(bs, si->main_data_begin,8);
    if (stereo == 1)
      putbits(bs, si->private_bits, 1);
      else putbits(bs, si->private_bits, 2);

   
     for (gr=0; gr<1; gr++) {
       for (ch=0; ch<stereo; ch++) {
         putbits(bs, si->ch[ch].gr[gr].part2_3_length, 12);
         putbits(bs, si->ch[ch].gr[gr].big_values, 9);
         putbits(bs, si->ch[ch].gr[gr].global_gain, 8);
         putbits(bs, si->ch[ch].gr[gr].scalefac_compress, 9);
         put1bit(bs, si->ch[ch].gr[gr].window_switching_flag);
         if (si->ch[ch].gr[gr].window_switching_flag) {
            putbits(bs, si->ch[ch].gr[gr].block_type, 2);
            put1bit(bs, si->ch[ch].gr[gr].mixed_block_flag);
            for (i=0; i<2; i++)
               putbits(bs, si->ch[ch].gr[gr].table_select[i], 5);
            for (i=0; i<3; i++)
               putbits(bs, si->ch[ch].gr[gr].subblock_gain[i], 3);
            }
         else 
           {  
            for (i=0; i<3; i++)
            putbits(bs, si->ch[ch].gr[gr].table_select[i], 5);
            putbits(bs, si->ch[ch].gr[gr].region0_count, 4);
            putbits(bs, si->ch[ch].gr[gr].region1_count, 3);
           }      

         put1bit(bs, si->ch[ch].gr[gr].scalefac_scale);
         put1bit(bs, si->ch[ch].gr[gr].count1table_select);
       }
     }
  }
}

struct {
   int l[5];
   int s[3];} sfbtable = {{0, 6, 11, 16, 21},
                          {0, 6, 12}};
                         
int slen[2][16] = {{0, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4},
                   {0, 1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 2, 3}};
struct  {
   int l[23];
   int s[14];} sfBandIndex[6] =
    {{{0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576},
     {0,4,8,12,18,24,32,42,56,74,100,132,174,192}},
    {{0,6,12,18,24,30,36,44,54,66,80,96,114,136,162,194,232,278,330,394,464,540,576},
     {0,4,8,12,18,26,36,48,62,80,104,136,180,192}},
    {{0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576},
     {0,4,8,12,18,26,36,48,62,80,104,134,174,192}},

    {{0,4,8,12,16,20,24,30,36,44,52,62,74,90,110,134,162,196,238,288,342,418,576},
     {0,4,8,12,16,22,30,40,52,66,84,106,136,192}},
    {{0,4,8,12,16,20,24,30,36,42,50,60,72,88,106,128,156,190,230,276,330,384,576},
     {0,4,8,12,16,22,28,38,50,64,80,100,126,192}},
    {{0,4,8,12,16,20,24,30,36,44,54,66,82,102,126,156,194,240,296,364,448,550,576},
     {0,4,8,12,16,22,30,42,58,78,104,138,180,192}}};



void III_get_scale_factors(scalefac, si, gr, ch, fr_ps)
III_scalefac_t *scalefac;
III_side_info_t *si;
int gr, ch;
frame_params *fr_ps;
{
int sfb, i, window;
struct gr_info_s *gr_info = &(si->ch[ch].gr[gr]);

    if (gr_info->window_switching_flag && (gr_info->block_type == 2)) { 
      if (gr_info->mixed_block_flag) { /* MIXED */ /* NEW - ag 11/25 */
         for (sfb = 0; sfb < 8; sfb++)
            (*scalefac)[ch].l[sfb] = hgetbits( 
                 slen[0][gr_info->scalefac_compress]);
         for (sfb = 3; sfb < 6; sfb++)
            for (window=0; window<3; window++)
               (*scalefac)[ch].s[window][sfb] = hgetbits(
                 slen[0][gr_info->scalefac_compress]);
         for (sfb = 6; sfb < 12; sfb++)
            for (window=0; window<3; window++)
               (*scalefac)[ch].s[window][sfb] = hgetbits(
                 slen[1][gr_info->scalefac_compress]);
         for (sfb=12,window=0; window<3; window++)
            (*scalefac)[ch].s[window][sfb] = 0;
      }
      else {  /* SHORT*/
         for (i=0; i<2; i++) 
            for (sfb = sfbtable.s[i]; sfb < sfbtable.s[i+1]; sfb++)
               for (window=0; window<3; window++)
                  (*scalefac)[ch].s[window][sfb] = hgetbits( 
                    slen[i][gr_info->scalefac_compress]);
         for (sfb=12,window=0; window<3; window++)
            (*scalefac)[ch].s[window][sfb] = 0;
      }
    }          
    else {   /* LONG types 0,1,3 */
        for (i=0; i<4; i++) {
           if ((si->ch[ch].scfsi[i] == 0) || (gr == 0))
              for (sfb = sfbtable.l[i]; sfb < sfbtable.l[i+1]; sfb++)
                  (*scalefac)[ch].l[sfb] = hgetbits(
                 slen[(i<2)?0:1][gr_info->scalefac_compress]);
        }
        (*scalefac)[ch].l[22] = 0; 
    }
}

/****************** new MPEG2 stuf  ***********/

static unsigned nr_of_sfb_block[6][3][4] = {{{6, 5, 5, 5},{ 9, 9, 9, 9 },{6, 9, 9, 9}},
                                         {{6, 5, 7, 3},{ 9, 9, 12, 6},{6, 9, 12, 6}},
                                         {{11, 10, 0, 0},{ 18, 18, 0, 0},{15,18,0,0 }},
                                         {{7, 7, 7, 0},{ 12, 12, 12, 0},{6, 15, 12, 0}},
                                         {{6, 6, 6, 3},{12, 9, 9, 6},{6, 12, 9, 6}},
                                         {{8, 8, 5, 0},{15,12,9,0},{6,18,9,0}}};
static unsigned scalefac_buffer[54];

void III_get_LSF_scale_data(scalefac, si, gr, ch, fr_ps)
III_scalefac_t *scalefac;
III_side_info_t *si;
int gr, ch;
frame_params *fr_ps;
{
short sfb, i,j,k, window;
short blocktypenumber, blocknumber;

struct gr_info_s *gr_info = &(si->ch[ch].gr[gr]);
unsigned scalefac_comp, int_scalefac_comp, new_slen[4];
   
layer *hdr = fr_ps->header;
scalefac_comp =  gr_info->scalefac_compress;

    blocktypenumber = 0;
    if ((gr_info->block_type == 2) && (gr_info->mixed_block_flag == 0))
                                                        blocktypenumber = 1;

   if ((gr_info->block_type == 2) && (gr_info->mixed_block_flag == 1))
                                                        blocktypenumber = 2;

    if(!((( hdr->mode_ext == 1) || (hdr->mode_ext == 3)) && (ch == 1)))
    {
	if(scalefac_comp < 400)
        {
		new_slen[0] = (scalefac_comp >> 4) / 5 ;
		new_slen[1] = (scalefac_comp >> 4) % 5 ;
		new_slen[2] = (scalefac_comp % 16) >> 2 ;
		new_slen[3] = (scalefac_comp % 4);
                si->ch[ch].gr[gr].preflag = 0;

                blocknumber = 0;
         }

	else if( scalefac_comp  < 500)
        {
		new_slen[0] = ((scalefac_comp - 400 )  >> 2) / 5 ;
		new_slen[1] = ((scalefac_comp - 400) >> 2) % 5 ;
		new_slen[2] = (scalefac_comp - 400 ) % 4 ;
		new_slen[3] = 0;
                si->ch[ch].gr[gr].preflag = 0;
                blocknumber = 1;

        }

	else if( scalefac_comp  < 512)
        {
		new_slen[0] = (scalefac_comp - 500 ) / 3 ;
		new_slen[1] = (scalefac_comp - 500)  % 3 ;
		new_slen[2] = 0 ;
		new_slen[3] = 0;
                si->ch[ch].gr[gr].preflag = 1;
                blocknumber = 2;

        }
     }

    if((((hdr->mode_ext == 1) || (hdr->mode_ext == 3)) && (ch == 1)))
    {
      /*   intensity_scale = scalefac_comp %2; */
         int_scalefac_comp = scalefac_comp >> 1;
	
        if(int_scalefac_comp  < 180)
        {
		new_slen[0] = int_scalefac_comp  / 36 ;
		new_slen[1] = (int_scalefac_comp % 36 ) / 6 ;
		new_slen[2] = (int_scalefac_comp % 36) % 6;
		new_slen[3] = 0;
                si->ch[ch].gr[gr].preflag = 0;
                blocknumber = 3;

         }

	else if( int_scalefac_comp  < 244)
        {
		new_slen[0] = ((int_scalefac_comp - 180 )  % 64 ) >> 4 ;
		new_slen[1] = ((int_scalefac_comp - 180) % 16) >> 2 ;
		new_slen[2] = (int_scalefac_comp - 180 ) % 4 ;
		new_slen[3] = 0;
                si->ch[ch].gr[gr].preflag = 0;
                blocknumber = 4;

        }

	else if( int_scalefac_comp  < 255)
        {
		new_slen[0] = (int_scalefac_comp - 244 ) / 3 ;
		new_slen[1] = (int_scalefac_comp - 244 )  % 3 ;
		new_slen[2] = 0 ;
		new_slen[3] = 0;
                si->ch[ch].gr[gr].preflag = 0;
                blocknumber = 5;

        }
     }
     
     for(i=0;i< 45;i++) scalefac_buffer[i] = 0;

     k = 0;
     for(i = 0;i < 4;i++)
     {