predisto.c

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

/******************************************************************/
/* Multilingual JMZ 08/03/1995 */

if(n_ml_ch >0)
{
	for (i = 0; i < sblimit_ml; i++)
	  for(j = 7; j < (n_ml_ch+7); ++j)
	  {
	     k=j;
	     if ((used[k][i] != 2) && (small > mnr[k][i])) 
	     {
                  small = mnr[k][i];
                  min_sb = i;  min_ch = k;
	     }
	}
}

/* Multilingual JMZ 08/03/1995 */
/******************************************************************/

	 
     if(min_sb > -1) 
     { 
       if (min_ch < stereo) 
       {
	 increment = 12 * ((*alloc)[min_sb][bit_alloc[min_ch][min_sb]+1].group * 
	             (*alloc)[min_sb][bit_alloc[min_ch][min_sb]+1].bits);
		     /* how many bits are needed */
         if (used[min_ch][min_sb])
          increment -= 12 * ((*alloc)[min_sb][bit_alloc[min_ch][min_sb]].group * 
                            (*alloc)[min_sb][bit_alloc[min_ch][min_sb]].bits);
       } 
       else if (min_ch < 7 || n_ml_ch == 0) /* Multichannel */ 
       {
	 increment = 12 * ((*alloc_mc)[min_sb][bit_alloc[min_ch][min_sb]+1].group * 
	             (*alloc_mc)[min_sb][bit_alloc[min_ch][min_sb]+1].bits);
		     /* how many bits are needed */
         if (used[min_ch][min_sb])
          increment -= 12 * ((*alloc_mc)[min_sb][bit_alloc[min_ch][min_sb]].group * 
                            (*alloc_mc)[min_sb][bit_alloc[min_ch][min_sb]].bits);
       } 
       else /* MultiLingual 7/8/95 WtK */ 
       {
	  increment   = ((*alloc_ml)[min_sb][bit_alloc[min_ch][min_sb]+1].group * 
			 (*alloc_ml)[min_sb][bit_alloc[min_ch][min_sb]+1].bits);
	  if (used[min_ch][min_sb])
	   increment -= ((*alloc_ml)[min_sb][bit_alloc[min_ch][min_sb]].group * 
			 (*alloc_ml)[min_sb][bit_alloc[min_ch][min_sb]].bits);
	  if (fr_ps->header->multiling_fs==1) increment *=  6;
	  else                                increment *= 12;
       }

       /* scale factor bits required for subband [min] */
       if (used[min_ch][min_sb]) scale = seli = 0;
       else 
       {			  /* this channel had no bits or scfs before */
         seli = 2;
         scale = 6 * sfsPerScfsi[scfsi[min_ch][min_sb]];
	}
	
       if(fr_ps->header->ext_bit_stream_present == 1)
       {
	if (adb_mpg1 > bspl_mpg1 + bscf_mpg1 + bsel_mpg1 + seli + scale + increment) 
	{
	   bspl_mpg1 += increment;  /* bits for subband sample */
	   bscf_mpg1 += scale;      /* bits for scale factor */
	   bsel_mpg1 += seli;       /* bits for scfsi code */
	}
	else
	   used[min_ch][min_sb] = 2;  /* can't increase this alloc */
       }
	
       
       if ((ad > bspl + bscf + bsel + seli + scale + increment) && (used[min_ch][min_sb] != 2)) 
       {
	    ba = ++bit_alloc[min_ch][min_sb]; /* next up alloc */
	    bspl += increment;		    /* bits for subband sample */
	    bscf += scale;		    /* bits for scale factor */
	    bsel += seli;			    /* bits for scfsi code */
	    used[min_ch][min_sb] = 1;	    /* subband has bits */
	    if (min_ch<7)
	      mnr[min_ch][min_sb] = -perm_smr[min_ch][min_sb] +
				    snr[(*alloc)[min_sb][ba].quant+1];
	    else
	      mnr[min_ch][min_sb] = -perm_smr[min_ch][min_sb] +
				    snr[(*alloc_ml)[min_sb][ba].quant+1];
			    
	    /* Check if subband has been fully allocated max bits */
	    if (min_ch < stereo) 
	    {
	     if (ba >= (1<<(*alloc)[min_sb][0].bits)-1) used[min_ch][min_sb] = 2;
	    } 
	    else if (min_ch < 7 || n_ml_ch == 0) /* Multichannel */ 
	    {
	     if (ba >= (1<<(*alloc_mc)[min_sb][0].bits)-1) used[min_ch][min_sb] = 2;
	    } 
	    else 
	    {
	     if (ba >= (1<<(*alloc_ml)[min_sb][0].bits)-1) used[min_ch][min_sb] = 2;
	    }
	}
	else used[min_ch][min_sb] = 2;  /* can't increase this alloc */

      }   /* end of if-loop if min_sb >-1 */
   } while(min_sb > -1);   /* until could find no channel */
   /* Calculate the number of bits left */

   ad -= bspl+bscf+bsel; 
   *adb = ad;
   for (i=sblimit;i<SBLIMIT;i++) for (k = 0; k < 2; k++) 
      bit_alloc[k][i]=0;
   for (i=sblimit_ml;i<SBLIMIT;i++) for (k = 7; k < 7+n_ml_ch; k++) 
      bit_alloc[k][i]=0;
}
 

