/* * MP3 quantization * * Copyright (c) 1999 Mark Taylor * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library 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 * Library General Public License for more details. * * You should have received a copy of the GNU Library General Public * License along with this library; if not, write to the * Free Software Foundation, Inc., 59 Temple Place - Suite 330, * Boston, MA 02111-1307, USA. */ /* $Id: vbrquantize.c,v 1.41 2001/03/12 07:26:08 markt Exp $ */ #ifdef HAVE_CONFIG_H # include #endif #include #include "util.h" #include "l3side.h" #include "quantize.h" #include "reservoir.h" #include "quantize_pvt.h" #include "lame-analysis.h" #ifdef WITH_DMALLOC #include #endif #undef MAXQUANTERROR typedef union { float f; int i; } fi_union; #define MAGIC_FLOAT (65536*(128)) #define MAGIC_INT 0x4b000000 #ifdef TAKEHIRO_IEEE754_HACK #ifdef MAXQUANTERROR #define DUFFBLOCK() do { \ xp = xr34[0] * sfpow34_p1; \ xe = xr34[0] * sfpow34_eq; \ xm = xr34[0] * sfpow34_m1; \ if (xm > IXMAX_VAL) \ return -1; \ xp += MAGIC_FLOAT; \ xe += MAGIC_FLOAT; \ xm += MAGIC_FLOAT; \ fi[0].f = xp; \ fi[1].f = xe; \ fi[2].f = xm; \ fi[0].f = xp + (adj43asm - MAGIC_INT)[fi[0].i]; \ fi[1].f = xe + (adj43asm - MAGIC_INT)[fi[1].i]; \ fi[2].f = xm + (adj43asm - MAGIC_INT)[fi[2].i]; \ fi[0].i -= MAGIC_INT; \ fi[1].i -= MAGIC_INT; \ fi[2].i -= MAGIC_INT; \ x0 = fabs(xr[0]); \ xp = x0 - pow43[fi[0].i] * sfpow_p1; \ xe = x0 - pow43[fi[1].i] * sfpow_eq; \ xm = x0 - pow43[fi[2].i] * sfpow_m1; \ xp *= xp; \ xe *= xe; \ xm *= xm; \ xfsf_eq = Max(xfsf_eq, xe); \ xfsf_p1 = Max(xfsf_p1, xp); \ xfsf_m1 = Max(xfsf_m1, xm); \ ++xr; \ ++xr34; \ } while(0) #else #define DUFFBLOCK() do { \ xp = xr34[0] * sfpow34_p1; \ xe = xr34[0] * sfpow34_eq; \ xm = xr34[0] * sfpow34_m1; \ if (xm > IXMAX_VAL) \ return -1; \ xp += MAGIC_FLOAT; \ xe += MAGIC_FLOAT; \ xm += MAGIC_FLOAT; \ fi[0].f = xp; \ fi[1].f = xe; \ fi[2].f = xm; \ fi[0].f = xp + (adj43asm - MAGIC_INT)[fi[0].i]; \ fi[1].f = xe + (adj43asm - MAGIC_INT)[fi[1].i]; \ fi[2].f = xm + (adj43asm - MAGIC_INT)[fi[2].i]; \ fi[0].i -= MAGIC_INT; \ fi[1].i -= MAGIC_INT; \ fi[2].i -= MAGIC_INT; \ x0 = fabs(xr[0]); \ xp = x0 - pow43[fi[0].i] * sfpow_p1; \ xe = x0 - pow43[fi[1].i] * sfpow_eq; \ xm = x0 - pow43[fi[2].i] * sfpow_m1; \ xfsf_p1 += xp * xp; \ xfsf_eq += xe * xe; \ xfsf_m1 += xm * xm; \ ++xr; \ ++xr34; \ } while(0) #endif #else /********************************************************************* * 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 *********************************************************************/ # define QUANTFAC(rx) adj43[rx] # define ROUNDFAC 0.4054 # define XRPOW_FTOI(src,dest) ((dest) = (int)(src)) #endif static FLOAT8 calc_sfb_noise(const FLOAT8 *xr, const FLOAT8 *xr34, const int bw, const int sf) { int j; fi_union fi; FLOAT8 temp; FLOAT8 xfsf=0; FLOAT8 sfpow,sfpow34; sfpow = POW20(sf+210); /*pow(2.0,sf/4.0); */ sfpow34 = IPOW20(sf+210); /*pow(sfpow,-3.0/4.0);*/ for ( j=0; j < bw ; ++j) { #if 0 int ix; if (xr34[j]*sfpow34 > IXMAX_VAL) return -1; ix=floor( xr34[j]*sfpow34); temp = fabs(xr[j])- pow43[ix]*sfpow; temp *= temp; if (ix < IXMAX_VAL) { temp2 = fabs(xr[j])- pow43[ix+1]*sfpow; temp2 *=temp2; if (temp2 IXMAX_VAL) return -1; #ifdef TAKEHIRO_IEEE754_HACK temp = sfpow34*xr34[j]; temp += MAGIC_FLOAT; fi.f = temp; fi.f = temp + (adj43asm - MAGIC_INT)[fi.i]; fi.i -= MAGIC_INT; #else temp = xr34[j]*sfpow34; XRPOW_FTOI(temp, fi.i); XRPOW_FTOI(temp + QUANTFAC(fi.i), fi.i); #endif temp = fabs(xr[j])- pow43[fi.i]*sfpow; temp *= temp; #endif #ifdef MAXQUANTERROR xfsf = Max(xfsf,temp); #else xfsf += temp; #endif } #ifdef MAXQUANTERROR return xfsf; #else return xfsf;//bw; #endif } static FLOAT8 calc_sfb_noise_ave(const FLOAT8 *xr, const FLOAT8 *xr34, const int bw, const int sf) { double xp; double xe; double xm; #ifdef TAKEHIRO_IEEE754_HACK double x0; #endif int xx[3], j; fi_union *fi = (fi_union *)xx; FLOAT8 sfpow34_eq, sfpow34_p1, sfpow34_m1; FLOAT8 sfpow_eq, sfpow_p1, sfpow_m1; FLOAT8 xfsf_eq = 0, xfsf_p1 = 0, xfsf_m1 = 0; sfpow_eq = POW20(sf + 210); /*pow(2.0,sf/4.0); */ sfpow_m1 = sfpow_eq * .8408964153; /* pow(2,(sf-1)/4.0) */ sfpow_p1 = sfpow_eq * 1.189207115; sfpow34_eq = IPOW20(sf + 210); /*pow(sfpow,-3.0/4.0);*/ sfpow34_m1 = sfpow34_eq * 1.13878863476; /* .84089 ^ -3/4 */ sfpow34_p1 = sfpow34_eq * 0.878126080187; #ifdef TAKEHIRO_IEEE754_HACK /* * loop unrolled into "Duff's Device". Robert Hegemann */ j = (bw+3) / 4; switch (bw % 4) { default: case 0: do{ DUFFBLOCK(); case 3: DUFFBLOCK(); case 2: DUFFBLOCK(); case 1: DUFFBLOCK(); } while (--j); } #else for (j = 0; j < bw; ++j) { if (xr34[j]*sfpow34_m1 > IXMAX_VAL) return -1; xe = xr34[j]*sfpow34_eq; XRPOW_FTOI(xe, fi[0].i); XRPOW_FTOI(xe + QUANTFAC(fi[0].i), fi[0].i); xe = fabs(xr[j])- pow43[fi[0].i]*sfpow_eq; xe *= xe; xp = xr34[j]*sfpow34_p1; XRPOW_FTOI(xp, fi[0].i); XRPOW_FTOI(xp + QUANTFAC(fi[0].i), fi[0].i); xp = fabs(xr[j])- pow43[fi[0].i]*sfpow_p1; xp *= xp; xm = xr34[j]*sfpow34_m1; XRPOW_FTOI(xm, fi[0].i); XRPOW_FTOI(xm + QUANTFAC(fi[0].i), fi[0].i); xm = fabs(xr[j])- pow43[fi[0].i]*sfpow_m1; xm *= xm; #ifdef MAXQUANTERROR xfsf_eq = Max(xfsf,xm); xfsf_p1 = Max(xfsf_p1,xp); xfsf_m1 = Max(xfsf_m1,xm); #else xfsf_eq += xe; xfsf_p1 += xp; xfsf_m1 += xm; #endif } #endif if (xfsf_eq < xfsf_p1) xfsf_eq = xfsf_p1; if (xfsf_eq < xfsf_m1) xfsf_eq = xfsf_m1; #ifdef MAXQUANTERROR return xfsf_eq; #else return xfsf_eq;//bw; #endif } static int find_scalefac(const FLOAT8 *xr, const FLOAT8 *xr34, const int sfb, const FLOAT8 l3_xmin, const int bw) { FLOAT8 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,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); #if 0 assert(delsf==1); /* when for loop goes up to 7 */ #endif return sf; } static int find_scalefac_ave(const FLOAT8 *xr, const FLOAT8 *xr34, const int sfb, const FLOAT8 l3_xmin, const int bw) { FLOAT8 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); #if 0 assert(delsf==1); /* when for loop goes up to 7 */ #endif return sf; } /* ??? How do the following tables look like for MPEG-2-LSF ??? */ static const int max_range_short[SBPSY_s] = {15, 15, 15, 15, 15, 15, 7, 7, 7, 7, 7, 7 }; static const 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}; static const int max_range_short_lsf[SBPSY_s] = {15, 15, 15, 15, 15, 15, 7, 7, 7, 7, 7, 7 }; /*static const int max_range_short_lsf_pretab[SBPSY_s] = {}*/ static const int max_range_long_lsf[SBPSY_l] = {15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7}; static const int max_range_long_lsf_pretab[SBPSY_l] = { 7,7,7,7,7,7, 3,3,3,3,3, 0,0,0,0, 0,0,0, 0,0,0 }; static int compute_scalefacs_short_lsf ( int sf[SBPSY_s][3],gr_info *cod_info, int scalefac[SBPSY_s][3],int sbg[3]) { int maxrange, maxrange1, maxrange2, maxover; int sfb, i; int ifqstep = ( cod_info->scalefac_scale == 0 ) ? 2 : 4; maxover = 0; maxrange1 = max_range_short_lsf[0]; maxrange2 = max_range_short_lsf[6]; 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 (maxsf1 < -sf[sfb][i]) maxsf1 = -sf[sfb][i]; } else { if (maxsf2 < -sf[sfb][i]) maxsf2 = -sf[sfb][i]; } if (minsf > -sf[sfb][i]) 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 (maxover < -(sf[sfb][i] + scalefac[sfb][i]*ifqstep)) maxover = -(sf[sfb][i] + scalefac[sfb][i]*ifqstep); } } } return maxover; } static int compute_scalefacs_long_lsf ( int sf [SBPSY_l], const gr_info * const cod_info, int scalefac [SBPSY_l] ) { const int * max_range = max_range_long_lsf; int ifqstep = ( cod_info->scalefac_scale == 0 ) ? 2 : 4; int sfb; int maxover; if (cod_info->preflag) { max_range = max_range_long_lsf_pretab; 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[sfb]) scalefac[sfb] = max_range[sfb]; /* sf[sfb] should now be positive: */ if (-(sf[sfb] + scalefac[sfb]*ifqstep) > maxover) { maxover = -(sf[sfb] + scalefac[sfb]*ifqstep); } } } return maxover; } /* 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]; */ static int compute_scalefacs_short(int sf[SBPSY_s][3],gr_info *cod_info, int scalefac[SBPSY_s][3],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]= 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; } /* 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]; */ static 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 * * ************************************************************************/ static int VBR_quantize_granule( lame_global_flags *gfp, FLOAT8 xr34[576], int l3_enc[576], const III_psy_ratio * const ratio, III_scalefac_t * const scalefac, const int gr, const int ch) { lame_internal_flags *gfc=gfp->internal_flags; int status; 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 ( gfc->is_mpeg1 ) status=scale_bitcount(scalefac, cod_info); else status=scale_bitcount_lsf(gfc,scalefac, cod_info); if (status!=0) { return -1; } /* quantize xr34 */ cod_info->part2_3_length = count_bits(gfc,l3_enc,xr34,cod_info); if (cod_info->part2_3_length >= LARGE_BITS) return -2; cod_info->part2_3_length += cod_info->part2_length; if (gfc->use_best_huffman==1) { best_huffman_divide(gfc, gr, ch, cod_info, l3_enc); } return 0; } /*********************************************************************** * * calc_short_block_vbr_sf() * calc_long_block_vbr_sf() * * Mark Taylor 2000-??-?? * Robert Hegemann 2000-10-25 made functions of it * ***********************************************************************/ static const int MAX_SF_DELTA = 4; static int short_block_vbr_sf ( const lame_internal_flags * const gfc, const III_psy_xmin * const l3_xmin, const FLOAT8 xr34_orig[576], const FLOAT8 xr34 [576], III_scalefac_t * const vbrsf ) { int j, sfb, b; int vbrmax = -10000; /* initialize for maximum search */ for (j = 0, sfb = 0; sfb < SBMAX_s; sfb++) { for (b = 0; b < 3; b++) { const int start = gfc->scalefac_band.s[ sfb ]; const int end = gfc->scalefac_band.s[ sfb+1 ]; const int width = end - start; vbrsf->s[sfb][b] = find_scalefac_ave (&xr34[j], &xr34_orig[j], sfb, l3_xmin->s[sfb][b], width); j += width; } } for (sfb = 0; sfb < SBMAX_s; sfb++) { for (b = 0; b < 3; b++) { if (sfb > 0) if (vbrsf->s[sfb][b] > vbrsf->s[sfb-1][b]+MAX_SF_DELTA) vbrsf->s[sfb][b] = vbrsf->s[sfb-1][b]+MAX_SF_DELTA; if (sfb < SBMAX_s-1) if (vbrsf->s[sfb][b] > vbrsf->s[sfb+1][b]+MAX_SF_DELTA) vbrsf->s[sfb][b] = vbrsf->s[sfb+1][b]+MAX_SF_DELTA; if (vbrmax < vbrsf->s[sfb][b]) vbrmax = vbrsf->s[sfb][b]; } } return vbrmax; } static int long_block_vbr_sf ( const lame_internal_flags * const gfc, const III_psy_xmin * const l3_xmin, const FLOAT8 xr34_orig[576], const FLOAT8 xr34 [576], III_scalefac_t * const vbrsf ) { int sfb; int vbrmax = -10000; /* initialize for maximum search */ for (sfb = 0; sfb < SBMAX_l; sfb++) { const int start = gfc->scalefac_band.l[ sfb ]; const int end = gfc->scalefac_band.l[ sfb+1 ]; const int width = end - start; vbrsf->l[sfb] = find_scalefac_ave (&xr34[start], &xr34_orig[start], sfb, l3_xmin->l[sfb], width); } for (sfb = 0; sfb < SBMAX_l; sfb++) { if (sfb > 0) if (vbrsf->l[sfb] > vbrsf->l[sfb-1]+MAX_SF_DELTA) vbrsf->l[sfb] = vbrsf->l[sfb-1]+MAX_SF_DELTA; if (sfb < SBMAX_l-1) if (vbrsf->l[sfb] > vbrsf->l[sfb+1]+MAX_SF_DELTA) vbrsf->l[sfb] = vbrsf->l[sfb+1]+MAX_SF_DELTA; if (vbrmax < vbrsf->l[sfb]) vbrmax = vbrsf->l[sfb]; } return vbrmax; } /* a variation for vbr-mtrh */ static int short_block_sf ( const lame_internal_flags * const gfc, const III_psy_xmin * const l3_xmin, const FLOAT8 xr34_orig[576], const FLOAT8 xr34 [576], III_scalefac_t * const vbrsf ) { int j, sfb, b; int vbrmean, vbrmin, vbrmax; int sf_cache[SBMAX_s]; for (j = 0, sfb = 0; sfb < SBMAX_s; sfb++) { for (b = 0; b < 3; b++) { const int start = gfc->scalefac_band.s[ sfb ]; const int end = gfc->scalefac_band.s[ sfb+1 ]; const int width = end - start; if (0 == gfc->noise_shaping_amp) { /* the faster and sloppier mode to use at lower quality */ vbrsf->s[sfb][b] = find_scalefac (&xr34[j], &xr34_orig[j], sfb, l3_xmin->s[sfb][b], width); } else { /* the slower and better mode to use at higher quality */ vbrsf->s[sfb][b] = find_scalefac_ave (&xr34[j], &xr34_orig[j], sfb, l3_xmin->s[sfb][b], width); } j += width; } } vbrmax = -10000; for (b = 0; b < 3; b++) { /* make working copy, select_kth_int will reorder! */ for (sfb = 0; sfb < SBMAX_s; sfb++) sf_cache[sfb] = vbrsf->s[sfb][b]; /* find median value, take it as mean */ vbrmean = select_kth_int (sf_cache, SBMAX_s, (SBMAX_s+1)/2); /* get min value */ vbrmin = 10000; for (sfb = 0; sfb < SBMAX_s; sfb++) { if (vbrmin > vbrsf->s[sfb][b]) vbrmin = vbrsf->s[sfb][b]; } /* patch sfb12 */ vbrsf->s[SBPSY_s][b] = Min (vbrsf->s[SBPSY_s][b], vbrmean); vbrsf->s[SBPSY_s][b] = Max (vbrsf->s[SBPSY_s][b], vbrmin-(vbrmean-vbrmin)); /* cut peaks */ for (sfb = 0; sfb < SBMAX_s; sfb++) { if (vbrsf->s[sfb][b] > vbrmean+(vbrmean-vbrmin)) vbrsf->s[sfb][b] = vbrmean+(vbrmean-vbrmin); } /* get max value */ for (sfb = 0; sfb < SBMAX_s; sfb++) { if (vbrmax < vbrsf->s[sfb][b]) vbrmax = vbrsf->s[sfb][b]; } } return vbrmax; } /* a variation for vbr-mtrh */ static int long_block_sf ( const lame_internal_flags * const gfc, const III_psy_xmin * const l3_xmin, const FLOAT8 xr34_orig[576], const FLOAT8 xr34 [576], III_scalefac_t * const vbrsf ) { int sfb; int vbrmean, vbrmin, vbrmax; int sf_cache[SBMAX_l]; for (sfb = 0; sfb < SBMAX_l; sfb++) { const int start = gfc->scalefac_band.l[ sfb ]; const int end = gfc->scalefac_band.l[ sfb+1 ]; const int width = end - start; if (0 == gfc->noise_shaping_amp) { /* the faster and sloppier mode to use at lower quality */ vbrsf->l[sfb] = find_scalefac (&xr34[start], &xr34_orig[start], sfb, l3_xmin->l[sfb], width); } else { /* the slower and better mode to use at higher quality */ vbrsf->l[sfb] = find_scalefac_ave (&xr34[start], &xr34_orig[start], sfb, l3_xmin->l[sfb], width); } } /* make working copy, select_kth_int will reorder! */ for (sfb = 0; sfb < SBMAX_l; sfb++) sf_cache[sfb] = vbrsf->l[sfb]; /* find median value, take it as mean */ vbrmean = select_kth_int (sf_cache, SBMAX_l, (SBMAX_l+1)/2); /* get min value */ vbrmin = +10000; for (sfb = 0; sfb < SBMAX_l; sfb++) { if (vbrmin > vbrsf->l[sfb]) vbrmin = vbrsf->l[sfb]; } /* patch sfb21 */ vbrsf->l[SBPSY_l] = Min (vbrsf->l[SBPSY_l], vbrmean); vbrsf->l[SBPSY_l] = Max (vbrsf->l[SBPSY_l], vbrmin-(vbrmean-vbrmin)); /* cut peaks */ for (sfb = 0; sfb < SBMAX_l; sfb++) { if (vbrsf->l[sfb] > vbrmean+(vbrmean-vbrmin)) vbrsf->l[sfb] = vbrmean+(vbrmean-vbrmin); } /* get max value */ vbrmax = -10000; for (sfb = 0; sfb < SBMAX_l; sfb++) { if (vbrmax < vbrsf->l[sfb]) vbrmax = vbrsf->l[sfb]; } return vbrmax; } /****************************************************************** * * short block scalefacs * ******************************************************************/ static void short_block_scalefacs ( lame_global_flags *gfp, gr_info * const cod_info, III_scalefac_t * const scalefac, III_scalefac_t * const vbrsf, int * const VBRmax ) { lame_internal_flags *gfc=gfp->internal_flags; const int * max_range; int sfb, b; int maxover, maxover0, maxover1, mover; int v0, v1; int minsfb; int vbrmax = *VBRmax; max_range = gfc->is_mpeg1 ? max_range_short : max_range_short_lsf; maxover0 = 0; maxover1 = 0; for (sfb = 0; sfb < SBPSY_s; sfb++) { for (b = 0; b < 3; b++) { v0 = (vbrmax - vbrsf->s[sfb][b]) - (4*14 + 2*max_range[sfb]); v1 = (vbrmax - vbrsf->s[sfb][b]) - (4*14 + 4*max_range[sfb]); if (maxover0 < v0) maxover0 = v0; if (maxover1 < v1) maxover1 = v1; } } if (gfc->noise_shaping == 2) /* allow scalefac_scale=1 */ mover = Min (maxover0, maxover1); else mover = maxover0; 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; assert(cod_info->global_gain < 256); if (vbr_mtrh == gfp->VBR && cod_info->global_gain > 1) { /* just to be safe, reduce global_gain by one */ cod_info->global_gain -= 1; } if (cod_info->global_gain > 255) cod_info->global_gain = 255; for (sfb = 0; sfb < SBPSY_s; sfb++) { for (b = 0; b < 3; b++) { vbrsf->s[sfb][b] -= vbrmax; } } if ( gfc->is_mpeg1 ) maxover = compute_scalefacs_short (vbrsf->s, cod_info, scalefac->s, cod_info->subblock_gain); else maxover = compute_scalefacs_short_lsf (vbrsf->s, cod_info, scalefac->s, cod_info->subblock_gain); assert (maxover <= 0); /* adjust global_gain so at least 1 subblock gain = 0 */ minsfb = 999; /* prepare for minimum search */ for (b = 0; b < 3; b++) if (minsfb > cod_info->subblock_gain[b]) minsfb = cod_info->subblock_gain[b]; if (minsfb > cod_info->global_gain/8) minsfb = cod_info->global_gain/8; vbrmax -= 8*minsfb; cod_info->global_gain -= 8*minsfb; for (b = 0; b < 3; b++) cod_info->subblock_gain[b] -= minsfb; *VBRmax = vbrmax; } /****************************************************************** * * long block scalefacs * ******************************************************************/ static void long_block_scalefacs ( lame_global_flags *gfp, gr_info * const cod_info, III_scalefac_t * const scalefac, III_scalefac_t * const vbrsf, int * const VBRmax ) { lame_internal_flags *gfc=gfp->internal_flags; const int * max_range; const int * max_rangep; int sfb; int maxover, maxover0, maxover1, maxover0p, maxover1p, mover; int v0, v1, v0p, v1p; int vbrmax = *VBRmax; max_range = gfc->is_mpeg1 ? max_range_long : max_range_long_lsf; max_rangep = gfc->is_mpeg1 ? max_range_long : max_range_long_lsf_pretab; maxover0 = 0; maxover1 = 0; maxover0p = 0; /* pretab */ maxover1p = 0; /* pretab */ for ( sfb = 0; sfb < SBPSY_l; sfb++ ) { v0 = (vbrmax - vbrsf->l[sfb]) - 2*max_range[sfb]; v1 = (vbrmax - vbrsf->l[sfb]) - 4*max_range[sfb]; v0p = (vbrmax - vbrsf->l[sfb]) - 2*(max_rangep[sfb]+pretab[sfb]); v1p = (vbrmax - vbrsf->l[sfb]) - 4*(max_rangep[sfb]+pretab[sfb]); if (maxover0 < v0) maxover0 = v0; if (maxover1 < v1) maxover1 = v1; if (maxover0p < v0p) maxover0p = v0p; if (maxover1p < v1p) maxover1p = v1p; } mover = Min (maxover0, maxover0p); if (gfc->noise_shaping == 2) { /* allow scalefac_scale=1 */ mover = Min (mover, maxover1); mover = Min (mover, maxover1p); } 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 { assert(0); /* this should not happen */ } /* sf = (cod_info->global_gain-210.0) */ cod_info->global_gain = vbrmax + 210; assert (cod_info->global_gain < 256); if (vbr_mtrh == gfp->VBR && cod_info->global_gain > 1) { /* just to be safe, reduce global gain by one */ cod_info->global_gain -= 1; } if (cod_info->global_gain > 255) cod_info->global_gain = 255; for (sfb = 0; sfb < SBPSY_l; sfb++) vbrsf->l[sfb] -= vbrmax; if ( gfc->is_mpeg1 == 1 ) maxover = compute_scalefacs_long (vbrsf->l, cod_info, scalefac->l); else maxover = compute_scalefacs_long_lsf (vbrsf->l, cod_info, scalefac->l); assert (maxover <= 0); *VBRmax = vbrmax; } /*********************************************************************** * * calc_fac() * * Mark Taylor 2000-??-?? * Robert Hegemann 2000-10-20 made functions of it * ***********************************************************************/ static FLOAT8 calc_fac ( const int ifac ) { if (ifac+210 < Q_MAX) return 1/IPOW20 (ifac+210); else return pow (2.0, 0.75*ifac/4.0); } /*********************************************************************** * * quantize xr34 based on scalefactors * * calc_short_block_xr34 * calc_long_block_xr34 * * Mark Taylor 2000-??-?? * Robert Hegemann 2000-10-20 made functions of them * ***********************************************************************/ static void short_block_xr34 ( const lame_internal_flags * const gfc, const gr_info * const cod_info, const III_scalefac_t * const scalefac, const FLOAT8 xr34_orig[576], FLOAT8 xr34 [576] ) { int sfb, l, j, b; int ifac, ifqstep, start, end; FLOAT8 fac; /* even though there is no scalefactor for sfb12 * subblock gain affects upper frequencies too, that's why * we have to go up to SBMAX_s */ ifqstep = ( cod_info->scalefac_scale == 0 ) ? 2 : 4; for ( j = 0, sfb = 0; sfb < SBMAX_s; sfb++ ) { start = gfc->scalefac_band.s[ sfb ]; end = gfc->scalefac_band.s[ sfb+1 ]; for (b = 0; b < 3; b++) { ifac = 8*cod_info->subblock_gain[b]+ifqstep*scalefac->s[sfb][b]; fac = calc_fac( ifac ); /* * loop unrolled into "Duff's Device". Robert Hegemann */ l = (end-start+7) / 8; switch ((end-start) % 8) { default: case 0: do{ xr34[j] = xr34_orig[j]*fac; j++; case 7: xr34[j] = xr34_orig[j]*fac; j++; case 6: xr34[j] = xr34_orig[j]*fac; j++; case 5: xr34[j] = xr34_orig[j]*fac; j++; case 4: xr34[j] = xr34_orig[j]*fac; j++; case 3: xr34[j] = xr34_orig[j]*fac; j++; case 2: xr34[j] = xr34_orig[j]*fac; j++; case 1: xr34[j] = xr34_orig[j]*fac; j++; } while (--l); } } } } static void long_block_xr34 ( const lame_internal_flags * const gfc, const gr_info * const cod_info, const III_scalefac_t * const scalefac, const FLOAT8 xr34_orig[576], FLOAT8 xr34 [576] ) { int sfb, l, j; int ifac, ifqstep, start, end; FLOAT8 fac; ifqstep = ( cod_info->scalefac_scale == 0 ) ? 2 : 4; for ( sfb = 0; sfb < SBMAX_l; sfb++ ) { ifac = ifqstep*scalefac->l[sfb]; if (cod_info->preflag) ifac += ifqstep*pretab[sfb]; fac = calc_fac( ifac ); start = gfc->scalefac_band.l[ sfb ]; end = gfc->scalefac_band.l[ sfb+1 ]; /* * loop unrolled into "Duff's Device". Robert Hegemann */ j = start; l = (end-start+7) / 8; switch ((end-start) % 8) { default: case 0: do{ xr34[j] = xr34_orig[j]*fac; j++; case 7: xr34[j] = xr34_orig[j]*fac; j++; case 6: xr34[j] = xr34_orig[j]*fac; j++; case 5: xr34[j] = xr34_orig[j]*fac; j++; case 4: xr34[j] = xr34_orig[j]*fac; j++; case 3: xr34[j] = xr34_orig[j]*fac; j++; case 2: xr34[j] = xr34_orig[j]*fac; j++; case 1: xr34[j] = xr34_orig[j]*fac; j++; } while (--l); } } } /************************************************************************ * * 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? * ************************************************************************/ static int VBR_noise_shaping ( lame_global_flags *gfp, FLOAT8 xr [576], FLOAT8 xr34orig [576], III_psy_ratio *ratio, int l3_enc [576], int digital_silence, int minbits, int maxbits, III_scalefac_t *scalefac, III_psy_xmin *l3_xmin, int gr, int ch ) { lame_internal_flags *gfc=gfp->internal_flags; III_scalefac_t save_sf; III_scalefac_t vbrsf; gr_info *cod_info; FLOAT8 xr34[576]; int shortblock; int vbrmax; int global_gain_adjust = 0; cod_info = &gfc->l3_side.gr[gr].ch[ch].tt; shortblock = (cod_info->block_type == SHORT_TYPE); if (shortblock) vbrmax = short_block_vbr_sf (gfc, l3_xmin, xr34orig, xr, &vbrsf); else vbrmax = long_block_vbr_sf (gfc, l3_xmin, xr34orig, xr, &vbrsf); /* save a copy of vbrsf, incase we have to recomptue scalefacs */ memcpy (&save_sf, &vbrsf, sizeof(III_scalefac_t)); do { memset (scalefac, 0, sizeof(III_scalefac_t)); if (shortblock) { short_block_scalefacs (gfp, cod_info, scalefac, &vbrsf, &vbrmax); short_block_xr34 (gfc, cod_info, scalefac, xr34orig, xr34); } else { long_block_scalefacs (gfp, cod_info, scalefac, &vbrsf, &vbrmax); long_block_xr34 (gfc, cod_info, scalefac, xr34orig, xr34); } VBR_quantize_granule (gfp, xr34, l3_enc, ratio, scalefac, gr, ch); /* decrease noise until we use at least minbits */ if (cod_info->part2_3_length < minbits) { if (digital_silence) break; //if (cod_info->part2_3_length == cod_info->part2_length) break; if (vbrmax+210 == 0) break; /* decrease global gain, recompute scale factors */ --vbrmax; --global_gain_adjust; memcpy (&vbrsf, &save_sf, sizeof(III_scalefac_t)); } } while (cod_info->part2_3_length < minbits); /* inject noise until we meet our bit limit */ while (cod_info->part2_3_length > Min (maxbits, MAX_BITS)) { /* increase global gain, keep existing scale factors */ ++cod_info->global_gain; if (cod_info->global_gain > 255) ERRORF (gfc,"%ld impossible to encode ??? frame! bits=%d\n", // gfp->frameNum, cod_info->part2_3_length); -1, cod_info->part2_3_length); VBR_quantize_granule (gfp, xr34, l3_enc, ratio, scalefac, gr, ch); ++global_gain_adjust; } return global_gain_adjust; } /************************************************************************ * * VBR_noise_shaping2() * * may result in a need of too many bits, then do it CBR like * * Robert Hegemann 2000-10-25 * ***********************************************************************/ int VBR_noise_shaping2 ( lame_global_flags *gfp, FLOAT8 xr [576], FLOAT8 xr34orig [576], III_psy_ratio * const ratio, int l3_enc [576], int digital_silence, int minbits, int maxbits, III_scalefac_t * const scalefac, III_psy_xmin * const l3_xmin, int gr, int ch ) { lame_internal_flags *gfc=gfp->internal_flags; III_scalefac_t vbrsf; gr_info *cod_info; FLOAT8 xr34[576]; int shortblock, ret, bits, huffbits; int vbrmax, best_huffman = gfc->use_best_huffman; cod_info = &gfc->l3_side.gr[gr].ch[ch].tt; shortblock = (cod_info->block_type == SHORT_TYPE); if (shortblock) { vbrmax = short_block_sf (gfc, l3_xmin, xr34orig, xr, &vbrsf); short_block_scalefacs (gfp, cod_info, scalefac, &vbrsf, &vbrmax); short_block_xr34 (gfc, cod_info, scalefac, xr34orig, xr34); } else { vbrmax = long_block_sf (gfc, l3_xmin, xr34orig, xr, &vbrsf); long_block_scalefacs (gfp, cod_info, scalefac, &vbrsf, &vbrmax); long_block_xr34 (gfc, cod_info, scalefac, xr34orig, xr34); } gfc->use_best_huffman = 0; /* we will do it later */ ret = VBR_quantize_granule (gfp, xr34, l3_enc, ratio, scalefac, gr, ch); gfc->use_best_huffman = best_huffman; if (ret == -1) /* Houston, we have a problem */ return -1; if (cod_info->part2_3_length < minbits) { huffbits = minbits - cod_info->part2_length; bits = bin_search_StepSize (gfc, cod_info, huffbits, gfc->OldValue[ch], xr34, l3_enc); gfc->OldValue[ch] = cod_info->global_gain; cod_info->part2_3_length = bits + cod_info->part2_length; } if (cod_info->part2_3_length > maxbits) { huffbits = maxbits - cod_info->part2_length; bits = bin_search_StepSize (gfc, cod_info, huffbits, gfc->OldValue[ch], xr34, l3_enc); gfc->OldValue[ch] = cod_info->global_gain; cod_info->part2_3_length = bits; if (bits > huffbits) { bits = inner_loop (gfc, cod_info, huffbits, xr34, l3_enc); cod_info->part2_3_length = bits; } if (bits >= LARGE_BITS) /* Houston, we have a problem */ return -2; cod_info->part2_3_length += cod_info->part2_length; } if (cod_info->part2_length >= LARGE_BITS) /* Houston, we have a problem */ return -2; assert (cod_info->global_gain < 256); return 0; } void VBR_quantize(lame_global_flags *gfp, FLOAT8 pe[2][2], FLOAT8 ms_ener_ratio[2], FLOAT8 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; III_psy_xmin l3_xmin[2][2]; int minbits,maxbits,max_frame_bits,totbits,gr,ch,i,bits_ok; int bitsPerFrame,mean_bits; int analog_silence; FLOAT8 qadjust; III_side_info_t * l3_side; gr_info *cod_info; int digital_silence[2][2]; FLOAT8 masking_lower_db=0; FLOAT8 xr34[2][2][576]; // static const FLOAT8 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 FLOAT8 dbQ[10]= {-5.5,-4.25,-3.0,-2.50, -1.75, -.75, -.5, -.25, .25, .75};*/ /* a third dbQ table ?!? */ static const FLOAT8 dbQ[10]= {-6.06,-4.4,-2.9,-1.57, -0.4, 0.61, 1.45, 2.13, 2.65, 3.0}; qadjust=0; /* start with -1 db quality improvement over quantize.c VBR */ l3_side = &gfc->l3_side; //gfc->ATHlower += (4-gfp->VBR_q)*4.0; //if (gfc->ATHlower < 0) gfc->ATHlower=0; /* now find out: if the frame can be considered analog silent * if each granule can be considered digital silent * and calculate l3_xmin and the fresh xr34 array */ assert( gfp->VBR_q <= 9 ); assert( gfp->VBR_q >= 0 ); analog_silence=1; for (gr = 0; gr < gfc->mode_gr; gr++) { /* copy data to be quantized into xr */ if (gfc->mode_ext==MPG_MD_MS_LR) { ms_convert(xr[gr],xr[gr]); } for (ch = 0; ch < gfc->channels_out; ch++) { /* if in the following sections the quality would not be adjusted * then we would only have to call calc_xmin once here and * could drop subsequently calls (rh 2000/07/17) */ int over_ath; cod_info = &l3_side->gr[gr].ch[ch].tt; cod_info->part2_3_length=LARGE_BITS; if (cod_info->block_type == SHORT_TYPE) { cod_info->sfb_lmax = 0; /* No sb*/ cod_info->sfb_smin = 0; } else { /* MPEG 1 doesnt use last scalefactor band */ cod_info->sfb_lmax = SBPSY_l; cod_info->sfb_smin = SBPSY_s; /* No sb */ if (cod_info->mixed_block_flag) { cod_info->sfb_lmax = 8; cod_info->sfb_smin = 3; } } /* quality setting */ masking_lower_db = dbQ[gfp->VBR_q]; if (pe[gr][ch]>750) { masking_lower_db -= Min(10,4*(pe[gr][ch]-750.)/750.); } gfc->masking_lower = pow(10.0,masking_lower_db/10); /* masking thresholds */ over_ath = calc_xmin(gfp,xr[gr][ch],&ratio[gr][ch],cod_info,&l3_xmin[gr][ch]); /* if there are bands with more energy than the ATH * then we say the frame is not analog silent */ if (over_ath) { analog_silence = 0; } /* if there is no line with more energy than 1e-20 * then this granule is considered to be digital silent * plus calculation of xr34 */ digital_silence[gr][ch] = 1; for(i=0;i<576;i++) { FLOAT8 temp=fabs(xr[gr][ch][i]); xr34[gr][ch][i]=sqrt(sqrt(temp)*temp); digital_silence[gr][ch] &= temp < 1E-20; } } /* ch */ } /* gr */ /* compute minimum allowed bits from minimum allowed bitrate */ if (analog_silence) { gfc->bitrate_index=1; } else { gfc->bitrate_index=gfc->VBR_min_bitrate; } getframebits(gfp, &bitsPerFrame, &mean_bits); minbits = (mean_bits/gfc->channels_out); /* compute maximum allowed bits from max allowed bitrate */ 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/gfc->channels_out); { /* compute a target mean_bits based on compression ratio * which was set based on VBR_q */ int bit_rate = gfp->out_samplerate*16*gfc->channels_out/(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,125); minbits=Max(minbits,.40*(mean_bits/gfc->channels_out)); maxbits=Min(maxbits,2.5*(mean_bits/gfc->channels_out)); /* * 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++) { int minbits_lr[2]; minbits_lr[0]=minbits; minbits_lr[1]=minbits; #if 0 if (gfc->mode_ext==MPG_MD_MS_LR) { FLOAT8 fac; fac = .33*(.5-ms_ener_ratio[gr])/.5; if (fac<0) fac=0; if (fac>.5) fac=.5; minbits_lr[0] = (1+fac)*minbits; minbits_lr[1] = Max(125,(1-fac)*minbits); } #endif for (ch = 0; ch < gfc->channels_out; ch++) { int adjusted,shortblock; cod_info = &l3_side->gr[gr].ch[ch].tt; /* 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->channels_out*gfc->mode_gr))) { shortblock = (cod_info->block_type == SHORT_TYPE); /* Adjust allowed masking based on quality setting */ if (qadjust!=0 /*|| shortblock*/) { masking_lower_db = dbQ[gfp->VBR_q] + qadjust; /* if (shortblock) masking_lower_db -= 4; */ if (pe[gr][ch]>750) masking_lower_db -= Min(10,4*(pe[gr][ch]-750.)/750.); gfc->masking_lower = pow(10.0,masking_lower_db/10); calc_xmin( gfp, xr[gr][ch], ratio[gr]+ch, cod_info, l3_xmin[gr]+ch); } /* digital silent granules do not need the full round trip, * but this can be optimized later on */ adjusted = VBR_noise_shaping (gfp,xr[gr][ch],xr34[gr][ch], ratio[gr]+ch,l3_enc[gr][ch], digital_silence[gr][ch], minbits_lr[ch], maxbits,scalefac[gr]+ch, l3_xmin[gr]+ch,gr,ch); if (adjusted>10) { /* global_gain was changed by a large amount to get bits < maxbits */ /* quality is set to high. we could set bits = LARGE_BITS * to force re-encoding. But most likely the other channels/granules * will also use too many bits, and the entire frame will * be > max_frame_bits, forcing re-encoding below. */ // cod_info->part2_3_bits = LARGE_BITS; } } totbits += cod_info->part2_3_length; } } bits_ok=1; if (totbits>max_frame_bits) { /* lower quality */ qadjust += Max(.125,Min(1,(totbits-max_frame_bits)/300.0)); /* adjusting minbits and maxbits is necessary too * cos lowering quality is not enough in rare cases * when each granule still needs almost maxbits, it wont fit */ minbits = Max(125,minbits*0.975); maxbits = Max(minbits,maxbits*0.975); // DEBUGF("%i totbits>max_frame_bits totbits=%i maxbits=%i \n",gfp->frameNum,totbits,max_frame_bits); // DEBUGF("next masking_lower_db = %f \n",masking_lower_db + qadjust); 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->channels_out; ch++) { best_scalefac_store(gfc, gr, ch, l3_enc, l3_side, scalefac); totbits += l3_side->gr[gr].ch[ch].tt.part2_3_length; } } if (analog_silence && !gfp->VBR_hard_min) { gfc->bitrate_index = 1; } else { gfc->bitrate_index = gfc->VBR_min_bitrate; } for( ; 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); } // DEBUGF("%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->channels_out; ch++) { cod_info = &l3_side->gr[gr].ch[ch].tt; ResvAdjust (gfc, 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 (gfc, l3_side, mean_bits); }