l3loop.c

mp3文件格式与wav文件格式的音频文件转换工具

    int sfb, start, end, i;
    int condition = 0;
    double temp, log2 = log( 2.0 );
    gr_info *cod_info = &l3_side->gr[gr].ch[ch].tt;

    xrmax[gr][ch] = xr_max( xr, 0, 576 );
    scfsi_set = 0;

    /* the total energy of the granule */    
    for ( temp = 0.0, i = 0; i < 576; i++ )
        temp += xr[i] * xr[i];
    if ( temp == 0.0 )
        en_tot[gr][ch] = 0.0;
    else
        en_tot[gr][ch] = log( temp ) / log2 ;

/* the energy of each scalefactor band, en */
/* the allowed distortion of each scalefactor band, xm */

    if(cod_info->window_switching_flag == 0 || cod_info->block_type!=2)
        for(sfb=0;sfb<21;sfb++)
        {
            start = scalefac_band_long[ sfb ];
            end   = scalefac_band_long[ sfb+1 ];

            for ( temp = 0.0, i = start; i < end; i++ )
                temp += xr[i] * xr[i];
            if ( temp == 0.0 )
                en[gr][ch][sfb] = 0.0;
            else
                en[gr][ch][sfb] = log( temp )/ log2;

            if ( l3_xmin->l[gr][ch][sfb] == 0.0 )
                xm[gr][ch][sfb] = 0.0;
            else
                xm[gr][ch][sfb] = log( l3_xmin->l[gr][ch][sfb] ) / log2;
        }
    if(gr==1)
    {
        int gr2, tp;

        for(gr2=0;gr2<2;gr2++)
        {
/* The spectral values are not all zero */
            if(xrmax[ch][gr2]!=0.0)
                condition++;
/* None of the granules contains short blocks */
            if((cod_info->window_switching_flag==0) || (cod_info->block_type!=2))
                condition++;
        }
        if(abs(en_tot[0]-en_tot[1])<en_tot_krit) condition++;
        for(tp=0,sfb=0;sfb<21;sfb++) 
            tp += abs(en[ch][0][sfb]-en[ch][1][sfb]);
        if (tp<en_dif_krit) 
            condition++;

        if(condition==6)
        {
            for(scfsi_band=0;scfsi_band<4;scfsi_band++)
            {
                int sum0 = 0, sum1 = 0;
                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 */
}




int part2_length(L3_scalefac_t *scalefac, 
                 int gr, int ch, 
                 L3_side_info_t *si)
/***************************************************************************/ 
/* calculates the number of bits needed to encode the scalefacs in the     */
/* main data block                                                         */
/***************************************************************************/ 
{
    int slen1, slen2, bits, partition;
    gr_info *gi = &si->gr[gr].ch[ch].tt;

    bits = 0;
    if(config.mpeg.type==TYPE_MPEG_I)
    {
	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 };

	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 += (6 * slen1);  This is wrong SS 19-12-96 */
		bits += (5 * slen1);

	    if ( (gr == 0) || (si->scfsi[ch][2] == 0) )
		/*  bits += (6 * slen1);   This is wrong SS 19-12-96 */
		bits += (5 * slen2);

	    if ( (gr == 0) || (si->scfsi[ch][3] == 0) )
		/* bits += (6 * slen1);   This is wrong SS 19-12-96 */
		bits += (5 * slen2);
	}
    }
    else
    {   /* MPEG 2 */
	if(!gi->sfb_partition_table) ERROR("(!gi->sfb_partition_table)");
	for ( partition = 0; partition < 4; partition++ )
	    bits += gi->slen[partition] * gi->sfb_partition_table[partition];
    }
    return bits;
}





int scale_bitcount(L3_scalefac_t *scalefac, 
                   gr_info *cod_info,
		   int gr, int ch )
/*************************************************************************/
/* Also calculates the number of bits necessary to code the scalefactors. */
/*************************************************************************/
{
    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;
}