void matri(double (*sbs_sample)[3][12][32], frame_params *fr_ps, double (*sb_sample)[3][12][32],
	 unsigned int (*scalar)[3][32], int sblimit, unsigned int (*scfsi)[32], 
	 unsigned int (*scfsi_dyn)[32], unsigned int (*bit_alloc)[32], 
	 unsigned int (*subband)[3][12][32])
{
  int i, j, k, l, ch1, ch2, m, n;
  
  layer *info = fr_ps->header;

	for(k = 0; k < 8; k++)
	{
          if(fr_ps->header->mc_pred[k] == 0)
	  {	
	    switch(fr_ps->header->tc_alloc[k])
	    {
		case 0: 
	 	    for( j = 0; j < 3; ++j)
			for(l = 0; l < 12; l ++)
			{
				sb_sample[0][j][l][k] = sb_sample[5][j][l][k] + sbs_sample[2][j][l][k] + sbs_sample[3][j][l][k];
				sb_sample[1][j][l][k] = sb_sample[6][j][l][k] + sbs_sample[2][j][l][k] + sbs_sample[4][j][l][k];
			}
			m = 0; n = 2;
			scale_factor_calc(scalar,sblimit, m, n, k, sb_sample);
		     break;
		case 1:
	 	    for( j = 0; j < 3; ++j)
			for(l = 0; l < 12; l ++)
			{
				sb_sample[0][j][l][k] = sbs_sample[5][j][l][k] + sb_sample[2][j][l][k] + sbs_sample[3][j][l][k];
			}
			
			m = 0; n = 1;
			scale_factor_calc(scalar,sblimit, m, n, k, sb_sample);
			trans_pattern(scalar, scfsi, fr_ps,scfsi_dyn);
			pre_quant(sbs_sample, m, n, sb_sample, scalar, bit_alloc, subband, fr_ps);

	 	    for( j = 0; j < 3; ++j)
			for(l = 0; l < 12; l ++)
			{
				sbs_sample[2][j][l][k] = sbs_sample[0][j][l][k] - sbs_sample[5][j][l][k] - sbs_sample[3][j][l][k];
				sb_sample[1][j][l][k] = sb_sample[6][j][l][k] + sbs_sample[2][j][l][k] + sbs_sample[4][j][l][k];
			}
			m = 1; n = 2;
			scale_factor_calc(scalar,sblimit, m, n, k, sb_sample);
			
		     break;
		case 2:
	 	    for( j = 0; j < 3; ++j)
			for(l = 0; l < 12; l ++)
			{
				sb_sample[1][j][l][k] = sbs_sample[6][j][l][k] + sb_sample[2][j][l][k] + sbs_sample[4][j][l][k];
			}
			
			m = 1; n = 2;
			scale_factor_calc(scalar,sblimit, m, n, k, sb_sample);
			trans_pattern(scalar, scfsi, fr_ps,scfsi_dyn);
			pre_quant(sbs_sample, m, n, sb_sample, scalar, bit_alloc, subband, fr_ps);

	 	    for( j = 0; j < 3; ++j)
			for(l = 0; l < 12; l ++)
			{
				sbs_sample[2][j][l][k] = sbs_sample[1][j][l][k] - sbs_sample[6][j][l][k] - sbs_sample[4][j][l][k];
				sb_sample[0][j][l][k] = sb_sample[5][j][l][k] + sbs_sample[2][j][l][k] + sbs_sample[3][j][l][k];
			}
			m = 0; n = 1;
			scale_factor_calc(scalar,sblimit, m, n, k, sb_sample);
			
		     break;
		case 3: 
	 	    for( j = 0; j < 3; ++j)
			for(l = 0; l < 12; l ++)
			{
				sb_sample[0][j][l][k] = sbs_sample[5][j][l][k] + sbs_sample[2][j][l][k] + sb_sample[3][j][l][k];
				sb_sample[1][j][l][k] = sb_sample[6][j][l][k] + sbs_sample[2][j][l][k] + sbs_sample[4][j][l][k];
			}
			m = 0; n = 2;
			scale_factor_calc(scalar,sblimit, m, n, k, sb_sample);
		     break;
		case 4: 
	 	    for( j = 0; j < 3; ++j)
			for(l = 0; l < 12; l ++)
			{
				sb_sample[0][j][l][k] = sb_sample[5][j][l][k] + sbs_sample[2][j][l][k] + sbs_sample[3][j][l][k];
				sb_sample[1][j][l][k] = sbs_sample[6][j][l][k] + sbs_sample[2][j][l][k] + sb_sample[4][j][l][k];
			}
			m = 0; n = 2;
			scale_factor_calc(scalar,sblimit, m, n, k, sb_sample);
		     break;
		case 5: 
	 	    for( j = 0; j < 3; ++j)
			for(l = 0; l < 12; l ++)
			{
				sb_sample[0][j][l][k] = sbs_sample[5][j][l][k] + sbs_sample[2][j][l][k] + sb_sample[3][j][l][k];
				sb_sample[1][j][l][k] = sbs_sample[6][j][l][k] + sbs_sample[2][j][l][k] + sb_sample[4][j][l][k];
			}
			m = 0; n = 2;
			scale_factor_calc(scalar,sblimit, m, n, k, sb_sample);
		     break;
		case 6:
	 	    for( j = 0; j < 3; ++j)
			for(l = 0; l < 12; l ++)
			{
				sb_sample[1][j][l][k] = sbs_sample[6][j][l][k] + sb_sample[2][j][l][k] + sbs_sample[4][j][l][k];
			}
			
			m = 1; n = 2;
			scale_factor_calc(scalar,sblimit, m, n, k, sb_sample);
			trans_pattern(scalar, scfsi, fr_ps,scfsi_dyn);
			pre_quant(sbs_sample, m, n, sb_sample, scalar, bit_alloc, subband, fr_ps);

	 	    for( j = 0; j < 3; ++j)
			for(l = 0; l < 12; l ++)
			{
				sbs_sample[2][j][l][k] = sbs_sample[1][j][l][k] - sbs_sample[6][j][l][k] - sbs_sample[4][j][l][k];
				sb_sample[0][j][l][k] = sbs_sample[5][j][l][k] + sbs_sample[2][j][l][k] + sb_sample[3][j][l][k];
			}
			m = 0; n = 1;
			scale_factor_calc(scalar,sblimit, m, n, k, sb_sample);
			
		     break;
		case 7:
	 	    for( j = 0; j < 3; ++j)
			for(l = 0; l < 12; l ++)
			{
				sb_sample[0][j][l][k] = sbs_sample[5][j][l][k] + sb_sample[2][j][l][k] + sbs_sample[3][j][l][k];
			}
			
			m = 0; n = 1;
			scale_factor_calc(scalar,sblimit, m, n, k, sb_sample);
			trans_pattern(scalar, scfsi, fr_ps,scfsi_dyn);
			pre_quant(sbs_sample, m, n, sb_sample, scalar, bit_alloc, subband, fr_ps);

	 	    for( j = 0; j < 3; ++j)
			for(l = 0; l < 12; l ++)
			{
				sbs_sample[2][j][l][k] = sbs_sample[0][j][l][k] - sbs_sample[5][j][l][k] - sbs_sample[3][j][l][k];
				sb_sample[1][j][l][k] = sbs_sample[6][j][l][k] + sbs_sample[2][j][l][k] + sb_sample[4][j][l][k];
			}
			m = 1; n = 2;
			scale_factor_calc(scalar,sblimit, m, n, k, sb_sample);
			
		     break;
	    }
	  }
	} 
	
	for(i = 8; i < 12; i++)
	{
          if(fr_ps->header->mc_pred[k] == 0)
	  {
	    switch(fr_ps->header->tc_alloc[i])
	    {
		case 0: 
	 	    for( j = 0; j < 3; ++j)
			for(l = 0; l < 12; l ++)
			    for( k = sb_groups[i-1] + 1; k <= sb_groups[i]; k++)
			    {
				sb_sample[0][j][l][k] = sb_sample[5][j][l][k] + sbs_sample[2][j][l][k] + sbs_sample[3][j][l][k];
				sb_sample[1][j][l][k] = sb_sample[6][j][l][k] + sbs_sample[2][j][l][k] + sbs_sample[4][j][l][k];
			    }
			 m = 0; n = 2;    
			 scale_factor_calc(scalar,sblimit, m, n, i, sb_sample);
		     break;
		case 1:
	 	    for( j = 0; j < 3; ++j)
			for(l = 0; l < 12; l ++)
			    for( k = sb_groups[i-1] + 1; k <= sb_groups[i]; k++)
			    {
				sb_sample[0][j][l][k] = sbs_sample[5][j][l][k] + sb_sample[2][j][l][k] + sbs_sample[3][j][l][k];
			    }
			
			m = 0; n = 1;
			scale_factor_calc(scalar,sblimit, m, n, i, sb_sample);
			trans_pattern(scalar, scfsi, fr_ps,scfsi_dyn);
			pre_quant(sbs_sample, m, n, sb_sample, scalar, bit_alloc, subband, fr_ps);

	 	    for( j = 0; j < 3; ++j)
			for(l = 0; l < 12; l ++)
			    for( k = sb_groups[i-1] + 1; k <= sb_groups[i]; k++)
			    {
				sbs_sample[2][j][l][k] = sbs_sample[0][j][l][k] - sbs_sample[5][j][l][k] - sbs_sample[3][j][l][k];
				sb_sample[1][j][l][k] = sb_sample[6][j][l][k] + sbs_sample[2][j][l][k] + sbs_sample[4][j][l][k];
			    }
			m = 1; n = 2;
			scale_factor_calc(scalar,sblimit, m, n, i, sb_sample);
		     break;
		case 2:
	 	    for( j = 0; j < 3; ++j)
			for(l = 0; l < 12; l ++)
			    for( k = sb_groups[i-1] + 1; k <= sb_groups[i]; k++)
			    {
				sb_sample[1][j][l][k] = sbs_sample[6][j][l][k] + sb_sample[2][j][l][k] + sbs_sample[4][j][l][k];
			    }
			
			m = 1; n = 2;
			scale_factor_calc(scalar,sblimit, m, n, i, sb_sample);
			trans_pattern(scalar, scfsi, fr_ps,scfsi_dyn);
			pre_quant(sbs_sample, m, n, sb_sample, scalar, bit_alloc, subband, fr_ps);

	 	    for( j = 0; j < 3; ++j)
			for(l = 0; l < 12; l ++)
			    for( k = sb_groups[i-1] + 1; k <= sb_groups[i]; k++)
			    {
				sbs_sample[2][j][l][k] = sbs_sample[1][j][l][k] - sbs_sample[6][j][l][k] - sbs_sample[4][j][l][k];
				sb_sample[0][j][l][k] = sb_sample[5][j][l][k] + sbs_sample[2][j][l][k] + sbs_sample[3][j][l][k];
			    }
			m = 0; n = 1;
			scale_factor_calc(scalar,sblimit, m, n, i, sb_sample);
			    
		     break;
		case 3: 
	 	    for( j = 0; j < 3; ++j)
			for(l = 0; l < 12; l ++)
			    for( k = sb_groups[i-1] + 1; k <= sb_groups[i]; k++)
			    {
				sb_sample[0][j][l][k] = sbs_sample[5][j][l][k] + sbs_sample[2][j][l][k] + sb_sample[3][j][l][k];
				sb_sample[1][j][l][k] = sb_sample[6][j][l][k] + sbs_sample[2][j][l][k] + sbs_sample[4][j][l][k];
			    }
			m = 0; n = 2;
			scale_factor_calc(scalar,sblimit, m, n, i, sb_sample);
		     break;
		case 4: 
	 	    for( j = 0; j < 3; ++j)
			for(l = 0; l < 12; l ++)
			    for( k = sb_groups[i-1] + 1; k <= sb_groups[i]; k++)
			    {
				sb_sample[0][j][l][k] = sb_sample[5][j][l][k] + sbs_sample[2][j][l][k] + sbs_sample[3][j][l][k];
				sb_sample[1][j][l][k] = sbs_sample[6][j][l][k] + sbs_sample[2][j][l][k] + sb_sample[4][j][l][k];
			    }
			m = 0; n = 2;
			scale_factor_calc(scalar,sblimit, m, n, i, sb_sample);
		     break;
		case 5: 
	 	    for( j = 0; j < 3; ++j)
			for(l = 0; l < 12; l ++)
			    for( k = sb_groups[i-1] + 1; k <= sb_groups[i]; k++)
			    {
				sb_sample[0][j][l][k] = sbs_sample[5][j][l][k] + sbs_sample[2][j][l][k] + sb_sample[3][j][l][k];
				sb_sample[1][j][l][k] = sbs_sample[6][j][l][k] + sbs_sample[2][j][l][k] + sb_sample[4][j][l][k];
			    }
			m = 0; n = 2;
			scale_factor_calc(scalar,sblimit, m, n, i, sb_sample);
		     break;
		case 6:
	 	    for( j = 0; j < 3; ++j)
			for(l = 0; l < 12; l ++)
			    for( k = sb_groups[i-1] + 1; k <= sb_groups[i]; k++)
			    {
				sb_sample[1][j][l][k] = sbs_sample[6][j][l][k] + sb_sample[2][j][l][k] + sbs_sample[4][j][l][k];
			    }
			
			m = 1; n = 2;
			scale_factor_calc(scalar,sblimit, m, n, i, sb_sample);
			trans_pattern(scalar, scfsi, fr_ps,scfsi_dyn);
			pre_quant(sbs_sample, m, n, sb_sample, scalar, bit_alloc, subband, fr_ps);

	 	    for( j = 0; j < 3; ++j)
			for(l = 0; l < 12; l ++)
			    for( k = sb_groups[i-1] + 1; k <= sb_groups[i]; k++)
			    {
				sbs_sample[2][j][l][k] = sbs_sample[1][j][l][k] - sbs_sample[6][j][l][k] - sbs_sample[4][j][l][k];
				sb_sample[0][j][l][k] = sbs_sample[5][j][l][k] + sbs_sample[2][j][l][k] + sb_sample[3][j][l][k];
			    }
			m = 0; n = 1;
			scale_factor_calc(scalar,sblimit, m, n, i, sb_sample);
			
		     break;
		case 7:
	 	    for( j = 0; j < 3; ++j)
			for(l = 0; l < 12; l ++)
			    for( k = sb_groups[i-1] + 1; k <= sb_groups[i]; k++)
			    {
				sb_sample[0][j][l][k] = sbs_sample[5][j][l][k] + sb_sample[2][j][l][k] + sbs_sample[3][j][l][k];
			    }