shithub: aacenc

Download patch

ref: c00c2e541fcdc34f8a015bf9da28f04911fa9483
parent: 15eebf2ac836c134507c6e5c42979d44c1cfdd7c
author: menno <menno>
date: Mon Sep 25 13:39:46 EDT 2000 

Added VBR quantizer (but not working yet)


--- a/enc_tf.c
+++ b/enc_tf.c
@@ -193,35 +193,6 @@
 }
 
 
-#define NZEROS 10
-#define NPOLES 10
-#define GAIN   1.769346444e+01
-
-static float xv1[NZEROS+1], yv1[NPOLES+1];
-static float xv2[NZEROS+1], yv2[NPOLES+1];
-
-static double filter(double in, int ch)
-  {
-	float *xv, *yv;
-	if (ch == 0) { xv = xv1; yv = yv1; }
-	else {xv = xv2; yv = yv2; }
-      { xv[0] = xv[1]; xv[1] = xv[2]; xv[2] = xv[3]; xv[3] = xv[4]; xv[4] = xv[5]; xv[5] = xv[6]; xv[6] = xv[7]; xv[7] = xv[8]; xv[8] = xv[9]; xv[9] = xv[10]; 
-        xv[10] = in / GAIN;
-        yv[0] = yv[1]; yv[1] = yv[2]; yv[2] = yv[3]; yv[3] = yv[4]; yv[4] = yv[5]; yv[5] = yv[6]; yv[6] = yv[7]; yv[7] = yv[8]; yv[8] = yv[9]; yv[9] = yv[10]; 
-        yv[10] =   (xv[0] + xv[10]) + 10 * (xv[1] + xv[9]) + 45 * (xv[2] + xv[8])
-                     + 120 * (xv[3] + xv[7]) + 210 * (xv[4] + xv[6]) + 252 * xv[5]
-                     + ( -0.0031942899 * yv[0]) + ( -0.0495126652 * yv[1])
-                     + ( -0.3523340657 * yv[2]) + ( -1.5191103652 * yv[3])
-                     + ( -4.4065847179 * yv[4]) + ( -9.0160440949 * yv[5])
-                     + (-13.2344234780 * yv[6]) + (-13.8407183240 * yv[7])
-                     + ( -9.9529291465 * yv[8]) + ( -4.4996258124 * yv[9]);
-        return yv[10];
-      }
-}
-
-
-
-
 
 /*******************************************************************************
  ***
--- a/quant.c
+++ b/quant.c
@@ -396,9 +396,9 @@
 	double invQuantFac;
 	double linediff, noise;
 
-	*over_noise = 0.0;
-	*tot_noise = 0.0;
-	*max_noise = -999.0;
+	*over_noise = 1;
+	*tot_noise = 1;
+	*max_noise = 1E-20;
 
 	if (quantInfo->block_type!=ONLY_SHORT_WINDOW)
 		PulseDecoder(quantInfo, quant);
@@ -492,8 +492,7 @@
 
 int count_bits(AACQuantInfo* quantInfo,
 			   int quant[NUM_COEFF]
-//			   ,int output_book_vector[SFB_NUM_MAX*2]
-                        )
+			   )
 {
 	int i, bits = 0;
 
@@ -998,184 +997,333 @@
 	return 0;
 }
 
-#if 0
 
+#if 0 // VBR quantizer not finished yet
+
+#if (defined(__GNUC__) && defined(__i386__))
+#define USE_GNUC_ASM
+#endif
+#ifdef _MSC_VER
+#define USE_MSC_ASM
+#endif
+
+/*********************************************************************
+ * XRPOW_FTOI is a macro to convert floats to ints.  
+ * if XRPOW_FTOI(x) = nearest_int(x), then QUANTFAC(x)=adj43asm[x]
+ *                                         ROUNDFAC= -0.0946
+ *
+ * if XRPOW_FTOI(x) = floor(x), then QUANTFAC(x)=asj43[x]   
+ *                                   ROUNDFAC=0.4054
+ *********************************************************************/
+#ifdef USE_GNUC_ASM
+#  define ROUNDFAC -0.0946
+#elif defined (USE_MSC_ASM)
+#  define ROUNDFAC -0.0946
+#else
+#  define ROUNDFAC 0.4054
+#endif
+
+
+
+int compute_scalefacs(AACQuantInfo* quantInfo,
+					  int sf[SFB_NUM_MAX],
+					  int scalefac[SFB_NUM_MAX])
+{
+	int sfb;
+	int maxover;
+	int ifqstep = 2;
+	
+
+//	if (cod_info->preflag)
+//		for ( sfb = 11; sfb < SBPSY_l; sfb++ ) 
+//			sf[sfb] += pretab[sfb]*ifqstep;
+
+
+	maxover = 0;
+	for (sfb = 0; sfb < quantInfo->nr_of_sfb; sfb++) {
+
+		if (sf[sfb]<0) {
+			/* ifqstep*scalefac >= -sf[sfb], so round UP */
+			scalefac[sfb]=-sf[sfb]/ifqstep  + (-sf[sfb] % ifqstep != 0);
+			if (scalefac[sfb] > /*max_range[sfb]*/10) scalefac[sfb]=10/*max_range[sfb]*/;
+			
+			/* sf[sfb] should now be positive: */
+			if (  -(sf[sfb] + scalefac[sfb]*ifqstep)  > maxover) {
+				maxover = -(sf[sfb] + scalefac[sfb]*ifqstep);
+			}
+		}
+	}
+
+	return maxover;
+}
+  
+  
+
+double calc_sfb_noise_ave(double *xr, double *xr34, int bw,int sf)
+{
+	int j;
+	double xfsf=0, xfsf_p1=0, xfsf_m1=0;
+	double sfpow34,sfpow34_p1,sfpow34_m1;
+	double sfpow,sfpow_p1,sfpow_m1;
+
+	sfpow = pow(2.0,((double)sf)*.25);
+	sfpow34  = pow(2.0,-((double)sf)*.1875);
+
+	sfpow_m1 = sfpow*.8408964153;
+	sfpow34_m1 = sfpow34*1.13878863476;
+
+	sfpow_p1 = sfpow*1.189207115;  
+	sfpow34_p1 = sfpow34*0.878126080187;
+
+	for ( j=0; j < bw ; j++) {
+		int ix;
+		double temp,temp_p1,temp_m1;
+
+		if (xr34[j]*sfpow34_m1 > 8191) return -1;
+
+		temp = xr34[j]*sfpow34;
+		XRPOW_FTOI(temp, ix);
+		XRPOW_FTOI(temp + QUANTFAC(ix), ix);
+		temp = fabs(xr[j])- pow_quant[ix]*sfpow;
+		temp *= temp;
+
+		temp_p1 = xr34[j]*sfpow34_p1;
+		XRPOW_FTOI(temp_p1, ix);
+		XRPOW_FTOI(temp_p1 + QUANTFAC(ix), ix);
+		temp_p1 = fabs(xr[j])- pow_quant[ix]*sfpow_p1;
+		temp_p1 *= temp_p1;
+		
+		temp_m1 = xr34[j]*sfpow34_m1;
+		XRPOW_FTOI(temp_m1, ix);
+		XRPOW_FTOI(temp_m1 + QUANTFAC(ix), ix);
+		temp_m1 = fabs(xr[j])- pow_quant[ix]*sfpow_m1;
+		temp_m1 *= temp_m1;
+
+		xfsf += temp;
+		xfsf_p1 += temp_p1;
+		xfsf_m1 += temp_m1;
+	}
+	if (xfsf_p1>xfsf) xfsf = xfsf_p1;
+	if (xfsf_m1>xfsf) xfsf = xfsf_m1;
+	return xfsf/bw;
+}
+
+int find_scalefac(double *xr,double *xr34,int sfb,
+				  double l3_xmin,int bw)
+{
+	double xfsf;
+	int i,sf,sf_ok,delsf;
+
+	/* search will range from sf:  -209 -> 45  */
+	sf = -82;
+	delsf = 128;
+
+	sf_ok=10000;
+	for (i=0; i<7; i++) {
+		delsf /= 2;
+		xfsf = calc_sfb_noise_ave(xr,xr34,bw,sf);
+
+		if (xfsf < 0) {
+			/* scalefactors too small */
+			sf += delsf;
+		}else{
+			if (sf_ok==10000) sf_ok=sf;  
+			if (xfsf > l3_xmin)  {
+				/* distortion.  try a smaller scalefactor */
+				sf -= delsf;
+			}else{
+				sf_ok = sf;
+				sf += delsf;
+			}
+		}
+	} 
+//	assert(sf_ok!=10000);
+
+	return sf;
+}
+
 int