void calc_noise(double xr[576], 
                int ix[576], 
                gr_info *cod_info,
	            double xfsf[4][CBLIMIT] )
/*************************************************************************/
/*   Function: Calculate the distortion introduced by the quantization   */
/*   in each scale factor band.                                          */
/*************************************************************************/
{
    int start, end, sfb, l, i;
    double sum,step,bw;
    double (*xr_s)[192][3]; /*D192_3 *xr_s;*/
    int    (*ix_s)[192][3]; /*I192_3 *ix_s;*/

    xr_s = (double (*)[192][3]) xr;
    ix_s = (int    (*)[192][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;
            if(ix[l]<PRECALC_SIZE)
                temp = fabs(xr[l]) - pow43[ix[l]] * step;
            else
            {
               temp = fabs(xr[l]) - pow((double)ix[l],4.0/3.0)*step;
                printf("EHHHHHHH !?!?! ---> %d\n",ix[l]);
            }
            sum += temp * temp; 
        }
        xfsf[0][sfb] = sum / bw;
    }

    for ( i = 0; i < 3; i++ )
    {
        step = pow( 2.0, (cod_info->quantizerStepSize) * 0.25 ); /* subblock_gain ? */
        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;
                if((*ix_s)[l][i]<PRECALC_SIZE)
                    temp = fabs((*xr_s)[l][i]) - pow43[(*ix_s)[l][i]] * step;
                else
                {
                    temp = fabs((*xr_s)[l][i]) - pow((double)(*ix_s)[l][i],4.0/3.0)*step;
                    printf("EHHHHHHH !?!?! ---> %d\n",(*ix_s)[l][i]);
                }
                sum += temp * temp;
            }       
            xfsf[i+1][sfb] = sum / bw;
        }
    }
}





void calc_xmin(double xr[2][2][576], 
               L3_psy_ratio_t *ratio,
	       gr_info *cod_info, 
               L3_psy_xmin_t *l3_xmin,
	       int gr, int ch )
/*************************************************************************/
/*  Calculate the allowed distortion for each scalefactor band,          */
/*  as determined by the psychoacoustic model.                           */
/*  xmin(sb) = ratio(sb) * en(sb) / bw(sb)                               */
/*************************************************************************/
{
    int start, end, sfb, l, b;
    double en, bw;

    double (*xr_s)[192][3]; /*D192_3 *xr_s;*/

    xr_s = (double (*)[192][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;
    }
}



int loop_break(L3_scalefac_t *scalefac, 
               gr_info *cod_info,
	       int gr, int ch)
/*************************************************************************/
/*  Function: Returns zero if there is a scalefac which has not been     */
/*   amplified. Otherwise it returns one.                                */
/*************************************************************************/
{
    int i, sfb, temp = 1;

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

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





void preemphasis(double xr[576], 
                 double xfsf[4][CBLIMIT],
       	         L3_psy_xmin_t  *l3_xmin,
	         int gr, int ch, 
                 L3_side_info_t *l3_side )
/*************************************************************************/
/*  See ISO 11172-3  section  C.1.5.4.3.4                                */
/*************************************************************************/
{
    int i, sfb, start, end, scfsi_band, over;
    double ifqstep;
    gr_info *cod_info = &l3_side->gr[gr].ch[ch].tt;

    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 ) ? SQRT2
		: 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 ];
		for( i = start; i < end; i++ )
		    xr[i] *= pow( ifqstep, (double) pretab[sfb] );
	    }
	}
    }
}




int amp_scalefac_bands(double xr[576], 
                       double xfsf[4][CBLIMIT],
		       L3_psy_xmin_t    *l3_xmin, 
                       L3_side_info_t *l3_side,
	               L3_scalefac_t  *scalefac,
		       int gr, int ch, int iteration )
/*************************************************************************/
/*  Amplify the scalefactor bands that violate the masking threshold.    */
/*  See ISO 11172-3 Section C.1.5.4.3.5                                  */
/*************************************************************************/
{