decode.c

mpeg layerI II III, support window and linux

         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,fp)
III_scalefac_t *scalefac;
III_side_info_t *si;
int gr, ch;
frame_params *fr_ps;
FILE *fp;
{
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;
#ifdef  DEBUG_PRINT
#ifdef  DEBUG_SCALEFAC
                       fprintf(fp,"ID=1,for start, stop and short block\n");
                       for (sfb=0; sfb<8; sfb++)
                       {
                           fprintf(fp,"scf[%d]->l[%d] = %d\n",ch,sfb,(*scalefac)[ch].l[sfb]) ;
                       } 
                       for (sfb=3; sfb<=12; sfb++)
                       {
                           for (window=0; window<3; window++)
                           {
                                fprintf(fp,"scf[%d]->s[%d][%d] = %d\n",ch,window,sfb,(*scalefac)[ch].s[window][sfb]) ;
                           } 
                       }
#endif
#endif  





         
      }
      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;
#ifdef  DEBUG_PRINT
#ifdef  DEBUG_SCALEFAC
                       fprintf(fp,"ID=1,for short block\n");
                       
                       for (sfb=0; sfb<=12; sfb++)
                       {
                           for (window=0; window<3; window++)
                           {
                                fprintf(fp,"scf[%d]->s[%d][%d] = %d\n",ch,window,sfb,(*scalefac)[ch].s[window][sfb]) ;
                           } 
                       }
#endif
#endif  
      }
    }
    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;
#ifdef  DEBUG_PRINT
#ifdef  DEBUG_SCALEFAC 
               fprintf(fp,"ID=1,for long,start or stop  block\n"); 
               for (sfb=0; sfb<23; sfb++)
               {
                   fprintf(fp,"scf[%d]->l[%d] = %d\n",ch,sfb,(*scalefac)[ch].l[sfb]);
               }
               
#endif
#endif 


        
    }
}

/****************** 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++)
     {
        for(j = 0; j < nr_of_sfb_block[blocknumber][blocktypenumber][i]; j++)
        {
           if(new_slen[i] == 0)
           {
                scalefac_buffer[k] = 0;
           }
           else
           {
               scalefac_buffer[k] =  hgetbits(new_slen[i]);
           }
           k++;

        }
     }

}



void III_get_LSF_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,k = 0, window;
struct gr_info_s *gr_info = &(si->ch[ch].gr[gr]);

     III_get_LSF_scale_data(scalefac, si, gr, ch, fr_ps);


    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] = scalefac_buffer[k];
              k++;
         }
         for (sfb = 3; sfb < 12; sfb++)
            for (window=0; window<3; window++)
            {
               (*scalefac)[ch].s[window][sfb] = scalefac_buffer[k];
               k++;
            }
            for (sfb=12,window=0; window<3; window++)
                     (*scalefac)[ch].s[window][sfb] = 0;

       }
       else {  /* SHORT*/
           for (sfb = 0; sfb < 12; sfb++)
               for (window=0; window<3; window++)
               {
                  (*scalefac)[ch].s[window][sfb] = scalefac_buffer[k];
                  k++;
               }
               for (sfb=12,window=0; window<3; window++)
                                   (*scalefac)[ch].s[window][sfb] = 0;
      }
    }
    else {   /* LONG types 0,1,3 */

           for (sfb = 0; sfb < 21; sfb++)
            {
                  (*scalefac)[ch].l[sfb] = scalefac_buffer[k];
                   k++;
            }
            (*scalefac)[ch].l[22] = 0;


    }
}



/* Already declared in huffman.c
struct huffcodetab ht[HTN];
*/
int huffman_initialized = FALSE;

void initialize_huffman() {
   FILE *fi;

   if (huffman_initialized) return;
   if (!(fi = OpenTableFile("huffdec") )) {
      printf("Please check huffman table 'huffdec'\n");
      exit(1);
   }

   if (fi==NULL) {

      fprintf(stderr,"decoder table open error\n");

      exit(3);