home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 2000 #5 / Amiga Plus CD - 2000 - No. 5.iso / Tools / Dev / lame_src / quantize.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-01-01  |  34.1 KB  |  1,134 lines
  1. #undef MAXNOISE
  2. /*
  3.  *    MP3 quantization
  4.  *
  5.  *    Copyright (c) 1999 Mark Taylor
  6.  *
  7.  * This program is free software; you can redistribute it and/or modify
  8.  * it under the terms of the GNU General Public License as published by
  9.  * the Free Software Foundation; either version 2, or (at your option)
  10.  * any later version.
  11.  *
  12.  * This program is distributed in the hope that it will be useful,
  13.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.  * GNU General Public License for more details.
  16.  *
  17.  * You should have received a copy of the GNU General Public License
  18.  * along with this program; see the file COPYING.  If not, write to
  19.  * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  20.  */
  21.  
  22.  
  23.  
  24. #include <assert.h>
  25. #include "util.h"
  26. #include "l3side.h"
  27. #include "quantize.h"
  28. #include "reservoir.h"
  29. #include "quantize-pvt.h"
  30. #include "gtkanal.h"
  31.  
  32.  
  33.  
  34.  
  35. /************************************************************************/
  36. /*  iteration_loop()                                                    */
  37. /************************************************************************/
  38. void
  39. iteration_loop( lame_global_flags *gfp,
  40.                 FLOAT8 pe[2][2], FLOAT8 ms_ener_ratio[2],
  41.         FLOAT8 xr[2][2][576], III_psy_ratio ratio[2][2],
  42.         int l3_enc[2][2][576],
  43.         III_scalefac_t scalefac[2][2])
  44. {
  45.   lame_internal_flags *gfc=gfp->internal_flags;
  46.   FLOAT8 xfsf[4][SBMAX_l];
  47.   FLOAT8 noise[4]; /* over,max_noise,over_noise,tot_noise; */
  48.   III_psy_xmin l3_xmin[2];
  49.   gr_info *cod_info;
  50.   int bitsPerFrame;
  51.   int mean_bits,max_bits;
  52.   int ch, gr, i, bit_rate;
  53.   III_side_info_t *l3_side;
  54.  
  55.   l3_side = &gfc->l3_side;
  56.   iteration_init(gfp,l3_side,l3_enc);
  57.   bit_rate = bitrate_table[gfp->version][gfc->bitrate_index];
  58.   getframebits(gfp,&bitsPerFrame, &mean_bits);
  59.   ResvFrameBegin(gfp, l3_side, mean_bits, bitsPerFrame );
  60.  
  61.   /* quantize! */
  62.   for ( gr = 0; gr < gfc->mode_gr; gr++ ) {
  63.     int targ_bits[2];
  64.  
  65.     if (gfc->mode_ext==MPG_MD_MS_LR) 
  66.       ms_convert(xr[gr], xr[gr]);
  67.     
  68.     max_bits=on_pe(gfp,pe,l3_side,targ_bits,mean_bits, gr);
  69.  
  70.     if (gfc->mode_ext==MPG_MD_MS_LR) 
  71.       reduce_side(targ_bits,ms_ener_ratio[gr],mean_bits,max_bits);
  72.     
  73.     for (ch=0 ; ch < gfc->stereo ; ch ++) {
  74.       cod_info = &l3_side->gr[gr].ch[ch].tt;    
  75.  
  76.       if (!init_outer_loop(gfp,xr[gr][ch], cod_info))
  77.         {
  78.           /* xr contains no energy 
  79.            * cod_info-> was initialized in init_outer_loop
  80.        */
  81.           memset(&scalefac[gr][ch],0,sizeof(III_scalefac_t));
  82.           memset(l3_enc[gr][ch],0,576*sizeof(int));
  83.       memset(xfsf,0,sizeof(xfsf));
  84.       noise[0]=noise[1]=noise[2]=noise[3]=0;
  85.         }
  86.       else
  87.     {
  88.           calc_xmin(gfp,xr[gr][ch], &ratio[gr][ch], cod_info, &l3_xmin[ch]);
  89.       outer_loop( gfp,xr[gr][ch], targ_bits[ch], noise,
  90.               &l3_xmin[ch], l3_enc[gr][ch], 
  91.               &scalefac[gr][ch], cod_info, xfsf, ch);
  92.         }
  93.  
  94.  
  95.       best_scalefac_store(gfp,gr, ch, l3_enc, l3_side, scalefac);
  96.       if (gfc->use_best_huffman==1 && cod_info->block_type != SHORT_TYPE) {
  97.     best_huffman_divide(gfc, gr, ch, cod_info, l3_enc[gr][ch]);
  98.       }
  99.       assert((int)cod_info->part2_3_length < 4096);
  100.  
  101.       if (gfp->gtkflag)
  102.     set_pinfo (gfp, cod_info, &ratio[gr][ch], &scalefac[gr][ch], xr[gr][ch], xfsf, noise, gr, ch);
  103.  
  104.  
  105. /*#define NORES_TEST */
  106. #ifndef NORES_TEST
  107.       ResvAdjust(gfp,cod_info, l3_side, mean_bits );
  108. #endif
  109.       /* set the sign of l3_enc */
  110.       for ( i = 0; i < 576; i++) {
  111.     if (xr[gr][ch][i] < 0)
  112.       l3_enc[gr][ch][i] *= -1;
  113.       }
  114.  
  115.  
  116.     } /* loop over ch */
  117.   } /* loop over gr */
  118.  
  119. #ifdef NORES_TEST
  120.   /* replace ResvAdjust above with this code if you do not want
  121.      the second granule to use bits saved by the first granule.
  122.      when combined with --nores, this is usefull for testing only */
  123.   for ( gr = 0; gr < gfc->mode_gr; gr++ ) {
  124.     for ( ch =  0; ch < gfc->stereo; ch++ ) {
  125.     cod_info = &l3_side->gr[gr].ch[ch].tt;
  126.     ResvAdjust(gfp, cod_info, l3_side, mean_bits );
  127.     }
  128.   }
  129. #endif
  130.   ResvFrameEnd(gfp,l3_side, mean_bits );
  131. }
  132.  
  133.  
  134.  
  135.  
  136. /*
  137.  *  ABR_iteration_loop()
  138.  *
  139.  *  encode a frame with a disired average bitrate
  140.  *
  141.  *  mt 2000/05/31
  142.  */
  143. void
  144. ABR_iteration_loop (lame_global_flags *gfp,
  145.                 FLOAT8 pe[2][2], FLOAT8 ms_ener_ratio[2],
  146.                 FLOAT8 xr[2][2][576], III_psy_ratio ratio[2][2],
  147.                 int l3_enc[2][2][576],
  148.                 III_scalefac_t scalefac[2][2])
  149. {
  150.   lame_internal_flags *gfc=gfp->internal_flags;
  151.   
  152.   III_psy_xmin l3_xmin;
  153.   gr_info  *cod_info = NULL;
  154.   int       targ_bits[2][2];
  155.   FLOAT8    xfsf[4][SBMAX_l];
  156.   FLOAT8    noise[4];
  157.   int       bit_rate,bitsPerFrame, mean_bits,totbits,max_frame_bits;
  158.   int       i,ch, gr, ath_over;
  159.   int       analog_silence_bits;
  160.   III_side_info_t *l3_side;
  161.  
  162.   l3_side = &gfc->l3_side;
  163.   iteration_init(gfp,l3_side,l3_enc);
  164.  
  165.  
  166.  
  167.  
  168.   gfc->bitrate_index = gfc->VBR_max_bitrate;
  169.   getframebits (gfp,&bitsPerFrame, &mean_bits);
  170.   max_frame_bits=ResvFrameBegin (gfp,l3_side, mean_bits, bitsPerFrame);
  171.  
  172.   gfc->bitrate_index = 1;
  173.   getframebits (gfp,&bitsPerFrame, &mean_bits);
  174.   analog_silence_bits = mean_bits/gfc->stereo;
  175.  
  176.   /* compute a target  mean_bits based on compression ratio 
  177.    * which was set based on VBR_q  
  178.    */
  179.   /*
  180.   bit_rate = gfp->out_samplerate*16*gfc->stereo/(1000.0*gfp->compression_ratio);
  181.    */
  182.   bit_rate = gfp->VBR_mean_bitrate_kbps;
  183.   bitsPerFrame = (bit_rate*gfp->framesize*1000)/gfp->out_samplerate;
  184.   mean_bits = (bitsPerFrame - 8*gfc->sideinfo_len) / gfc->mode_gr;
  185.  
  186.  
  187.   for(gr = 0; gr < gfc->mode_gr; gr++) {
  188.  
  189.     for(ch = 0; ch < gfc->stereo; ch++) {
  190.       if (pe[gr][ch]<750) {
  191.     targ_bits[gr][ch]=(mean_bits/gfc->stereo)*Max(.5,(pe[gr][ch])/750.0);
  192.       }else{
  193.     int add_bits=(pe[gr][ch]-750)/1.4;
  194.     
  195.     cod_info = &l3_side->gr[gr].ch[ch].tt;
  196.     targ_bits[gr][ch]=(mean_bits/gfc->stereo);
  197.     
  198.     /* short blocks us a little extra, no matter what the pe */
  199.     if (cod_info->block_type==SHORT_TYPE) {
  200.       if (add_bits<mean_bits/4) add_bits=mean_bits/4;
  201.     }
  202.     /* at most increase bits by 1.5*average */
  203.     if (add_bits > .75*mean_bits) add_bits=mean_bits*.75;
  204.     if (add_bits < 0) add_bits=0;
  205.     
  206.     targ_bits[gr][ch] += add_bits;
  207.       }
  208.     }
  209.   }
  210.   if (gfc->mode_ext==MPG_MD_MS_LR) 
  211.     for(gr = 0; gr < gfc->mode_gr; gr++) 
  212.       reduce_side(targ_bits[gr],ms_ener_ratio[gr],mean_bits,4095);
  213.  
  214.  
  215.   totbits=0;
  216.   for(gr = 0; gr < gfc->mode_gr; gr++) {
  217.     for(ch = 0; ch < gfc->stereo; ch++) {
  218.       if (targ_bits[gr][ch] > 4095) targ_bits[gr][ch]=4095;
  219.       totbits += targ_bits[gr][ch];
  220.     }
  221.   }
  222.  
  223.   if (totbits > max_frame_bits) {
  224.     for(gr = 0; gr < gfc->mode_gr; gr++) 
  225.       for(ch = 0; ch < gfc->stereo; ch++) 
  226.     targ_bits[gr][ch] *= ((float)max_frame_bits/(float)totbits); 
  227.   }
  228.  
  229.  
  230.   totbits=0;
  231.   for(gr = 0; gr < gfc->mode_gr; gr++) {
  232.  
  233.     if (gfc->mode_ext==MPG_MD_MS_LR) 
  234.       ms_convert(xr[gr], xr[gr]);
  235.  
  236.     for(ch = 0; ch < gfc->stereo; ch++) {
  237.       cod_info = &l3_side->gr[gr].ch[ch].tt;
  238.  
  239.       if (!init_outer_loop(gfp,xr[gr][ch], cod_info))
  240.         {
  241.           /* xr contains no energy 
  242.            * cod_info was set in init_outer_loop above
  243.        */
  244.           memset(&scalefac[gr][ch],0,sizeof(III_scalefac_t));
  245.           memset(l3_enc[gr][ch],0,576*sizeof(int));
  246.       noise[0]=noise[1]=noise[2]=noise[3]=0;
  247.         }
  248.       else
  249.     {
  250.       ath_over = calc_xmin(gfp,xr[gr][ch], &ratio[gr][ch], cod_info, &l3_xmin);
  251.       if (0==ath_over) {
  252.         /* analog silence */
  253.         targ_bits[gr][ch]=analog_silence_bits;
  254.       }
  255.  
  256.       outer_loop( gfp,xr[gr][ch], targ_bits[gr][ch], noise,
  257.               &l3_xmin, l3_enc[gr][ch], 
  258.               &scalefac[gr][ch], cod_info, xfsf, ch);
  259.  
  260.     }
  261.  
  262.       totbits += cod_info->part2_3_length;
  263.       if (gfp->gtkflag) 
  264.     set_pinfo(gfp, cod_info, &ratio[gr][ch], &scalefac[gr][ch], xr[gr][ch], xfsf, noise, gr, ch);
  265.     }
  266.   }
  267.   /*******************************************************************
  268.    * find a bitrate which can handle totbits 
  269.    *******************************************************************/
  270.   for( gfc->bitrate_index =  gfc->VBR_min_bitrate ;
  271.        gfc->bitrate_index <= gfc->VBR_max_bitrate;
  272.        gfc->bitrate_index++    ) {
  273.     getframebits (gfp,&bitsPerFrame, &mean_bits);
  274.     max_frame_bits=ResvFrameBegin (gfp,l3_side, mean_bits, bitsPerFrame);
  275.     if( totbits <= max_frame_bits) break;
  276.   }
  277.   assert (gfc->bitrate_index <= gfc->VBR_max_bitrate);
  278.  
  279.  
  280.  
  281.   /*******************************************************************
  282.    * update reservoir status after FINAL quantization/bitrate 
  283.    *******************************************************************/
  284.   for (gr = 0; gr < gfc->mode_gr; gr++)
  285.     for (ch = 0; ch < gfc->stereo; ch++) {
  286.       cod_info = &l3_side->gr[gr].ch[ch].tt;
  287.  
  288.       best_scalefac_store(gfp,gr, ch, l3_enc, l3_side, scalefac);
  289.       if (gfc->use_best_huffman==1 && cod_info->block_type != SHORT_TYPE) {
  290.     best_huffman_divide(gfc, gr, ch, cod_info, l3_enc[gr][ch]);
  291.       }
  292.       if (gfp->gtkflag) {
  293.     gfc->pinfo->LAMEmainbits[gr][ch]=cod_info->part2_3_length;
  294.       }
  295.       ResvAdjust (gfp,cod_info, l3_side, mean_bits);
  296.       /* set the sign of l3_enc from the sign of xr */
  297.       for ( i = 0; i < 576; i++) {
  298.     if (xr[gr][ch][i] < 0) l3_enc[gr][ch][i] *= -1;
  299.       }
  300.  
  301.     }
  302.   ResvFrameEnd (gfp,l3_side, mean_bits);
  303. }
  304.  
  305.  
  306.  
  307.  
  308. /************************************************************************
  309.  *
  310.  * VBR_iteration_loop()   
  311.  *
  312.  * tries to find out how many bits are needed for each granule and channel
  313.  * to get an acceptable quantization. An appropriate bitrate will then be
  314.  * choosed for quantization.  rh 8/99                                                
  315.  *
  316.  ************************************************************************/
  317. void
  318. VBR_iteration_loop (lame_global_flags *gfp,
  319.                 FLOAT8 pe[2][2], FLOAT8 ms_ener_ratio[2],
  320.                 FLOAT8 xr[2][2][576], III_psy_ratio ratio[2][2],
  321.                 int l3_enc[2][2][576],
  322.                 III_scalefac_t scalefac[2][2])
  323. {
  324.   plotting_data bst_pinfo;
  325.   lame_internal_flags *gfc=gfp->internal_flags;
  326.   gr_info         bst_cod_info, clean_cod_info;
  327.   III_scalefac_t  bst_scalefac;
  328.   int             bst_l3_enc[576]; 
  329.   
  330.   III_psy_xmin l3_xmin;
  331.   gr_info  *cod_info = NULL;
  332.   int       save_bits[2][2];
  333.   FLOAT8    noise[4];          /* over,max_noise,over_noise,tot_noise; */
  334.   FLOAT8    xfsf[4][SBMAX_l];
  335.   int       this_bits, dbits;
  336.   int       used_bits=0;
  337.   int       min_bits,max_bits,min_mean_bits=0;
  338.   int       frameBits[15];
  339.   int       bitsPerFrame;
  340.   int       bits;
  341.   int       mean_bits;
  342.   int       i,ch, gr, analog_silence;
  343.   int        reparted = 0;
  344.   int       reduce_s_ch=0;
  345.   III_side_info_t *l3_side;
  346.  
  347.   l3_side = &gfc->l3_side;
  348.   iteration_init(gfp,l3_side,l3_enc);
  349.  
  350.     /* my experiences are, that side channel reduction  
  351.      * does more harm than good when VBR encoding
  352.      * (Robert.Hegemann@gmx.de 2000-02-18)
  353.   if (gfc->mode_ext==MPG_MD_MS_LR) 
  354.     reduce_s_ch=1;
  355.      */
  356.  
  357.  
  358.   /*******************************************************************
  359.    * how many bits are available for each bitrate?
  360.    *******************************************************************/
  361.   for( gfc->bitrate_index = 1;
  362.        gfc->bitrate_index <= gfc->VBR_max_bitrate;
  363.        gfc->bitrate_index++    ) {
  364.     getframebits (gfp,&bitsPerFrame, &mean_bits);
  365.     if (gfc->bitrate_index == gfc->VBR_min_bitrate) {
  366.       /* always use at least this many bits per granule per channel */
  367.       /* unless we detect analog silence, see below */
  368.       min_mean_bits=mean_bits/gfc->stereo;
  369.     }
  370.     frameBits[gfc->bitrate_index]=
  371.       ResvFrameBegin (gfp,l3_side, mean_bits, bitsPerFrame);
  372.   }
  373.  
  374.   gfc->bitrate_index=gfc->VBR_max_bitrate;
  375.  
  376.   
  377.   /*******************************************************************
  378.    * how many bits would we use of it?
  379.    *******************************************************************/
  380.   analog_silence=1;
  381.   for (gr = 0; gr < gfc->mode_gr; gr++) {
  382.     int num_chan=gfc->stereo;
  383.     /* determine quality based on mid channel only */
  384.     if (reduce_s_ch) num_chan=1;  
  385.  
  386.  
  387.     /* copy data to be quantized into xr */
  388.     if (gfc->mode_ext==MPG_MD_MS_LR) 
  389.     ms_convert(xr[gr],xr[gr]);
  390.  
  391.     for (ch = 0; ch < num_chan; ch++) { 
  392.       int real_bits;
  393.       
  394.       /******************************************************************
  395.        * find smallest number of bits for an allowable quantization
  396.        ******************************************************************/
  397.       cod_info = &l3_side->gr[gr].ch[ch].tt;
  398.       min_bits = Max(125,min_mean_bits);
  399.  
  400.       if (!init_outer_loop(gfp,xr[gr][ch], cod_info))
  401.       {
  402.         /* xr contains no energy 
  403.          * cod_info was set in init_outer_loop above
  404.      */
  405.         memset(&scalefac[gr][ch],0,sizeof(III_scalefac_t));
  406.         memset(l3_enc[gr][ch],0,576*sizeof(int));
  407.         save_bits[gr][ch] = 0;
  408.     if (gfp->gtkflag) {
  409.       memset(xfsf,0,sizeof(xfsf));
  410.       set_pinfo(gfp, cod_info, &ratio[gr][ch], &scalefac[gr][ch], xr[gr][ch], xfsf, noise, gr, ch);
  411.     }
  412.     continue; /* with next channel */
  413.       }
  414.       
  415.       memcpy( &clean_cod_info, cod_info, sizeof(gr_info) );
  416.       
  417.       /* disable analog_silence if *any* of the granules != silence */
  418.       /* if energy < ATH, set min_bits = 125 */
  419.       i = calc_xmin(gfp,xr[gr][ch], &ratio[gr][ch], cod_info, &l3_xmin);
  420.       if (i) {
  421.     analog_silence=0;
  422.       }else{
  423.     if (!gfp->VBR_hard_min) min_bits=125;
  424.       }
  425.  
  426.       if (cod_info->block_type==SHORT_TYPE) {
  427.       min_bits += Max(1000,pe[gr][ch]);
  428.       min_bits=Min(min_bits,1800);
  429.       }
  430.  
  431.       max_bits = 1200 + frameBits[gfc->VBR_max_bitrate]/(gfc->stereo*gfc->mode_gr);
  432.       max_bits=Min(max_bits,2500);
  433.       max_bits=Max(max_bits,min_bits);
  434.  
  435.       dbits = (max_bits-min_bits)/4;
  436.       this_bits = (max_bits+min_bits)/2;
  437.       real_bits = max_bits+1;
  438.  
  439.       /* bin search to within +/- 10 bits of optimal */
  440.       do {
  441.       assert(this_bits>=min_bits);
  442.       assert(this_bits<=max_bits);
  443.  
  444.       if( this_bits >= real_bits ){
  445.           /* 
  446.            * we already found a quantization with fewer bits
  447.            * so we can skip this try
  448.            */
  449.           this_bits -= dbits;
  450.           dbits /= 2;
  451.           continue; /* skips the rest of this do-while loop */
  452.       }
  453.  
  454.       /*
  455.        *  OK, start with a fresh setting
  456.        *  - scalefac  will be set up by outer_loop
  457.        *  - l3_enc    will be set up by outer_loop
  458.        *  + cod_info  we will restore our initialized one, see below
  459.        */
  460.       memcpy( cod_info, &clean_cod_info, sizeof(gr_info) );
  461.       outer_loop( gfp,xr[gr][ch], this_bits, noise, &l3_xmin,
  462.                       l3_enc[gr][ch], &scalefac[gr][ch], cod_info, xfsf, ch);
  463.  
  464.  
  465.       /* is quantization as good as we are looking for ?
  466.            */
  467.       if (noise[0] <= 0) {
  468.           /* 
  469.            * we now know it can be done with "real_bits"
  470.            * and maybe we can skip some iterations
  471.            */
  472.           real_bits = cod_info->part2_3_length;
  473.           /*
  474.            * save best quantization so far
  475.            */
  476.               memcpy( &bst_scalefac, &scalefac[gr][ch], sizeof(III_scalefac_t)  );
  477.               memcpy(  bst_l3_enc,    l3_enc  [gr][ch], sizeof(int)*576         );
  478.               memcpy( &bst_cod_info,  cod_info,         sizeof(gr_info)         );
  479.               if (gfp->gtkflag) {
  480.             set_pinfo(gfp, cod_info, &ratio[gr][ch], &scalefac[gr][ch], xr[gr][ch], xfsf, noise, gr, ch);
  481.                 memcpy( &bst_pinfo, gfc->pinfo, sizeof(plotting_data) );
  482.           }
  483.           /*
  484.            * try with fewer bits
  485.            */
  486.           this_bits -= dbits;
  487.       } else {
  488.           /*
  489.            * try with more bits
  490.            */
  491.           this_bits += dbits;
  492.       }
  493.       dbits /= 2;
  494.       } while (dbits>10) ;
  495.       
  496.       if (real_bits <= max_bits)
  497.       {
  498.         /* restore best quantization found */
  499.         memcpy(  cod_info,         &bst_cod_info, sizeof(gr_info)        );
  500.         memcpy( &scalefac[gr][ch], &bst_scalefac, sizeof(III_scalefac_t) );
  501.         memcpy(  l3_enc  [gr][ch],  bst_l3_enc,   sizeof(int)*576        );
  502.         if (gfp->gtkflag) {
  503.           memcpy( gfc->pinfo, &bst_pinfo, sizeof(plotting_data) );
  504.     }
  505.       } 
  506.       else
  507.       { /* we didn't find any satisfying quantization above
  508.          * the only thing we still need to set is the gtk info field
  509.          */
  510.         if (gfp->gtkflag)
  511.       set_pinfo(gfp, cod_info, &ratio[gr][ch], &scalefac[gr][ch], xr[gr][ch], xfsf, noise, gr, ch);
  512.       }
  513.  
  514.       assert((int)cod_info->part2_3_length <= max_bits);
  515.       assert((int)cod_info->part2_3_length < 4096);
  516.       save_bits[gr][ch] = cod_info->part2_3_length;
  517.       used_bits += save_bits[gr][ch];
  518.       
  519.     } /* for ch */
  520.   } /* for gr */
  521.  
  522.  
  523.   if (reduce_s_ch) {
  524.     /* number of bits needed was found for MID channel above.  Use formula
  525.      * (fixed bitrate code) to set the side channel bits */
  526.     for (gr = 0; gr < gfc->mode_gr; gr++) {
  527.       FLOAT8 fac = .33*(.5-ms_ener_ratio[gr])/.5;
  528.       save_bits[gr][1]=((1-fac)/(1+fac))*save_bits[gr][0];
  529.       save_bits[gr][1]=Max(125,save_bits[gr][1]);
  530.       used_bits += save_bits[gr][1];
  531.     }
  532.   }
  533.  
  534.   /******************************************************************
  535.    * find lowest bitrate able to hold used bits
  536.    ******************************************************************/
  537.   for( gfc->bitrate_index =   ((analog_silence && !gfp->VBR_hard_min) ? 1 : gfc->VBR_min_bitrate );
  538.        gfc->bitrate_index < gfc->VBR_max_bitrate;
  539.        gfc->bitrate_index++    ) {
  540.     if( used_bits <= frameBits[gfc->bitrate_index] ) break;
  541.   }
  542.  
  543.   /*******************************************************************
  544.    * calculate quantization for this bitrate
  545.    *******************************************************************/  
  546.   getframebits (gfp,&bitsPerFrame, &mean_bits);
  547.   bits=ResvFrameBegin (gfp,l3_side, mean_bits, bitsPerFrame);
  548.  
  549.   /* repartion available bits in same proportion */
  550.   if (used_bits > bits ) {
  551.     reparted = 1;
  552.     for( gr = 0; gr < gfc->mode_gr; gr++) {
  553.       for(ch = 0; ch < gfc->stereo; ch++) {
  554.     save_bits[gr][ch]=(save_bits[gr][ch]*frameBits[gfc->bitrate_index])/used_bits;
  555.       }
  556.     }
  557.     used_bits=0;
  558.     for( gr = 0; gr < gfc->mode_gr; gr++) {
  559.       for(ch = 0; ch < gfc->stereo; ch++) {
  560.     used_bits += save_bits[gr][ch];
  561.       }
  562.     }
  563.   }
  564.   assert(used_bits <= bits);
  565.  
  566.   for(gr = 0; gr < gfc->mode_gr; gr++) {
  567.     for(ch = 0; ch < gfc->stereo; ch++) {
  568.       if (reparted || (reduce_s_ch && ch == 1))
  569.       {
  570.         cod_info = &l3_side->gr[gr].ch[ch].tt;
  571.            
  572.     if (!init_outer_loop(gfp,xr[gr][ch], cod_info))
  573.         {
  574.           /* xr contains no energy 
  575.            * cod_info was set in init_outer_loop above
  576.        */
  577.           memset(&scalefac[gr][ch],0,sizeof(III_scalefac_t));
  578.           memset(l3_enc[gr][ch],0,576*sizeof(int));
  579.       noise[0]=noise[1]=noise[2]=noise[3]=0;
  580.         }
  581.     else
  582.     {
  583.           calc_xmin(gfp,xr[gr][ch], &ratio[gr][ch], cod_info, &l3_xmin);
  584.     
  585.           outer_loop( gfp,xr[gr][ch], save_bits[gr][ch], noise,
  586.                &l3_xmin, l3_enc[gr][ch], 
  587.               &scalefac[gr][ch], cod_info, xfsf, ch);
  588.     }
  589.     if (gfp->gtkflag) 
  590.       set_pinfo(gfp, cod_info, &ratio[gr][ch], &scalefac[gr][ch], xr[gr][ch], xfsf, noise, gr, ch);
  591.       }
  592.     }
  593.   }
  594.  
  595.   /*******************************************************************
  596.    * update reservoir status after FINAL quantization/bitrate 
  597.    *******************************************************************/
  598.   for (gr = 0; gr < gfc->mode_gr; gr++)
  599.     for (ch = 0; ch < gfc->stereo; ch++) {
  600.       cod_info = &l3_side->gr[gr].ch[ch].tt;
  601.       best_scalefac_store(gfp,gr, ch, l3_enc, l3_side, scalefac);
  602.       if (gfc->use_best_huffman==1 && cod_info->block_type != SHORT_TYPE) {
  603.     best_huffman_divide(gfc, gr, ch, cod_info, l3_enc[gr][ch]);
  604.       }
  605.       if (gfp->gtkflag) {
  606.     gfc->pinfo->LAMEmainbits[gr][ch]=cod_info->part2_3_length;
  607.       }
  608.       ResvAdjust (gfp,cod_info, l3_side, mean_bits);
  609.     }
  610.  
  611.   /*******************************************************************
  612.    * set the sign of l3_enc from the sign of xr
  613.    *******************************************************************/
  614.   for (gr = 0; gr < gfc->mode_gr; gr++)
  615.     for (ch = 0; ch < gfc->stereo; ch++) {
  616.       for ( i = 0; i < 576; i++) {
  617.         if (xr[gr][ch][i] < 0) l3_enc[gr][ch][i] *= -1;
  618.       }
  619.     }
  620.  
  621.   ResvFrameEnd (gfp,l3_side, mean_bits);
  622. }
  623.  
  624.  
  625.  
  626.  
  627.  
  628. /************************************************************************/
  629. /*  init_outer_loop  mt 6/99                                            */
  630. /*  returns 0 if all energies in xr are zero, else 1                    */
  631. /************************************************************************/
  632. int init_outer_loop(lame_global_flags *gfp,
  633.     FLOAT8 xr[576],        /*  could be L/R OR MID/SIDE */
  634.     gr_info *cod_info)
  635. {
  636.   int i;
  637.  
  638.  
  639.   for ( i = 0; i < 4; i++ )
  640.     cod_info->slen[i] = 0;
  641.   cod_info->sfb_partition_table = &nr_of_sfb_block[0][0][0];
  642.  
  643.   cod_info->part2_3_length    = 0;
  644.   cod_info->big_values        = 0;
  645.   cod_info->count1            = 0;
  646.   cod_info->scalefac_compress = 0;
  647.   cod_info->table_select[0]   = 0;
  648.   cod_info->table_select[1]   = 0;
  649.   cod_info->table_select[2]   = 0;
  650.   cod_info->subblock_gain[0]  = 0;
  651.   cod_info->subblock_gain[1]  = 0;
  652.   cod_info->subblock_gain[2]  = 0;
  653.   cod_info->region0_count     = 0;
  654.   cod_info->region1_count     = 0;
  655.   cod_info->part2_length      = 0;
  656.   cod_info->preflag           = 0;
  657.   cod_info->scalefac_scale    = 0;
  658.   cod_info->global_gain       = 210;
  659.   cod_info->count1table_select= 0;
  660.   cod_info->count1bits        = 0;
  661.   
  662.   /*
  663.    *  check if there is some energy we have to quantize
  664.    *  if so, then return 1 else 0
  665.    */
  666.   for (i=0; i<576; i++) 
  667.     if ( 1e-99 < fabs (xr[i]) )
  668.       return 1;
  669.   
  670.   return 0;
  671. }
  672.  
  673.  
  674.  
  675.  
  676. /************************************************************************/
  677. /*  outer_loop                                                         */
  678. /************************************************************************/
  679. /*  Function: The outer iteration loop controls the masking conditions  */
  680. /*  of all scalefactorbands. It computes the best scalefac and          */
  681. /*  global gain. This module calls the inner iteration loop             
  682.  * 
  683.  *  mt 5/99 completely rewritten to allow for bit reservoir control,   
  684.  *  mid/side channels with L/R or mid/side masking thresholds, 
  685.  *  and chooses best quantization instead of last quantization when 
  686.  *  no distortion free quantization can be found.  
  687.  *  
  688.  *  added VBR support mt 5/99
  689.  ************************************************************************/
  690. void outer_loop(
  691.     lame_global_flags *gfp,
  692.     FLOAT8 xr[576],        
  693.     int targ_bits,
  694.     FLOAT8 best_noise[4],
  695.     III_psy_xmin *l3_xmin,   /* the allowed distortion of the scalefactor */
  696.     int l3_enc[576],         /* vector of quantized values ix(0..575) */
  697.     III_scalefac_t *scalefac, /* scalefactors */
  698.     gr_info *cod_info,
  699.     FLOAT8 xfsf[4][SBMAX_l],
  700.     int ch)
  701. {
  702.   lame_internal_flags *gfc=gfp->internal_flags;
  703.   III_scalefac_t scalefac_w;
  704.   gr_info save_cod_info;
  705.   int l3_enc_w[576]; 
  706.   int i, iteration;
  707.   int status,bits_found=0;
  708.   int huff_bits;
  709.   FLOAT8 xrpow[576],temp;
  710.   int better;
  711.   int over=0;
  712.   calc_noise_result noise_info;
  713.   calc_noise_result best_noise_info;
  714.   FLOAT8 xfsf_w[4][SBMAX_l];
  715.   FLOAT8 distort[4][SBMAX_l];
  716.  
  717.   int notdone=1;
  718.  
  719.   noise_info.over_count = 100;
  720.   noise_info.tot_count = 100;
  721.   noise_info.max_noise = 0;
  722.   noise_info.tot_noise = 0;
  723.   noise_info.over_noise = 0;
  724.   noise_info.tot_avg_noise = 0;
  725.   noise_info.over_avg_noise = 0;
  726.   best_noise_info = noise_info;
  727.  
  728.  
  729.  
  730.   /* reset of iteration variables */
  731.   memset(&scalefac_w, 0, sizeof(III_scalefac_t));
  732.   for (i=0;i<576;i++) {
  733.     temp=fabs(xr[i]);
  734.     xrpow[i]=sqrt(sqrt(temp)*temp);
  735.   }
  736.   
  737.   bits_found=bin_search_StepSize2(gfp,targ_bits,gfc->OldValue[ch],
  738.                   l3_enc_w,xrpow,cod_info);
  739.   gfc->OldValue[ch] = cod_info->global_gain;
  740.  
  741.  
  742.  
  743.  
  744.   /* BEGIN MAIN LOOP */
  745.   iteration = 0;
  746.   while ( notdone  ) {
  747.     ++iteration;
  748.  
  749.  
  750.     /* inner_loop starts with the initial quantization step computed above
  751.      * and slowly increases until the bits < huff_bits.
  752.      * Thus it is important not to start with too large of an inital
  753.      * quantization step.  Too small is ok, but inner_loop will take longer 
  754.      */
  755.     huff_bits = targ_bits - cod_info->part2_length;
  756.     if (huff_bits < 0) {
  757.       assert(iteration != 1);
  758.       /* scale factors too large, not enough bits. use previous quantizaton */
  759.       notdone=0;
  760.     } else {
  761.       /* if this is the first iteration, see if we can reuse the quantization
  762.        * computed in bin_search_StepSize above */
  763.       int real_bits;
  764.  
  765.       if (iteration==1) {
  766.     if(bits_found>huff_bits) {
  767.       cod_info->global_gain++;
  768.       real_bits = inner_loop(gfp,xrpow, l3_enc_w, huff_bits, cod_info);
  769.     } else real_bits=bits_found;
  770.       }
  771.       else {
  772.     real_bits=inner_loop(gfp,xrpow, l3_enc_w, huff_bits, cod_info);
  773.       }
  774.  
  775.  
  776.       cod_info->part2_3_length = real_bits;
  777.  
  778.       /* compute the distortion in this quantization */
  779.       if (gfc->noise_shaping==0) {
  780.           over=0;
  781.       }else{
  782.     /* coefficients and thresholds both l/r (or both mid/side) */
  783.     over=calc_noise( gfp,xr, l3_enc_w, cod_info, 
  784.               xfsf_w,distort, l3_xmin, &scalefac_w, 
  785.               &noise_info);
  786.       }
  787.  
  788.  
  789.       /* check if this quantization is better the our saved quantization */
  790.       if (iteration == 1) better=1;
  791.       else 
  792.     better=quant_compare(gfp->experimentalX,
  793.          &best_noise_info, &noise_info);
  794.  
  795.       /* save data so we can restore this quantization later */    
  796.       if (better) {
  797.     best_noise_info = noise_info;
  798.  
  799.     memcpy(scalefac, &scalefac_w, sizeof(III_scalefac_t));
  800.     memcpy(l3_enc,l3_enc_w,sizeof(int)*576);
  801.     memcpy(&save_cod_info,cod_info,sizeof(save_cod_info));
  802.  
  803.     if (gfp->gtkflag) {
  804.       memcpy(xfsf, xfsf_w, sizeof(xfsf_w));
  805.     }
  806.       }
  807.     }
  808.  
  809.  
  810.     /* if no bands with distortion, we are done */
  811.     if (!gfp->experimentalX) {
  812.         if (gfc->noise_shaping_stop==0 && over==0)
  813.           notdone=0;
  814.     } else {
  815.         /* do at least 7 tries and stop 
  816.          * if our best quantization so far had no distorted bands
  817.          * this gives us more possibilities for our different quant_compare modes
  818.          */
  819.         if (iteration>7 && gfc->noise_shaping_stop==0 && best_noise_info.over_count==0)
  820.           notdone=0;
  821.     }
  822.  
  823.  
  824.  
  825.     if (notdone) {
  826.     amp_scalefac_bands( gfp, xrpow, cod_info, &scalefac_w, distort);
  827.  
  828.     /* check to make sure we have not amplified too much */
  829.     /* loop_break returns 0 if there is an unamplified scalefac */
  830.     /* scale_bitcount returns 0 if no scalefactors are too large */
  831.  
  832.     if ( (status = loop_break(&scalefac_w, cod_info)) == 0 ) {
  833.             /* not all scalefactors have been amplified.  so these 
  834.              * scalefacs are possibly valid.  encode them: */
  835.         if ( gfp->version == 1 ) {
  836.         status = scale_bitcount(&scalefac_w, cod_info);
  837.         }else{
  838.         status = scale_bitcount_lsf(&scalefac_w, cod_info);
  839.         }
  840.         if (status) {
  841.  
  842.                  /*  some scalefactors are too large.  lets try setting
  843.           * scalefac_scale=1 */
  844.         if (gfc->noise_shaping > 1 && !cod_info->scalefac_scale) {
  845.             inc_scalefac_scale(gfp, &scalefac_w, cod_info, xrpow);
  846.             status = 0;
  847.         } else if (cod_info->block_type == SHORT_TYPE && gfp->experimentalZ && gfc->noise_shaping > 1) {
  848.             inc_subblock_gain(gfp, &scalefac_w, cod_info, xrpow);
  849.             status = loop_break(&scalefac_w, cod_info);
  850.         }
  851.         if (!status) {
  852.             if ( gfp->version == 1 ) {
  853.             status = scale_bitcount(&scalefac_w, cod_info);
  854.             }else{
  855.             status = scale_bitcount_lsf(&scalefac_w, cod_info);
  856.             }
  857.         }
  858.  
  859.  
  860.  
  861.  
  862.         }
  863.  
  864.     }
  865.     notdone = !status;
  866.     }
  867.  
  868.  
  869.     /* Check if the last scalefactor band is distorted.
  870.      * in VBR mode we can't get rid of the distortion, so quit now
  871.      * and VBR mode will try again with more bits.  
  872.      * (makes a 10% speed increase, the files I tested were
  873.      * binary identical, 2000/05/20 Robert.Hegemann@gmx.de)
  874.      */
  875.     if (gfp->VBR==vbr_rh || iteration>100)
  876.       {
  877.         if (cod_info->block_type == SHORT_TYPE)
  878.           {
  879.             if ((distort[1][SBMAX_s-1] > 0)
  880.           ||(distort[2][SBMAX_s-1] > 0)
  881.           ||(distort[3][SBMAX_s-1] > 0)) notdone=0;
  882.           }
  883.         else
  884.           {
  885.             if (distort[0][SBMAX_l-1] > 0) notdone=0;
  886.           }
  887.       }
  888.  
  889.  
  890.   }    /* done with main iteration */
  891.  
  892.   memcpy(cod_info,&save_cod_info,sizeof(save_cod_info));
  893.   cod_info->part2_3_length += cod_info->part2_length;
  894.  
  895.  
  896.   /* finish up */
  897.   assert( cod_info->global_gain < 256 );
  898.  
  899.   best_noise[0]=best_noise_info.over_count;
  900.   best_noise[1]=best_noise_info.max_noise;
  901.   best_noise[2]=best_noise_info.over_avg_noise;
  902.   best_noise[3]=best_noise_info.tot_avg_noise;
  903. }
  904.  
  905.  
  906.  
  907.  
  908.  
  909.   
  910.  
  911.  
  912.  
  913.  
  914.  
  915.  
  916.  
  917.  
  918.  
  919.  
  920.  
  921.  
  922.  
  923.  
  924. /*************************************************************************/
  925. /*            amp_scalefac_bands                                         */
  926. /*************************************************************************/
  927.  
  928. /* 
  929.   Amplify the scalefactor bands that violate the masking threshold.
  930.   See ISO 11172-3 Section C.1.5.4.3.5
  931. */
  932.  
  933. void amp_scalefac_bands(lame_global_flags *gfp,
  934.             FLOAT8 xrpow[576], 
  935.             gr_info *cod_info,
  936.             III_scalefac_t *scalefac,
  937.             FLOAT8 distort[4][SBMAX_l])
  938. {
  939.     int start, end, l,i,j;
  940.     u_int    sfb;
  941.     FLOAT8 ifqstep34;
  942.     FLOAT8 distort_thresh;
  943.     lame_internal_flags *gfc=gfp->internal_flags;
  944.  
  945.     if ( cod_info->scalefac_scale == 0 )
  946.       ifqstep34 = 1.29683955465100964055; /* 2**(.75*.5)*/
  947.     else
  948.       ifqstep34 = 1.68179283050742922612;  /* 2**(.75*1) */
  949.  
  950.     /* distort_thresh = 0, unless all bands have distortion 
  951.      * less than masking.  In that case, just amplify bands with distortion
  952.      * within 95% of largest distortion/masking ratio */
  953.     distort_thresh = -900;
  954.     for ( sfb = 0; sfb < cod_info->sfb_lmax; sfb++ ) {
  955.     distort_thresh = Max(distort[0][sfb],distort_thresh);
  956.     }
  957.  
  958.     for ( sfb = cod_info->sfb_smax; sfb < 12; sfb++ ) {
  959.     for ( i = 0; i < 3; i++ ) {
  960.         distort_thresh = Max(distort[i+1][sfb],distort_thresh);
  961.     }
  962.     }
  963.     distort_thresh=Min(distort_thresh * 1.05, 0.0);
  964.  
  965.  
  966.  
  967.     for ( sfb = 0; sfb < cod_info->sfb_lmax; sfb++ ) {
  968.       if ( distort[0][sfb]>distort_thresh  ) {
  969.     scalefac->l[sfb]++;
  970.     start = gfc->scalefac_band.l[sfb];
  971.     end   = gfc->scalefac_band.l[sfb+1];
  972.     for ( l = start; l < end; l++ )
  973.       xrpow[l] *= ifqstep34;
  974.       }
  975.     }
  976.     
  977.  
  978.     for ( j=0,sfb = cod_info->sfb_smax; sfb < 12; sfb++ ) {
  979.       start = gfc->scalefac_band.s[sfb];
  980.       end   = gfc->scalefac_band.s[sfb+1];
  981.       for ( i = 0; i < 3; i++ ) {
  982.     int j2 = j;
  983.     if ( distort[i+1][sfb]>distort_thresh) {
  984.       scalefac->s[sfb][i]++;
  985.       for (l = start; l < end; l++)
  986.         xrpow[j2++] *= ifqstep34;
  987.     }
  988.     j += end-start;
  989.       }
  990.     }
  991. }
  992.  
  993.  
  994. void inc_scalefac_scale(lame_global_flags *gfp,
  995.             III_scalefac_t *scalefac,
  996.             gr_info *cod_info,
  997.             FLOAT8 xrpow[576])
  998. {
  999.     int start, end, l,i,j;
  1000.     int    sfb;
  1001.     lame_internal_flags *gfc=gfp->internal_flags;
  1002.     const FLOAT8 ifqstep34 = 1.29683955465100964055;
  1003.  
  1004.     for ( sfb = 0; sfb < cod_info->sfb_lmax; sfb++ ) {
  1005.     int s = scalefac->l[sfb];
  1006.     if (cod_info->preflag)
  1007.         s += pretab[sfb];
  1008.     if (s & 1) {
  1009.         s++;
  1010.         start = gfc->scalefac_band.l[sfb];
  1011.         end   = gfc->scalefac_band.l[sfb+1];
  1012.         for ( l = start; l < end; l++ )
  1013.         xrpow[l] *= ifqstep34;
  1014.     }
  1015.     scalefac->l[sfb] = s >> 1;
  1016.     cod_info->preflag = 0;
  1017.     }
  1018.  
  1019.     for ( j=0,sfb = cod_info->sfb_smax; sfb < 12; sfb++ ) {
  1020.       start = gfc->scalefac_band.s[sfb];
  1021.       end   = gfc->scalefac_band.s[sfb+1];
  1022.       for ( i = 0; i < 3; i++ ) {
  1023.             int j2=j;
  1024.         if (scalefac->s[sfb][i] & 1) {
  1025.                 scalefac->s[sfb][i]++;
  1026.         for (l = start; l < end; l++)
  1027.           xrpow[j2++] *= ifqstep34;
  1028.         }
  1029.         scalefac->s[sfb][i] >>= 1;
  1030.         j += end-start;
  1031.     }
  1032.     }
  1033.     cod_info->scalefac_scale = 1;
  1034. }
  1035.  
  1036. void inc_subblock_gain(lame_global_flags *gfp,
  1037.                III_scalefac_t *scalefac,
  1038.                gr_info *cod_info,
  1039.                FLOAT8 xrpow[576])
  1040. {
  1041.     int start, end, l,i;
  1042.     int    sfb;
  1043.     lame_internal_flags *gfc=gfp->internal_flags;
  1044.  
  1045.     fun_reorder(gfc->scalefac_band.s,xrpow);
  1046.  
  1047.     for ( i = 0; i < 3; i++ ) {
  1048.     if (cod_info->subblock_gain[i] >= 7)
  1049.         continue;
  1050.  
  1051.     for ( sfb = cod_info->sfb_smax; sfb < 12; sfb++ ) {
  1052.         if (scalefac->s[sfb][i] >= 8) {
  1053.         break;
  1054.         }
  1055.     }
  1056.     if (sfb == 12)
  1057.         continue;
  1058.  
  1059.     for ( sfb = cod_info->sfb_smax; sfb < 12; sfb++ ) {
  1060.         if (scalefac->s[sfb][i] >= 2) {
  1061.         scalefac->s[sfb][i] -= 2;
  1062.         } else {
  1063.         FLOAT8 amp = pow(2.0, 0.75*(2 - scalefac->s[sfb][i]));
  1064.         scalefac->s[sfb][i] = 0;
  1065.         start = gfc->scalefac_band.s[sfb];
  1066.         end   = gfc->scalefac_band.s[sfb+1];
  1067.         for (l = start; l < end; l++)
  1068.             xrpow[l * 3 + i] *= amp;
  1069.         }
  1070.     }
  1071.     {
  1072.         FLOAT8 amp = pow(2.0, 0.75*2);
  1073.         start = gfc->scalefac_band.s[sfb];
  1074.         for (l = start; l < 192; l++)
  1075.         xrpow[l * 3 + i] *= amp;
  1076.     }
  1077.     cod_info->subblock_gain[i]++;
  1078.     }
  1079.  
  1080.     freorder(gfc->scalefac_band.s,xrpow);
  1081. }
  1082.  
  1083. INLINE 
  1084. int quant_compare(int experimentalX,
  1085.     calc_noise_result *best,
  1086.     calc_noise_result *calc)
  1087. {
  1088.   /*
  1089.     noise is given in decibals (db) relative to masking thesholds.
  1090.  
  1091.     over_noise:  sum of quantization noise > masking
  1092.     tot_noise:   sum of all quantization noise
  1093.     max_noise:   max quantization noise 
  1094.  
  1095.    */
  1096.   int better=0;
  1097.  
  1098.   switch (experimentalX) {
  1099.   default:
  1100.   case 0: better =   calc->over_count      < best->over_count
  1101.                  ||( calc->over_count     == best->over_count
  1102.                   && calc->over_avg_noise <= best->over_avg_noise ); break;
  1103.  
  1104.   case 1: better = calc->max_noise < best->max_noise; break;
  1105.  
  1106.   case 2: better = calc->tot_avg_noise < best->tot_avg_noise; break;
  1107.   
  1108.   case 3: better =  calc->tot_avg_noise < best->tot_avg_noise
  1109.                  && calc->max_noise     < best->max_noise + 2; break;
  1110.   
  1111.   case 4: better = ( ( (0>=calc->max_noise) && (best->max_noise>2)) ||
  1112.      ( (0>=calc->max_noise) && (best->max_noise<0) && ((best->max_noise+2)>calc->max_noise) && (calc->tot_avg_noise<best->tot_avg_noise) ) ||
  1113.      ( (0>=calc->max_noise) && (best->max_noise>0) && ((best->max_noise+2)>calc->max_noise) && (calc->tot_avg_noise<(best->tot_avg_noise+best->over_avg_noise)) ) ||
  1114.      ( (0<calc->max_noise) && (best->max_noise>-0.5) && ((best->max_noise+1)>calc->max_noise) && ((calc->tot_avg_noise+calc->over_avg_noise)<(best->tot_avg_noise+best->over_avg_noise)) ) ||
  1115.      ( (0<calc->max_noise) && (best->max_noise>-1) && ((best->max_noise+1.5)>calc->max_noise) && ((calc->tot_avg_noise+calc->over_avg_noise+calc->over_avg_noise)<(best->tot_avg_noise+best->over_avg_noise+best->over_avg_noise)) ) );
  1116.      break;
  1117.      
  1118.   case 5: better =   calc->over_avg_noise  < best->over_avg_noise
  1119.                  ||( calc->over_avg_noise == best->over_avg_noise
  1120.                   && calc->tot_avg_noise   < best->tot_avg_noise ); break;
  1121.   
  1122.   case 6: better =     calc->over_avg_noise  < best->over_avg_noise
  1123.                  ||(   calc->over_avg_noise == best->over_avg_noise
  1124.                   &&(  calc->max_noise       < best->max_noise
  1125.                    ||( calc->max_noise      == best->max_noise
  1126.                     && calc->tot_avg_noise  <= best->tot_avg_noise ))); break;
  1127.   
  1128.   case 7: better =  calc->over_count < best->over_count
  1129.                  || calc->over_noise < best->over_noise; break;
  1130.   }
  1131.  
  1132.   return better;
  1133. }
  1134.