loop.c

功能非常完善的MP3编译码器,输入文件WAV或AIFF,能够方便的嵌入到你自己的系统当中.

                l3_side->scfsi[ch][scfsi_band] = 0;
                start = scfsi_band_long[scfsi_band];
                end   = scfsi_band_long[scfsi_band+1];
                for ( sfb = start; sfb < end; sfb++ )
                { 
                    sum0 += abs( en[ch][0][sfb] - en[ch][1][sfb] );
                    sum1 += abs( xm[ch][0][sfb] - xm[ch][1][sfb] );
                }

                if ( sum0 < en_scfsi_band_krit && sum1 < xm_scfsi_band_krit )
		{
                    l3_side->scfsi[ch][scfsi_band] = 1;
		    scfsi_set |= (1 << scfsi_band);
		}
                else
                    l3_side->scfsi[ch][scfsi_band] = 0;
            } /* for scfsi_band */
        } /* if condition == 6 */
        else
            for ( scfsi_band = 0; scfsi_band < 4; scfsi_band++ )
                l3_side->scfsi[ch][scfsi_band] = 0;
    } /* if gr == 1 */
}



/***************************************************************************/ 
/*        part2_length                                                     */ 
/***************************************************************************/ 

/* calculates the number of bits needed to encode the scalefacs in the     */
/* main data block                                                         */

int part2_length( III_scalefac_t *scalefac, frame_params *fr_ps,
	      int gr, int ch, III_side_info_t *si )
{
  int slen1, slen2, bits;
  gr_info *gi = &si->gr[gr].ch[ch].tt;


	static int slen1_tab[16] = { 0, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4 };
	static int slen2_tab[16] = { 0, 1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 2, 3 };

  bits = 0;


	slen1 = slen1_tab[ gi->scalefac_compress ];
	slen2 = slen2_tab[ gi->scalefac_compress ];

	if ( (gi->window_switching_flag == 1) && (gi->block_type == 2) )
	{
	  if ( gi->mixed_block_flag )
	  {
			bits += (8 * slen1) + (9 * slen1) + (18 * slen2);
	  }
	  else
	  {
			bits += (18 * slen1) + (18 * slen2);
	  }
	}
	else
	{
	  if ( (gr == 0) || (si->scfsi[ch][0] == 0) )
			bits += (6 * slen1);

	  if ( (gr == 0) || (si->scfsi[ch][1] == 0) )
			bits += (5 * slen1);

	  if ( (gr == 0) || (si->scfsi[ch][2] == 0) )
			bits += (5 * slen2);

	  if ( (gr == 0) || (si->scfsi[ch][3] == 0) )
			bits += (5 * slen2);
	}
    return bits;
}



/*************************************************************************/
/*            scale_bitcount                                             */
/*************************************************************************/


/* Also calculates the number of bits necessary to code the scalefactors. */

