home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 2000 #5 / Amiga Plus CD - 2000 - No. 5.iso / Tools / Dev / lame_src / vbrquantize.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-01-01  |  25.1 KB  |  965 lines
  1. /*
  2.  *    MP3 quantization
  3.  *
  4.  *    Copyright (c) 1999 Mark Taylor
  5.  *
  6.  * This program is free software; you can redistribute it and/or modify
  7.  * it under the terms of the GNU General Public License as published by
  8.  * the Free Software Foundation; either version 2, or (at your option)
  9.  * any later version.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program; see the file COPYING.  If not, write to
  18.  * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  19.  */
  20. #include <assert.h>
  21. #include "util.h"
  22. #include "l3side.h"
  23. #include "quantize.h"
  24. #include "reservoir.h"
  25. #include "quantize-pvt.h"
  26. #include "gtkanal.h"
  27.  
  28.  
  29. #if (defined(__GNUC__) && defined(__i386__))
  30. #define USE_GNUC_ASM
  31. #endif
  32. #ifdef _MSC_VER
  33. #define USE_MSC_ASM
  34. #endif
  35.  
  36.  
  37.  
  38. /*********************************************************************
  39.  * XRPOW_FTOI is a macro to convert floats to ints.  
  40.  * if XRPOW_FTOI(x) = nearest_int(x), then QUANTFAC(x)=adj43asm[x]
  41.  *                                         ROUNDFAC= -0.0946
  42.  *
  43.  * if XRPOW_FTOI(x) = floor(x), then QUANTFAC(x)=asj43[x]   
  44.  *                                   ROUNDFAC=0.4054
  45.  *********************************************************************/
  46. #ifdef USE_GNUC_ASM
  47. #  define QUANTFAC(rx)  adj43asm[rx]
  48. #  define ROUNDFAC -0.0946
  49. #  define XRPOW_FTOI(src, dest) \
  50.      asm ("fistpl %0 " : "=m"(dest) : "t"(src) : "st")
  51. #elif defined (USE_MSC_ASM)
  52. #  define QUANTFAC(rx)  adj43asm[rx]
  53. #  define ROUNDFAC -0.0946
  54. #  define XRPOW_FTOI(src, dest) do { \
  55.      FLOAT8 src_ = (src); \
  56.      int dest_; \
  57.      { \
  58.        __asm fld src_ \
  59.        __asm fistp dest_ \
  60.      } \
  61.      (dest) = dest_; \
  62.    } while (0)
  63. #else
  64. #  define QUANTFAC(rx)  adj43[rx]
  65. #  define ROUNDFAC 0.4054
  66. #  define XRPOW_FTOI(src,dest) ((dest) = (int)(src))
  67. #endif
  68.  
  69.  
  70.  
  71. #undef MAXQUANTERROR
  72.  
  73.  
  74. FLOAT8 calc_sfb_noise(FLOAT8 *xr, FLOAT8 *xr34, int bw, int sf)
  75. {
  76.   int j;
  77.   FLOAT8 xfsf=0;
  78.   FLOAT8 sfpow,sfpow34;
  79.  
  80.   sfpow = POW20(sf+210); /*pow(2.0,sf/4.0); */
  81.   sfpow34  = IPOW20(sf+210); /*pow(sfpow,-3.0/4.0);*/
  82.  
  83.   for ( j=0; j < bw ; ++j) {
  84.     int ix;
  85.     FLOAT8 temp;
  86.  
  87. #if 0
  88.     if (xr34[j]*sfpow34 > IXMAX_VAL) return -1;
  89.     ix=floor( xr34[j]*sfpow34);
  90.     temp = fabs(xr[j])- pow43[ix]*sfpow;
  91.     temp *= temp;
  92.  
  93.     if (ix < IXMAX_VAL) {
  94.       temp2 = fabs(xr[j])- pow43[ix+1]*sfpow;
  95.       temp2 *=temp2;
  96.       if (temp2<temp) {
  97.     temp=temp2;
  98.     ++ix;
  99.       }
  100.     }
  101. #else
  102.     if (xr34[j]*sfpow34 > IXMAX_VAL) return -1;
  103.  
  104.     temp = xr34[j]*sfpow34;
  105.     XRPOW_FTOI(temp, ix);
  106.     XRPOW_FTOI(temp + QUANTFAC(ix), ix);
  107.     temp = fabs(xr[j])- pow43[ix]*sfpow;
  108.     temp *= temp;
  109.     
  110. #endif
  111.     
  112. #ifdef MAXQUANTERROR
  113.     xfsf = Max(xfsf,temp);
  114. #else
  115.     xfsf += temp;
  116. #endif
  117.   }
  118. #ifdef MAXQUANTERROR
  119.   return xfsf;
  120. #else
  121.   return xfsf/bw;
  122. #endif
  123. }
  124.  
  125.  
  126.  
  127.  
  128.  
  129. FLOAT8 calc_sfb_noise_ave(FLOAT8 *xr, FLOAT8 *xr34, int bw,int sf)
  130. {
  131.   int j;
  132.   FLOAT8 xfsf=0, xfsf_p1=0, xfsf_m1=0;
  133.   FLOAT8 sfpow34,sfpow34_p1,sfpow34_m1;
  134.   FLOAT8 sfpow,sfpow_p1,sfpow_m1;
  135.  
  136.   sfpow = POW20(sf+210); /*pow(2.0,sf/4.0); */
  137.   sfpow34  = IPOW20(sf+210); /*pow(sfpow,-3.0/4.0);*/
  138.  
  139.   sfpow_m1 = sfpow*.8408964153;  /* pow(2,(sf-1)/4.0) */
  140.   sfpow34_m1 = sfpow34*1.13878863476;       /* .84089 ^ -3/4 */
  141.  
  142.   sfpow_p1 = sfpow*1.189207115;  
  143.   sfpow34_p1 = sfpow34*0.878126080187;
  144.  
  145.   for ( j=0; j < bw ; ++j) {
  146.     int ix;
  147.     FLOAT8 temp,temp_p1,temp_m1;
  148.  
  149.     if (xr34[j]*sfpow34_m1 > IXMAX_VAL) return -1;
  150.  
  151.     temp = xr34[j]*sfpow34;
  152.     XRPOW_FTOI(temp, ix);
  153.     XRPOW_FTOI(temp + QUANTFAC(ix), ix);
  154.     temp = fabs(xr[j])- pow43[ix]*sfpow;
  155.     temp *= temp;
  156.  
  157.     temp_p1 = xr34[j]*sfpow34_p1;
  158.     XRPOW_FTOI(temp_p1, ix);
  159.     XRPOW_FTOI(temp_p1 + QUANTFAC(ix), ix);
  160.     temp_p1 = fabs(xr[j])- pow43[ix]*sfpow_p1;
  161.     temp_p1 *= temp_p1;
  162.     
  163.     temp_m1 = xr34[j]*sfpow34_m1;
  164.     XRPOW_FTOI(temp_m1, ix);
  165.     XRPOW_FTOI(temp_m1 + QUANTFAC(ix), ix);
  166.     temp_m1 = fabs(xr[j])- pow43[ix]*sfpow_m1;
  167.     temp_m1 *= temp_m1;
  168.  
  169. #ifdef MAXQUANTERROR
  170.     xfsf = Max(xfsf,temp);
  171.     xfsf_p1 = Max(xfsf_p1,temp_p1);
  172.     xfsf_m1 = Max(xfsf_m1,temp_m1);
  173. #else
  174.     xfsf += temp;
  175.     xfsf_p1 += temp_p1;
  176.     xfsf_m1 += temp_m1;
  177. #endif
  178.   }
  179.   if (xfsf_p1>xfsf) xfsf = xfsf_p1;
  180.   if (xfsf_m1>xfsf) xfsf = xfsf_m1;
  181. #ifdef MAXQUANTERROR
  182.   return xfsf;
  183. #else
  184.   return xfsf/bw;
  185. #endif
  186. }
  187.  
  188.  
  189.  
  190. int find_scalefac(FLOAT8 *xr,FLOAT8 *xr34,int sfb,
  191.              FLOAT8 l3_xmin,int bw)
  192. {
  193.   FLOAT8 xfsf;
  194.   int i,sf,sf_ok,delsf;
  195.  
  196.   /* search will range from sf:  -209 -> 45  */
  197.   sf = -82;
  198.   delsf = 128;
  199.  
  200.   sf_ok=10000;
  201.   for (i=0; i<7; i++) {
  202.     delsf /= 2;
  203.     //      xfsf = calc_sfb_noise(xr,xr34,bw,sf);
  204.     xfsf = calc_sfb_noise_ave(xr,xr34,bw,sf);
  205.  
  206.     if (xfsf < 0) {
  207.       /* scalefactors too small */
  208.       sf += delsf;
  209.     }else{
  210.       if (sf_ok==10000) sf_ok=sf;  
  211.       if (xfsf > l3_xmin)  {
  212.     /* distortion.  try a smaller scalefactor */
  213.     sf -= delsf;
  214.       }else{
  215.     sf_ok = sf;
  216.     sf += delsf;
  217.       }
  218.     }
  219.   } 
  220.   assert(sf_ok!=10000);
  221.   //  assert(delsf==1);  /* when for loop goes up to 7 */
  222.  
  223.   return sf;
  224. }
  225.  
  226.  
  227.  
  228. /*
  229.     sfb=0..5  scalefac < 16 
  230.     sfb>5     scalefac < 8
  231.  
  232.     ifqstep = ( cod_info->scalefac_scale == 0 ) ? 2 : 4;
  233.     ol_sf =  (cod_info->global_gain-210.0);
  234.     ol_sf -= 8*cod_info->subblock_gain[i];
  235.     ol_sf -= ifqstep*scalefac[gr][ch].s[sfb][i];
  236.  
  237. */
  238. int compute_scalefacs_short(int sf[SBPSY_s][3],gr_info *cod_info,
  239. int scalefac[SBPSY_s][3],unsigned int sbg[3])
  240. {
  241.   int maxrange,maxrange1,maxrange2,maxover;
  242.   int sfb,i;
  243.   int ifqstep = ( cod_info->scalefac_scale == 0 ) ? 2 : 4;
  244.  
  245.   maxover=0;
  246.   maxrange1 = 15;
  247.   maxrange2 = 7;
  248.  
  249.  
  250.   for (i=0; i<3; ++i) {
  251.     int maxsf1=0,maxsf2=0,minsf=1000;
  252.     /* see if we should use subblock gain */
  253.     for ( sfb = 0; sfb < SBPSY_s; sfb++ ) {
  254.       if (sfb < 6) {
  255.     if (-sf[sfb][i]>maxsf1) maxsf1 = -sf[sfb][i];
  256.       } else {
  257.     if (-sf[sfb][i]>maxsf2) maxsf2 = -sf[sfb][i];
  258.       }
  259.       if (-sf[sfb][i]<minsf) minsf = -sf[sfb][i];
  260.     }
  261.  
  262.     /* boost subblock gain as little as possible so we can
  263.      * reach maxsf1 with scalefactors 
  264.      * 8*sbg >= maxsf1   
  265.      */
  266.     maxsf1 = Max(maxsf1-maxrange1*ifqstep,maxsf2-maxrange2*ifqstep);
  267.     sbg[i]=0;
  268.     if (minsf >0 ) sbg[i] = floor(.125*minsf + .001);
  269.     if (maxsf1 > 0)  sbg[i]  = Max(sbg[i],maxsf1/8 + (maxsf1 % 8 != 0));
  270.     if (sbg[i] > 7) sbg[i]=7;
  271.  
  272.  
  273.     for ( sfb = 0; sfb < SBPSY_s; sfb++ ) {
  274.       sf[sfb][i] += 8*sbg[i];
  275.  
  276.       if (sf[sfb][i] < 0) {
  277.     maxrange = sfb < 6 ? maxrange1 : maxrange2;
  278.     scalefac[sfb][i]=-sf[sfb][i]/ifqstep + (-sf[sfb][i]%ifqstep != 0);
  279.     if (scalefac[sfb][i]>maxrange) scalefac[sfb][i]=maxrange;
  280.     
  281.     if (-(sf[sfb][i] + scalefac[sfb][i]*ifqstep) >maxover)  {
  282.       maxover=-(sf[sfb][i] + scalefac[sfb][i]*ifqstep);
  283.     }
  284.       }
  285.     }
  286.   }
  287.  
  288.   return maxover;
  289. }
  290.  
  291.  
  292.  
  293.  
  294.  
  295. int max_range_short[SBPSY_s]=
  296. {15, 15, 15, 15, 15, 15 ,  7,    7,    7,    7,   7,     7 };
  297. int max_range_long[SBPSY_l]=
  298. {15,   15,  15,  15,  15,  15,  15,  15,  15,  15,  15,   7,   7,   7,   7,   7,   7,   7,    7,    7,    7};
  299.  
  300.  
  301. /*
  302.       ifqstep = ( cod_info->scalefac_scale == 0 ) ? 2 : 4;
  303.       ol_sf =  (cod_info->global_gain-210.0);
  304.       ol_sf -= ifqstep*scalefac[gr][ch].l[sfb];
  305.       if (cod_info->preflag && sfb>=11) 
  306.       ol_sf -= ifqstep*pretab[sfb];
  307. */
  308. int compute_scalefacs_long(int sf[SBPSY_l],gr_info *cod_info,int scalefac[SBPSY_l])
  309. {
  310.   int sfb;
  311.   int maxover;
  312.   int ifqstep = ( cod_info->scalefac_scale == 0 ) ? 2 : 4;
  313.   
  314.  
  315.   if (cod_info->preflag)
  316.     for ( sfb = 11; sfb < SBPSY_l; sfb++ ) 
  317.       sf[sfb] += pretab[sfb]*ifqstep;
  318.  
  319.  
  320.   maxover=0;
  321.   for ( sfb = 0; sfb < SBPSY_l; sfb++ ) {
  322.  
  323.     if (sf[sfb]<0) {
  324.       /* ifqstep*scalefac >= -sf[sfb], so round UP */
  325.       scalefac[sfb]=-sf[sfb]/ifqstep  + (-sf[sfb] % ifqstep != 0);
  326.       if (scalefac[sfb] > max_range_long[sfb]) scalefac[sfb]=max_range_long[sfb];
  327.       
  328.       /* sf[sfb] should now be positive: */
  329.       if (  -(sf[sfb] + scalefac[sfb]*ifqstep)  > maxover) {
  330.     maxover = -(sf[sfb] + scalefac[sfb]*ifqstep);
  331.       }
  332.     }
  333.   }
  334.  
  335.   return maxover;
  336. }
  337.   
  338.   
  339.  
  340.  
  341.  
  342.  
  343.  
  344.  
  345. /************************************************************************
  346.  *
  347.  * quantize and encode with the given scalefacs and global gain
  348.  *
  349.  * compute scalefactors, l3_enc, and return number of bits needed to encode
  350.  *
  351.  *
  352.  ************************************************************************/
  353. void
  354. VBR_quantize_granule(lame_global_flags *gfp,
  355.                 FLOAT8 xr34[576], int l3_enc[2][2][576],
  356.              III_psy_ratio *ratio,      III_psy_xmin l3_xmin,
  357.                 III_scalefac_t scalefac[2][2],int gr, int ch)
  358. {
  359.   lame_internal_flags *gfc=gfp->internal_flags;
  360.   int status;
  361.   gr_info *cod_info;  
  362.   III_side_info_t * l3_side;
  363.   l3_side = &gfc->l3_side;
  364.   cod_info = &l3_side->gr[gr].ch[ch].tt;
  365.  
  366.  
  367.   /* encode scalefacs */
  368.   if ( gfp->version == 1 ) 
  369.     status=scale_bitcount(&scalefac[gr][ch], cod_info);
  370.   else
  371.     status=scale_bitcount_lsf(&scalefac[gr][ch], cod_info);
  372.  
  373.   if (status!=0) {
  374.     cod_info->part2_3_length = LARGE_BITS;
  375.     return;
  376.   }
  377.   
  378.   /* quantize xr34 */
  379.   cod_info->part2_3_length = count_bits(gfp,l3_enc[gr][ch],xr34,cod_info);
  380.   if (cod_info->part2_3_length >= LARGE_BITS) return;
  381.   cod_info->part2_3_length += cod_info->part2_length;
  382.  
  383.   
  384.   if (gfc->use_best_huffman==1 && cod_info->block_type != SHORT_TYPE) {
  385.     best_huffman_divide(gfc, gr, ch, cod_info, l3_enc[gr][ch]);
  386.   }
  387.   return;
  388. }
  389.   
  390.  
  391.  
  392.  
  393.  
  394.  
  395.  
  396.  
  397.  
  398.  
  399.  
  400.  
  401.  
  402.  
  403.  
  404.  
  405.  
  406.  
  407. /************************************************************************
  408.  *
  409.  * VBR_noise_shaping()
  410.  *
  411.  * compute scalefactors, l3_enc, and return number of bits needed to encode
  412.  *
  413.  * return code:    0   scalefactors were found with all noise < masking
  414.  *
  415.  *               n>0   scalefactors required too many bits.  global gain
  416.  *                     was decreased by n
  417.  *                     If n is large, we should probably recompute scalefacs
  418.  *                     with a lower quality.
  419.  *
  420.  *               n<0   scalefactors used less than minbits.
  421.  *                     global gain was increased by n.  
  422.  *                     If n is large, might want to recompute scalefacs
  423.  *                     with a higher quality setting?
  424.  *
  425.  ************************************************************************/
  426. int
  427. VBR_noise_shaping
  428. (
  429.  lame_global_flags *gfp,
  430.  FLOAT8 xr[576], III_psy_ratio *ratio,
  431.  int l3_enc[2][2][576], int *ath_over, int minbits, int maxbits,
  432.  III_scalefac_t scalefac[2][2],
  433.  int gr,int ch)
  434. {
  435.   lame_internal_flags *gfc=gfp->internal_flags;
  436.   int       start,end,bw,sfb,l, i,j, vbrmax;
  437.   III_scalefac_t vbrsf;
  438.   III_scalefac_t save_sf;
  439.   int maxover0,maxover1,maxover0p,maxover1p,maxover,mover;
  440.   int ifqstep;
  441.   III_psy_xmin l3_xmin;
  442.   III_side_info_t * l3_side;
  443.   gr_info *cod_info;  
  444.   FLOAT8 xr34[576];
  445.   int shortblock;
  446.   int global_gain_adjust=0;
  447.  
  448.   l3_side = &gfc->l3_side;
  449.   cod_info = &l3_side->gr[gr].ch[ch].tt;
  450.   shortblock = (cod_info->block_type == SHORT_TYPE);
  451.   *ath_over = calc_xmin( gfp,xr, ratio, cod_info, &l3_xmin);
  452.  
  453.   
  454.   for(i=0;i<576;i++) {
  455.     FLOAT8 temp=fabs(xr[i]);
  456.     xr34[i]=sqrt(sqrt(temp)*temp);
  457.   }
  458.  
  459. #define MAX_SF_DELTA 4  
  460.   vbrmax=-10000;
  461.   if (shortblock) {
  462.     for ( j=0, sfb = 0; sfb < SBMAX_s; sfb++ )  {
  463.       for ( i = 0; i < 3; i++ ) {
  464.     start = gfc->scalefac_band.s[ sfb ];
  465.     end   = gfc->scalefac_band.s[ sfb+1 ];
  466.     bw = end - start;
  467.     vbrsf.s[sfb][i] = find_scalefac(&xr[j],&xr34[j],sfb,
  468.                     l3_xmin.s[sfb][i],bw);
  469.     j += bw;
  470.       }
  471.     }
  472.  
  473.     for ( sfb = 0; sfb < SBMAX_s; sfb++ )  {
  474.       for ( i = 0; i < 3; i++ ) {
  475.     if (sfb>0) 
  476.       vbrsf.s[sfb][i] = Min(vbrsf.s[sfb-1][i]+MAX_SF_DELTA,vbrsf.s[sfb][i]);
  477.     if (sfb< SBMAX_s-1) 
  478.       vbrsf.s[sfb][i] = Min(vbrsf.s[sfb+1][i]+MAX_SF_DELTA,vbrsf.s[sfb][i]);
  479.       }
  480.     }
  481.  
  482.     for ( j=0, sfb = 0; sfb < SBMAX_s; sfb++ )  {
  483.       for ( i = 0; i < 3; i++ ) {
  484.     if (vbrsf.s[sfb][i]>vbrmax) vbrmax=vbrsf.s[sfb][i];
  485.       }
  486.     }
  487.  
  488.   }else{
  489.     for ( sfb = 0; sfb < SBMAX_l; sfb++ )   {
  490.       start = gfc->scalefac_band.l[ sfb ];
  491.       end   = gfc->scalefac_band.l[ sfb+1 ];
  492.       bw = end - start;
  493.       vbrsf.l[sfb] = find_scalefac(&xr[start],&xr34[start],sfb,
  494.                    l3_xmin.l[sfb],bw);
  495.  
  496.     }
  497.  
  498.     for ( sfb = 0; sfb < SBMAX_l; sfb++ )   {
  499.       if (sfb>0) 
  500.     vbrsf.l[sfb] = Min(vbrsf.l[sfb-1]+MAX_SF_DELTA,vbrsf.l[sfb]);
  501.       if (sfb< SBMAX_l-1) 
  502.     vbrsf.l[sfb] = Min(vbrsf.l[sfb+1]+MAX_SF_DELTA,vbrsf.l[sfb]);
  503.  
  504.     }
  505.  
  506.     for ( sfb = 0; sfb < SBMAX_l; sfb++ )   
  507.       if (vbrsf.l[sfb]>vbrmax) vbrmax = vbrsf.l[sfb];
  508.  
  509.  
  510.   } /* compute needed scalefactors */
  511.  
  512.  
  513.  
  514.   /* save a copy of vbrsf, incase we have to recomptue scalefacs */
  515.   memcpy(&save_sf,&vbrsf,sizeof(III_scalefac_t));
  516.  
  517.  
  518.   do { 
  519.  
  520.   memset(&scalefac[gr][ch],0,sizeof(III_scalefac_t));
  521.     
  522.   if (shortblock) {
  523.     /******************************************************************
  524.      *
  525.      *  short block scalefacs
  526.      *
  527.      ******************************************************************/
  528.     maxover0=0;
  529.     maxover1=0;
  530.     for ( sfb = 0; sfb < SBPSY_s; sfb++ ) {
  531.       for ( i = 0; i < 3; i++ ) {
  532.     maxover0 = Max(maxover0,(vbrmax - vbrsf.s[sfb][i]) - (4*14 + 2*max_range_short[sfb]) );
  533.     maxover1 = Max(maxover1,(vbrmax - vbrsf.s[sfb][i]) - (4*14 + 4*max_range_short[sfb]) );
  534.       }
  535.     }
  536.     if (gfc->noise_shaping==2)
  537.       /* allow scalefac_scale=1 */
  538.       mover = Min(maxover0,maxover1);
  539.     else
  540.       mover = maxover0; 
  541.  
  542.  
  543.     vbrmax -= mover;
  544.     maxover0 -= mover;
  545.     maxover1 -= mover;
  546.  
  547.     if (maxover0==0) 
  548.       cod_info->scalefac_scale = 0;
  549.     else if (maxover1==0)
  550.       cod_info->scalefac_scale = 1;
  551.  
  552.  
  553.     /* sf =  (cod_info->global_gain-210.0) */
  554.     cod_info->global_gain = vbrmax +210;
  555.     assert(cod_info->global_gain < 256);
  556.     if (cod_info->global_gain>255) cod_info->global_gain=255;
  557.     
  558.     for ( sfb = 0; sfb < SBPSY_s; sfb++ ) {
  559.       for ( i = 0; i < 3; i++ ) {
  560.     vbrsf.s[sfb][i]-=vbrmax;
  561.       }
  562.     }
  563.     maxover=compute_scalefacs_short(vbrsf.s,cod_info,scalefac[gr][ch].s,cod_info->subblock_gain);
  564.     assert(maxover <=0);
  565.     {
  566.       /* adjust global_gain so at least 1 subblock gain = 0 */
  567.       int minsfb=999;
  568.       for (i=0; i<3; i++) minsfb = Min(minsfb,cod_info->subblock_gain[i]);
  569.       minsfb = Min(cod_info->global_gain/8,minsfb);
  570.       vbrmax -= 8*minsfb; 
  571.       cod_info->global_gain -= 8*minsfb;
  572.       for (i=0; i<3; i++) cod_info->subblock_gain[i] -= minsfb;
  573.     }
  574.     
  575.     
  576.     
  577.     /* quantize xr34[] based on computed scalefactors */
  578.     ifqstep = ( cod_info->scalefac_scale == 0 ) ? 2 : 4;
  579.     for ( j=0, sfb = 0; sfb < SBPSY_s; sfb++ ) {
  580.       start = gfc->scalefac_band.s[ sfb ];
  581.       end   = gfc->scalefac_band.s[ sfb+1 ];
  582.       for (i=0; i<3; i++) {
  583.     int ifac;
  584.     FLOAT8 fac;
  585.     ifac = (8*cod_info->subblock_gain[i]+ifqstep*scalefac[gr][ch].s[sfb][i]);
  586.     if (ifac+210<Q_MAX) 
  587.       fac = 1/IPOW20(ifac+210);
  588.     else
  589.       fac = pow(2.0,.75*ifac/4.0);
  590.     for ( l = start; l < end; l++ ) 
  591.       xr34[j++]*=fac;
  592.       }
  593.     }
  594.     
  595.     
  596.     
  597.   }else{
  598.     /******************************************************************
  599.      *
  600.      *  long block scalefacs
  601.      *
  602.      ******************************************************************/
  603.     maxover0=0;
  604.     maxover1=0;
  605.     maxover0p=0;
  606.     maxover1p=0;
  607.     
  608.     
  609.     for ( sfb = 0; sfb < SBPSY_l; sfb++ ) {
  610.       maxover0 = Max(maxover0,(vbrmax - vbrsf.l[sfb]) - 2*max_range_long[sfb] );
  611.       maxover0p = Max(maxover0,(vbrmax - vbrsf.l[sfb]) - 2*(max_range_long[sfb]+pretab[sfb]) );
  612.       maxover1 = Max(maxover1,(vbrmax - vbrsf.l[sfb]) - 4*max_range_long[sfb] );
  613.       maxover1p = Max(maxover1,(vbrmax - vbrsf.l[sfb]) - 4*(max_range_long[sfb]+pretab[sfb]));
  614.     }
  615.     mover = Min(maxover0,maxover0p);
  616.     if (gfc->noise_shaping==2) {
  617.       /* allow scalefac_scale=1 */
  618.       mover = Min(mover,maxover1);
  619.       mover = Min(mover,maxover1p);
  620.     }
  621.  
  622.  
  623.     vbrmax -= mover;
  624.     maxover0 -= mover;
  625.     maxover0p -= mover;
  626.     maxover1 -= mover;
  627.     maxover1p -= mover;
  628.  
  629.  
  630.     if (maxover0<=0) {
  631.       cod_info->scalefac_scale = 0;
  632.       cod_info->preflag=0;
  633.       vbrmax -= maxover0;
  634.     } else if (maxover0p<=0) {
  635.       cod_info->scalefac_scale = 0;
  636.       cod_info->preflag=1;
  637.       vbrmax -= maxover0p;
  638.     } else if (maxover1==0) {
  639.       cod_info->scalefac_scale = 1;
  640.       cod_info->preflag=0;
  641.     } else if (maxover1p==0) {
  642.       cod_info->scalefac_scale = 1;
  643.       cod_info->preflag=1;
  644.     } else {
  645.       ERRORF("error vbrquantize.c...\n");
  646.       LAME_ERROR_EXIT();
  647.     }
  648.  
  649.     
  650.     /* sf =  (cod_info->global_gain-210.0) */
  651.     cod_info->global_gain = vbrmax +210;
  652.     assert(cod_info->global_gain < 256);
  653.     if (cod_info->global_gain>255) cod_info->global_gain=255;
  654.  
  655.     
  656.     for ( sfb = 0; sfb < SBPSY_l; sfb++ )   
  657.       vbrsf.l[sfb] -= vbrmax;
  658.     
  659.     
  660.     maxover=compute_scalefacs_long(vbrsf.l,cod_info,scalefac[gr][ch].l);
  661.     assert(maxover <=0);
  662.     
  663.     
  664.     /* quantize xr34[] based on computed scalefactors */
  665.     ifqstep = ( cod_info->scalefac_scale == 0 ) ? 2 : 4;
  666.     for ( sfb = 0; sfb < SBPSY_l; sfb++ ) {
  667.       int ifac;
  668.       FLOAT8 fac;
  669.       ifac = ifqstep*scalefac[gr][ch].l[sfb];
  670.       if (cod_info->preflag)
  671.     ifac += ifqstep*pretab[sfb];
  672.  
  673.       if (ifac+210<Q_MAX) 
  674.     fac = 1/IPOW20(ifac+210);
  675.       else
  676.     fac = pow(2.0,.75*ifac/4.0);
  677.  
  678.       start = gfc->scalefac_band.l[ sfb ];
  679.       end   = gfc->scalefac_band.l[ sfb+1 ];
  680.       for ( l = start; l < end; l++ ) {
  681.         xr34[l]*=fac;
  682.       }
  683.     }
  684.   } 
  685.  
  686.   VBR_quantize_granule(gfp,xr34,l3_enc,ratio,l3_xmin,scalefac,gr,ch);
  687.  
  688.  
  689.  
  690.  
  691.   if (cod_info->part2_3_length < minbits) {
  692.     /* decrease global gain, recompute scale factors */
  693.     if (*ath_over==0) break;  
  694.     if (cod_info->part2_3_length-cod_info->part2_length== 0) break;
  695.     if (vbrmax+210 ==0 ) break;
  696.     
  697.  
  698.  
  699.     --vbrmax;
  700.     --global_gain_adjust;
  701.     memcpy(&vbrsf,&save_sf,sizeof(III_scalefac_t));
  702.     for(i=0;i<576;i++) {
  703.       FLOAT8 temp=fabs(xr[i]);
  704.       xr34[i]=sqrt(sqrt(temp)*temp);
  705.     }
  706.  
  707.   }
  708.  
  709.   } while ((cod_info->part2_3_length < minbits));
  710.  
  711.  
  712.  
  713.   while (cod_info->part2_3_length > Min(maxbits,4095)) {
  714.     /* increase global gain, keep exisiting scale factors */
  715.     ++cod_info->global_gain;
  716.     if (cod_info->global_gain > 255) 
  717.       ERRORF("%ld impossible to encode this frame! bits=%d\n",
  718.           gfp->frameNum,cod_info->part2_3_length);
  719.     VBR_quantize_granule(gfp,xr34,l3_enc,ratio,l3_xmin,scalefac,gr,ch);
  720.  
  721.     ++global_gain_adjust;
  722.   }
  723.  
  724.  
  725.   return global_gain_adjust;
  726. }
  727.  
  728.  
  729.  
  730.  
  731. void
  732. VBR_quantize(lame_global_flags *gfp,
  733.                 FLOAT8 pe[2][2], FLOAT8 ms_ener_ratio[2],
  734.                 FLOAT8 xr[2][2][576], III_psy_ratio ratio[2][2],
  735.                 int l3_enc[2][2][576],
  736.                 III_scalefac_t scalefac[2][2])
  737. {
  738.   lame_internal_flags *gfc=gfp->internal_flags;
  739.   int minbits,maxbits,max_frame_bits,totbits,gr,ch,i,bits_ok;
  740.   int bitsPerFrame,mean_bits;
  741.   FLOAT8 qadjust;
  742.   III_side_info_t * l3_side;
  743.   gr_info *cod_info;  
  744.   int ath_over[2][2];
  745.   FLOAT8 masking_lower_db;
  746.   // static const FLOAT8 dbQ[10]={-6.0,-5.0,-4.0,-3.0, -2.0, -1.0, -.25, .5, 1.25, 2.0};
  747.   /* from quantize.c VBR algorithm */
  748.   static const FLOAT8 dbQ[10]={-5.0,-3.75,-2.5,-1.25,  0,  0.4,  0.8, 1.2, 1.6,2.0};
  749.  
  750.   qadjust=-2.5;   /* start with -1 db quality improvement over quantize.c VBR */
  751.  
  752.   l3_side = &gfc->l3_side;
  753.   gfc->ATH_lower = (4-gfp->VBR_q)*4.0; 
  754.   if (gfc->ATH_lower < 0) gfc->ATH_lower=0;
  755.   iteration_init(gfp,l3_side,l3_enc);
  756.  
  757.  
  758.  
  759.   /* compute minimum allowed bits from minimum allowed bitrate */
  760.   gfc->bitrate_index=gfc->VBR_min_bitrate;
  761.   getframebits(gfp,&bitsPerFrame, &mean_bits);
  762.   minbits = (mean_bits/gfc->stereo);
  763.  
  764.   /* compute maximum allowed bits from max allowed bitrate */
  765.   gfc->bitrate_index=gfc->VBR_max_bitrate;
  766.   getframebits(gfp,&bitsPerFrame, &mean_bits);
  767.   max_frame_bits = ResvFrameBegin(gfp,l3_side, mean_bits, bitsPerFrame);
  768.   maxbits=2.5*(mean_bits/gfc->stereo);
  769.  
  770.   {
  771.   /* compute a target  mean_bits based on compression ratio 
  772.    * which was set based on VBR_q  
  773.    */
  774.   int bit_rate = gfp->out_samplerate*16*gfc->stereo/(1000.0*gfp->compression_ratio);
  775.   bitsPerFrame = (bit_rate*gfp->framesize*1000)/gfp->out_samplerate;
  776.   mean_bits = (bitsPerFrame - 8*gfc->sideinfo_len) / gfc->mode_gr;
  777.   }
  778.  
  779.   //  minbits=Max(minbits,.66*(mean_bits/gfc->stereo));
  780.   maxbits=Min(maxbits,2.5*(mean_bits/gfc->stereo));
  781.  
  782.  
  783.   if (gfc->mode_ext==MPG_MD_MS_LR) 
  784.     for (gr = 0; gr < gfc->mode_gr; gr++) 
  785.       ms_convert(xr[gr],xr[gr]);
  786.  
  787.   for (gr = 0; gr < gfc->mode_gr; gr++) {
  788.     for (ch = 0; ch < gfc->stereo; ch++) { 
  789.       cod_info = &l3_side->gr[gr].ch[ch].tt;
  790.       cod_info->part2_3_length=LARGE_BITS;
  791.     }
  792.   }
  793.  
  794.  
  795.  
  796.  
  797.  
  798.  
  799.   /* 
  800.    * loop over all ch,gr, encoding anything with bits > .5*(max_frame_bits/4)
  801.    *
  802.    * If a particular granule uses way too many bits, it will be re-encoded
  803.    * on the next iteration of the loop (with a lower quality setting).  
  804.    * But granules which dont use
  805.    * use too many bits will not be re-encoded.
  806.    *
  807.    * minbits:  minimum allowed bits for 1 granule 1 channel
  808.    * maxbits:  maximum allowwed bits for 1 granule 1 channel
  809.    * max_frame_bits:  maximum allowed bits for entire frame
  810.    * (max_frame_bits/4)   estimate of average bits per granule per channel
  811.    * 
  812.    */
  813.  
  814.   do {
  815.   
  816.     totbits=0;
  817.     for (gr = 0; gr < gfc->mode_gr; gr++) {
  818.       int minbits_lr[2];
  819.       minbits_lr[0]=minbits;
  820.       minbits_lr[1]=minbits;
  821. #if 0
  822.       if (gfc->mode_ext==MPG_MD_MS_LR) {
  823.     FLOAT8 fac;
  824.     fac = .33*(.5-ms_ener_ratio[gr])/.5;
  825.     if (fac<0) fac=0;
  826.     if (fac>.5) fac=.5;
  827.     minbits_lr[0] *= 1+fac;
  828.     minbits_lr[1] *= 1-fac;
  829.       }
  830. #endif
  831.  
  832.       for (ch = 0; ch < gfc->stereo; ch++) { 
  833.     int adjusted,shortblock;
  834.     cod_info = &l3_side->gr[gr].ch[ch].tt;
  835.     
  836.     /* ENCODE this data first pass, and on future passes unless it uses
  837.      * a very small percentage of the max_frame_bits  */
  838.     if (cod_info->part2_3_length > (max_frame_bits/(2*gfc->stereo*gfc->mode_gr))) {
  839.       
  840.       shortblock = (cod_info->block_type == SHORT_TYPE);
  841.       
  842.       /* Adjust allowed masking based on quality setting */
  843.       assert( gfp->VBR_q <= 9 );
  844.       assert( gfp->VBR_q >= 0 );
  845.       masking_lower_db = dbQ[gfp->VBR_q] + qadjust;
  846.  
  847.       if (pe[gr][ch]>750)
  848.         masking_lower_db -= Min(10,4*(pe[gr][ch]-750.)/750.);
  849.       /*
  850.       if (shortblock) masking_lower_db -= 4;
  851.       */
  852.       
  853.       gfc->masking_lower = pow(10.0,masking_lower_db/10);
  854.         
  855.       adjusted = VBR_noise_shaping (gfp,xr[gr][ch],&ratio[gr][ch],l3_enc,
  856.               &ath_over[gr][ch],minbits_lr[ch],maxbits,scalefac,gr,ch);
  857.       if (adjusted>10) {
  858.         /* global_gain was changed by a large amount to get bits < maxbits */
  859.         /* quality is set to high.  we could set bits = LARGE_BITS
  860.          * to force re-encoding.  But most likely the other channels/granules
  861.          * will also use too many bits, and the entire frame will
  862.          * be > max_frame_bits, forcing re-encoding below.
  863.          */
  864.         //     cod_info->part2_3_bits = LARGE_BITS;
  865.       }
  866.     }
  867.     totbits += cod_info->part2_3_length;
  868.       }
  869.     }
  870.     bits_ok=1;
  871.     if (totbits>max_frame_bits) {
  872.       qadjust += Max(.25,(totbits-max_frame_bits)/300.0);
  873.       //      DEBUGF("%i totbits>max_frame_bits   totbits=%i  maxbits=%i \n",gfp->frameNum,totbits,max_frame_bits);
  874.       //      DEBUGF("next masking_lower_db = %f \n",masking_lower_db + qadjust);
  875.       bits_ok=0;
  876.     }
  877.     
  878.   } while (!bits_ok);
  879.   
  880.  
  881.   /* find optimal scalefac storage.  Cant be done above because
  882.    * might enable scfsi which breaks the interation loops */
  883.   totbits=0;
  884.   for (gr = 0; gr < gfc->mode_gr; gr++) {
  885.     for (ch = 0; ch < gfc->stereo; ch++) {
  886.       best_scalefac_store(gfp,gr, ch, l3_enc, l3_side, scalefac);
  887.       totbits += l3_side->gr[gr].ch[ch].tt.part2_3_length;
  888.     }
  889.   }
  890.  
  891.  
  892.  
  893.   
  894.   if (gfp->gtkflag) {
  895.     for (gr = 0; gr < gfc->mode_gr; gr++) {
  896.       for (ch = 0; ch < gfc->stereo; ch++) {
  897.     III_psy_xmin l3_xmin;
  898.     calc_noise_result noise_info;
  899.     FLOAT8 noise[4];
  900.     FLOAT8 xfsf[4][SBMAX_l];
  901.     FLOAT8 distort[4][SBMAX_l];
  902.  
  903.     cod_info = &l3_side->gr[gr].ch[ch].tt;
  904.  
  905.     /* recompute allowed noise with no 'masking_lower' for
  906.      * frame analyzer */
  907.     gfc->masking_lower=1.0;
  908.     cod_info = &l3_side->gr[gr].ch[ch].tt;    
  909.     calc_xmin( gfp,xr[gr][ch], &ratio[gr][ch], cod_info, &l3_xmin);
  910.     
  911.     calc_noise( gfp, xr[gr][ch], l3_enc[gr][ch], cod_info, 
  912.                   xfsf,distort, &l3_xmin, &scalefac[gr][ch], 
  913.                   &noise_info);
  914.     noise[0] = noise_info.over_count;
  915.     noise[1] = noise_info.max_noise;
  916.     noise[2] = noise_info.over_avg_noise;
  917.     noise[3] = noise_info.tot_avg_noise;
  918.  
  919.     set_pinfo (gfp, cod_info, &ratio[gr][ch], &scalefac[gr][ch], xr[gr][ch], xfsf, noise, gr, ch);
  920.       }
  921.     }
  922.   }
  923.  
  924.  
  925.   
  926.  
  927.   for( gfc->bitrate_index = (gfp->VBR_hard_min ? gfc->VBR_min_bitrate : 1);
  928.        gfc->bitrate_index < gfc->VBR_max_bitrate;
  929.        gfc->bitrate_index++    ) {
  930.  
  931.     getframebits (gfp,&bitsPerFrame, &mean_bits);
  932.     maxbits = ResvFrameBegin(gfp,l3_side, mean_bits, bitsPerFrame);
  933.     if (totbits <= maxbits) break;
  934.   }
  935.   if (gfc->bitrate_index == gfc->VBR_max_bitrate) {
  936.     getframebits (gfp,&bitsPerFrame, &mean_bits);
  937.     maxbits = ResvFrameBegin(gfp,l3_side, mean_bits, bitsPerFrame);
  938.   }
  939.  
  940.   //  DEBUGF("%i total_bits=%i max_frame_bits=%i index=%i  \n",gfp->frameNum,totbits,max_frame_bits,gfc->bitrate_index);
  941.  
  942.   for (gr = 0; gr < gfc->mode_gr; gr++) {
  943.     for (ch = 0; ch < gfc->stereo; ch++) {
  944.       cod_info = &l3_side->gr[gr].ch[ch].tt;
  945.  
  946.  
  947.       ResvAdjust (gfp,cod_info, l3_side, mean_bits);
  948.       
  949.       /*******************************************************************
  950.        * set the sign of l3_enc from the sign of xr
  951.        *******************************************************************/
  952.       for ( i = 0; i < 576; i++) {
  953.         if (xr[gr][ch][i] < 0) l3_enc[gr][ch][i] *= -1;
  954.       }
  955.     }
  956.   }
  957.   ResvFrameEnd (gfp,l3_side, mean_bits);
  958.  
  959.  
  960.  
  961. }
  962.  
  963.  
  964.  
  965.