-VBR_noise_shaping(lame_global_flags *gfp,
-				  double xr[576], III_psy_ratio *ratio,
-				  int l3_enc[2][2][576], int *ath_over, int minbits, int maxbits,
-				  III_scalefac_t scalefac[2][2],
-				  int gr,int ch)
+VBR_quantize_granule(AACQuantInfo* quantInfo,
+					 double *pow_spectrum,
+					 int quant[1024]
+					 )
 {
-	lame_internal_flags *gfc=gfp->internal_flags;
-	int       start,end,bw,sfb,l, i, vbrmax;
-	III_scalefac_t vbrsf;
-	III_scalefac_t save_sf;
-	int maxover0,maxover1,maxover0p,maxover1p,maxover,mover;
+	quantize(quantInfo, pow_spectrum, quant);
+
+	return count_bits(quantInfo, quant);
+}
+
+int
+VBR_noise_shaping(AACQuantInfo* quantInfo,
+				  double xr[1024],
+				  double xr34orig[1024],
+				  double allowed_dist[SFB_NUM_MAX],
+				  int quant[1024], int minbits, int maxbits,
+				  int scalefac[SFB_NUM_MAX])
+{
+	int start,end,bw,sfb,l, vbrmax;
+	int bits_used;
+	int vbrsf[SFB_NUM_MAX];
+	int save_sf[SFB_NUM_MAX];
+	int maxover0,maxover1,maxover,mover;
 	int ifqstep;
-	III_psy_xmin l3_xmin;
-	III_side_info_t * l3_side;
-	gr_info *cod_info;  
-	double xr34[576];
-	int shortblock;
-	int global_gain_adjust=0;
+	double xr34[1024];
 
-	l3_side = &gfc->l3_side;
-	cod_info = &l3_side->gr[gr].ch[ch].tt;
-	shortblock = (cod_info->block_type == SHORT_TYPE);
-	*ath_over = calc_xmin( gfp,xr, ratio, cod_info, &l3_xmin);
+	
+//	for(i=0;i<1024;i++) {
+//		double temp=fabs(xr[i]);
+//		xr34[i]=sqrt(sqrt(temp)*temp);
+//	}
+	memcpy(xr34, xr34orig, sizeof(xr34));
 
 	
-	for(i=0;i<576;i++) {
-		double temp=fabs(xr[i]);
-		xr34[i]=sqrt(sqrt(temp)*temp);
-	}
-	
-	
 	vbrmax=-10000;
 	
-	int sflist[3]={-10000,-10000,-10000};
-	for ( sfb = 0; sfb < SBPSY_l; sfb++ )   {
-		start = gfc->scalefac_band.l[ sfb ];
-		end   = gfc->scalefac_band.l[ sfb+1 ];
+	for ( sfb = 0; sfb < quantInfo->nr_of_sfb; sfb++ )   {
+		start = quantInfo->sfb_offset[sfb];
+		end   = quantInfo->sfb_offset[sfb+1];
 		bw = end - start;
-		vbrsf.l[sfb] = find_scalefac(&xr[start],&xr34[start],1,sfb,
-			l3_xmin.l[sfb],bw);
-		if (vbrsf.l[sfb]>vbrmax) vbrmax = vbrsf.l[sfb];
+		vbrsf[sfb] = find_scalefac(&xr[start],&xr34[start],sfb,
+			allowed_dist[sfb],bw);
+	}
 
-		/* code to find the 3 largest (counting duplicates) contributed
-		* by Microsoft Employee #12 */
-		if (vbrsf.l[sfb]>sflist[0]) {
-			sflist[2]=sflist[1];
-			sflist[1]=sflist[0];
-			sflist[0]=vbrsf.l[sfb];
-		} else if (vbrsf.l[sfb]>sflist[1]) {
-			sflist[2]=sflist[1];
-			sflist[1]=vbrsf.l[sfb];
-		} else if (vbrsf.l[sfb]>sflist[2]) {
-			sflist[2]=vbrsf.l[sfb];
-		}
+#define MAX_SF_DELTA 4
+
+	for ( sfb = 0; sfb < quantInfo->nr_of_sfb; sfb++ )   {
+		if (sfb>0) 
+			vbrsf[sfb] = min(vbrsf[sfb-1]+MAX_SF_DELTA,vbrsf[sfb]);
+		if (sfb< quantInfo->nr_of_sfb-1) 
+			vbrsf[sfb] = min(vbrsf[sfb+1]+MAX_SF_DELTA,vbrsf[sfb]);
 	}
-//	vbrmax=sflist[2];
 
+	for ( sfb = 0; sfb < quantInfo->nr_of_sfb; sfb++ )   
+		if (vbrsf[sfb]>vbrmax) vbrmax = vbrsf[sfb];
+
+
 	/* save a copy of vbrsf, incase we have to recomptue scalefacs */
-	memcpy(&save_sf,&vbrsf,sizeof(III_scalefac_t));
+	memcpy(&save_sf,&vbrsf,sizeof(int)*SFB_NUM_MAX);
 
-	do { 
 
-		memset(&scalefac[gr][ch],0,sizeof(III_scalefac_t));
-		
-		/******************************************************************
-		*
-		*  long block scalefacs
-		*
-		******************************************************************/
+	do {
+
+		memset(scalefac,0,sizeof(int)*SFB_NUM_MAX);
+
 		maxover0=0;
 		maxover1=0;
-		maxover0p=0;
-		maxover1p=0;
 		
 		
-		for ( sfb = 0; sfb < SBPSY_l; sfb++ ) {
-			maxover0 = Max(maxover0,(vbrmax - vbrsf.l[sfb]) - 2*max_range_long[sfb] );
-			maxover0p = Max(maxover0,(vbrmax - vbrsf.l[sfb]) - 2*(max_range_long[sfb]+pretab[sfb]) );
-			maxover1 = Max(maxover1,(vbrmax - vbrsf.l[sfb]) - 4*max_range_long[sfb] );
-			maxover1p = Max(maxover1,(vbrmax - vbrsf.l[sfb]) - 4*(max_range_long[sfb]+pretab[sfb]));
+		for ( sfb = 0; sfb < quantInfo->nr_of_sfb; sfb++ ) {
+			maxover0 = max(maxover0,(vbrmax - vbrsf[sfb]) - 2*/*max_range[sfb]*/10 );
+			maxover1 = max(maxover1,(vbrmax - vbrsf[sfb]) - 4*/*max_range[sfb]*/10 );
 		}
-		mover = Min(maxover0,maxover0p);
+		mover = maxover0;
 
 
 		vbrmax -= mover;
 		maxover0 -= mover;
-		maxover0p -= mover;
 		maxover1 -= mover;
-		maxover1p -= mover;
 
-
+#if 0
 		if (maxover0<=0) {
-			cod_info->scalefac_scale = 0;
 			cod_info->preflag=0;
 			vbrmax -= maxover0;
 		} else if (maxover0p<=0) {
-			cod_info->scalefac_scale = 0;
 			cod_info->preflag=1;
 			vbrmax -= maxover0p;
 		} else if (maxover1==0) {
-			cod_info->scalefac_scale = 1;
 			cod_info->preflag=0;
 		} else if (maxover1p==0) {
-			cod_info->scalefac_scale = 1;
 			cod_info->preflag=1;
-		} else {
-			fprintf(stderr,"error vbrquantize.c...\n");
-			exit(1);
 		}
+#endif
 
 		
-		/* sf =  (cod_info->global_gain-210.0) */
-		cod_info->global_gain = vbrmax +210;
-		if (cod_info->global_gain>255) cod_info->global_gain=255;
+		quantInfo->common_scalefac = vbrmax +210;
+//		assert(cod_info->global_gain < 256);
+		if (quantInfo->common_scalefac>255) quantInfo->common_scalefac = 255;
+
 		
-		for ( sfb = 0; sfb < SBPSY_l; sfb++ )   
-			vbrsf.l[sfb] -= vbrmax;
+		for ( sfb = 0; sfb < quantInfo->nr_of_sfb; sfb++ )   
+			vbrsf[sfb] -= vbrmax;
 		
 		
-		maxover=compute_scalefacs_long(vbrsf.l,cod_info,scalefac[gr][ch].l);
-		assert(maxover <=0);
+		maxover = compute_scalefacs(quantInfo,vbrsf,scalefac);
+//		assert(maxover <=0);
 		
 		
 		/* quantize xr34[] based on computed scalefactors */
-		ifqstep = ( cod_info->scalefac_scale == 0 ) ? 2 : 4;
-		for ( sfb = 0; sfb < SBPSY_l; sfb++ ) {
+		ifqstep = 2;
+		for ( sfb = 0; sfb < quantInfo->nr_of_sfb; sfb++ ) {
 			int ifac;
 			double fac;
-			ifac = ifqstep*scalefac[gr][ch].l[sfb];
-			if (cod_info->preflag)
-				ifac += ifqstep*pretab[sfb];
+			ifac = ifqstep*scalefac[sfb];
+//			if (cod_info->preflag)
+//				ifac += ifqstep*pretab[sfb];
 
-			if (ifac+210<Q_MAX) 
-				fac = 1/IPOW20(ifac+210);
-			else
+//			if (ifac+210<330) 
+//				fac = 1/pow(2.0,-((double)ifac)*.1875);
+//			else
 				fac = pow(2.0,.75*ifac/4.0);
 
-			start = gfc->scalefac_band.l[ sfb ];
-			end   = gfc->scalefac_band.l[ sfb+1 ];
+			start = quantInfo->sfb_offset[sfb];
+			end   = quantInfo->sfb_offset[sfb+1];
 			for ( l = start; l < end; l++ ) {
 				xr34[l]*=fac;
 			}
-		}
-		
-		VBR_quantize_granule(gfp,xr,xr34,l3_enc,ratio,l3_xmin,scalefac,gr,ch);
+		} 
 
-		if (cod_info->part2_3_length < minbits) {
+		bits_used = VBR_quantize_granule(quantInfo, xr34, quant);
+
+
+		if (bits_used < minbits) {
 			/* decrease global gain, recompute scale factors */
-			if (*ath_over==0) break;  
-			if (cod_info->part2_3_length-cod_info->part2_length== 0) break;
+//			if (digital_silence) break;  
 			if (vbrmax+210 ==0 ) break;
-		
-			--vbrmax;
-			--global_gain_adjust;
-			memcpy(&vbrsf,&save_sf,sizeof(III_scalefac_t));
-			for(i=0;i<576;i++) {
-				double temp=fabs(xr[i]);
-				xr34[i]=sqrt(sqrt(temp)*temp);
-			}
+			
 
+
+			--vbrmax;
+			memcpy(&vbrsf,&save_sf,sizeof(int)*SFB_NUM_MAX);
+			memcpy(xr34, xr34orig, sizeof(xr34));
 		}
 
-	} while ((cod_info->part2_3_length < minbits));
+	} while ((bits_used < minbits));
 
-	while (cod_info->part2_3_length > Min(maxbits,4095)) {
+	
+	while (bits_used > min(maxbits,4095)) {
 		/* increase global gain, keep exisiting scale factors */
-		++cod_info->global_gain;
-		VBR_quantize_granule(gfp,xr,xr34,l3_enc,ratio,l3_xmin,scalefac,gr,ch);
-		++global_gain_adjust;
+		++quantInfo->common_scalefac;
+		bits_used = VBR_quantize_granule(quantInfo, xr34, quant);
 	}
 
-	return global_gain_adjust;
+	return bits_used;
 }
 
-int tf_encode_spectrum_aac(
+int calc_xmin(AACQuantInfo* quantInfo, double xr[1024], double ratio[MAX_SCFAC_BANDS],
+	       double allowed_dist[MAX_SCFAC_BANDS], double masking_lower)
+{
+	int start, end, bw,l,ath_over=0;
+	int sfb;
+	double en0, ener;
+
+	for ( sfb = 0; sfb < quantInfo->nr_of_sfb; sfb++ ){
+		start = quantInfo->sfb_offset[sfb];
+		end   = quantInfo->sfb_offset[sfb+1];
+		bw = end - start;
+		
+		for (en0 = 0.0, l = start; l < end; l++ ) {
+			ener = xr[l] * xr[l];
+			en0 += ener;
+		}
+		en0 /= bw;
+		
+		allowed_dist[sfb] = en0 * ratio[sfb] * masking_lower / en0;
+	}
+	
+	return 0;
+}
+
+int tf_encode_spectrum_aac_VBR(
 			   double      *p_spectrum[MAX_TIME_CHANNELS],
 			   double      *PsySigMaskRatio[MAX_TIME_CHANNELS],
 			   double      allowed_dist[MAX_TIME_CHANNELS][MAX_SCFAC_BANDS],
@@ -1190,12 +1338,9 @@
                )
 {
 	int quant[NUM_COEFF];
-	int s_quant[NUM_COEFF];
 	int i;
 	int k;
 	double max_dct_line = 0;
-	int store_common_scalefac;
-	int best_scale_factor[SFB_NUM_MAX];
 	double pow_spectrum[NUM_COEFF];
 	double requant[NUM_COEFF];
 	int sb;
@@ -1205,15 +1350,12 @@
 	int *ptr_book_vector;
 
 	/* Set up local pointers to quantInfo elements for convenience */
-	int* sfb_offset = quantInfo -> sfb_offset;
-	int* scale_factor = quantInfo -> scale_factor;
+	int* sfb_offset = quantInfo->sfb_offset;
+	int* scale_factor = quantInfo->scale_factor;
 	int* common_scalefac = &(quantInfo -> common_scalefac);
 
-	int outer_loop_count, notdone;
-	int over, better;
+	int outer_loop_count;
 	int best_over = 100;
-	int best_common_scalefac;
-	double noise_thresh;
 	double sfQuantFac;
 	double over_noise, tot_noise, max_noise;
 	double noise[SFB_NUM_MAX];
@@ -1221,6 +1363,14 @@
 	double best_over_noise = 0;
 	double best_tot_noise = 0;
 
+	int max_bits = 3 * average_block_bits;
+	int min_bits = average_block_bits / 1;
+	int totbits, bits_ok;
+	double masking_lower_db = 0;
+	double masking_lower = 0;
+	double qadjust = 0;
+	int used_bits;
+
 	/* Set block type in quantization info */
 	quantInfo -> block_type = block_type[MONO_CHAN];
 
@@ -1328,11 +1478,6 @@
 		}
 	}
 
-	/* Compute allowed distortion */
-	for(sb = 0; sb < quantInfo->nr_of_sfb; sb++) {
-		allowed_dist[MONO_CHAN][sb] = energy[MONO_CHAN][sb] * SigMaskRatio[sb];
-	}
-
 	/** find the maximum spectral coefficient **/
 	/* Bug fix, 3/10/98 CL */
 	/* for(i=0; i<NUM_COEFF; i++){ */
@@ -1353,53 +1498,47 @@
 	}
 
 	outer_loop_count = 0;
-	max_bits = average_block_bits + 1;
+	used_bits = max_bits + 1;
 
+	calc_xmin(quantInfo, p_spectrum[0], SigMaskRatio, allowed_dist[0],
+		masking_lower);
+
 	do {
 
-		int adjusted,shortblock;
+		int shortblock;
 		totbits=0;
 				
 		/* ENCODE this data first pass, and on future passes unless it uses
 		* a very small percentage of the max_frame_bits  */
-		if (max_bits > average_block_bits) {
+		if (used_bits > max_bits) {
 
 			shortblock = (quantInfo->block_type == ONLY_SHORT_WINDOW);
 
-			/* Adjust allowed masking based on quality setting */
-			masking_lower_db = dbQ[0] + qadjust;
+			if (qadjust!=0 /*|| shortblock*/) {
+				/* Adjust allowed masking based on quality setting */
+				masking_lower_db = /*dbQ[0]*/0 + qadjust;
 
-//			if (pe[gr][ch]>750)
-//				masking_lower_db -= 4*(pe[gr][ch]-750.)/750.;
+//				if (pe[gr][ch]>750)
+//					masking_lower_db -= 4*(pe[gr][ch]-750.)/750.;
 
-			masking_lower = pow(10.0,masking_lower_db/10);
-			adjusted = VBR_noise_shaping (quantInfo, p_spectrum[0], p_ratio[0], quant,
-				average_block_bits, &max_bits);
+				masking_lower = pow(10.0,masking_lower_db/10);
+				calc_xmin(quantInfo, p_spectrum[0], SigMaskRatio, allowed_dist[0],
+					masking_lower);
+			}
+
+			used_bits = VBR_noise_shaping(quantInfo, p_spectrum[0], pow_spectrum,
+				allowed_dist[0], quant,	min_bits, max_bits, scale_factor);
 		}
 		bits_ok=1;
-		if (max_bits > average_block_bits) {
-			qadjust += Max(.25,(max_bits - average_block_bits)/300.0);
+		if (used_bits > max_bits) {
+			qadjust += max(.25,(used_bits - max_bits)/300.0);
+			min_bits = max(125,min_bits*0.975);
+			max_bits = max(min_bits,max_bits*0.975);
 			bits_ok=0;
 		}
 		
 	} while (!bits_ok);
 
-	if (max_dct_line > 0) {
-		*common_scalefac = best_common_scalefac;
-		for (sb = 0; sb < quantInfo->nr_of_sfb; sb++) {
-			scale_factor[sb] = best_scale_factor[sb];
-		}
-		for (i = 0; i < 1024; i++)
-			quant[i] = s_quant[i]*sign[i];
-	} else {
-		*common_scalefac = 0;
-		for (sb = 0; sb < quantInfo->nr_of_sfb; sb++) {
-			scale_factor[sb] = 0;
-		}
-		for (i = 0; i < 1024; i++)
-			quant[i] = 0;
-	}
-
 	calc_noise(quantInfo, p_spectrum[0], quant, requant, noise, allowed_dist[0],
 			&over_noise, &tot_noise, &max_noise);
 	count_bits(quantInfo, quant);
@@ -1447,809 +1586,3 @@
 	return FNO_ERROR;
 }
 #endif
-#if 0
-
-
-
-/*
- *	MP3 quantization
- *
- *	Copyright (c) 1999 Mark Taylor
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2, or (at your option)
- * any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; see the file COPYING.  If not, write to
- * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-
-
-#if (defined(__GNUC__) && defined(__i386__))
-#define USE_GNUC_ASM
-#endif
-#ifdef _MSC_VER
-#define USE_MSC_ASM
-#endif
-
-
-
-/*********************************************************************
- * XRPOW_FTOI is a macro to convert floats to ints.  
- * if XRPOW_FTOI(x) = nearest_int(x), then QUANTFAC(x)=adj43asm[x]
- *                                         ROUNDFAC= -0.0946
- *
- * if XRPOW_FTOI(x) = floor(x), then QUANTFAC(x)=asj43[x]   
- *                                   ROUNDFAC=0.4054
- *********************************************************************/
-#ifdef USE_GNUC_ASM
-#  define QUANTFAC(rx)  adj43asm[rx]
-#  define ROUNDFAC -0.0946
-#  define XRPOW_FTOI(src, dest) \
-     asm ("fistpl %0 " : "=m"(dest) : "t"(src) : "st")
-#elif defined (USE_MSC_ASM)
-#  define QUANTFAC(rx)  adj43asm[rx]
-#  define ROUNDFAC -0.0946
-#  define XRPOW_FTOI(src, dest) do { \
-     double src_ = (src); \
-     int dest_; \
-     { \
-       __asm fld src_ \
-       __asm fistp dest_ \
-     } \
-     (dest) = dest_; \
-   } while (0)
-#else
-#  define QUANTFAC(rx)  adj43[rx]
-#  define ROUNDFAC 0.4054
-#  define XRPOW_FTOI(src,dest) ((dest) = (int)(src))
-#endif
-
-
-
-
-
-
-double calc_sfb_noise(double *xr, double *xr34, int stride, int bw, int sf)
-{
-  int j;
-  double xfsf=0;
-  double sfpow,sfpow34;
-
-  sfpow = pow(2.0, sf+210); /*pow(2.0,sf/4.0); */
-  sfpow34  = IPOW20(sf+210); /*pow(sfpow,-3.0/4.0);*/
-
-  for ( j=0; j < stride*bw ; j += stride) {
-    int ix;
-    double temp;
-
-    if (xr34[j]*sfpow34 > IXMAX_VAL) return -1;
-
-    temp = xr34[j]*sfpow34;
-    XRPOW_FTOI(temp, ix);
-    XRPOW_FTOI(temp + QUANTFAC(ix), ix);
-    temp = fabs(xr[j])- pow43[ix]*sfpow;
-    temp *= temp;
-    
-    xfsf += temp;
-  }
-  return xfsf/bw;
-}
-
-
-
-
-
-double calc_sfb_noise_ave(double *xr, double *xr34, int stride, int bw,int sf)
-{
-  int j;
-  double xfsf=0, xfsf_p1=0, xfsf_m1=0;
-  double sfpow34,sfpow34_p1,sfpow34_m1;
-  double sfpow,sfpow_p1,sfpow_m1;
-
-  sfpow = POW20(sf+210); /*pow(2.0,sf/4.0); */
-  sfpow34  = IPOW20(sf+210); /*pow(sfpow,-3.0/4.0);*/
-
-  sfpow_m1 = sfpow*.8408964153;  /* pow(2,(sf-1)/4.0) */
-  sfpow34_m1 = sfpow34*1.13878863476;       /* .84089 ^ -3/4 */
-
-  sfpow_p1 = sfpow*1.189207115;  
-  sfpow34_p1 = sfpow34*0.878126080187;
-
-  for ( j=0; j < stride*bw ; j += stride) {
-    int ix;
-    double temp,temp_p1,temp_m1;
-
-    if (xr34[j]*sfpow34_m1 > IXMAX_VAL) return -1;
-
-    temp = xr34[j]*sfpow34;
-    XRPOW_FTOI(temp, ix);
-    XRPOW_FTOI(temp + QUANTFAC(ix), ix);
-    temp = fabs(xr[j])- pow43[ix]*sfpow;
-    temp *= temp;
-
-    temp_p1 = xr34[j]*sfpow34_p1;
-    XRPOW_FTOI(temp_p1, ix);
-    XRPOW_FTOI(temp_p1 + QUANTFAC(ix), ix);
-    temp_p1 = fabs(xr[j])- pow43[ix]*sfpow_p1;
-    temp_p1 *= temp_p1;
-    
-    temp_m1 = xr34[j]*sfpow34_m1;
-    XRPOW_FTOI(temp_m1, ix);
-    XRPOW_FTOI(temp_m1 + QUANTFAC(ix), ix);
-    temp_m1 = fabs(xr[j])- pow43[ix]*sfpow_m1;
-    temp_m1 *= temp_m1;
-
-    xfsf += temp;
-    xfsf_p1 += temp_p1;
-    xfsf_m1 += temp_m1;
-  }
-  if (xfsf_p1>xfsf) xfsf = xfsf_p1;
-  if (xfsf_m1>xfsf) xfsf = xfsf_m1;
-  return xfsf/bw;
-}
-
-
-
-int find_scalefac(double *xr,double *xr34,int stride,int sfb,
-		     double l3_xmin,int bw)
-{
-  double xfsf;
-  int i,sf,sf_ok,delsf;
-
-  /* search will range from sf:  -209 -> 45  */
-  sf = -82;
-  delsf = 128;
-
-  sf_ok=10000;
-  for (i=0; i<7; i++) {
-    delsf /= 2;
-    //      xfsf = calc_sfb_noise(xr,xr34,stride,bw,sf);
-    xfsf = calc_sfb_noise_ave(xr,xr34,stride,bw,sf);
-
-    if (xfsf < 0) {
-      /* scalefactors too small */
-      sf += delsf;
-    }else{
-      if (sf_ok==10000) sf_ok=sf;  
-      if (xfsf > l3_xmin)  {
-	/* distortion.  try a smaller scalefactor */
-	sf -= delsf;
-      }else{
-	sf_ok = sf;
-	sf += delsf;
-      }
-    }
-  } 
-  assert(sf_ok!=10000);
-  //  assert(delsf==1);  /* when for loop goes up to 7 */
-
-  return sf;
-}
-
-
-
-/*
-    sfb=0..5  scalefac < 16 
-    sfb>5     scalefac < 8
-
-    ifqstep = ( cod_info->scalefac_scale == 0 ) ? 2 : 4;
-    ol_sf =  (cod_info->global_gain-210.0);
-    ol_sf -= 8*cod_info->subblock_gain[i];
-    ol_sf -= ifqstep*scalefac[gr][ch].s[sfb][i];
-
-*/
-int compute_scalefacs_short(int sf[SBPSY_s][3],gr_info *cod_info,
-int scalefac[SBPSY_s][3],unsigned int sbg[3])
-{
-  int maxrange,maxrange1,maxrange2,maxover;
-  int sfb,i;
-  int ifqstep = ( cod_info->scalefac_scale == 0 ) ? 2 : 4;
-
-  maxover=0;
-  maxrange1 = 15;
-  maxrange2 = 7;
-
-
-  for (i=0; i<3; ++i) {
-    int maxsf1=0,maxsf2=0,minsf=1000;
-    /* see if we should use subblock gain */
-    for ( sfb = 0; sfb < SBPSY_s; sfb++ ) {
-      if (sfb < 6) {
-	if (-sf[sfb][i]>maxsf1) maxsf1 = -sf[sfb][i];
-      } else {
-	if (-sf[sfb][i]>maxsf2) maxsf2 = -sf[sfb][i];
-      }
-      if (-sf[sfb][i]<minsf) minsf = -sf[sfb][i];
-    }
-
-    /* boost subblock gain as little as possible so we can
-     * reach maxsf1 with scalefactors 
-     * 8*sbg >= maxsf1   
-     */
-    maxsf1 = Max(maxsf1-maxrange1*ifqstep,maxsf2-maxrange2*ifqstep);
-    sbg[i]=0;
-    if (minsf >0 ) sbg[i] = floor(.125*minsf + .001);
-    if (maxsf1 > 0)  sbg[i]  = Max(sbg[i],maxsf1/8 + (maxsf1 % 8 != 0));
-    if (sbg[i] > 7) sbg[i]=7;
-
-
-    for ( sfb = 0; sfb < SBPSY_s; sfb++ ) {
-      sf[sfb][i] += 8*sbg[i];
-
-      if (sf[sfb][i] < 0) {
-	maxrange = sfb < 6 ? maxrange1 : maxrange2;
-	scalefac[sfb][i]=-sf[sfb][i]/ifqstep + (-sf[sfb][i]%ifqstep != 0);
-	if (scalefac[sfb][i]>maxrange) scalefac[sfb][i]=maxrange;
-	
-	if (-(sf[sfb][i] + scalefac[sfb][i]*ifqstep) >maxover)  {
-	  maxover=-(sf[sfb][i] + scalefac[sfb][i]*ifqstep);
-	}
-      }
-    }
-  }
-
-  return maxover;
-}
-
-
-
-
-
-int max_range_short[SBPSY_s]=
-{15, 15, 15, 15, 15, 15 ,  7,    7,    7,    7,   7,     7 };
-int max_range_long[SBPSY_l]=
-{15,   15,  15,  15,  15,  15,  15,  15,  15,  15,  15,   7,   7,   7,   7,   7,   7,   7,    7,    7,    7};
-
-
-/*
-	  ifqstep = ( cod_info->scalefac_scale == 0 ) ? 2 : 4;
-	  ol_sf =  (cod_info->global_gain-210.0);
-	  ol_sf -= ifqstep*scalefac[gr][ch].l[sfb];
-	  if (cod_info->preflag && sfb>=11) 
-	  ol_sf -= ifqstep*pretab[sfb];
-*/
-int compute_scalefacs_long(int sf[SBPSY_l],gr_info *cod_info,int scalefac[SBPSY_l])
-{
-  int sfb;
-  int maxover;
-  int ifqstep = ( cod_info->scalefac_scale == 0 ) ? 2 : 4;
-  
-
-  if (cod_info->preflag)
-    for ( sfb = 11; sfb < SBPSY_l; sfb++ ) 
-      sf[sfb] += pretab[sfb]*ifqstep;
-
-
-  maxover=0;
-  for ( sfb = 0; sfb < SBPSY_l; sfb++ ) {
-
-    if (sf[sfb]<0) {
-      /* ifqstep*scalefac >= -sf[sfb], so round UP */
-      scalefac[sfb]=-sf[sfb]/ifqstep  + (-sf[sfb] % ifqstep != 0);
-      if (scalefac[sfb] > max_range_long[sfb]) scalefac[sfb]=max_range_long[sfb];
-      
-      /* sf[sfb] should now be positive: */
-      if (  -(sf[sfb] + scalefac[sfb]*ifqstep)  > maxover) {
-	maxover = -(sf[sfb] + scalefac[sfb]*ifqstep);
-      }
-    }
-  }
-
-  return maxover;
-}
-  
-  
-
-
-
-
-
-
-/************************************************************************
- *
- * quantize and encode with the given scalefacs and global gain
- *
- * compute scalefactors, l3_enc, and return number of bits needed to encode
- *
- *
- ************************************************************************/
-void
-VBR_quantize_granule(lame_global_flags *gfp,
-		     double xr[576],
-                double xr34[576], int l3_enc[2][2][576],
-		     III_psy_ratio *ratio,      III_psy_xmin l3_xmin,
-                III_scalefac_t scalefac[2][2],int gr, int ch)
-{
-  lame_internal_flags *gfc=gfp->internal_flags;
-  gr_info *cod_info;  
-  III_side_info_t * l3_side;
-  l3_side = &gfc->l3_side;
-  cod_info = &l3_side->gr[gr].ch[ch].tt;
-
-  /* encode scalefacs */
-  if ( gfp->version == 1 ) 
-    scale_bitcount(&scalefac[gr][ch], cod_info);
-  else
-    scale_bitcount_lsf(&scalefac[gr][ch], cod_info);
-
-
-  /* quantize xr34 */
-  cod_info->part2_3_length = count_bits(gfp,l3_enc[gr][ch],xr34,cod_info);
-  cod_info->part2_3_length += cod_info->part2_length;
-  
-  if (gfc->use_best_huffman==1 && cod_info->block_type != SHORT_TYPE) {
-    best_huffman_divide(gfc, gr, ch, cod_info, l3_enc[gr][ch]);
-  }
-
-  return;
-}
-  
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-/************************************************************************
- *
- * VBR_noise_shaping()
- *
- * compute scalefactors, l3_enc, and return number of bits needed to encode
- *
- * return code:    0   scalefactors were found with all noise < masking
- *
- *               n>0   scalefactors required too many bits.  global gain
- *                     was decreased by n
- *                     If n is large, we should probably recompute scalefacs
- *                     with a lower quality.
- *
- *               n<0   scalefactors used less than minbits.
- *                     global gain was increased by n.  
- *                     If n is large, might want to recompute scalefacs
- *                     with a higher quality setting?
- *
- ************************************************************************/
-int
-VBR_noise_shaping
-(
- lame_global_flags *gfp,
- double xr[576], III_psy_ratio *ratio,
- int l3_enc[2][2][576], int *ath_over, int minbits, int maxbits,
- III_scalefac_t scalefac[2][2],
- int gr,int ch)
-{
-  lame_internal_flags *gfc=gfp->internal_flags;
-  int       start,end,bw,sfb,l, i, vbrmax;
-  III_scalefac_t vbrsf;
-  III_scalefac_t save_sf;
-  int maxover0,maxover1,maxover0p,maxover1p,maxover,mover;
-  int ifqstep;
-  III_psy_xmin l3_xmin;
-  III_side_info_t * l3_side;
-  gr_info *cod_info;  
-  double xr34[576];
-  int shortblock;
-  int global_gain_adjust=0;
-
-  l3_side = &gfc->l3_side;
-  cod_info = &l3_side->gr[gr].ch[ch].tt;
-  shortblock = (cod_info->block_type == SHORT_TYPE);
-  *ath_over = calc_xmin( gfp,xr, ratio, cod_info, &l3_xmin);
-
-  
-  for(i=0;i<576;i++) {
-    double temp=fabs(xr[i]);
-    xr34[i]=sqrt(sqrt(temp)*temp);
-  }
-  
-  
-  vbrmax=-10000;
-  if (shortblock) {
-    for ( sfb = 0; sfb < SBPSY_s; sfb++ )  {
-      for ( i = 0; i < 3; i++ ) {
-	start = gfc->scalefac_band.s[ sfb ];
-	end   = gfc->scalefac_band.s[ sfb+1 ];
-	bw = end - start;
-	vbrsf.s[sfb][i] = find_scalefac(&xr[3*start+i],&xr34[3*start+i],3,sfb,
-					l3_xmin.s[sfb][i],bw);
-	if (vbrsf.s[sfb][i]>vbrmax) vbrmax=vbrsf.s[sfb][i];
-      }
-    }
-  }else{
-    int sflist[3]={-10000,-10000,-10000};
-    for ( sfb = 0; sfb < SBPSY_l; sfb++ )   {
-      start = gfc->scalefac_band.l[ sfb ];
-      end   = gfc->scalefac_band.l[ sfb+1 ];
-      bw = end - start;
-      vbrsf.l[sfb] = find_scalefac(&xr[start],&xr34[start],1,sfb,
-				   l3_xmin.l[sfb],bw);
-      if (vbrsf.l[sfb]>vbrmax) vbrmax = vbrsf.l[sfb];
-
-      /* code to find the 3 largest (counting duplicates) contributed
-       * by Microsoft Employee #12 */
-      if (vbrsf.l[sfb]>sflist[0]) {
-	sflist[2]=sflist[1];
-	sflist[1]=sflist[0];
-	sflist[0]=vbrsf.l[sfb];
-      } else if (vbrsf.l[sfb]>sflist[1]) {
-	sflist[2]=sflist[1];
-	sflist[1]=vbrsf.l[sfb];
-      } else if (vbrsf.l[sfb]>sflist[2]) {
-	sflist[2]=vbrsf.l[sfb];
-      }
-    }
-    //    vbrmax=sflist[2];
-  } /* compute needed scalefactors */
-
-  /* save a copy of vbrsf, incase we have to recomptue scalefacs */
-  memcpy(&save_sf,&vbrsf,sizeof(III_scalefac_t));
-
-#undef SCALEFAC_SCALE
-
-  do { 
-
-  memset(&scalefac[gr][ch],0,sizeof(III_scalefac_t));
-    
-  if (shortblock) {
-    /******************************************************************
-     *
-     *  short block scalefacs
-     *
-     ******************************************************************/
-    maxover0=0;
-    maxover1=0;
-    for ( sfb = 0; sfb < SBPSY_s; sfb++ ) {
-      for ( i = 0; i < 3; i++ ) {
-	maxover0 = Max(maxover0,(vbrmax - vbrsf.s[sfb][i]) - (4*14 + 2*max_range_short[sfb]) );
-	maxover1 = Max(maxover1,(vbrmax - vbrsf.s[sfb][i]) - (4*14 + 4*max_range_short[sfb]) );
-      }
-    }
-#ifdef SCALEFAC_SCALE
-    mover = Min(maxover0,maxover1);
-#else
-    mover = maxover0; 
-#endif
-
-    vbrmax -= mover;
-    maxover0 -= mover;
-    maxover1 -= mover;
-
-    if (maxover0==0) 
-      cod_info->scalefac_scale = 0;
-    else if (maxover1==0)
-      cod_info->scalefac_scale = 1;
-
-
-    /* sf =  (cod_info->global_gain-210.0) */
-    cod_info->global_gain = vbrmax +210;
-    if (cod_info->global_gain>255) cod_info->global_gain=255;
-    
-    for ( sfb = 0; sfb < SBPSY_s; sfb++ ) {
-      for ( i = 0; i < 3; i++ ) {
-	vbrsf.s[sfb][i]-=vbrmax;
-      }
-    }
-    maxover=compute_scalefacs_short(vbrsf.s,cod_info,scalefac[gr][ch].s,cod_info->subblock_gain);
-    assert(maxover <=0);
-    {
-      /* adjust global_gain so at least 1 subblock gain = 0 */
-      int minsfb=999;
-      for (i=0; i<3; i++) minsfb = Min(minsfb,cod_info->subblock_gain[i]);
-      minsfb = Min(cod_info->global_gain/8,minsfb);
-      vbrmax -= 8*minsfb; 
-      cod_info->global_gain -= 8*minsfb;
-      for (i=0; i<3; i++) cod_info->subblock_gain[i] -= minsfb;
-    }
-    
-    
-    
-    /* quantize xr34[] based on computed scalefactors */
-    ifqstep = ( cod_info->scalefac_scale == 0 ) ? 2 : 4;
-    for ( sfb = 0; sfb < SBPSY_s; sfb++ ) {
-      start = gfc->scalefac_band.s[ sfb ];
-      end   = gfc->scalefac_band.s[ sfb+1 ];
-      for (i=0; i<3; i++) {
-	int ifac;
-	double fac;
-	ifac = (8*cod_info->subblock_gain[i]+ifqstep*scalefac[gr][ch].s[sfb][i]);
-	if (ifac+210<Q_MAX) 
-	  fac = 1/IPOW20(ifac+210);
-	else
-	  fac = pow(2.0,.75*ifac/4.0);
-	for ( l = start; l < end; l++ ) 
-	  xr34[3*l +i]*=fac;
-      }
-    }
-    
-    
-    
-  }else{
-    /******************************************************************
-     *
-     *  long block scalefacs
-     *
-     ******************************************************************/
-    maxover0=0;
-    maxover1=0;
-    maxover0p=0;
-    maxover1p=0;
-    
-    
-    for ( sfb = 0; sfb < SBPSY_l; sfb++ ) {
-      maxover0 = Max(maxover0,(vbrmax - vbrsf.l[sfb]) - 2*max_range_long[sfb] );
-      maxover0p = Max(maxover0,(vbrmax - vbrsf.l[sfb]) - 2*(max_range_long[sfb]+pretab[sfb]) );
-      maxover1 = Max(maxover1,(vbrmax - vbrsf.l[sfb]) - 4*max_range_long[sfb] );
-      maxover1p = Max(maxover1,(vbrmax - vbrsf.l[sfb]) - 4*(max_range_long[sfb]+pretab[sfb]));
-    }
-    mover = Min(maxover0,maxover0p);
-#ifdef SCALEFAC_SCALE
-    mover = Min(mover,maxover1);
-    mover = Min(mover,maxover1p);
-#endif
-
-
-    vbrmax -= mover;
-    maxover0 -= mover;
-    maxover0p -= mover;
-    maxover1 -= mover;
-    maxover1p -= mover;
-
-
-    if (maxover0<=0) {
-      cod_info->scalefac_scale = 0;
-      cod_info->preflag=0;
-      vbrmax -= maxover0;
-    } else if (maxover0p<=0) {
-      cod_info->scalefac_scale = 0;
-      cod_info->preflag=1;
-      vbrmax -= maxover0p;
-    } else if (maxover1==0) {
-      cod_info->scalefac_scale = 1;
-      cod_info->preflag=0;
-    } else if (maxover1p==0) {
-      cod_info->scalefac_scale = 1;
-      cod_info->preflag=1;
-    } else {
-      fprintf(stderr,"error vbrquantize.c...\n");
-      exit(1);
-    }
-
-    
-    /* sf =  (cod_info->global_gain-210.0) */
-    cod_info->global_gain = vbrmax +210;
-    if (cod_info->global_gain>255) cod_info->global_gain=255;
-    
-    for ( sfb = 0; sfb < SBPSY_l; sfb++ )   
-      vbrsf.l[sfb] -= vbrmax;
-    
-    
-    maxover=compute_scalefacs_long(vbrsf.l,cod_info,scalefac[gr][ch].l);
-    assert(maxover <=0);
-    
-    
-    /* quantize xr34[] based on computed scalefactors */
-    ifqstep = ( cod_info->scalefac_scale == 0 ) ? 2 : 4;
-    for ( sfb = 0; sfb < SBPSY_l; sfb++ ) {
-      int ifac;
-      double fac;
-      ifac = ifqstep*scalefac[gr][ch].l[sfb];
-      if (cod_info->preflag)
-	ifac += ifqstep*pretab[sfb];
-
-      if (ifac+210<Q_MAX) 
-	fac = 1/IPOW20(ifac+210);
-      else
-	fac = pow(2.0,.75*ifac/4.0);
-
-      start = gfc->scalefac_band.l[ sfb ];
-      end   = gfc->scalefac_band.l[ sfb+1 ];
-      for ( l = start; l < end; l++ ) {
-    	xr34[l]*=fac;
-      }
-    }
-  } 
-  
-  VBR_quantize_granule(gfp,xr,xr34,l3_enc,ratio,l3_xmin,scalefac,gr,ch);
-
-  if (cod_info->part2_3_length < minbits) {
-    /* decrease global gain, recompute scale factors */
-    if (*ath_over==0) break;  
-    if (cod_info->part2_3_length-cod_info->part2_length== 0) break;
-    if (vbrmax+210 ==0 ) break;
-    
-    //        printf("not enough bits, decreasing vbrmax. g_gainv=%i\n",cod_info->global_gain);
-    //        printf("%i minbits=%i   part2_3_length=%i  part2=%i\n",
-    //    	   gfp->frameNum,minbits,cod_info->part2_3_length,cod_info->part2_length);
-    --vbrmax;
-    --global_gain_adjust;
-    memcpy(&vbrsf,&save_sf,sizeof(III_scalefac_t));
-    for(i=0;i<576;i++) {
-      double temp=fabs(xr[i]);
-      xr34[i]=sqrt(sqrt(temp)*temp);
-    }
-
-  }
-
-  } while ((cod_info->part2_3_length < minbits));
-
-  while (cod_info->part2_3_length > Min(maxbits,4095)) {
-    /* increase global gain, keep exisiting scale factors */
-    ++cod_info->global_gain;
-    VBR_quantize_granule(gfp,xr,xr34,l3_enc,ratio,l3_xmin,scalefac,gr,ch);
-    ++global_gain_adjust;
-  }
-
-  return global_gain_adjust;
-}
-
-
-
-
-void
-VBR_quantize(lame_global_flags *gfp,
-                double pe[2][2], double ms_ener_ratio[2],
-                double xr[2][2][576], III_psy_ratio ratio[2][2],
-                int l3_enc[2][2][576],
-                III_scalefac_t scalefac[2][2])
-{
-	lame_internal_flags *gfc=gfp->internal_flags;
-	int minbits,maxbits,max_frame_bits,totbits,gr,ch,i,bits_ok;
-	int bitsPerFrame,mean_bits;
-	double qadjust;
-	III_side_info_t * l3_side;
-	gr_info *cod_info;  
-	int ath_over[2][2];
-	double masking_lower_db;
-	// static const double dbQ[10]={-6.0,-5.0,-4.0,-3.0, -2.0, -1.0, -.25, .5, 1.25, 2.0};
-	/* from quantize.c VBR algorithm */
-	static const double dbQ[10]={-5.0,-3.75,-2.5,-1.25,  0,  0.4,  0.8, 1.2, 1.6,2.0};
-
-	qadjust=-1;   /* start with -1 db quality improvement over quantize.c VBR */
-
-
-	ATH_lower = (4 - VBR_q) * 4.0; 
-	if (ATH_lower < 0) ATH_lower=0;
-	iteration_init(gfp,l3_side,l3_enc);
-
-	gfc->bitrate_index=gfc->VBR_min_bitrate;
-	getframebits(gfp,&bitsPerFrame, &mean_bits);
-	minbits = .4*(mean_bits/numChannel);
-
-	gfc->bitrate_index=gfc->VBR_max_bitrate;
-	getframebits(gfp,&bitsPerFrame, &mean_bits);
-	max_frame_bits = ResvFrameBegin(gfp,l3_side, mean_bits, bitsPerFrame);
-	maxbits=2.5*(mean_bits/numChannel);
-
-	{
-	/* compute a target  mean_bits based on compression ratio 
-	* which was set based on VBR_q  
-		*/
-		int bit_rate = gfp->out_samplerate*16*numChannel/(1000.0*gfp->compression_ratio);
-		bitsPerFrame = (bit_rate*gfp->framesize*1000)/gfp->out_samplerate;
-		mean_bits = (bitsPerFrame - 8*gfc->sideinfo_len) / gfc->mode_gr;
-	}
-
-	minbits=Max(minbits,.4*(mean_bits/numChannel));
-	maxbits=Min(maxbits,2.5*(mean_bits/numChannel));
-
-	for (gr = 0; gr < gfc->mode_gr; gr++) {
-		for (ch = 0; ch < gfc->stereo; ch++) { 
-			cod_info->part2_3_length=LARGE_BITS;
-		}
-	}
-
-
-
-	/* 
-	* loop over all ch,gr, encoding anything with bits > .5*(max_frame_bits/4)
-	*
-	* If a particular granule uses way too many bits, it will be re-encoded
-	* on the next iteration of the loop (with a lower quality setting).  
-	* But granules which dont use
-	* use too many bits will not be re-encoded.
-	*
-	* minbits:  minimum allowed bits for 1 granule 1 channel
-	* maxbits:  maximum allowwed bits for 1 granule 1 channel
-	* max_frame_bits:  maximum allowed bits for entire frame
-	* (max_frame_bits/4)   estimate of average bits per granule per channel
-	* 
-	*/
-
-	do {
-
-		totbits=0;
-		for (gr = 0; gr < gfc->mode_gr; gr++) {
-			for (ch = 0; ch < numChannel; ch++) { 
-				int adjusted,shortblock;
-				
-				/* ENCODE this data first pass, and on future passes unless it uses
-				* a very small percentage of the max_frame_bits  */
-				if (cod_info->part2_3_length > (max_frame_bits/(2*gfc->stereo))) {
-
-					shortblock = (quantInfo->block_type == ONLY_SHORT_WINDOW);
-
-					/* Adjust allowed masking based on quality setting */
-					masking_lower_db = dbQ[gfp->VBR_q] + qadjust;
-
-//					if (pe[gr][ch]>750)
-//						masking_lower_db -= 4*(pe[gr][ch]-750.)/750.;
-					
-					gfc->masking_lower = pow(10.0,masking_lower_db/10);
-					adjusted = VBR_noise_shaping (gfp,xr[gr][ch],&ratio[gr][ch],l3_enc,&ath_over[gr][ch],minbits,maxbits,scalefac,gr,ch);
-				}
-				totbits += cod_info->part2_3_length;
-			}
-		}
-		bits_ok=1;
-		if (totbits>max_frame_bits) {
-			qadjust += Max(.25,(totbits-max_frame_bits)/300.0);
-			bits_ok=0;
-		}
-		
-	} while (!bits_ok);
-
-
-	/* find optimal scalefac storage.  Cant be done above because
-	* might enable scfsi which breaks the interation loops */
-	totbits=0;
-	for (gr = 0; gr < gfc->mode_gr; gr++) {
-		for (ch = 0; ch < gfc->stereo; ch++) {
-			best_scalefac_store(gfp,gr, ch, l3_enc, l3_side, scalefac);
-			totbits += l3_side->gr[gr].ch[ch].tt.part2_3_length;
-		}
-	}
-
-	
-	for( gfc->bitrate_index = (gfp->VBR_hard_min ? gfc->VBR_min_bitrate : 1);
-	gfc->bitrate_index < gfc->VBR_max_bitrate;
-	gfc->bitrate_index++    ) {
-
-		getframebits (gfp,&bitsPerFrame, &mean_bits);
-		maxbits = ResvFrameBegin(gfp,l3_side, mean_bits, bitsPerFrame);
-		if (totbits <= maxbits) break;
-	}
-	if (gfc->bitrate_index == gfc->VBR_max_bitrate) {
-		getframebits (gfp,&bitsPerFrame, &mean_bits);
-		maxbits = ResvFrameBegin(gfp,l3_side, mean_bits, bitsPerFrame);
-	}
-
-	//  printf("%i total_bits=%i max_frame_bits=%i index=%i  \n",gfp->frameNum,totbits,max_frame_bits,gfc->bitrate_index);
-
-	for (gr = 0; gr < gfc->mode_gr; gr++) {
-		for (ch = 0; ch < gfc->stereo; ch++) {
-			cod_info = &l3_side->gr[gr].ch[ch].tt;
-
-
-			ResvAdjust (gfp,cod_info, l3_side, mean_bits);
-			
-			/*******************************************************************
-			* set the sign of l3_enc from the sign of xr
-			*******************************************************************/
-			for ( i = 0; i < 576; i++) {
-				if (xr[gr][ch][i] < 0) l3_enc[gr][ch][i] *= -1;
-			}
-		}
-	}
-	ResvFrameEnd (gfp,l3_side, mean_bits);
-}
-
-#endif
\ No newline at end of file