int scale_bitcount( III_scalefac_t *scalefac, gr_info *cod_info,
		int gr, int ch )
{
    int i, k, sfb, max_slen1 = 0, max_slen2 = 0, /*a, b, */ ep = 2;


    static int slen1[16] = { 0, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4 };
    static int slen2[16] = { 0, 1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 2, 3 };
    static int pow2[5]   = { 1, 2, 4, 8, 16 };

    if ( cod_info->window_switching_flag != 0 && cod_info->block_type == 2 )
    {
        if ( cod_info->mixed_block_flag == 0 ) 
        {
            /* a = 18; b = 18;  */
            for ( i = 0; i < 3; i++ )
            {
                for ( sfb = 0; sfb < 6; sfb++ )
                    if ( scalefac->s[gr][ch][sfb][i] > max_slen1 )
                        max_slen1 = scalefac->s[gr][ch][sfb][i];
                for (sfb = 6; sfb < 12; sfb++ )
                    if ( scalefac->s[gr][ch][sfb][i] > max_slen2 )
                        max_slen2 = scalefac->s[gr][ch][sfb][i];
            }
        }
        else
        {/* mixed_block_flag = 1 */
            /* a = 17; b = 18;  */
            for ( sfb = 0; sfb < 8; sfb++ )
                if ( scalefac->l[gr][ch][sfb] > max_slen1 )
                    max_slen1 = scalefac->l[gr][ch][sfb];
            for ( i = 0; i < 3; i++ )
            {
                for ( sfb = 3; sfb < 6; sfb++ )
                    if ( scalefac->s[gr][ch][sfb][i] > max_slen1 )
                        max_slen1 = scalefac->s[gr][ch][sfb][i];
                for ( sfb = 6; sfb < 12; sfb++ )
                    if ( scalefac->s[gr][ch][sfb][i] > max_slen2 )
                        max_slen2 = scalefac->s[gr][ch][sfb][i];
            }
        }

    }
    else
    { /* block_type == 1,2,or 3 */
        /* a = 11; b = 10;   */
        for ( sfb = 0; sfb < 11; sfb++ )
            if ( scalefac->l[gr][ch][sfb] > max_slen1 )
                max_slen1 = scalefac->l[gr][ch][sfb];
        for ( sfb = 11; sfb < 21; sfb++ )
            if ( scalefac->l[gr][ch][sfb] > max_slen2 )
                max_slen2 = scalefac->l[gr][ch][sfb];
    }

    for ( k = 0; k < 16; k++ )
    {
        if ( (max_slen1 < pow2[slen1[k]]) && (max_slen2 < pow2[slen2[k]]) )
        { 
            ep = 0;
            break;
        } 
    }

    if ( ep == 0 )
        cod_info->scalefac_compress = k;
    return ep;
}


double	noisePowTab[8191+15];


void	genNoisePowTab( void )
{
	int	i;

	for( i = 0 ; i < 8191+15 ; i++ )
		noisePowTab[i] = pow( i, 4.0/3.0 );
}


/*************************************************************************/
/*            calc_noise                                                 */
/*************************************************************************/

/*   Function: Calculate the distortion introduced by the quantization   */
/*   in each scale factor band.                                          */

void calc_noise( double xr[576], int ix[576], gr_info *cod_info,
	    double xfsf[4][CBLIMIT] )
{
  int start, end, l, i;
	unsigned int sfb;
  double sum,step,bw;

  D192_3 *xr_s;
  I192_3 *ix_s;

  xr_s = (D192_3 *) xr;
  ix_s = (I192_3 *) ix;

  step = pow( 2.0, (cod_info->quantizerStepSize) * 0.25 );
  for ( sfb = 0; sfb < cod_info->sfb_lmax; sfb++ )
  {
    start = scalefac_band_long[ sfb ];
    end   = scalefac_band_long[ sfb+1 ];
		bw = end - start;

    for ( sum = 0.0, l = start; l < end; l++ )
    {
      double temp;
      temp = fabs( xr[l] ) - noisePowTab[ix[l]] * step;
      sum += temp * temp; 
    }
    xfsf[0][sfb] = sum / bw;
  }

  for ( i = 0; i < 3; i++ )
  {
    for ( sfb = cod_info->sfb_smax; sfb < 12; sfb++ )
    {
      start = scalefac_band_short[ sfb ];
      end   = scalefac_band_short[ sfb+1 ];
			bw = end - start;
      
      for ( sum = 0.0, l = start; l < end; l++ )
      {
        double temp;
        temp = fabs( (*xr_s)[l][i] ) - noisePowTab[(*ix_s)[l][i]] * step;
        sum += temp * temp;
      }       
      xfsf[i+1][sfb] = sum / bw;
    }
  }
}




/*************************************************************************/
/*            calc_xmin                                                  */
/*************************************************************************/

/*
  Calculate the allowed distortion for each scalefactor band,
  as determined by the psychoacoustic model.
  xmin(sb) = ratio(sb) * en(sb) / bw(sb)
*/

void calc_xmin( double xr[2][2][576], III_psy_ratio *ratio,
	   gr_info *cod_info, III_psy_xmin *l3_xmin,
	   int gr, int ch )
{
    int start, end, l, b;
		uint sfb;
    double en, bw;

    D192_3 *xr_s;

    xr_s = (D192_3 *) xr[gr][ch] ;

    for ( sfb = cod_info->sfb_smax; sfb < SFB_SMAX - 1; sfb++ )
    {
        start = scalefac_band_short[ sfb ];
        end   = scalefac_band_short[ sfb + 1 ];
	bw = end - start;
        for ( b = 0; b < 3; b++ )
        {
            for ( en = 0.0, l = start; l < end; l++ )
                en += (*xr_s)[l][b] * (*xr_s)[l][b];
            l3_xmin->s[gr][ch][sfb][b] = ratio->s[gr][ch][sfb][b] * en / bw;
        }
    }

    for ( sfb = 0; sfb < cod_info->sfb_lmax; sfb++ )
    {
        start = scalefac_band_long[ sfb ];
        end   = scalefac_band_long[ sfb+1 ];
	bw = end - start;

        for ( en = 0.0, l = start; l < end; l++ )
            en += xr[gr][ch][l] * xr[gr][ch][l];
        l3_xmin->l[gr][ch][sfb] = ratio->l[gr][ch][sfb] * en / bw;
    }
}



/*************************************************************************/
/*            loop_break                                                 */
/*************************************************************************/

/*  Function: Returns zero if there is a scalefac which has not been
    amplified. Otherwise it returns one. 
*/

int loop_break( III_scalefac_t *scalefac, gr_info *cod_info,
	    int gr, int ch )
{
    uint i, sfb;

    for ( sfb = 0; sfb < cod_info->sfb_lmax; sfb++ )
        if ( scalefac->l[gr][ch][sfb] == 0 )
            return 0;

    for ( sfb = cod_info->sfb_smax; sfb < 12; sfb++ )
        for ( i = 0; i < 3; i++ )
            if ( scalefac->s[gr][ch][sfb][i] == 0 )
                return 0;
    return 1;
}



/*************************************************************************/
/*            preemphasis                                                */
/*************************************************************************/

/*
  See ISO 11172-3  section  C.1.5.4.3.4
*/

void preemphasis( double xr[576], double xfsf[4][CBLIMIT],
	     III_psy_xmin  *l3_xmin,
	     int gr, int ch, III_side_info_t *l3_side )
{
  int i, start, end, scfsi_band, over;
	uint sfb;
  double ifqstep;
  gr_info *cod_info = &l3_side->gr[gr].ch[ch].tt;
	double	mulval;

  if ( gr == 1 )
  {
		/*
			If the second granule is being coded and scfsi is active in
			at least one scfsi_band, the preemphasis in the second granule
			is set equal to the setting in the first granule
		*/
		for ( scfsi_band = 0; scfsi_band < 4; scfsi_band++ )
			if ( l3_side->scfsi[ch][scfsi_band] )
			{
				cod_info->preflag = l3_side->gr[0].ch[ch].tt.preflag;
				return;
			}

  }

  /*
    Preemphasis is switched on if in all the upper four scalefactor
    bands the actual distortion exceeds the threshold after the
    first call of the inner loop
  */
  if ( cod_info->block_type != 2 && cod_info->preflag == 0 )
  {	
		over = 0;
		for ( sfb = 17; sfb < 21; sfb++ )
			if ( xfsf[0][sfb] > l3_xmin->l[gr][ch][sfb] )
				over++;

		if (over == 4 )
		{
			cod_info->preflag = 1;
			ifqstep = ( cod_info->scalefac_scale == 0 ) ? sqrt(2.)
	:		pow( 2.0, (0.5 * (1.0 + (double) cod_info->scalefac_scale)) );

			for ( sfb = 0; sfb < cod_info->sfb_lmax; sfb++ )
			{
				l3_xmin->l[gr][ch][sfb] *= pow( ifqstep, 2.0 * (double) pretab[sfb] );
				start = scalefac_band_long[ sfb ];
				end   = scalefac_band_long[ sfb+1 ];

				mulval = pow( ifqstep, (double) pretab[sfb] );
				for( i = start; i < end; i++ )
					xr[i] *= mulval;
			}
		}
  }
}


/*************************************************************************/
/*            amp_scalefac_bands                                         */
/*************************************************************************/

/* 
  Amplify the scalefactor bands that violate the masking threshold.
  See ISO 11172-3 Section C.1.5.4.3.5
*/

int amp_scalefac_bands( double xr[576], double xfsf[4][CBLIMIT],
		    III_psy_xmin *l3_xmin, III_side_info_t *l3_side,
		    III_scalefac_t *scalefac,
		    int gr, int ch, int iteration )
{
  int start, end, l, i, scfsi_band, over = 0;
	uint sfb;
  double ifqstep, ifqstep2;
  D192_3 *xr_s;
  gr_info *cod_info, *gr0;
  int copySF, preventSF;
  cod_info = &l3_side->gr[gr].ch[ch].tt;
  gr0      = &l3_side->gr[0].ch[ch].tt;


  xr_s = (D192_3 *) xr;
  copySF = 0;
  preventSF = 0;

  if ( cod_info->scalefac_scale == 0 )
		ifqstep = 1.414213562;							/* sqrt( 2.0 ); */
  else
		ifqstep = pow( 2.0, 0.5 * (1.0 + (double) cod_info->scalefac_scale) );

  if ( gr == 1 )
  {
		for ( scfsi_band = 0; scfsi_band < 4; scfsi_band++ )
	    if ( l3_side->scfsi[ch][scfsi_band] )
	    {
				if ( gr0->scalefac_scale == 0 )

					ifqstep = 1.414213562;				/* sqrt( 2.0 ); */
				else
					ifqstep = pow( 2.0, 0.5 * (1.0 + (double) gr0->scalefac_scale) );

				if ( iteration == 1 )
					copySF = 1;
				else
			    preventSF = 1;
				break;
	    }
	
  }

  ifqstep2 = ifqstep * ifqstep;
  scfsi_band = 0;
    
  for ( sfb = 0; sfb < cod_info->sfb_lmax; sfb++ )
  {
		if ( copySF || preventSF )
		{
	    if ( (int) sfb == scfsi_band_long[scfsi_band + 1] )
				scfsi_band += 1;
	    if ( l3_side->scfsi[ch][scfsi_band] )
	    {
				if ( copySF )
		    scalefac->l[gr][ch][sfb] = scalefac->l[0][ch][sfb];
				continue;
	    }
		}	    
		if ( xfsf[0][sfb] > l3_xmin->l[gr][ch][sfb] )
		{
	    over++;
	    l3_xmin->l[gr][ch][sfb] *= ifqstep2;
	    scalefac->l[gr][ch][sfb]++;
	    start = scalefac_band_long[sfb];
	    end   = scalefac_band_long[sfb+1];
	    for ( l = start; l < end; l++ )
				xr[l] *= ifqstep;
		}
  }

  for ( i = 0; i < 3; i++ )
    for ( sfb = cod_info->sfb_smax; sfb < 12; sfb++ )
      if ( xfsf[i+1][sfb] > l3_xmin->s[gr][ch][sfb][i] )
      {
        over++;
        l3_xmin->s[gr][ch][sfb][i] *= ifqstep2;
        scalefac->s[gr][ch][sfb][i]++;
        start = scalefac_band_short[sfb];
        end   = scalefac_band_short[sfb+1];
        for ( l = start; l < end; l++ )
            (*xr_s)[l][i] *= ifqstep;
      }
  return over;
}




/*************************************************************************/
/*            quantize                                                   */
/*************************************************************************/

/*
  Function: Quantization of the vector xr ( -> ix)
*/




extern	float bladeTable[];


/*____ bladTabValue() _________________________________________________________*/

int INLINE bladTabValue( float in )
{
	int	* pTabEntry;
	int			i;
	int			retVal = 0;
	int			in2;



	pTabEntry = (int *) bladeTable;
	in2 = * ((int *) &in);

	if( in2 >= pTabEntry[5] )
	{

		if( in >= 165102.593750 )
		{
			i = nint( pow( in, 0.75) - 0.0946 );
			if( i > 8192 )
			{
				tjBitOverflow1 = TRUE;

				if( i > 8191 + 14 )
					tjBitOverflow2 = TRUE;
			}		
			return	i;
		}


		if( in2 >= * pTabEntry++ )
		{