home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 2 / AACD 2.iso / AACD / Sound / LAME / Source / loop.c < prev    next >
Encoding:
C/C++ Source or Header  |  1999-06-04  |  81.6 KB  |  3,035 lines
  1. /**********************************************************************
  2.  * ISO MPEG Audio Subgroup Software Simulation Group (1996)
  3.  * ISO 13818-3 MPEG-2 Audio Encoder - Lower Sampling Frequency Extension
  4.  *
  5.  * $Id: loop.c,v 1.2 1997/01/19 22:28:29 rowlands Exp $ 
  6.  *
  7.  * $Log: loop.c,v $
  8.  * Revision 1.2  1997/01/19 22:28:29  rowlands
  9.  * Layer 3 bug fixes from Seymour Shlien
  10.  *
  11.  * Revision 1.1  1996/02/14 04:04:23  rowlands
  12.  * Initial revision
  13.  *
  14.  * Received from Mike Coleman
  15.  **********************************************************************/
  16.  
  17. #include <stdio.h>
  18. #include <stdlib.h>
  19. #include <math.h>
  20. #include <assert.h>
  21. #include "globalflags.h"
  22. #include "common.h"
  23. #include "l3side.h"
  24. #include "loop.h"
  25. #include "huffman.h"
  26. #include "l3bitstream.h"
  27. #include "reservoir.h"
  28. #include "loop-pvt.h"
  29. #include "gtkanal.h"
  30.  
  31.  
  32.  
  33. void VBR_on_pe(frame_params *fr_ps, layer *info, III_side_info_t *l3_side, 
  34.            int VBRbits[2][2],
  35.            double pe[][2], int *mean_bits)
  36.  
  37. { 
  38.   int extrabits=0;
  39.   int nshort=0;
  40.   int index,gr,ch;
  41.   int bitsPerFrame;
  42.   int stereo = fr_ps->stereo;  
  43.   int fullframebits;
  44.  
  45.   getframebits(info,stereo,&bitsPerFrame,mean_bits);
  46.   fullframebits= ResvFrameBegin( fr_ps, l3_side, *mean_bits, bitsPerFrame );
  47.   
  48.   
  49.   for (gr=0;gr<2;gr++)
  50.     for (ch=0;ch<2;ch++) {
  51.       int shortblock = (l3_side->gr[gr].ch[ch].tt.block_type==2);
  52.       if (shortblock) nshort ++;
  53.       VBRbits[gr][ch] = fullframebits/4;
  54.     }
  55.   index = nshort;
  56.   /* if (index>3) index=3; */
  57.   
  58.   if (index>0) {
  59.     info->bitrate_index += index;
  60.     /* nshort=1: min 160kbs.  (1 shortblock granule)
  61.      * nshort=2: min 190kbs.  (2 shortblock granules)
  62.      * nshort=3: min 220kbs   (3 shortblock granules)
  63.      * nshort=4: min 256kbs   (4 shortblock granules) */
  64.     if (info->bitrate_index < 9 + index) info->bitrate_index = 9+index;  
  65.     if (info->bitrate_index > 14) info->bitrate_index=14;
  66.     
  67.     getframebits(info,stereo,&bitsPerFrame,mean_bits);
  68.     extrabits= ResvFrameBegin( fr_ps, l3_side, *mean_bits, bitsPerFrame );
  69.     extrabits -= fullframebits;
  70.   }
  71.   /* divide extra bits based on PE */
  72.   if (extrabits > 0) {
  73.     double pe2[2][2],pe_tot=0;
  74.     for (gr=0;gr<2;gr++) {
  75.       for (ch=0;ch<2;ch++) {
  76.     int shortblock = (l3_side->gr[gr].ch[ch].tt.block_type==2);
  77.     pe2[gr][ch] = Min(pe[gr][ch],2800.);
  78.     if (shortblock)  pe2[gr][ch] = Max(pe2[gr][ch],1800.0);
  79.     pe_tot += pe2[gr][ch];
  80.       }
  81.     }
  82.     for (gr=0;gr<2;gr++) {
  83.       for (ch=0;ch<2;ch++) {
  84.     VBRbits[gr][ch] += (extrabits*pe2[gr][ch])/pe_tot;
  85.       }
  86.     }
  87.   }
  88. }
  89.  
  90.  
  91.  
  92.  
  93. void VBR_on_over(frame_params *fr_ps, layer *info, III_side_info_t *l3_side, 
  94.            int VBRbits[2][2],
  95.            int over[2][2], int *mean_bits)
  96.  
  97. { 
  98.   int extrabits=0;
  99.   int gr,ch;
  100.   int bitsPerFrame;
  101.   int stereo = fr_ps->stereo;  
  102.   int fullframebits;
  103.  
  104.   getframebits(info,stereo,&bitsPerFrame,mean_bits);
  105.   fullframebits= ResvFrameBegin( fr_ps, l3_side, *mean_bits, bitsPerFrame );
  106.   
  107.   info->bitrate_index ++;
  108.   getframebits(info,stereo,&bitsPerFrame,mean_bits);
  109.   extrabits= ResvFrameBegin( fr_ps, l3_side, *mean_bits, bitsPerFrame );
  110.   extrabits -= fullframebits;
  111.  
  112.   /* divide extra bits based on OVER */
  113.   if (extrabits > 0) {
  114.     double over2[2][2],over_tot=0;
  115.     for (gr=0;gr<2;gr++) {
  116.       for (ch=0;ch<2;ch++) {
  117.     over2[gr][ch] = over[2][2] + 1;
  118.     over_tot += over2[gr][ch];
  119.       }
  120.     }
  121.     for (gr=0;gr<2;gr++) {
  122.       for (ch=0;ch<2;ch++) {
  123.     VBRbits[gr][ch] += (extrabits*over2[gr][ch])/over_tot;
  124.       }
  125.     }
  126.   }
  127. }
  128.  
  129.  
  130.  
  131.  
  132.  
  133.  
  134.  
  135.  
  136.  
  137.  
  138.  
  139. /* #define DEBUG */
  140. /* #define DEBUGSC */
  141.  
  142. int scale_bitcount_lsf( III_scalefac_t *scalefac, gr_info *cod_info,
  143.                     int gr, int ch );
  144.  
  145.  
  146. /* turn on chris' xrpow speedups */
  147. static int xrpow_flag=0;
  148.  
  149. static int convert_mdct, convert_psy, reduce_sidechannel;
  150. /*
  151. 4 possibilities:
  152.  
  153. 1   MDCT input L/R, quantize L/R,   psy-model thresholds: L/R    -m s
  154. 2   MDCT input L/R, quantize M/S,   psy-model thresholds: L/R    -m j
  155. 3   MDCT input M/S, quantize M/S,   psy-model thresholds: M/S    -m f 
  156. 4   MDCT input L/R, quantize M/S,   psy-model thresholds: M/S     coming soon
  157.  
  158. 1:  convert_mdct = 0, convert_psy=0,  reduce_sidechannel=0
  159. 2:  convert_mdct = 1, convert_psy=1,  reduce_sidechannel=1
  160. 3:  convert_mdct = 0, convert_psy=0,  reduce_sidechannel=1
  161. 4:  convert_mdct = 1, convert_psy=0,  reduce_sidechannel=1
  162.  
  163. if (convert_mdct), then iteration_loop will quantize M/S data from
  164. the L/R input MDCT coefficients.
  165.  
  166. if (convert_psy), then calc_noise will compute the noise for the L/R
  167. channels from M/S MDCT data and L/R psy-model threshold information.
  168. Distortion in ether L or R channel will be marked as distortion in
  169. both Mid and Side channels.  
  170.  
  171. if (reduce_sidechannel) then outer_loop will allocate less bits
  172. to the side channel and more bits to the mid channel based on relative 
  173. energies.
  174. */
  175.  
  176.  
  177.  
  178.  
  179. /*
  180.   Here are MPEG1 Table B.8 and MPEG2 Table B.1
  181.   -- Layer III scalefactor bands.
  182.   Index into this using a method such as:
  183.     idx  = fr_ps->header->sampling_frequency
  184.            + (fr_ps->header->version * 3)
  185. */
  186.  
  187. struct scalefac_struct sfBandIndex[6] =
  188. {
  189.  
  190.   { /* Table B.2.b: 22.05 kHz */
  191.     {0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576},
  192.     {0,4,8,12,18,24,32,42,56,74,100,132,174,192}
  193.   },
  194.   { /* Table B.2.c: 24 kHz */
  195.     {0,6,12,18,24,30,36,44,54,66,80,96,114,136,162,194,232,278,330,394,464,540,576},
  196.     {0,4,8,12,18,26,36,48,62,80,104,136,180,192}
  197.   },
  198.   { /* Table B.2.a: 16 kHz */
  199.     {0,6,12,18,24,30,36,44,45,66,80,96,116,140,168,200,238,248,336,396,464,522,576},
  200.     {0,4,8,12,18,26,36,48,62,80,104,134,174,192}
  201.   },
  202.   { /* Table B.8.b: 44.1 kHz */
  203.     {0,4,8,12,16,20,24,30,36,44,52,62,74,90,110,134,162,196,238,288,342,418,576},
  204.     {0,4,8,12,16,22,30,40,52,66,84,106,136,192}
  205.   },
  206.   { /* Table B.8.c: 48 kHz */
  207.     {0,4,8,12,16,20,24,30,36,42,50,60,72,88,106,128,156,190,230,276,330,384,576},
  208.     {0,4,8,12,16,22,28,38,50,64,80,100,126,192}
  209.   },
  210.   { /* Table B.8.a: 32 kHz */
  211.     {0,4,8,12,16,20,24,30,36,44,54,66,82,102,126,156,194,240,296,364,448,550,576},
  212.     {0,4,8,12,16,22,30,42,58,78,104,138,180,192}
  213.   }
  214. };
  215.  
  216. /*
  217.   The following table is used to implement the scalefactor
  218.   partitioning for MPEG2 as described in section
  219.   2.4.3.2 of the IS. The indexing corresponds to the
  220.   way the tables are presented in the IS:
  221.  
  222.   [table_number][row_in_table][column of nr_of_sfb]
  223. */
  224. static unsigned nr_of_sfb_block[6][3][4] =
  225. {
  226.   {
  227.     {6, 5, 5, 5},
  228.     {9, 9, 9, 9},
  229.     {6, 9, 9, 9}
  230.   },
  231.   {
  232.     {6, 5, 7, 3},
  233.     {9, 9, 12, 6},
  234.     {6, 9, 12, 6}
  235.   },
  236.   {
  237.     {11, 10, 0, 0},
  238.     {18, 18, 0, 0},
  239.     {15,18,0,0}
  240.   },
  241.   {
  242.     {7, 7, 7, 0},
  243.     {12, 12, 12, 0},
  244.     {6, 15, 12, 0}
  245.   },
  246.   {
  247.     {6, 6, 6, 3},
  248.     {12, 9, 9, 6},
  249.     {6, 12, 9, 6}
  250.   },
  251.   {
  252.     {8, 8, 5, 0},
  253.     {15,12,9,0},
  254.     {6,18,9,0}
  255.   }
  256. };
  257.  
  258. /*
  259.   table of largest scalefactors for MPEG2
  260. */
  261. static unsigned max_sfac_tab[6][4] =
  262. {
  263.     {4, 4, 3, 3},
  264.     {4, 4, 3, 0},
  265.     {3, 2, 0, 0},
  266.     {4, 5, 5, 0},
  267.     {3, 3, 3, 0},
  268.     {2, 2, 0, 0}
  269. };
  270.  
  271. /* Table B.6: layer3 preemphasis */
  272. int  pretab[21] =
  273. {
  274.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  275.     1, 1, 1, 1, 2, 2, 3, 3, 3, 2
  276. };
  277.  
  278. /* This is the scfsi_band table from 2.4.2.7 of the IS */
  279. int scfsi_band_long[5] = { 0, 6, 11, 16, 21 };
  280.  
  281. int *scalefac_band_long  = &sfBandIndex[3].l[0];
  282. int *scalefac_band_short = &sfBandIndex[3].s[0];
  283.  
  284.  
  285. void ms_convert(double xr[2][576],double xr_org[2][576])
  286. {
  287.   int i;
  288.   for ( i = 0; i < 576; i++ ) {
  289.     xr[0][i] = (xr_org[0][i]+xr_org[1][i])/sqrt(2.0);
  290.     xr[1][i] = (xr_org[0][i]-xr_org[1][i])/sqrt(2.0);
  291.   }
  292. }
  293.  
  294.  
  295.  
  296.  
  297.  
  298.  
  299.  
  300. /************************************************************************/
  301. /*  iteration_loop()                                                    */
  302. /************************************************************************/
  303. void
  304. iteration_loop( double pe[][2], double ms_ener_ratio[2],
  305.         double xr_org[2][2][576], III_psy_ratio *ratio,
  306.         III_side_info_t *l3_side, int l3_enc[2][2][576],
  307.         double xr_dec[2][2][576],
  308.         III_scalefac_t *scalefac, frame_params *fr_ps)
  309. {
  310.   static int firstcall = 1;
  311.   III_psy_xmin l3_xmin;
  312.   III_psy_xmin l3_xmin_save;
  313.   gr_info *cod_info;
  314.   layer *info;
  315.   int *main_data_begin;
  316.   int VBRbits[2][2];
  317.   int best_over[2][2];
  318.   int bitsPerFrame;
  319.   int mean_bits;
  320.   int stereo = fr_ps->stereo;
  321.   
  322.   int ch, gr, i, mode_gr, bit_rate;
  323.   double xr[2][2][576];
  324.   
  325.   
  326.   main_data_begin = &l3_side->main_data_begin;
  327.   l3_side->resvDrain = 0;
  328.   
  329.   
  330.   if ( firstcall ) {
  331.     *main_data_begin = 0;
  332.     firstcall = 0;
  333.   }
  334.   
  335.   
  336.   info = fr_ps->header;
  337.   mode_gr = (info->version == 1) ? 2 : 1;
  338.   bit_rate = bitrate[info->version][info->lay-1][info->bitrate_index];
  339.  
  340.   scalefac_band_long  = &sfBandIndex[info->sampling_frequency + (info->version * 3)].l[0];
  341.   scalefac_band_short = &sfBandIndex[info->sampling_frequency + (info->version * 3)].s[0];
  342.   
  343.   
  344.   convert_mdct=0;
  345.   convert_psy=0;
  346.   reduce_sidechannel=0;
  347.   if (info->mode_ext==2) {
  348.     convert_mdct = 1;
  349.     convert_psy = 1;
  350.     reduce_sidechannel=1;
  351.   }
  352.   if (force_ms) {
  353.     convert_mdct = 0;
  354.     convert_psy = 0;
  355.     reduce_sidechannel=1;
  356.   }
  357.   
  358.  
  359.   /* remove coefficients in scalefactor band 21 (12 for short blocks)
  360.    * FhG does this for bps <= 128kbs, so we will too.  
  361.    * This amounds to a 16kHz low-pass filter.  If that offends you, you
  362.    * probably should not be encoding at 128kbs!
  363.    * There is no ratio[21] or xfsf[21], so when these coefficients are
  364.    * included they are just quantized as is.
  365.    */
  366.   if (gpsycho && sfb21) {
  367.     if (bit_rate <= 64*stereo) {
  368.       for (ch =0 ; ch < 2 ; ch++)
  369.     for ( gr = 0; gr < mode_gr; gr++ ) {
  370.       int shortblock = (l3_side->gr[gr].ch[0].tt.block_type==2);
  371.       if (shortblock) {
  372.         int j;
  373.         for (j=0; j<3; j++) {
  374.           int start = scalefac_band_short[ SFB_SMAX-1 ];
  375.           for ( i = start; i < 192; i++ ) {
  376.         int i0 = 3*i+j; 
  377.         xr_org[gr][ch][i0]=0;
  378.           }
  379.         }
  380.       }else{
  381.         int start = scalefac_band_long[ SFB_LMAX-1 ];
  382.         for ( i = start; i < 576; i++ ) xr_org[gr][ch][i]=0;
  383.       }
  384.     }
  385.     }
  386.   }
  387.   
  388.   
  389.   /* dont use xrpow for ISO psy model */
  390.   if (!gpsycho) xrpow_flag=0;
  391.   
  392.   
  393.   
  394.   /* some intializations. */
  395.   memset((char *) &l3_xmin, 0, sizeof(l3_xmin));
  396.   for ( gr = 0; gr < mode_gr; gr++ ){
  397.     for ( ch = 0; ch < stereo; ch++ ){
  398.       cod_info = (gr_info *) &(l3_side->gr[gr].ch[ch]);
  399.       gr_deco(cod_info);
  400.       calc_xmin( xr_org, ratio, cod_info, &l3_xmin, gr, ch );
  401.     }
  402.   }
  403.   memcpy(&l3_xmin_save,&l3_xmin,sizeof(l3_xmin));
  404.  
  405.   /* dont bother with scfsi */
  406.   for ( ch = 0; ch < stereo; ch++ )
  407.     for ( i = 0; i < 4; i++ )
  408.       l3_side->scfsi[ch][i] = 0;
  409.   
  410.  
  411.   /* copy data to be quantized into xr */
  412.   if (convert_mdct) for ( gr = 0; gr < mode_gr; gr++ ) ms_convert(xr[gr],xr_org[gr]);
  413.   else memcpy(xr,xr_org,sizeof(xr));   
  414.  
  415.   
  416.  
  417.   if (VBR) {
  418.     VBR_on_pe(fr_ps,info,l3_side,VBRbits,pe,&mean_bits);
  419.   }else{
  420.     getframebits(info,stereo,&bitsPerFrame,&mean_bits);
  421.     ResvFrameBegin( fr_ps, l3_side, mean_bits, bitsPerFrame );
  422.   }
  423.  
  424.  
  425.  
  426.   /* quantize! */
  427.   if (gpsycho) {
  428.     do {
  429.       int max_over;
  430.       
  431.       for ( gr = 0; gr < mode_gr; gr++ )    
  432.     outer_loop( xr, mean_bits, VBRbits, bit_rate, best_over[gr],
  433.             &l3_xmin,l3_enc, fr_ps, 
  434.             scalefac,gr,stereo, l3_side, ratio, pe, ms_ener_ratio);
  435.       if (!VBR) break;
  436.  
  437.       /* see if we should try a higher bitrate quantization */
  438.       max_over=0;
  439.       for ( gr = 0; gr < mode_gr; gr++ ) 
  440.     for (ch=0 ; ch < stereo ; ch ++ ) {
  441.       if (best_over[gr][ch]>max_over) max_over=best_over[gr][ch];
  442.     }
  443.       if (max_over <= VBR_q) break;
  444.  
  445.       VBR_on_over(fr_ps,info,l3_side,VBRbits,best_over,&mean_bits);
  446.       /* restore data for another call to outer_loop */
  447.       if (convert_mdct) for ( gr = 0; gr < mode_gr; gr++ ) ms_convert(xr[gr],xr_org[gr]);
  448.       else memcpy(xr,xr_org,sizeof(xr));   
  449.       memcpy(&l3_xmin,&l3_xmin_save,sizeof(l3_xmin));
  450.       
  451.     } while (info->bitrate_index < 14);  /* max allowed 320 kbs */
  452.  
  453.   }else{
  454.     /* ISO outer_loop */
  455.     for ( gr = 0; gr < mode_gr; gr++ )    
  456.       outer_loop_old( xr, mean_bits, &l3_xmin,l3_enc, fr_ps, 
  457.               scalefac,gr,stereo, l3_side, ratio, pe );
  458.   }
  459.     
  460.   if (VBR) {
  461.     /* update reservoir status after FINAL quantization/bitrate */
  462.     for ( gr = 0; gr < mode_gr; gr++ ) {
  463.       for (ch=0 ; ch < stereo ; ch ++ ) {
  464.         gr_info *cod_info = &l3_side->gr[gr].ch[ch].tt;
  465.     ResvAdjust( fr_ps, cod_info, l3_side, mean_bits );
  466.       }
  467.     }
  468.   }
  469.   
  470.   /* set the sign of l3_enc */
  471.   for ( gr = 0; gr < mode_gr; gr++ )
  472.     for ( ch =  0; ch < stereo; ch++ )
  473.       {
  474.     int *pi = &l3_enc[gr][ch][0];
  475.     
  476.     for ( i = 0; i < 576; i++)         {
  477.       double pr = xr[gr][ch][i];
  478.       if ( (pr < 0) && (pi[i] > 0) )   pi[i] *= -1;
  479.     }
  480.       }
  481.   ResvFrameEnd( fr_ps, l3_side, mean_bits );
  482. }
  483.  
  484.  
  485.  
  486.  
  487.  
  488.  
  489.  
  490.  
  491.  
  492. /************************************************************************/
  493. /*  quantanf_init                                                       */
  494. /************************************************************************/
  495. int quantanf_init( double xr[576] )
  496. /* Function: Calculate the first quantization step quantanf.       */
  497. {
  498.     int i, tp = 0;
  499.     double system_const, minlimit;
  500.     double sfm = 0.0, sum1 = 0.0, sum2 = 0.0;
  501.     
  502.     system_const = 8.0;
  503.     minlimit = -100.0;
  504.  
  505.     for ( i = 0; i < 576; i++ )
  506.     {
  507.         if ( xr[i] != 0 )
  508.     {
  509.             double tpd = xr[i] * xr[i];
  510.             sum1 += log( tpd );
  511.             sum2 += tpd;
  512.         }
  513.     }
  514.     if ( sum2 != 0.0 )
  515.     {
  516.         sfm = exp( sum1 / 576.0 ) / (sum2 / 576.0);
  517.         tp = nint( system_const * log(sfm) );
  518.     if ( tp < minlimit )
  519.         tp = minlimit;
  520. #ifdef DEBUG
  521.         printf(" quantanf = %d (quantanf_init)\n",tp );
  522. #endif
  523.     }
  524.       return(tp-70.0); /* SS 19-12-96. Starting value of
  525.                           global_gain or quantizerStepSize 
  526.                           has to be reduced for iteration_loop
  527.                        */
  528. }
  529.  
  530.  
  531.   
  532. /************************************************************************/
  533. /*  outer_loop                                                         */
  534. /************************************************************************/
  535. /*  Function: The outer iteration loop controls the masking conditions  */
  536. /*  of all scalefactorbands. It computes the best scalefac and          */
  537. /*  global gain. This module calls the inner iteration loop             */
  538. /************************************************************************/
  539. void outer_loop(
  540.     double xr[2][2][576],        /*  could be L/R OR MID/SIDE */
  541.     int mean_bits,
  542.     int VBRbits[2][2],
  543.     int bit_rate,
  544.     int best_over[2],
  545.     III_psy_xmin  *l3_xmin,   /* the allowed distortion of the scalefactor */
  546.     int l3_enc[2][2][576],    /* vector of quantized values ix(0..575) */
  547.     frame_params *fr_ps,
  548.     III_scalefac_t *scalefac, /* scalefactors */
  549.     int gr, int stereo, III_side_info_t *l3_side,
  550.     III_psy_ratio *ratio, double pe[2][2], double ms_ener_ratio[2])
  551. {
  552.   int status[2],notdone[2]={0,0},count[2]={0,0},bits_found[2];
  553.   int targ_bits[2],real_bits[2],tbits,extra_bits; 
  554.   int scalesave_l[2][CBLIMIT], scalesave_s[2][CBLIMIT][3];
  555.   int sfb, bits, huff_bits, save_preflag[2], save_compress[2];
  556.   double xfsf[2][4][CBLIMIT];
  557.   double xrpow[2][2][576],temp;
  558.   int distort[2][4][CBLIMIT];
  559.   int save_l3_enc[2][576];  
  560.   int save_real_bits[2];
  561.   int i,over[2], iteration, ch, mstoggle;
  562.   double best_noise[2];
  563.   int better[2];
  564.   double tot_noise[2];
  565.  
  566.   
  567.   gr_info save_cod_info[2];
  568.   gr_info *cod_info[2];  
  569.   
  570.   cod_info[0] = &l3_side->gr[gr].ch[0].tt;
  571.   cod_info[1] = &l3_side->gr[gr].ch[1].tt;
  572.     
  573.   for (ch=0 ; ch < stereo ; ch ++ ){
  574.  
  575.     /* if ( info->version == 1 )
  576.       calc_scfsi( xr[gr][ch], l3_side, &l3_xmin, ch, gr ); 
  577.     */
  578.         
  579.     
  580.     /* reset of iteration variables */
  581.     
  582.     for ( sfb = 0; sfb < SFB_LMAX; sfb++ )
  583.       scalefac->l[gr][ch][sfb] = 0;
  584.     for ( sfb = 0; sfb < SFB_SMAX; sfb++ )
  585.       for ( i = 0; i < 3; i++ )
  586.     scalefac->s[gr][ch][sfb][i] = 0;
  587.     
  588.     for ( i = 0; i < 4; i++ )
  589.       cod_info[ch]->slen[i] = 0;
  590.     cod_info[ch]->sfb_partition_table = &nr_of_sfb_block[0][0][0];
  591.     
  592.     cod_info[ch]->part2_3_length    = 0;
  593.     cod_info[ch]->big_values        = 0;
  594.     cod_info[ch]->count1            = 0;
  595.     cod_info[ch]->scalefac_compress = 0;
  596.     cod_info[ch]->table_select[0]   = 0;
  597.     cod_info[ch]->table_select[1]   = 0;
  598.     cod_info[ch]->table_select[2]   = 0;
  599.     cod_info[ch]->subblock_gain[0]  = 0;
  600.     cod_info[ch]->subblock_gain[1]  = 0;
  601.     cod_info[ch]->subblock_gain[2]  = 0;
  602.     cod_info[ch]->region0_count     = 0;
  603.     cod_info[ch]->region1_count     = 0;
  604.     cod_info[ch]->part2_length      = 0;
  605.     cod_info[ch]->preflag           = 0;
  606.     cod_info[ch]->scalefac_scale    = 0;
  607.     cod_info[ch]->quantizerStepSize = 0.0;
  608.     cod_info[ch]->count1table_select= 0;
  609.     cod_info[ch]->address1          = 0;
  610.     cod_info[ch]->address2          = 0;
  611.     cod_info[ch]->address3          = 0;
  612.   }
  613.  
  614.  
  615.   
  616.   for (ch=0 ; ch < stereo ; ch ++) {
  617.     count[ch]=0;
  618.     best_over[ch] = 100;
  619.     best_noise[ch] = 1e30;
  620.     for (i=0; i<576; i++) 
  621.       if ( fabs(xr[gr][ch][i]) > 0 ) count[ch]++; 
  622.     notdone[ch]=count[ch];
  623.   }
  624.   
  625. #if 0
  626.   /* compute subblock gains */
  627.   for (ch=0 ; ch < stereo ; ch ++) {
  628.     int j,b;  double en[3],mx;
  629.     if ((cod_info[ch]->block_type ==2) && count[ch]) {
  630.       /* estimate energy within each subblock */
  631.       for (b=0; b<3; b++) en[b]=0;
  632.       for ( i=0,j = 0; j < 192; j++ ) {
  633.     for (b=0; b<3; b++) {
  634.       en[b]+=xr[gr][ch][i]*xr[gr][ch][i];
  635.       i++;
  636.     }
  637.       }
  638.       mx = 1e-12;
  639.       for (b=0; b<3; b++) mx=Max(mx,en[b]);
  640.       for (b=0; b<3; b++) en[b] = Max(en[b],1e-12)/mx;
  641.       printf("ener = %4.2f  %4.2f  %4.2f  \n",en[0],en[1],en[2]);
  642.       /* pick gain so that 2^(2gain)*en[0] = 1  */
  643.       /* gain = .5* log( 1/en[0] )/log(2) = -.5*log(en[])/log(2) */
  644.       for (b=0; b<3; b++) {
  645.     cod_info[ch]->subblock_gain[b]=nint(-.5*log(en[b])/log(2.0));
  646.     if (cod_info[ch]->subblock_gain[b] > 3) 
  647.       cod_info[ch]->subblock_gain[b]=3;
  648.     if (cod_info[ch]->subblock_gain[b] < 0) 
  649.       cod_info[ch]->subblock_gain[b]=0;
  650.       }
  651.     }
  652.   }
  653. #endif
  654.   
  655.   
  656.   if (VBR) {
  657.     for (ch=0 ; ch < stereo ; ch ++ )
  658.       targ_bits[ch]=VBRbits[gr][ch];
  659.  
  660.   }else { 
  661.     int add_bits[2]; 
  662.     double bits_needed;
  663.  
  664.     /* allocate targ_bits for granule */
  665.     ResvMaxBits2( mean_bits, &tbits, &extra_bits, gr);
  666.  
  667.     for (ch=0 ; ch < stereo ; ch ++ )
  668.       targ_bits[ch]=tbits/stereo;
  669.     
  670.     /******************************************************************
  671.      * allocate extra bits from reservoir based on PE 
  672.      ******************************************************************/
  673.     bits=0;
  674.     
  675.     for (ch=0; ch<stereo; ch++) {
  676.       
  677.       /* extra bits based on PE > 700 */
  678.       add_bits[ch]=(pe[gr][ch]-700)/2.0;  /* 3.0; */
  679.       if (convert_psy) bits_needed = (pe[gr][0]+pe[gr][1]-1400)/2.0;
  680.       
  681.       /* short blocks need extra, no matter what the pe */
  682.       if (cod_info[ch]->block_type==2) 
  683.     if (add_bits[ch]<500) add_bits[ch]=500;
  684.       
  685.       if (add_bits[ch] < 0) add_bits[ch]=0;
  686.       bits += add_bits[ch];
  687.     }
  688.     for (ch=0; ch<stereo; ch++) {
  689.       if (bits > extra_bits) add_bits[ch] = (extra_bits*add_bits[ch])/bits;
  690.       targ_bits[ch] = targ_bits[ch] + add_bits[ch];
  691.     }
  692.     for (ch=0; ch<stereo; ch++) 
  693.       extra_bits -= add_bits[ch];
  694.   }
  695.  
  696.  
  697.  
  698.   if (reduce_sidechannel) {
  699.     /*  ms_ener_ratio = 0:  allocate 66/33  mid/side  fac=.33  
  700.      *  ms_ener_ratio =.5:  allocate 50/50 mid/side   fac= 0 */
  701.     /* 75/25 split is fac=.5 */
  702.     /* float fac = .50*(.5-ms_ener_ratio[gr])/.5;*/
  703.     float fac = .33*(.5-ms_ener_ratio[gr])/.5;
  704.     targ_bits[0] += targ_bits[1]*fac;
  705.     targ_bits[1] -= targ_bits[1]*fac;
  706.   }
  707.   
  708.   /* dont allow to many bits per channel */  
  709.   for (ch=0; ch<stereo; ch++) {
  710.     int max_bits = mean_bits/2 + 1200;
  711.     if (targ_bits[ch] > max_bits) {
  712.       extra_bits += (targ_bits[ch] - max_bits);
  713.       targ_bits[ch] = max_bits;
  714.     }
  715.   }
  716.   
  717.   
  718.   
  719.   
  720.   /* BEGIN MAIN LOOP */
  721.   iteration = 0;
  722.   mstoggle=0;        
  723.  
  724.   /* compute initial quantization step */
  725.   for (ch=0 ; ch < stereo ; ch ++ )
  726.     if (count[ch]) {
  727.       if (xrpow_flag) {
  728.     for(i=0;i<576;i++)
  729.       {
  730.         temp=fabs(xr[gr][ch][i]);
  731.         xrpow[gr][ch][i]=sqrt(sqrt(temp)*temp);
  732.       }
  733.       }
  734.       bits_found[ch]=bin_search_StepSize(targ_bits[ch],-211.0,46,
  735.         l3_enc[gr][ch],xr[gr][ch],xrpow[gr][ch],cod_info[ch]); 
  736.     }
  737.   
  738.  
  739.  
  740.  
  741.   while ( (notdone[0] || notdone[1])  ) {
  742.     int pre_just_turned_on[2];
  743.     iteration ++;
  744.     for (ch=0 ; ch < stereo ; ch ++ ) 
  745.     /* inner_loop starts with the initial quantization step computed above
  746.      * and slowly increases until the bits < huff_bits.
  747.      * Thus is it important not to start with too large of an inital
  748.      * quantization step.  Too small is ok, but inner_loop will take longer 
  749.      */
  750.     for (ch=0 ; ch < stereo ; ch ++ ) 
  751.       if (notdone[ch]) {
  752.     cod_info[ch]->part2_length = part2_length( scalefac, fr_ps, gr, ch, l3_side );
  753.     huff_bits = targ_bits[ch] - cod_info[ch]->part2_length;
  754.     if (huff_bits < 0) {
  755.       fprintf(stderr,"ERROR: outer_loop(): huff_bits < 0. \n");
  756.       exit(-5);
  757.     }
  758.     /* if this is the first iteration, see if we can reuse the quantization
  759.      * computed in bin_search_StepSize above */
  760.     if (iteration==1) {
  761.       if(bits_found[ch]>huff_bits) {
  762.         cod_info[ch]->quantizerStepSize+=1.0;
  763.         real_bits[ch] = inner_loop( xr, xrpow, l3_enc, huff_bits, cod_info[ch], gr, ch );
  764.       } else real_bits[ch]=bits_found[ch];
  765.     }
  766.     else 
  767.       real_bits[ch]=inner_loop( xr, xrpow, l3_enc, huff_bits, cod_info[ch], gr, ch );
  768.       }
  769.  
  770.     if (convert_psy) 
  771.       /* mid/side coefficiets, l/r thresholds */
  772.       calc_noise2( &xr[gr][0], &l3_enc[gr][0], cod_info, xfsf,
  773.          distort, l3_xmin,gr,stereo,over,tot_noise);
  774.     else
  775.       /* coefficients and thresholds both l/r (or both mid/side) */
  776.       for (ch=0; ch<stereo; ch++)
  777.     if (notdone[ch])
  778.       over[ch]=calc_noise1( xr[gr][ch], l3_enc[gr][ch], cod_info[ch], 
  779.           xfsf[ch],distort[ch], l3_xmin,gr,ch, tot_noise[ch]);
  780.  
  781.  
  782.     
  783.     /* check if this quantization is better the our saved quantization */
  784.     for (ch=0 ; ch < stereo ; ch ++ ) {
  785.       better[ch]=0;
  786.       if (notdone[ch]) {
  787.     if (fast_mode) 
  788.       if (convert_psy)
  789.         better[ch] = (tot_noise[0]+tot_noise[1]) < 
  790.                             (best_noise[0]+best_noise[1]);
  791.       else
  792.         better[ch] = (tot_noise[ch] < best_noise[ch]);
  793.     else 
  794.       if (convert_psy) 
  795.         better[ch] = (over[0]+over[1]) <= (best_over[0]+best_over[1]);
  796.       else
  797.         better[ch] = (over[ch] <= best_over[ch]);
  798.       }
  799.     }
  800.     /* save data so we can restore this quantization later */    
  801.     for (ch=0 ; ch < stereo ; ch ++ ) {
  802.       if (better[ch]) {
  803.     best_noise[ch]=tot_noise[ch];
  804.     best_over[ch]=over[ch];
  805.     if (notdone[ch]) {
  806.       for ( sfb = 0; sfb < CBLIMIT; sfb++ ) /* save scaling factors */
  807.         scalesave_l[ch][sfb] = scalefac->l[gr][ch][sfb];
  808.       
  809.       for ( sfb = 0; sfb < SFB_SMAX; sfb++ )
  810.         for ( i = 0; i < 3; i++ )
  811.           scalesave_s[ch][sfb][i] = scalefac->s[gr][ch][sfb][i];
  812.       
  813.       save_preflag[ch]  = cod_info[ch]->preflag;
  814.       save_compress[ch] = cod_info[ch]->scalefac_compress;
  815.       
  816.       memcpy(save_l3_enc[ch],l3_enc[gr][ch],sizeof(l3_enc[gr][ch]));   
  817.       memcpy(&save_cod_info[ch],cod_info[ch],sizeof(save_cod_info[ch]));
  818.       save_real_bits[ch]=real_bits[ch];
  819.  
  820. #ifdef HAVEGTK
  821.       if (gtkflag) {
  822.         for ( i = 0; i < 3; i++ ) {
  823.           for ( sfb = cod_info[ch]->sfb_smax; sfb < 12; sfb++ )  {
  824.         pinfo->xfsf_s[gr][ch][3*sfb+i] =  
  825.           pinfo->thr_s[gr][ch][3*sfb+i]*xfsf[ch][i+1][sfb]/
  826.           (1e-20+l3_xmin->s[gr][ch][sfb][i]);
  827.           }
  828.         }
  829.         for ( sfb = 0; sfb < cod_info[ch]->sfb_lmax; sfb++ )   {
  830.           pinfo->xfsf[gr][ch][sfb] =  
  831.         pinfo->thr[gr][ch][sfb]*xfsf[ch][0][sfb]/
  832.         (1e-20 + l3_xmin->l[gr][ch][sfb]);
  833.         }
  834.         pinfo->over[gr][ch]=over[ch];
  835.         pinfo->noise[gr][ch]=tot_noise[ch];
  836.       }
  837. #endif
  838.       
  839.  
  840.     }
  841.       }
  842.     }
  843.  
  844.     /* if no bands with distortion, we are done */
  845.     for (ch=0 ; ch < stereo ; ch ++ ) 
  846.       if (notdone[ch]) {
  847.     if (convert_psy) 
  848.       notdone[ch] = (over[0] || over[1]);
  849.     else
  850.       notdone[ch] = over[ch];
  851.       }
  852.  
  853.  
  854.  
  855.  
  856.     /* see if we should apply preemphasis */
  857.     for (ch=0 ; ch < stereo ; ch ++ ) {
  858.       pre_just_turned_on[ch]=0;
  859.       if (notdone[ch]) pre_just_turned_on[ch]=
  860.      preemphasis2( xr[gr][ch], xrpow[gr][ch], l3_xmin, 
  861.            gr, ch, l3_side,    distort[ch]);
  862.     }
  863.     
  864.     
  865.     /* if we didn't just apply pre-emph, let us see if we should 
  866.      * amplify some scale factor bands */
  867.     for (ch=0 ; ch < stereo ; ch ++ ) 
  868.       if (notdone[ch] && (!pre_just_turned_on[ch]) ) {
  869.     if (convert_psy)  {
  870.       if (ch == mstoggle)  /* only amplify mstoggle channel */
  871.         amp_scalefac_bands2( xr[gr][ch], xrpow[gr][ch], l3_xmin,
  872.              l3_side, scalefac, gr, ch, iteration,distort[ch]);
  873.       /* next time around, amplify other channel */
  874.       if (ch == (stereo-1)) mstoggle = 1-mstoggle;  
  875.       
  876.     }else{
  877.       amp_scalefac_bands2( xr[gr][ch], xrpow[gr][ch], l3_xmin,
  878.         l3_side, scalefac, gr, ch, iteration,distort[ch]);
  879.     }
  880.       }
  881.     
  882.     
  883.     /* check to make sure we have not amplified too much */
  884.     for (ch=0 ; ch < stereo ; ch ++ ) {
  885.       if (notdone[ch]) {
  886.     if ( (status[ch] = loop_break(scalefac, cod_info[ch], gr, ch)) == 0 )
  887.       if ( fr_ps->header->version == 1 )
  888.         status[ch] = scale_bitcount( scalefac, cod_info[ch], gr, ch );
  889.       else
  890.         status[ch] = scale_bitcount_lsf( scalefac, cod_info[ch], gr, ch );
  891.     notdone[ch] = ( status[ch] == 0 );
  892.       }
  893.     }
  894.   }    /* done with main iteration */
  895.   
  896.  
  897.   
  898.   
  899.   /* restore some data */
  900.   for (ch=0 ; ch < stereo ; ch ++ ) {
  901.     if (count[ch] ) {
  902.       cod_info[ch]->preflag = save_preflag[ch];
  903.       cod_info[ch]->scalefac_compress = save_compress[ch];
  904.       
  905.       for ( sfb = 0; sfb < CBLIMIT; sfb++ ) {
  906.     scalefac->l[gr][ch][sfb] = scalesave_l[ch][sfb];    
  907.       }
  908.       
  909.       for ( i = 0; i < 3; i++ )
  910.     for ( sfb = 0; sfb < SFB_SMAX; sfb++ ) {
  911.       scalefac->s[gr][ch][sfb][i] = scalesave_s[ch][sfb][i];    
  912.     }
  913.  
  914.       { 
  915.     real_bits[ch]=save_real_bits[ch];  
  916.     memcpy(l3_enc[gr][ch],save_l3_enc[ch],sizeof(l3_enc[gr][ch]));   
  917.     memcpy(cod_info[ch],&save_cod_info[ch],sizeof(save_cod_info[ch]));
  918.     
  919.     if ( fr_ps->header->version == 1 )
  920.       status[ch] = scale_bitcount( scalefac, cod_info[ch], gr, ch );
  921.     else
  922.       status[ch] = scale_bitcount_lsf( scalefac, cod_info[ch], gr, ch );
  923.     if (status[ch]) {
  924.       printf("Error recomputing scalefac_compress...this should not happen");
  925.       exit(-10);
  926.     }
  927.       }
  928.       cod_info[ch]->part2_length   = part2_length( scalefac, fr_ps, gr, ch, l3_side );
  929.       cod_info[ch]->part2_3_length = cod_info[ch]->part2_length + real_bits[ch];
  930. #ifdef HAVEGTK
  931.       if (gtkflag)
  932.     pinfo->LAMEmainbits[gr][ch]=cod_info[ch]->part2_3_length;
  933. #endif
  934.     }      
  935.   }
  936.   
  937.   /* finish up */
  938.   for (ch=0 ; ch < stereo ; ch ++ ) {
  939.     if (!VBR) ResvAdjust( fr_ps, cod_info[ch], l3_side, mean_bits );
  940.     cod_info[ch]->global_gain = nint( cod_info[ch]->quantizerStepSize + 210.0 );
  941.     assert( cod_info[ch]->global_gain < 256 );
  942.   }
  943.  
  944.  
  945.  
  946.  
  947.  
  948. }
  949.  
  950.  
  951.  
  952.  
  953.  
  954.   
  955. /************************************************************************/
  956. /*  outer_loop                                                         */
  957. /************************************************************************/
  958. /*  Function: The outer iteration loop controls the masking conditions  */
  959. /*  of all scalefactorbands. It computes the best scalefac and          */
  960. /*  global gain. This module calls the inner iteration loop             */
  961. /************************************************************************/
  962. void outer_loop_old(
  963.     double xr[2][2][576],        /*  could be L/R OR MID/SIDE */
  964.     int mean_bits,
  965.     III_psy_xmin  *l3_xmin,   /* the allowed distortion of the scalefactor */
  966.     int l3_enc[2][2][576],    /* vector of quantized values ix(0..575) */
  967.     frame_params *fr_ps,
  968.     III_scalefac_t *scalefac, /* scalefactors */
  969.     int gr, int stereo, III_side_info_t *l3_side,
  970.     III_psy_ratio *ratio, double pe[2][2])
  971. {
  972.     int status ;
  973.     int max_bits[2]; 
  974.     int scalesave_l[CBLIMIT], scalesave_s[CBLIMIT][3];
  975.     int sfb, bits, huff_bits, save_preflag, save_compress;
  976.     double xfsf[4][CBLIMIT];
  977.     int i, over, iteration, ch;
  978.     int do_ch[2];
  979.  
  980.   gr_info *cod_info[2];  
  981.   cod_info[0] = &l3_side->gr[gr].ch[0].tt;
  982.   cod_info[1] = &l3_side->gr[gr].ch[1].tt;
  983.   
  984.   for (ch=0 ; ch < stereo ; ch ++ ){
  985.  
  986.     /* if ( info->version == 1 )
  987.       calc_scfsi( xr[gr][ch], l3_side, &l3_xmin, ch, gr );   */
  988.         
  989.     
  990.     /* reset of iteration variables */
  991.     
  992.     for ( sfb = 0; sfb < 21; sfb++ )
  993.       scalefac->l[gr][ch][sfb] = 0;
  994.     for ( sfb = 0; sfb < 13; sfb++ )
  995.       for ( i = 0; i < 3; i++ )
  996.     scalefac->s[gr][ch][sfb][i] = 0;
  997.     
  998.     for ( i = 0; i < 4; i++ )
  999.       cod_info[ch]->slen[i] = 0;
  1000.     cod_info[ch]->sfb_partition_table = &nr_of_sfb_block[0][0][0];
  1001.     
  1002.     cod_info[ch]->part2_3_length    = 0;
  1003.     cod_info[ch]->big_values        = 0;
  1004.     cod_info[ch]->count1            = 0;
  1005.     cod_info[ch]->scalefac_compress = 0;
  1006.     cod_info[ch]->table_select[0]   = 0;
  1007.     cod_info[ch]->table_select[1]   = 0;
  1008.     cod_info[ch]->table_select[2]   = 0;
  1009.     cod_info[ch]->subblock_gain[0]  = 0;
  1010.     cod_info[ch]->subblock_gain[1]  = 0;
  1011.     cod_info[ch]->subblock_gain[2]  = 0;
  1012.     cod_info[ch]->region0_count     = 0;
  1013.     cod_info[ch]->region1_count     = 0;
  1014.     cod_info[ch]->part2_length      = 0;
  1015.     cod_info[ch]->preflag           = 0;
  1016.     cod_info[ch]->scalefac_scale    = 0;
  1017.     cod_info[ch]->quantizerStepSize = 0.0;
  1018.     cod_info[ch]->count1table_select= 0;
  1019.   }
  1020.  
  1021.  
  1022.     /* all spectral values zero ? */
  1023.     for (ch=0 ; ch < stereo ; ch ++ )
  1024.       do_ch[ch]=(fabs(xr_max(xr[gr][ch], 0, 576)) != 0.0);  
  1025.  
  1026.  
  1027.     for (ch=0 ; ch < stereo ; ch ++ )
  1028.       if (do_ch[ch])
  1029.     cod_info[ch]->quantizerStepSize=(double) quantanf_init( xr[gr][ch] );    
  1030.     
  1031.  
  1032.     for (ch=0 ; ch < stereo ; ch ++ ) {
  1033.       if (do_ch[ch]) {
  1034.       /* calculation of number of available bit( per granule ) */
  1035.       max_bits[ch] = ResvMaxBits( fr_ps, l3_side, &pe[gr][ch], mean_bits,gr,ch);
  1036.       
  1037.       bin_search_StepSize(max_bits[ch],cod_info[ch]->quantizerStepSize,200,
  1038.               l3_enc[gr][ch],xr[gr][ch],xr[gr][ch],cod_info[ch]); 
  1039.     
  1040.       
  1041.       iteration = 0;
  1042.       do {
  1043.     iteration += 1;
  1044.  
  1045.     cod_info[ch]->part2_length = part2_length( scalefac, fr_ps, gr, ch, l3_side );
  1046.     huff_bits = max_bits[ch] - cod_info[ch]->part2_length;
  1047.     bits = inner_loop( xr, xr, l3_enc, huff_bits, cod_info[ch], gr, ch );
  1048.     
  1049.     /* distortion calculation */
  1050.     calc_noise( &xr[gr][ch][0], &l3_enc[gr][ch][0], cod_info[ch], xfsf); 
  1051.  
  1052.     
  1053. #ifdef HAVEGTK
  1054.       if (gtkflag) {
  1055.     for ( sfb = 0; sfb < cod_info[ch]->sfb_lmax; sfb++ ) {
  1056.       pinfo->xfsf[gr][ch][sfb] =  
  1057.         pinfo->thr[gr][ch][sfb]*xfsf[0][sfb]/
  1058.         (1e-20 + l3_xmin->l[gr][ch][sfb]);
  1059.     }
  1060.     for ( i = 0; i < 3; i++ ) {
  1061.       for ( sfb = cod_info[ch]->sfb_smax; sfb < 12; sfb++ )  {
  1062.         pinfo->xfsf_s[gr][ch][3*sfb+i] =  
  1063.         pinfo->thr_s[gr][ch][3*sfb+i]*xfsf[i+1][sfb]/
  1064.         (1e-20 + l3_xmin->s[gr][ch][sfb][i]);
  1065.       }
  1066.     }
  1067.     pinfo->noise[gr][ch]=0;
  1068.       }
  1069. #endif
  1070.     
  1071.     
  1072.     for ( sfb = 0; sfb < CBLIMIT; sfb++ ) /* save scaling factors */
  1073.       scalesave_l[sfb] = scalefac->l[gr][ch][sfb];
  1074.     
  1075.     for ( sfb = 0; sfb < SFB_SMAX; sfb++ )
  1076.       for ( i = 0; i < 3; i++ )
  1077.         scalesave_s[sfb][i] = scalefac->s[gr][ch][sfb][i];
  1078.     
  1079.     save_preflag  = cod_info[ch]->preflag;
  1080.     save_compress = cod_info[ch]->scalefac_compress;
  1081.     
  1082.     preemphasis( &xr[gr][ch][0], xfsf, l3_xmin, gr, ch, l3_side );
  1083.     
  1084.     
  1085.     over = amp_scalefac_bands( &xr[gr][ch][0], xfsf, l3_xmin,
  1086.                    l3_side, scalefac, gr, ch, iteration);
  1087.     
  1088.  
  1089. #ifdef HAVEGTK
  1090.       if (gtkflag) {
  1091.     pinfo->over[gr][ch]=over;
  1092.       }
  1093. #endif
  1094.     
  1095.     if ( (status = loop_break(scalefac, cod_info[ch], gr, ch)) == 0 )
  1096.       {
  1097.         if ( fr_ps->header->version == 1 )
  1098.           status = scale_bitcount( scalefac, cod_info[ch], gr, ch );
  1099.         else
  1100.           status = scale_bitcount_lsf( scalefac, cod_info[ch], gr, ch );
  1101.       }
  1102.       }
  1103.       while ( (status == 0) && (over > 0) ); 
  1104.       
  1105.       
  1106.       cod_info[ch]->preflag = save_preflag;
  1107.       cod_info[ch]->scalefac_compress = save_compress;
  1108.       
  1109.       for ( sfb = 0; sfb < 21; sfb++ )
  1110.     scalefac->l[gr][ch][sfb] = scalesave_l[sfb];    
  1111.       
  1112.       for ( i = 0; i < 3; i++ )
  1113.     for ( sfb = 0; sfb < 12; sfb++ )
  1114.       scalefac->s[gr][ch][sfb][i] = scalesave_s[sfb][i];    
  1115.       
  1116.       cod_info[ch]->part2_length   = part2_length( scalefac, fr_ps, gr, ch, l3_side );
  1117.       cod_info[ch]->part2_3_length = cod_info[ch]->part2_length + bits;
  1118. #ifdef HAVEGTK
  1119.       if (gtkflag){
  1120.     pinfo->LAMEmainbits[gr][ch]=cod_info[ch]->part2_3_length;
  1121.       }
  1122. #endif
  1123.       } /* end do_ch[] */
  1124.  
  1125.       ResvAdjust( fr_ps, cod_info[ch], l3_side, mean_bits );
  1126.       
  1127.       cod_info[ch]->global_gain = nint( cod_info[ch]->quantizerStepSize + 210.0 );
  1128.       assert( cod_info[ch]->global_gain < 256 );
  1129.     } /* end ch loop */
  1130. }
  1131.  
  1132.  
  1133.  
  1134.  
  1135.  
  1136.  
  1137.  
  1138. /*************************************************************************** 
  1139.  *         inner_loop                                                      * 
  1140.  *************************************************************************** 
  1141.  * The code selects the best quantizerStepSize for a particular set
  1142.  * of scalefacs                                                            */
  1143.  
  1144. int
  1145. inner_loop( double xr[2][2][576], double xrpow[2][2][576],
  1146.         int l3_enc[2][2][576], int max_bits,
  1147.         gr_info *cod_info, int gr, int ch )
  1148. {
  1149.     int bits;
  1150.  
  1151.     assert( max_bits >= 0 );
  1152.     cod_info->quantizerStepSize -= 1.0;;
  1153.     do
  1154.     {
  1155.       cod_info->quantizerStepSize += 1.0;
  1156.       if (xrpow_flag)
  1157.     quantize_xrpow( xrpow[gr][ch], l3_enc[gr][ch], cod_info );
  1158.       else
  1159.     quantize( xr[gr][ch], l3_enc[gr][ch], cod_info );
  1160.       bits= count_bits(l3_enc[gr][ch],cod_info);
  1161.     }
  1162.     while ( bits > max_bits );
  1163.     return bits;
  1164. }
  1165.  
  1166.  
  1167.  
  1168.  
  1169.  
  1170.  
  1171. /***************************************************************************/ 
  1172. /*        part2_length                                                     */ 
  1173. /***************************************************************************/ 
  1174.  
  1175. /* calculates the number of bits needed to encode the scalefacs in the     */
  1176. /* main data block                                                         */
  1177.  
  1178. int part2_length( III_scalefac_t *scalefac, frame_params *fr_ps,
  1179.           int gr, int ch, III_side_info_t *si )
  1180. {
  1181.     int slen1, slen2,  bits, partition;
  1182.     gr_info *gi = &si->gr[gr].ch[ch].tt;
  1183.  
  1184.     bits = 0;
  1185.     if ( fr_ps->header->version == 1 )
  1186.     {
  1187.     static int slen1_tab[16] = { 0, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4 };
  1188.     static int slen2_tab[16] = { 0, 1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 2, 3 };
  1189.  
  1190.     slen1 = slen1_tab[ gi->scalefac_compress ];
  1191.     slen2 = slen2_tab[ gi->scalefac_compress ];
  1192.  
  1193.     if ( (gi->window_switching_flag == 1) && (gi->block_type == 2) )
  1194.     {
  1195.         bits += (18 * slen1) + (18 * slen2);
  1196.     }
  1197.     else
  1198.     {
  1199.         if ( (gr == 0) || (si->scfsi[ch][0] == 0) )
  1200.         bits += (6 * slen1);
  1201.  
  1202.         if ( (gr == 0) || (si->scfsi[ch][1] == 0) )
  1203.         /*  bits += (6 * slen1);  This is wrong SS 19-12-96 */
  1204.         bits += (5 * slen1);
  1205.  
  1206.         if ( (gr == 0) || (si->scfsi[ch][2] == 0) )
  1207.         /*  bits += (6 * slen1);   This is wrong SS 19-12-96 */
  1208.         bits += (5 * slen2);
  1209.  
  1210.         if ( (gr == 0) || (si->scfsi[ch][3] == 0) )
  1211.         /* bits += (6 * slen1);   This is wrong SS 19-12-96 */
  1212.         bits += (5 * slen2);
  1213.     }
  1214.     }
  1215.     else
  1216.     {   /* MPEG 2 */
  1217.     assert( gi->sfb_partition_table );
  1218.     for ( partition = 0; partition < 4; partition++ )
  1219.         bits += gi->slen[partition] * gi->sfb_partition_table[partition];
  1220.     }
  1221.     return bits;
  1222. }
  1223.  
  1224.  
  1225.  
  1226. /*************************************************************************/
  1227. /*            scale_bitcount                                             */
  1228. /*************************************************************************/
  1229.  
  1230. /* Also calculates the number of bits necessary to code the scalefactors. */
  1231.  
  1232. int scale_bitcount( III_scalefac_t *scalefac, gr_info *cod_info,
  1233.         int gr, int ch )
  1234. {
  1235.     int i, k, sfb, max_slen1 = 0, max_slen2 = 0, /*a, b, */ ep = 2;
  1236.  
  1237.     static int slen1[16] = { 0, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4 };
  1238.     static int slen2[16] = { 0, 1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 2, 3 };
  1239.  
  1240.     if ( cod_info->window_switching_flag != 0 && cod_info->block_type == 2 )
  1241.     {
  1242.             /* a = 18; b = 18;  */
  1243.             for ( i = 0; i < 3; i++ )
  1244.             {
  1245.                 for ( sfb = 0; sfb < 6; sfb++ )
  1246.                     if ( scalefac->s[gr][ch][sfb][i] > max_slen1 )
  1247.                         max_slen1 = scalefac->s[gr][ch][sfb][i];
  1248.                 for (sfb = 6; sfb < 12; sfb++ )
  1249.                     if ( scalefac->s[gr][ch][sfb][i] > max_slen2 )
  1250.                         max_slen2 = scalefac->s[gr][ch][sfb][i];
  1251.             }
  1252.     }
  1253.     else
  1254.     { /* block_type == 1,2,or 3 */
  1255.         /* a = 11; b = 10;   */
  1256.         for ( sfb = 0; sfb < 11; sfb++ )
  1257.             if ( scalefac->l[gr][ch][sfb] > max_slen1 )
  1258.                 max_slen1 = scalefac->l[gr][ch][sfb];
  1259.         for ( sfb = 11; sfb < 21; sfb++ )
  1260.             if ( scalefac->l[gr][ch][sfb] > max_slen2 )
  1261.                 max_slen2 = scalefac->l[gr][ch][sfb];
  1262.     }
  1263.  
  1264.     for ( k = 0; k < 16; k++ )
  1265.     {
  1266.         if ( (max_slen1 < (1<<slen1[k])) && (max_slen2 < (1<<slen2[k])) )
  1267.         { 
  1268.             ep = 0;
  1269.             break;
  1270.         } 
  1271.     }
  1272.  
  1273.     if ( ep == 0 )
  1274.         cod_info->scalefac_compress = k;
  1275.     return ep;
  1276. }
  1277.  
  1278.  
  1279.  
  1280.  
  1281. /*************************************************************************/
  1282. /*            scale_bitcount_lsf                                         */
  1283. /*************************************************************************/
  1284.  
  1285. /* Also counts the number of bits to encode the scalefacs but for MPEG 2 */ 
  1286. /* Lower sampling frequencies  (24, 22.05 and 16 kHz.)                   */
  1287.  
  1288. /*  This is reverse-engineered from section 2.4.3.2 of the MPEG2 IS,     */
  1289. /* "Audio Decoding Layer III"                                            */
  1290.  
  1291. int scale_bitcount_lsf( III_scalefac_t *scalefac, gr_info *cod_info,
  1292.             int gr, int ch )
  1293. {
  1294.     int table_number, row_in_table, partition, nr_sfb, window, over;
  1295.     int i, sfb, max_sfac[ 4 ];
  1296.     unsigned *partition_table;
  1297.  
  1298.     /*
  1299.       Set partition table. Note that should try to use table one,
  1300.       but do not yet...
  1301.     */
  1302.     if ( cod_info->preflag )
  1303.     table_number = 2;
  1304.     else
  1305.     table_number = 0;
  1306.  
  1307.     for ( i = 0; i < 4; i++ )
  1308.     max_sfac[i] = 0;
  1309.  
  1310.     if ( cod_info->window_switching_flag != 0 && cod_info->block_type == 2 )
  1311.     {
  1312.         row_in_table = 1;
  1313.         partition_table = &nr_of_sfb_block[table_number][row_in_table][0];
  1314.         for ( sfb = 0, partition = 0; partition < 4; partition++ )
  1315.         {
  1316.         nr_sfb = partition_table[ partition ] / 3;
  1317.         for ( i = 0; i < nr_sfb; i++, sfb++ )
  1318.             for ( window = 0; window < 3; window++ )
  1319.             if ( scalefac->s[gr][ch][sfb][window] > max_sfac[partition] )
  1320.                 max_sfac[partition] = scalefac->s[gr][ch][sfb][window];
  1321.         }
  1322.     }
  1323.     else
  1324.     {
  1325.     row_in_table = 0;
  1326.     partition_table = &nr_of_sfb_block[table_number][row_in_table][0];
  1327.     partition = 0;
  1328.     for ( sfb = 0, partition = 0; partition < 4; partition++ )
  1329.     {
  1330.         nr_sfb = partition_table[ partition ];
  1331.         for ( i = 0; i < nr_sfb; i++, sfb++ )
  1332.         if ( scalefac->l[gr][ch][sfb] > max_sfac[partition] )
  1333.             max_sfac[partition] = scalefac->l[gr][ch][sfb];
  1334.     }
  1335.     }
  1336.  
  1337.     for ( over = 0, partition = 0; partition < 4; partition++ )
  1338.     {
  1339.     if ( max_sfac[partition] > max_sfac_tab[table_number][partition] )
  1340.         over++;
  1341.     }
  1342.     if ( !over )
  1343.     {
  1344.     /*
  1345.       Since no bands have been over-amplified, we can set scalefac_compress
  1346.       and slen[] for the formatter
  1347.     */
  1348.     static int log2tab[] = { 0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4 };
  1349.  
  1350.     unsigned slen1, slen2, slen3, slen4;
  1351.  
  1352.         cod_info->sfb_partition_table = &nr_of_sfb_block[table_number][row_in_table][0];
  1353.     for ( partition = 0; partition < 4; partition++ )
  1354.         cod_info->slen[partition] = log2tab[max_sfac[partition]];
  1355.  
  1356.     /* set scalefac_compress */
  1357.     slen1 = cod_info->slen[ 0 ];
  1358.     slen2 = cod_info->slen[ 1 ];
  1359.     slen3 = cod_info->slen[ 2 ];
  1360.     slen4 = cod_info->slen[ 3 ];
  1361.  
  1362.     switch ( table_number )
  1363.     {
  1364.       case 0:
  1365.         cod_info->scalefac_compress = (((slen1 * 5) + slen2) << 4)
  1366.         + (slen3 << 2)
  1367.         + slen4;
  1368.         break;
  1369.  
  1370.       case 1:
  1371.         cod_info->scalefac_compress = 400
  1372.         + (((slen1 * 5) + slen2) << 2)
  1373.         + slen3;
  1374.         break;
  1375.  
  1376.       case 2:
  1377.         cod_info->scalefac_compress = 500 + (slen1 * 3) + slen2;
  1378.         break;
  1379.  
  1380.       default:
  1381.         fprintf( stderr, "intensity stereo not implemented yet\n" );
  1382.         exit( EXIT_FAILURE );
  1383.         break;
  1384.     }
  1385.     }
  1386. #ifdef DEBUG
  1387.     if ( over ) 
  1388.         printf( "---WARNING !! Amplification of some bands over limits\n" );
  1389. #endif
  1390.     return over;
  1391. }
  1392.  
  1393.  
  1394. /*************************************************************************/
  1395. /*            calc_noise                                                 */
  1396. /*************************************************************************/
  1397.  
  1398. /*   Function: Calculate the distortion introduced by the quantization   */
  1399. /*   in each scale factor band.                                          */
  1400.  
  1401. void calc_noise( double xr[576], int ix[576], gr_info *cod_info,
  1402.         double xfsf[4][CBLIMIT])
  1403. {
  1404.     int start, end, sfb, l, i;
  1405.     double sum,step,bw;
  1406.  
  1407.     D192_3 *xr_s;
  1408.     I192_3 *ix_s;
  1409.  
  1410.     #define PRECALC_SIZE 1024 /* WAS 256 !!! */
  1411.     static double pow43[PRECALC_SIZE];
  1412.     static int init=0;
  1413.  
  1414.     if (init==0) {
  1415.       init++;
  1416.       for(i=0;i<PRECALC_SIZE;i++)
  1417.         pow43[i] = pow((double)i, 4.0/3.0);
  1418.     }
  1419.       
  1420.     xr_s = (D192_3 *) xr;
  1421.     ix_s = (I192_3 *) ix;
  1422.  
  1423.     step = pow( 2.0, (cod_info->quantizerStepSize) * 0.25 );
  1424.     for ( sfb = 0; sfb < cod_info->sfb_lmax; sfb++ )
  1425.     {
  1426.         start = scalefac_band_long[ sfb ];
  1427.         end   = scalefac_band_long[ sfb+1 ];
  1428.     bw = end - start;
  1429.  
  1430.         for ( sum = 0.0, l = start; l < end; l++ )
  1431.         {
  1432.             double temp;
  1433.         if (ix[l]<PRECALC_SIZE)
  1434.           temp = fabs(xr[l]) - pow43[ix[l]] * step;
  1435.         else
  1436.             {   
  1437.                temp = fabs(xr[l]) - pow((double)ix[l],4.0/3.0)*step;
  1438.            /*   printf("EHHHHHHH !?!?! ---> %d\n",ix[l]); .. table is not big enough */
  1439.             }
  1440.           sum += temp * temp; 
  1441.         }
  1442.         xfsf[0][sfb] = sum / bw;
  1443.     }
  1444.  
  1445.     for ( i = 0; i < 3; i++ )
  1446.     {
  1447.         step = pow( 2.0, (cod_info->quantizerStepSize) * 0.25 ); /* subblock_gain ? */
  1448.         for ( sfb = cod_info->sfb_smax; sfb < 12; sfb++ )
  1449.         {
  1450.             start = scalefac_band_short[ sfb ];
  1451.             end   = scalefac_band_short[ sfb+1 ];
  1452.         bw = end - start;
  1453.             
  1454.             for ( sum = 0.0, l = start; l < end; l++ )
  1455.             {
  1456.                 double temp;
  1457.         if((*ix_s)[l][i]<PRECALC_SIZE)
  1458.                     temp = fabs((*xr_s)[l][i]) - pow43[(*ix_s)[l][i]] * step;
  1459.                 else
  1460.                 {
  1461.                     temp = fabs((*xr_s)[l][i]) - pow((double)(*ix_s)[l][i],4.0/3.0)*step;
  1462.             /*    printf("EHHHHHHH !?!?! ---> %d\n",(*ix_s)[l][i]); */
  1463.                 }
  1464.                 sum += temp * temp;
  1465.             }       
  1466.             xfsf[i+1][sfb] = sum / bw;
  1467.         }
  1468.     }
  1469. }
  1470.  
  1471. /*************************************************************************/
  1472. /*            calc_noise                                                 */
  1473. /*************************************************************************/
  1474.  
  1475. /*   Function: Improved calc_noise for a single channel   */
  1476. int calc_noise1( double xr[576], int ix[576], gr_info *cod_info,
  1477.         double xfsf[4][CBLIMIT], int distort[4][CBLIMIT],
  1478.             III_psy_xmin *l3_xmin,int gr, int ch, double noise)
  1479.  
  1480. {
  1481.     int start, end, sfb, l, i, over=0;
  1482.     double sum,step,bw;
  1483.  
  1484.     D192_3 *xr_s;
  1485.     I192_3 *ix_s;
  1486.  
  1487.     #define PRECALC_SIZE 1024 /* WAS 256 !!! */
  1488.     static double pow43[PRECALC_SIZE];
  1489.     static int init=0;
  1490.     noise=0;
  1491.  
  1492.     if (init==0) {
  1493.       init++;
  1494.       for(i=0;i<PRECALC_SIZE;i++)
  1495.         pow43[i] = pow((double)i, 4.0/3.0);
  1496.     }
  1497.       
  1498.     xr_s = (D192_3 *) xr;
  1499.     ix_s = (I192_3 *) ix;
  1500.  
  1501.     step = pow( 2.0, (cod_info->quantizerStepSize) * 0.25 );
  1502.     for ( sfb = 0; sfb < cod_info->sfb_lmax; sfb++ )
  1503.     {
  1504.         start = scalefac_band_long[ sfb ];
  1505.         end   = scalefac_band_long[ sfb+1 ];
  1506.     bw = end - start;
  1507.  
  1508.         for ( sum = 0.0, l = start; l < end; l++ )
  1509.         {
  1510.             double temp;
  1511.         if (ix[l]<PRECALC_SIZE)
  1512.           temp = fabs(xr[l]) - pow43[ix[l]] * step;
  1513.         else
  1514.             {   
  1515.                temp = fabs(xr[l]) - pow((double)ix[l],4.0/3.0)*step;
  1516.            /*   printf("EHHHHHHH !?!?! ---> %d\n",ix[l]); .. table is not big enough */
  1517.             }
  1518.           sum += temp * temp; 
  1519.         }
  1520.         xfsf[0][sfb] = sum / bw;
  1521.     distort[0][sfb] = ( xfsf[0][sfb] > l3_xmin->l[gr][ch][sfb] );
  1522.     if (distort[0][sfb]) over++;
  1523.     noise += xfsf[0][sfb];
  1524.     }
  1525.  
  1526.  
  1527.     for ( i = 0; i < 3; i++ )
  1528.     {
  1529.         step = pow( 2.0, (cod_info->quantizerStepSize) * 0.25 ); /* subblock_gain ? */
  1530.     if (cod_info->subblock_gain[i] )
  1531.       step *= pow(2.0,-2.0*cod_info->subblock_gain[i]);
  1532.  
  1533.         for ( sfb = cod_info->sfb_smax; sfb < 12; sfb++ )
  1534.         {
  1535.             start = scalefac_band_short[ sfb ];
  1536.             end   = scalefac_band_short[ sfb+1 ];
  1537.         bw = end - start;
  1538.             
  1539.             for ( sum = 0.0, l = start; l < end; l++ )
  1540.             {
  1541.                 double temp;
  1542.         if((*ix_s)[l][i]<PRECALC_SIZE)
  1543.                     temp = fabs((*xr_s)[l][i]) - pow43[(*ix_s)[l][i]] * step;
  1544.                 else
  1545.                 {
  1546.                     temp = fabs((*xr_s)[l][i]) - pow((double)(*ix_s)[l][i],4.0/3.0)*step;
  1547.             /*    printf("EHHHHHHH !?!?! ---> %d\n",(*ix_s)[l][i]); */
  1548.                 }
  1549.                 sum += temp * temp;
  1550.             }       
  1551.             xfsf[i+1][sfb] = sum / bw;
  1552.         distort[i+1][sfb] = 
  1553.         ( xfsf[i+1][sfb] > l3_xmin->s[gr][ch][sfb][i] );
  1554.         if (distort[i+1][sfb]) over++;
  1555.         noise += xfsf[i+1][sfb];
  1556.         }
  1557.     }
  1558. return over;
  1559. }
  1560.  
  1561.  
  1562.  
  1563. /*************************************************************************/
  1564. /*            calc_noise2                                                */
  1565. /*************************************************************************/
  1566. /*   Improved version of calc_noise for dual channel.  This routine is */
  1567. /*   used when you are quantizaing mid and side channels using masking */
  1568. /*   thresholds from L and R channels */
  1569.  
  1570. void calc_noise2( double xr[2][576], int ix[2][576], gr_info *cod_info[2],
  1571.         double xfsf[2][4][CBLIMIT], int distort[2][4][CBLIMIT],
  1572.             III_psy_xmin *l3_xmin,int gr,int stereo, int over[2], 
  1573.             double noise[2])
  1574. {
  1575.     int start, end, sfb, l, i;
  1576.     double sum[2],step_s[3][2],step[2],bw;
  1577.  
  1578.     D192_3 *xr_s[2];
  1579.     I192_3 *ix_s[2];
  1580.  
  1581.     #define PRECALC_SIZE 1024 /* WAS 256 !!! */
  1582.     static double pow43[PRECALC_SIZE];
  1583.     int ch;
  1584.     static int init=0;
  1585.     double diff[2], qcoeff;
  1586.  
  1587.     if (init==0) {
  1588.       init++;
  1589.       for(i=0;i<PRECALC_SIZE;i++)
  1590.         pow43[i] = pow((double)i, 4.0/3.0);
  1591.     }
  1592.     
  1593.     
  1594.  
  1595.     /* calc_noise2: we can assume block types of both channels must be the same */
  1596.     if (cod_info[0]->block_type != 2) {
  1597.     for (ch=0 ; ch < stereo ; ch ++ ) {
  1598.       over[ch]=0;
  1599.       noise[ch]=0;
  1600.       step[ch] = pow( 2.0, (cod_info[ch]->quantizerStepSize) * 0.25 );
  1601.     }
  1602.     for ( sfb = 0; sfb < SFB_LMAX-1; sfb++ ) {
  1603.  
  1604.       start = scalefac_band_long[ sfb ];
  1605.       end   = scalefac_band_long[ sfb+1 ];
  1606.       bw = end - start;
  1607.       
  1608.       for (ch=0 ; ch < stereo ; ch ++ ) sum[ch]=0;
  1609.  
  1610.       for ( l = start; l < end; l++ ) {
  1611.  
  1612.     for (ch=0 ; ch < stereo ; ch ++ ) {
  1613.       qcoeff= (ix[ch][l] < PRECALC_SIZE) ?
  1614.         pow43[ix[ch][l]] * step[ch]: 
  1615.         pow((double)ix[ch][l],4.0/3.0)*step[ch];  
  1616.       if (xr[ch][l]<0) qcoeff=-qcoeff;
  1617.       diff[ch]=xr[ch][l]-qcoeff;
  1618.     }
  1619.     sum[0] += (diff[0]+diff[1])*(diff[0]+diff[1])/(2.0);
  1620.     sum[1] += (diff[0]-diff[1])*(diff[0]-diff[1])/(2.0);
  1621.       }
  1622.       for (ch=0 ; ch < stereo ; ch ++ ) {
  1623.     xfsf[ch][0][sfb] = sum[ch] / bw;
  1624.     distort[ch][0][sfb] = ( xfsf[ch][0][sfb] > l3_xmin->l[gr][ch][sfb] );
  1625.     if (distort[ch][0][sfb]) over[ch]++;
  1626.     noise[ch] += xfsf[ch][0][sfb];
  1627.       }
  1628.  
  1629.       /* if there is audible distortion in left or right channel, set flags
  1630.        * to denote distortion in both mid and side channels */
  1631.       for (ch=0 ; ch < stereo ; ch ++ ) {
  1632.     distort[ch][0][sfb] = (distort[0][0][sfb] || distort[1][0][sfb]);
  1633.       }
  1634.     }
  1635.     }
  1636.  
  1637.     /* calc_noise2: we can assume block types of both channels must be the same */
  1638.     if (cod_info[0]->block_type == 2) {
  1639.     for (ch=0 ; ch < stereo ; ch ++ ) {
  1640.  
  1641.       for (i=0;i<3;i++){
  1642.     step_s[i][ch] = pow( 2.0, (cod_info[ch]->quantizerStepSize) * 0.25 ); /* subblock_gain ? */
  1643.     if (cod_info[ch]->subblock_gain[i] )
  1644.       step_s[i][ch] *= pow(2.0,-2.0*cod_info[ch]->subblock_gain[i]);
  1645.       }
  1646.  
  1647.       over[ch] = 0;
  1648.       xr_s[ch] = (D192_3 *) xr[ch];
  1649.       ix_s[ch] = (I192_3 *) ix[ch];
  1650.     }
  1651.  
  1652.     for ( sfb = 0 ; sfb < SFB_SMAX-1; sfb++ ) {
  1653.       start = scalefac_band_short[ sfb ];
  1654.       end   = scalefac_band_short[ sfb+1 ];
  1655.       bw = end - start;
  1656.       for ( i = 0; i < 3; i++ ) {        
  1657.     for (ch=0 ; ch < stereo ; ch ++ ) sum[ch] = 0.0;
  1658.     for ( l = start; l < end; l++ )       {
  1659.       for (ch=0 ; ch < stereo ; ch ++ ) {
  1660.         qcoeff = ((*ix_s[ch])[l][i]<PRECALC_SIZE) ?
  1661.           pow43[(*ix_s[ch])[l][i]] * step_s[i][ch] :
  1662.           pow((double)(*ix_s[ch])[l][i],4.0/3.0)*step_s[i][ch]; 
  1663.         if ((*xr_s[ch])[l][i] < 0) qcoeff=-qcoeff;
  1664.         diff[ch] = (*xr_s[ch])[l][i] - qcoeff; 
  1665.       }
  1666.       sum[0] += (diff[0]+diff[1])*(diff[0]+diff[1])/(2.0);
  1667.       sum[1] += (diff[0]-diff[1])*(diff[0]-diff[1])/(2.0);
  1668.     }
  1669.     for (ch=0 ; ch < stereo ; ch ++ ) {
  1670.       xfsf[ch][i+1][sfb] = sum[ch] / bw;
  1671.       distort[ch][i+1][sfb] = 
  1672.         ( xfsf[ch][i+1][sfb] > l3_xmin->s[gr][ch][sfb][i] );
  1673.       if (distort[ch][i+1][sfb]) over[ch]++;
  1674.       noise[ch] = xfsf[ch][i+1][sfb];
  1675.     }
  1676.     /* if there is audible distortion in left or right channel, set flags
  1677.      * to denote distortion in both mid and side channels */
  1678.     for (ch=0 ; ch < stereo ; ch ++ ) 
  1679.       distort[ch][i+1][sfb] = 
  1680.         (distort[0][i+1][sfb]  || distort[1][i+1][sfb]  );
  1681.       }
  1682.     }
  1683.     }
  1684. }
  1685.     
  1686.  
  1687.  
  1688.  
  1689. /*************************************************************************/
  1690. /*            calc_xmin                                                  */
  1691. /*************************************************************************/
  1692.  
  1693. /*
  1694.   Calculate the allowed distortion for each scalefactor band,
  1695.   as determined by the psychoacoustic model.
  1696.   xmin(sb) = ratio(sb) * en(sb) / bw(sb)
  1697. */
  1698.  
  1699. void calc_xmin( double xr[2][2][576], III_psy_ratio *ratio,
  1700.        gr_info *cod_info, III_psy_xmin *l3_xmin,
  1701.        int gr, int ch )
  1702. {
  1703.     int start, end, sfb, l, b;
  1704.     double en0, bw;
  1705.  
  1706.     D192_3 *xr_s;
  1707.  
  1708.     xr_s = (D192_3 *) xr[gr][ch] ;
  1709.  
  1710.     for ( sfb = cod_info->sfb_smax; sfb < SFB_SMAX - 1; sfb++ )
  1711.     {
  1712.         start = scalefac_band_short[ sfb ];
  1713.         end   = scalefac_band_short[ sfb + 1 ];
  1714.     bw = end - start;
  1715.         for ( b = 0; b < 3; b++ )
  1716.         {
  1717.             for ( en0 = 0.0, l = start; l < end; l++ )
  1718.                 en0 += (*xr_s)[l][b] * (*xr_s)[l][b];
  1719.             l3_xmin->s[gr][ch][sfb][b] = ratio->s[gr][ch][sfb][b] * en0 / bw;
  1720.         }
  1721.     }
  1722.  
  1723.     for ( sfb = 0; sfb < cod_info->sfb_lmax; sfb++ )
  1724.     {
  1725.         start = scalefac_band_long[ sfb ];
  1726.         end   = scalefac_band_long[ sfb+1 ];
  1727.     bw = end - start;
  1728.  
  1729.         for ( en0 = 0.0, l = start; l < end; l++ )
  1730.             en0 += xr[gr][ch][l] * xr[gr][ch][l];
  1731.         l3_xmin->l[gr][ch][sfb] = ratio->l[gr][ch][sfb] * en0 / bw;
  1732.     }
  1733. }
  1734.  
  1735.  
  1736.  
  1737. /*************************************************************************/
  1738. /*            loop_break                                                 */
  1739. /*************************************************************************/
  1740.  
  1741. /*  Function: Returns zero if there is a scalefac which has not been
  1742.     amplified. Otherwise it returns one. 
  1743. */
  1744.  
  1745. int loop_break( III_scalefac_t *scalefac, gr_info *cod_info,
  1746.         int gr, int ch )
  1747. {
  1748.     int i, sfb;
  1749.  
  1750.     for ( sfb = 0; sfb < cod_info->sfb_lmax; sfb++ )
  1751.         if ( scalefac->l[gr][ch][sfb] == 0 )
  1752.         return 0;
  1753.  
  1754.     for ( sfb = cod_info->sfb_smax; sfb < 12; sfb++ )
  1755.         for ( i = 0; i < 3; i++ )
  1756.             if ( scalefac->s[gr][ch][sfb][i] == 0 )
  1757.         return 0;
  1758.  
  1759.     return 1;
  1760. }
  1761.  
  1762.  
  1763.  
  1764. /*************************************************************************/
  1765. /*            preemphasis                                                */
  1766. /*************************************************************************/
  1767.  
  1768. /*
  1769.   See ISO 11172-3  section  C.1.5.4.3.4
  1770. */
  1771.  
  1772. void preemphasis( double xr[576], double xfsf[4][CBLIMIT],
  1773.          III_psy_xmin  *l3_xmin,
  1774.          int gr, int ch, III_side_info_t *l3_side )
  1775. {
  1776.     int i, sfb, start, end, scfsi_band, over;
  1777.     double ifqstep;
  1778.     gr_info *cod_info = &l3_side->gr[gr].ch[ch].tt;
  1779.  
  1780.     if ( gr == 1 )
  1781.     {
  1782.     /*
  1783.       If the second granule is being coded and scfsi is active in
  1784.       at least one scfsi_band, the preemphasis in the second granule
  1785.       is set equal to the setting in the first granule
  1786.     */
  1787.     for ( scfsi_band = 0; scfsi_band < 4; scfsi_band++ )
  1788.         if ( l3_side->scfsi[ch][scfsi_band] )
  1789.         {
  1790.         cod_info->preflag = l3_side->gr[0].ch[ch].tt.preflag;
  1791.         return;
  1792.         }
  1793.     
  1794.     }
  1795.  
  1796.     /*
  1797.       Preemphasis is switched on if in all the upper four scalefactor
  1798.       bands the actual distortion exceeds the threshold after the
  1799.       first call of the inner loop
  1800.     */
  1801.     if ( cod_info->block_type != 2 && cod_info->preflag == 0 )
  1802.     {    
  1803.     over = 0;
  1804.     for ( sfb = 17; sfb < 21; sfb++ )
  1805.         if ( xfsf[0][sfb] > l3_xmin->l[gr][ch][sfb] )
  1806.         over++;
  1807.  
  1808.     if (over == 4 )
  1809.     {
  1810.         double t;
  1811.         cod_info->preflag = 1;
  1812.         ifqstep = ( cod_info->scalefac_scale == 0 ) ? sqrt(2.) : 2.0;
  1813.         for ( sfb = 0; sfb < cod_info->sfb_lmax; sfb++ )
  1814.         {
  1815.         t=pow( ifqstep, (double) pretab[sfb] );
  1816.         l3_xmin->l[gr][ch][sfb] *= t*t;
  1817.         start = scalefac_band_long[ sfb ];
  1818.         end   = scalefac_band_long[ sfb+1 ];
  1819.         for( i = start; i < end; i++ )
  1820.             xr[i]*=t;
  1821.         }
  1822.     }
  1823.     }
  1824. }
  1825.  
  1826.  
  1827. /*************************************************************************/
  1828. /*            amp_scalefac_bands                                         */
  1829. /*************************************************************************/
  1830.  
  1831. /* 
  1832.   Amplify the scalefactor bands that violate the masking threshold.
  1833.   See ISO 11172-3 Section C.1.5.4.3.5
  1834. */
  1835.  
  1836. int amp_scalefac_bands( double xr[576], double xfsf[4][CBLIMIT],
  1837.             III_psy_xmin *l3_xmin, III_side_info_t *l3_side,
  1838.             III_scalefac_t *scalefac,
  1839.             int gr, int ch, int iteration)
  1840. {
  1841.     int start, end, l, sfb, i, scfsi_band, over = 0;
  1842.     double ifqstep, ifqstep2;
  1843.     D192_3 *xr_s;
  1844.     gr_info *cod_info, *gr0;
  1845.     int copySF, preventSF;
  1846.     cod_info = &l3_side->gr[gr].ch[ch].tt;
  1847.     gr0      = &l3_side->gr[0].ch[ch].tt;
  1848.  
  1849.     xr_s = (D192_3 *) xr;
  1850.     copySF = 0;
  1851.     preventSF = 0;
  1852.  
  1853.  
  1854.     if ( cod_info->scalefac_scale == 0 )
  1855.     ifqstep = sqrt( 2.0 );
  1856.     else
  1857.     ifqstep = 2.0;
  1858.  
  1859.     if ( gr == 1 )
  1860.     {
  1861.     /*
  1862.       If the second granule is being coded and scfsi is active in at
  1863.       least one scfsi_band...
  1864.     */
  1865.     for ( scfsi_band = 0; scfsi_band < 4; scfsi_band++ )
  1866.         if ( l3_side->scfsi[ch][scfsi_band] )
  1867.         {
  1868.         /*
  1869.           a) ifqstep has to be set similar to the
  1870.            first granule...
  1871.         */
  1872.         if ( gr0->scalefac_scale == 0 )
  1873.             ifqstep = sqrt( 2.0 );
  1874.         else
  1875.             ifqstep = 2.0;
  1876.  
  1877.         if ( iteration == 1 )
  1878.         {
  1879.             /*
  1880.               b) If it is the first iteration, the scalefactors
  1881.               of scalefactor bands in which scfsi is enabled
  1882.               must be taken from the first granule
  1883.             */  
  1884.             copySF = 1;
  1885.         }
  1886.         else
  1887.         {
  1888.             /*
  1889.               c) If it is not the first iteration, the amplification
  1890.               must be prevented for scalefactor bands in which
  1891.               scfsi is enabled
  1892.             */
  1893.             preventSF = 1;
  1894.         }
  1895.         break;
  1896.         }
  1897.     
  1898.     }
  1899.  
  1900.     ifqstep2 = ifqstep * ifqstep;
  1901.     scfsi_band = 0;
  1902.     
  1903.     for ( sfb = 0; sfb < cod_info->sfb_lmax; sfb++ )
  1904.     {
  1905.     if ( copySF || preventSF )
  1906.     {
  1907.         if ( sfb == scfsi_band_long[scfsi_band + 1] )
  1908.         scfsi_band += 1;
  1909.         if ( l3_side->scfsi[ch][scfsi_band] )
  1910.         {
  1911.         if ( copySF )
  1912.             scalefac->l[gr][ch][sfb] = scalefac->l[0][ch][sfb];
  1913.         continue;
  1914.         }
  1915.     }        
  1916.  
  1917.  
  1918.     if ( xfsf[0][sfb] > l3_xmin->l[gr][ch][sfb] )
  1919.     {
  1920.         over++;
  1921.         l3_xmin->l[gr][ch][sfb] *= ifqstep2;
  1922.         scalefac->l[gr][ch][sfb]++;
  1923.         start = scalefac_band_long[sfb];
  1924.         end   = scalefac_band_long[sfb+1];
  1925.         for ( l = start; l < end; l++ )
  1926.         xr[l] *= ifqstep;
  1927.     }
  1928.     }
  1929.  
  1930.     /*
  1931.       Note that scfsi is not enabled for frames containing
  1932.       short blocks
  1933.     */
  1934.     for ( i = 0; i < 3; i++ )
  1935.       for ( sfb = cod_info->sfb_smax; sfb < 12; sfb++ ) {
  1936.             if ( xfsf[i+1][sfb] > l3_xmin->s[gr][ch][sfb][i] )
  1937.             {
  1938.                 over++;
  1939.                 l3_xmin->s[gr][ch][sfb][i] *= ifqstep2;
  1940.                 scalefac->s[gr][ch][sfb][i]++;
  1941. #ifdef DEBUGSC
  1942.                 printf( "cod_info->scalefac[%d][%d] = %d (amp_scale)\n",
  1943.                         i,sfb,scalefac->s[gr][ch][sfb][i] );
  1944. #endif
  1945.                 start = scalefac_band_short[sfb];
  1946.                 end   = scalefac_band_short[sfb+1];
  1947.                 for ( l = start; l < end; l++ )
  1948.                     (*xr_s)[l][i] *= ifqstep;
  1949.             }
  1950.       }
  1951.     return over;
  1952. }
  1953.  
  1954.  
  1955.  
  1956. /*************************************************************************/
  1957. /*            preemphasis                                                */
  1958. /*************************************************************************/
  1959.  
  1960. /*
  1961.   See ISO 11172-3  section  C.1.5.4.3.4
  1962. */
  1963. int preemphasis2( double xr[576], double xrpow[576], 
  1964.      III_psy_xmin  *l3_xmin,
  1965.      int gr, int ch, III_side_info_t *l3_side, int distort[4][CBLIMIT] )
  1966. {
  1967.     int i, sfb, start, end, scfsi_band, over;
  1968.     double ifqstep;
  1969.     gr_info *cod_info = &l3_side->gr[gr].ch[ch].tt;
  1970.  
  1971.     if ( gr == 1 )
  1972.     {
  1973.     /*
  1974.       If the second granule is being coded and scfsi is active in
  1975.       at least one scfsi_band, the preemphasis in the second granule
  1976.       is set equal to the setting in the first granule
  1977.     */
  1978.     for ( scfsi_band = 0; scfsi_band < 4; scfsi_band++ )
  1979.         if ( l3_side->scfsi[ch][scfsi_band] )
  1980.         {
  1981.         cod_info->preflag = l3_side->gr[0].ch[ch].tt.preflag;
  1982.         return 0;
  1983.         }
  1984.     
  1985.     }
  1986.  
  1987.     /*
  1988.       Preemphasis is switched on if in all the upper four scalefactor
  1989.       bands the actual distortion exceeds the threshold after the
  1990.       first call of the inner loop
  1991.     */
  1992.     over = 0;
  1993.     if ( cod_info->block_type != 2 && cod_info->preflag == 0 )
  1994.     {    
  1995.     for ( sfb = 17; sfb < 21; sfb++ )
  1996.         if ( distort[0][sfb] ) over++;
  1997.  
  1998.     if (over == 4 )
  1999.     {
  2000.         double t,t34;
  2001.         cod_info->preflag = 1;
  2002.         ifqstep = ( cod_info->scalefac_scale == 0 ) ? sqrt(2.) : 2.0;
  2003.         for ( sfb = 11; sfb < cod_info->sfb_lmax; sfb++ )
  2004.         {
  2005.         t=pow( ifqstep, (double) pretab[sfb] );
  2006.         t34=sqrt(sqrt(t)*t);
  2007.         l3_xmin->l[gr][ch][sfb] *= t*t;
  2008.         start = scalefac_band_long[ sfb ];
  2009.         end   = scalefac_band_long[ sfb+1 ];
  2010.         for( i = start; i < end; i++ ) xr[i]*=t;
  2011.         if (xrpow_flag)
  2012.           for( i = start; i < end; i++ ) xrpow[i]*=t34;
  2013.         }
  2014.     }
  2015.     }
  2016.     return (over == 4);
  2017. }
  2018.  
  2019.  
  2020.  
  2021.  
  2022. /*************************************************************************/
  2023. /*            amp_scalefac_bands                                         */
  2024. /*************************************************************************/
  2025.  
  2026. /* 
  2027.   Amplify the scalefactor bands that violate the masking threshold.
  2028.   See ISO 11172-3 Section C.1.5.4.3.5
  2029. */
  2030. int amp_scalefac_bands2( double xr[576], double xrpow[576], 
  2031.             III_psy_xmin *l3_xmin, III_side_info_t *l3_side,
  2032.             III_scalefac_t *scalefac,
  2033.             int gr, int ch, int iteration, int distort[4][CBLIMIT])
  2034. {
  2035.     int start, end, l, sfb, i, scfsi_band, over = 0;
  2036.     double ifqstep, ifqstep2, ifqstep34;
  2037.     D192_3 *xr_s;
  2038.     D192_3 *xrpow_s;
  2039.     gr_info *cod_info, *gr0;
  2040.     int copySF, preventSF;
  2041.     cod_info = &l3_side->gr[gr].ch[ch].tt;
  2042.     gr0      = &l3_side->gr[0].ch[ch].tt;
  2043.  
  2044.     xr_s = (D192_3 *) xr;
  2045.     xrpow_s = (D192_3 *) xrpow;
  2046.     copySF = 0;
  2047.     preventSF = 0;
  2048.  
  2049.  
  2050.     if ( cod_info->scalefac_scale == 0 )
  2051.     ifqstep = sqrt( 2.0 );
  2052.     else
  2053.     ifqstep = 2.0;
  2054.  
  2055.     if ( gr == 1 )
  2056.     {
  2057.     /*
  2058.       If the second granule is being coded and scfsi is active in at
  2059.       least one scfsi_band...
  2060.     */
  2061.     for ( scfsi_band = 0; scfsi_band < 4; scfsi_band++ )
  2062.         if ( l3_side->scfsi[ch][scfsi_band] )
  2063.         {
  2064.         /*
  2065.           a) ifqstep has to be set similar to the
  2066.            first granule...
  2067.         */
  2068.         if ( gr0->scalefac_scale == 0 )
  2069.             ifqstep = sqrt( 2.0 );
  2070.         else
  2071.             ifqstep = 2.0;
  2072.  
  2073.         if ( iteration == 1 )
  2074.         {
  2075.             /*
  2076.               b) If it is the first iteration, the scalefactors
  2077.               of scalefactor bands in which scfsi is enabled
  2078.               must be taken from the first granule
  2079.             */  
  2080.             copySF = 1;
  2081.         }
  2082.         else
  2083.         {
  2084.             /*
  2085.               c) If it is not the first iteration, the amplification
  2086.               must be prevented for scalefactor bands in which
  2087.               scfsi is enabled
  2088.             */
  2089.             preventSF = 1;
  2090.         }
  2091.         break;
  2092.         }
  2093.     
  2094.     }
  2095.  
  2096.     ifqstep2 = ifqstep * ifqstep;
  2097.     scfsi_band = 0;
  2098.     ifqstep34=sqrt(sqrt(ifqstep)*ifqstep);
  2099.     
  2100.     for ( sfb = 0; sfb < cod_info->sfb_lmax; sfb++ )
  2101.     {
  2102.     if ( copySF || preventSF )
  2103.     {
  2104.         if ( sfb == scfsi_band_long[scfsi_band + 1] )
  2105.         scfsi_band += 1;
  2106.         if ( l3_side->scfsi[ch][scfsi_band] )
  2107.         {
  2108.         if ( copySF )
  2109.             scalefac->l[gr][ch][sfb] = scalefac->l[0][ch][sfb];
  2110.         continue;
  2111.         }
  2112.     }        
  2113.  
  2114.  
  2115.     if ( distort[0][sfb]  ) 
  2116.     {
  2117.         over++;
  2118.         l3_xmin->l[gr][ch][sfb] *= ifqstep2;
  2119.         scalefac->l[gr][ch][sfb]++;
  2120.         start = scalefac_band_long[sfb];
  2121.         end   = scalefac_band_long[sfb+1];
  2122.         for ( l = start; l < end; l++ ) xr[l] *= ifqstep;
  2123.         if (xrpow_flag)
  2124.           for ( l = start; l < end; l++ ) xrpow[l] *= ifqstep34;
  2125.     }
  2126.     }
  2127.  
  2128.     /*
  2129.       Note that scfsi is not enabled for frames containing
  2130.       short blocks
  2131.     */
  2132.     for ( i = 0; i < 3; i++ )
  2133.       for ( sfb = cod_info->sfb_smax; sfb < 12; sfb++ ) {
  2134.             if ( distort[i+1][sfb])
  2135.             {
  2136.                 over++;
  2137.                 l3_xmin->s[gr][ch][sfb][i] *= ifqstep2;
  2138.                 scalefac->s[gr][ch][sfb][i]++;
  2139. #ifdef DEBUGSC
  2140.                 printf( "cod_info->scalefac[%d][%d] = %d (amp_scale)\n",
  2141.                         i,sfb,scalefac->s[gr][ch][sfb][i] );
  2142. #endif
  2143.                 start = scalefac_band_short[sfb];
  2144.                 end   = scalefac_band_short[sfb+1];
  2145.                 for ( l = start; l < end; l++ ) (*xr_s)[l][i] *= ifqstep;
  2146.         if (xrpow_flag) 
  2147.           for ( l = start; l < end; l++ ) (*xrpow_s)[l][i] *= ifqstep34;
  2148.             }
  2149.       }
  2150.     return over;
  2151. }
  2152.  
  2153.  
  2154.  
  2155.  
  2156.  
  2157.  
  2158. /*************************************************************************/
  2159. /*            quantize                                                   */
  2160. /*************************************************************************/
  2161.  
  2162. /*
  2163.   Function: Quantization of the vector xr ( -> ix)
  2164. */
  2165.  
  2166. void quantize( double xr[576], int ix[576], gr_info *cod_info )
  2167. {
  2168.     register int i,b;
  2169.     int j;
  2170.     double quantizerStepSize; /* double step */
  2171.     double istep_l,istep[3],temp;
  2172.     static int init=0;
  2173. #define LUTABSIZE 10000
  2174.     static int lutab[LUTABSIZE];
  2175.  
  2176.     if (init==0) {
  2177.       init++;
  2178.       for (i=0;i<LUTABSIZE;i++) {
  2179.     lutab[i]=nint(pow((double)i/10.0,0.75)-0.0946);
  2180.       }
  2181.       for (i=1;i<LUTABSIZE;i++) 
  2182.     if ((lutab[i]-lutab[i-1])==1) {  /* we have a change over this interval */
  2183.       lutab[i-1]=-1;
  2184.     }
  2185.     }
  2186.  
  2187.     quantizerStepSize = cod_info->quantizerStepSize;
  2188.     /* if subblock gain is used (short blocks), this should be: */
  2189.     /* step = pow( 2.0, (quantizerStepSize - 8.0 * (double) cod_info->subblock_gain[b]) * -0.25 ); */
  2190.     /* step = pow( 2.0, quantizerStepSize * -0.25) * 
  2191.        pow( 2.0, 2*(double) cod_info->subblock_gain[b]) */
  2192.  
  2193.     if ( quantizerStepSize == 0.0 )
  2194.     istep_l = 1.0;
  2195.     else
  2196.     istep_l = pow ( 2.0, quantizerStepSize * -0.25 );
  2197.  
  2198.     for (b=0;b<3;b++) {
  2199.       if ((cod_info->block_type==2))
  2200.     istep[b] = istep_l * pow(2.0,2* (double) cod_info->subblock_gain[b]);
  2201.       else istep[b] = istep_l;
  2202.     }
  2203.  
  2204.  
  2205.     i=0;
  2206.     for (j=0;j<192;j++) 
  2207.       for (b=0;b<3;b++) {
  2208.     temp=istep[b]*fabs(xr[i]); /* step always positive -> temp always postive */
  2209.     if (temp<0.499996)
  2210.       ix[i]=0;
  2211.     else
  2212.        if (temp<1.862955)
  2213.      ix[i]=1;
  2214.        else
  2215.        if (temp<3.565282)
  2216.      ix[i]=2;
  2217.        else
  2218.        if (temp<5.506396)
  2219.      ix[i]=3;
  2220.        else
  2221.        if (temp<7.638304)
  2222.      ix[i]=4;
  2223.        else
  2224.        if (temp<9.931741)
  2225.      ix[i]=5;
  2226.        else
  2227.        if (temp<1000.0) {
  2228.      ix[i]=lutab[(int)(temp*10.0)];
  2229.      if (ix[i]==-1) /* too close to an interface, calculate exact value */
  2230.        ix[i] = (int)( sqrt(sqrt(temp)*temp) + 0.4054);
  2231.        }
  2232.        else
  2233.      ix[i] = (int)( sqrt(sqrt(temp)*temp) + 0.4054); 
  2234.        i++;
  2235.       }
  2236.  
  2237. }
  2238.  
  2239.  
  2240. void quantize_xrpow( double xr[576], int ix[576], gr_info *cod_info )
  2241. {
  2242.   /* quantize on xr^(3/4) instead of xr */
  2243.     register int i,b,j;
  2244.     double quantizerStepSize;
  2245.     double istep_l,istep[3];
  2246.  
  2247.     quantizerStepSize = cod_info->quantizerStepSize;
  2248.  
  2249.     /*    istep_l = pow ( 2.0, quantizerStepSize * -0.25 ); */
  2250.     istep_l = pow ( 2.0, quantizerStepSize * -0.1875 );
  2251.  
  2252.  
  2253.     for (b=0;b<3;b++) {
  2254.       if ((cod_info->block_type==2))
  2255.     istep[b] = istep_l * pow(2.0,1.5* (double) cod_info->subblock_gain[b]);
  2256.       else istep[b] = istep_l;
  2257.     }
  2258.  
  2259.     i=0;
  2260.     for (j=0;j<192;j++) 
  2261.       for (b=0;b<3;b++) {
  2262.         ix[i] = (int)( istep[b]*xr[i]  + 0.4054);
  2263.         i++;
  2264.     }
  2265.  
  2266. }
  2267.  
  2268.  
  2269.  
  2270.  
  2271.  
  2272.  
  2273.  
  2274.  
  2275. /*************************************************************************/
  2276. /*            ix_max                                                     */
  2277. /*************************************************************************/
  2278.  
  2279. /*
  2280.   Function: Calculate the maximum of ix from 0 to 575
  2281. */
  2282.  
  2283. int ix_max( int ix[576], unsigned int begin, unsigned int end )
  2284. {
  2285.     int i, max = 0;
  2286.  
  2287.     for ( i = begin; i < end; i++ )
  2288.     {
  2289.         int x =  ix[i];
  2290.         if ( x > max )
  2291.             max = x;
  2292.     }
  2293.     return max;
  2294. }
  2295.  
  2296.  
  2297. /*************************************************************************/
  2298. /*            xr_max                                                     */
  2299. /*************************************************************************/
  2300.  
  2301. /*
  2302.   Function: Calculate the maximum of xr[576]  from 0 to 575
  2303. */
  2304.  
  2305. double xr_max( double xr[576], unsigned int begin, unsigned int end )
  2306. {
  2307.     int i;
  2308.     double max = 0.0, temp;
  2309.  
  2310.     for ( i = begin; i < end; i++ )
  2311.         if( (temp = fabs(xr[i])) > max )
  2312.         max = temp;
  2313.     return max;
  2314. }
  2315.  
  2316.  
  2317.  
  2318. /*        Noiseless coding  -- Huffman coding   */
  2319.  
  2320.  
  2321. /*************************************************************************/
  2322. /*            calc_runlen                                                */
  2323. /*************************************************************************/
  2324.  
  2325. /*
  2326. Function: Calculation of  count1, big_values
  2327. (Partitions ix into big values, quadruples and zeros).
  2328. */
  2329.  
  2330. void calc_runlen( int ix[576], gr_info *cod_info )
  2331. {
  2332.     int i;
  2333.  
  2334.     if ( cod_info->window_switching_flag && (cod_info->block_type == 2) )
  2335.     {  /* short blocks */
  2336.         cod_info->count1 = 0;
  2337.         cod_info->big_values = 288;
  2338.     }
  2339.     else
  2340.     {
  2341.         for ( i = 576; i > 1; i -= 2 )
  2342.         if ( ix[i-1] | ix[i-2] ) break;
  2343.  
  2344.         cod_info->count1 = 0 ;
  2345.         for ( ; i > 3; i -= 4 )
  2346.         if ( (ix[i-1] | ix[i-2] | ix[i-3] | ix[i-4]) <= 1 )
  2347.                 cod_info->count1++;
  2348.             else
  2349.                 break;
  2350.         
  2351.         cod_info->big_values = i/2;
  2352.     }
  2353. }
  2354.  
  2355.  
  2356.  
  2357. /*************************************************************************/
  2358. /*            count1_bitcount                                            */
  2359. /*************************************************************************/
  2360.  
  2361. /*
  2362.   Determines the number of bits to encode the quadruples.
  2363. */
  2364.  
  2365. int count1_bitcount( int ix[ 576 ], gr_info *cod_info )
  2366. {
  2367.     int abs_and_sign( int *x );
  2368.  
  2369.     int p, i, k, bitsum_count1;
  2370.     int v, w, x, y, signbits;
  2371.     int sum0 = 0, sum1 = 0;
  2372.  
  2373.     for ( i = cod_info->big_values * 2, k = 0; k < cod_info->count1; i += 4, k++ )
  2374.     { 
  2375.     v = ix[i];
  2376.     w = ix[i+1];
  2377.     x = ix[i+2];
  2378.     y = ix[i+3];
  2379.  
  2380.       /*
  2381.         v = ix[ i ];
  2382.         w = ix[ i + 1 ];
  2383.         x = ix[ i + 2 ];
  2384.         y = ix[ i + 3 ];
  2385.         
  2386.  
  2387.         abs_and_sign( &v );
  2388.         abs_and_sign( &w );
  2389.         abs_and_sign( &x );
  2390.         abs_and_sign( &y );
  2391.     */
  2392.         p = v + (w << 1) + (x << 2) + (y << 3);
  2393.         
  2394.         signbits = 0;
  2395.  
  2396.         if ( v != 0 )
  2397.             signbits ++;
  2398.         if ( w != 0 )
  2399.             signbits ++;
  2400.         if ( x != 0 )
  2401.             signbits ++;
  2402.         if ( y != 0 )
  2403.             signbits ++;
  2404.  
  2405.         sum0 += signbits;
  2406.         sum1 += signbits;
  2407.  
  2408.         sum0 += ht[ 32 ].hlen[ p ];
  2409.         sum1 += ht[ 33 ].hlen[ p ];
  2410.     }
  2411.  
  2412.     if ( sum0 < sum1 )
  2413.     {
  2414.         bitsum_count1 = sum0;
  2415.         cod_info->count1table_select = 0;
  2416.     }
  2417.     else
  2418.     {
  2419.         bitsum_count1 = sum1;
  2420.         cod_info->count1table_select = 1;
  2421.     }
  2422.     return( bitsum_count1 );
  2423. }
  2424.  
  2425.  
  2426.  
  2427.  
  2428.  
  2429. struct
  2430. {
  2431.     unsigned region0_count;
  2432.     unsigned region1_count;
  2433. } subdv_table[ 23 ] =
  2434. {
  2435. {0, 0}, /* 0 bands */
  2436. {0, 0}, /* 1 bands */
  2437. {0, 0}, /* 2 bands */
  2438. {0, 0}, /* 3 bands */
  2439. {0, 0}, /* 4 bands */
  2440. {0, 1}, /* 5 bands */
  2441. {1, 1}, /* 6 bands */
  2442. {1, 1}, /* 7 bands */
  2443. {1, 2}, /* 8 bands */
  2444. {2, 2}, /* 9 bands */
  2445. {2, 3}, /* 10 bands */
  2446. {2, 3}, /* 11 bands */
  2447. {3, 4}, /* 12 bands */
  2448. {3, 4}, /* 13 bands */
  2449. {3, 4}, /* 14 bands */
  2450. {4, 5}, /* 15 bands */
  2451. {4, 5}, /* 16 bands */
  2452. {4, 6}, /* 17 bands */
  2453. {5, 6}, /* 18 bands */
  2454. {5, 6}, /* 19 bands */
  2455. {5, 7}, /* 20 bands */
  2456. {6, 7}, /* 21 bands */
  2457. {6, 7}, /* 22 bands */
  2458. };
  2459.  
  2460.  
  2461.  
  2462.  
  2463. /*************************************************************************/
  2464. /*            subdivide                                                  */
  2465. /*************************************************************************/
  2466.  
  2467. /* presumable subdivides the bigvalue region which will
  2468.    use separate Huffman tables.
  2469. */
  2470.  
  2471. void subdivide( gr_info *cod_info )
  2472. {
  2473.     int scfb_anz = 0;
  2474.     int bigvalues_region;
  2475.     
  2476.     if ( cod_info->big_values == 0 )
  2477.     { /* no big_values region */
  2478.         cod_info->region0_count = 0;
  2479.         cod_info->region1_count = 0;
  2480.     }
  2481.     else
  2482.     {
  2483.         bigvalues_region = 2 * cod_info->big_values;
  2484.  
  2485.         if ( (cod_info->window_switching_flag == 0) )
  2486.         { /* long blocks */
  2487.             int thiscount, index;
  2488.             /* Calculate scfb_anz */
  2489.             while ( scalefac_band_long[scfb_anz] < bigvalues_region )
  2490.                 scfb_anz++;
  2491.             assert( scfb_anz < 23 );
  2492.  
  2493.             cod_info->region0_count = subdv_table[scfb_anz].region0_count;
  2494.             thiscount = cod_info->region0_count;
  2495.             index = thiscount + 1;
  2496.             while ( thiscount && (scalefac_band_long[index] > bigvalues_region) )
  2497.             {
  2498.                 thiscount -= 1;
  2499.                 index -= 1;
  2500.             }
  2501.             cod_info->region0_count = thiscount;
  2502.  
  2503.             cod_info->region1_count = subdv_table[scfb_anz].region1_count;
  2504.             index = cod_info->region0_count + cod_info->region1_count + 2;
  2505.             thiscount = cod_info->region1_count;
  2506.             while ( thiscount && (scalefac_band_long[index] > bigvalues_region) )
  2507.             {
  2508.                 thiscount -= 1;
  2509.                 index -= 1;
  2510.             }
  2511.             cod_info->region1_count = thiscount;
  2512.             cod_info->address1 = scalefac_band_long[cod_info->region0_count+1];
  2513.             cod_info->address2 = scalefac_band_long[cod_info->region0_count
  2514.                                                     + cod_info->region1_count + 2 ];
  2515.             cod_info->address3 = bigvalues_region;
  2516.         }
  2517.         else
  2518.         {
  2519.             if ( (cod_info->block_type == 2)  )
  2520.             { 
  2521.                 cod_info->region0_count =  8;
  2522.                 cod_info->region1_count =  36;
  2523.                 cod_info->address1 = 36;
  2524.                 cod_info->address2 = bigvalues_region;
  2525.                 cod_info->address3 = 0;  
  2526.             }
  2527.             else
  2528.             {
  2529.                 cod_info->region0_count = 7;
  2530.                 cod_info->region1_count = 13;
  2531.                 cod_info->address1 = scalefac_band_long[cod_info->region0_count+1];
  2532.                 cod_info->address2 = bigvalues_region;
  2533.                 cod_info->address3 = 0;
  2534.             }
  2535.         }
  2536.     }
  2537. }
  2538.  
  2539.  
  2540.  
  2541.  
  2542. /*************************************************************************/
  2543. /*            new_choose table                                           */
  2544. /*************************************************************************/
  2545.  
  2546. /*
  2547.   Choose the Huffman table that will encode ix[begin..end] with
  2548.   the fewest bits.
  2549.  
  2550.   Note: This code contains knowledge about the sizes and characteristics
  2551.   of the Huffman tables as defined in the IS (Table B.7), and will not work
  2552.   with any arbitrary tables.
  2553. */
  2554.  
  2555. int new_choose_table( int ix[576], unsigned int begin, unsigned int end, int * s )
  2556. {
  2557.     int i, max;
  2558.     int choice[ 2 ];
  2559.     int sum[ 2 ];
  2560.  
  2561.     max = ix_max( ix, begin, end );
  2562.  
  2563.     if ( max == 0 )
  2564.         return 0;
  2565.  
  2566.     choice[ 0 ] = 0;
  2567.     choice[ 1 ] = 0;
  2568.  
  2569.     if ( max < 15 )
  2570.     {
  2571.     /* try tables with no linbits */
  2572.         for ( i = 0; i < 14; i++ )
  2573.             if ( ht[i].xlen > max )
  2574.         {
  2575.         choice[ 0 ] = i;
  2576.                 break;
  2577.         }
  2578.  
  2579.     sum[ 0 ] = count_bit( ix, begin, end, choice[0] );
  2580.  
  2581.     switch ( choice[0] )
  2582.     {
  2583.       case 2:
  2584.         sum[ 1 ] = count_bit( ix, begin, end, 3 );
  2585.         if ( sum[1] <= sum[0] )
  2586.         {
  2587.         sum[0]=sum[1];
  2588.         choice[ 0 ] = 3;
  2589.         }
  2590.         break;
  2591.  
  2592.       case 5:
  2593.         sum[ 1 ] = count_bit( ix, begin, end, 6 );
  2594.         if ( sum[1] <= sum[0] )
  2595.         {
  2596.         sum[0]=sum[1];
  2597.         choice[ 0 ] = 6;
  2598.         }
  2599.         break;
  2600.  
  2601.       case 7:
  2602.         sum[ 1 ] = count_bit( ix, begin, end, 8 );
  2603.         if ( sum[1] <= sum[0] )
  2604.         {
  2605.         choice[ 0 ] = 8;
  2606.         sum[ 0 ] = sum[ 1 ];
  2607.         }
  2608.         sum[ 1 ] = count_bit( ix, begin, end, 9 );
  2609.         if ( sum[1] <= sum[0] )
  2610.         {
  2611.         sum[0]=sum[1];
  2612.         choice[ 0 ] = 9;
  2613.         }
  2614.         break;
  2615.  
  2616.       case 10:
  2617.         sum[ 1 ] = count_bit( ix, begin, end, 11 );
  2618.         if ( sum[1] <= sum[0] )
  2619.         {
  2620.         choice[ 0 ] = 11;
  2621.         sum[ 0 ] = sum[ 1 ];
  2622.         }
  2623.         sum[ 1 ] = count_bit( ix, begin, end, 12 );
  2624.         if ( sum[1] <= sum[0] )
  2625.         {
  2626.         sum[0]=sum[1];
  2627.         choice[ 0 ] = 12;
  2628.         }
  2629.         break;
  2630.  
  2631.       case 13:
  2632.         sum[ 1 ] = count_bit( ix, begin, end, 15 );
  2633.         if ( sum[1] <= sum[0] )
  2634.         {
  2635.         sum[0]=sum[1];
  2636.         choice[ 0 ] = 15;
  2637.         }
  2638.         break;
  2639.  
  2640.       default:
  2641.         break;
  2642.     }
  2643.     }
  2644.     else
  2645.     {
  2646.     /* try tables with linbits */
  2647.     max -= 15;
  2648.     
  2649.     for ( i = 15; i < 24; i++ )
  2650.     {
  2651.         if ( ht[i].linmax >= max )
  2652.         {
  2653.         choice[ 0 ] = i;
  2654.         break;
  2655.         }
  2656.     }
  2657.     for ( i = 24; i < 32; i++ )
  2658.     {
  2659.         if ( ht[i].linmax >= max )
  2660.         {
  2661.         choice[ 1 ] = i;
  2662.         break;
  2663.         }
  2664.     }
  2665.     
  2666.     sum[ 0 ] = count_bit( ix, begin, end, choice[0] );
  2667.     sum[ 1 ] = count_bit( ix, begin, end, choice[1] );
  2668.     if ( sum[1] < sum[0] )
  2669.     {
  2670.         sum[0]=sum[1];
  2671.         choice[ 0 ] = choice[ 1 ];
  2672.     }
  2673.     }
  2674.     *s=sum[0];
  2675.     return choice[ 0 ];
  2676. }
  2677.  
  2678.  
  2679. /*************************************************************************/
  2680. /*            choose table                                               */
  2681. /*************************************************************************/
  2682.  
  2683. int choose_table( int max )
  2684. {
  2685.     int  i, choice;
  2686.  
  2687.     if ( max == 0 )
  2688.         return 0;
  2689.     
  2690.     choice = 0;
  2691.  
  2692.     if ( max < 15 )
  2693.     {
  2694.         for ( i = 0; i < 15; i++ )
  2695.         {
  2696.             if ( ht[i].xlen > max )
  2697.             {
  2698.         choice = i;
  2699.         break;
  2700.             }
  2701.         }
  2702.     }
  2703.     else
  2704.     {    
  2705.     max -= 15;
  2706.     for (i = 15; i < 32; i++ )
  2707.     {
  2708.         if ( ht[i].linmax >= max )
  2709.         {
  2710.         choice = i;
  2711.         break;
  2712.         }
  2713.     }
  2714.     }
  2715.     assert( choice );
  2716.     return choice;
  2717. }
  2718.  
  2719.  
  2720.  
  2721. /*************************************************************************/
  2722. /*            bigv_bitcount                                              */
  2723. /*************************************************************************/
  2724.  
  2725. /*
  2726. Function: Select huffman code tables for bigvalues regions 
  2727. Function: Count the number of bits necessary to code the bigvalues region.
  2728. */
  2729.  
  2730. int bigv_bitcount( int ix[576], gr_info *cod_info )
  2731. {
  2732.     int bits = 0;
  2733.  
  2734.     cod_info->table_select[0] = 0;
  2735.     cod_info->table_select[1] = 0;
  2736.     cod_info->table_select[2] = 0;
  2737.     
  2738.     if ( cod_info->window_switching_flag && (cod_info->block_type == 2) )
  2739.     {
  2740.         /*
  2741.           Within each scalefactor band, data is given for successive
  2742.           time windows, beginning with window 0 and ending with window 2.
  2743.           Within each window, the quantized values are then arranged in
  2744.           order of increasing frequency...
  2745.           */
  2746.         int sfb, window, line, start, end, max1, max2, x, y;
  2747.         int region1Start;
  2748.         int *pmax;
  2749.         I192_3 *ix_s;
  2750.  
  2751.  
  2752.         region1Start = 12;
  2753.         max1 = max2 = 0;
  2754.  
  2755.         for ( sfb = 0; sfb < 13; sfb++ )
  2756.         {
  2757.             start = scalefac_band_short[ sfb ];
  2758.             end   = scalefac_band_short[ sfb+1 ];
  2759.             
  2760.             if ( start < region1Start )
  2761.                 pmax = &max1;
  2762.             else
  2763.                 pmax = &max2;
  2764.             
  2765.             for ( window = 0; window < 3; window++ )
  2766.                 for ( line = start; line < end; line += 2 )
  2767.                 {
  2768.                     x = ix[ (line * 3) + window ];
  2769.                     y = ix[ ((line + 1) * 3) + window ];
  2770.                     *pmax = *pmax > x ? *pmax : x;
  2771.                     *pmax = *pmax > y ? *pmax : y;
  2772.                 }
  2773.         }
  2774.         cod_info->table_select[0] = choose_table( max1 );
  2775.         cod_info->table_select[1] = choose_table( max2 );
  2776.  
  2777.         /*
  2778.           Within each scalefactor band, data is given for successive
  2779.           time windows, beginning with window 0 and ending with window 2.
  2780.           Within each window, the quantized values are then arranged in
  2781.           order of increasing frequency...
  2782.           */
  2783.  
  2784.             sfb = 0;
  2785.  
  2786.         ix_s = (I192_3 *) &ix[0];
  2787.  
  2788.         for ( ; sfb < 13; sfb++ )
  2789.         {
  2790.             unsigned tableindex = 100;
  2791.  
  2792.             start = scalefac_band_short[ sfb ];
  2793.             end   = scalefac_band_short[ sfb+1 ];
  2794.  
  2795.             if ( start < 12 )
  2796.                 tableindex = cod_info->table_select[ 0 ];
  2797.             else
  2798.                 tableindex = cod_info->table_select[ 1 ];
  2799.  
  2800.             for ( window = 0; window < 3; window++ )
  2801.                 for ( line = start; line < end; line += 2 )
  2802.                 {
  2803.                     unsigned int code, ext;
  2804.                     int cbits, xbits;
  2805.                     int x = (*ix_s)[line][window];
  2806.                     int y = (*ix_s)[line + 1][window];
  2807.                     bits += HuffmanCode( tableindex, x, y, &code, &ext, &cbits, &xbits );
  2808.                 }
  2809.         }
  2810.     }
  2811.     else
  2812.     {
  2813.         unsigned int table;
  2814.         int s;
  2815.         
  2816.         if ( cod_info->address1 > 0 )
  2817.         {
  2818.             table = cod_info->table_select[0] = new_choose_table( ix, 0, cod_info->address1, &s );
  2819.             if( table != 0 )  /* region0 */ 
  2820.                bits += s;
  2821.         }
  2822.  
  2823.         if ( cod_info->address2 > cod_info->address1 )
  2824.         {
  2825.             table = cod_info->table_select[1] = new_choose_table( ix, cod_info->address1, cod_info->address2, &s );
  2826.            if( table != 0 )  /* region1 */ 
  2827.                bits += s;
  2828.         }
  2829.  
  2830.         if ( cod_info->big_values * 2 > cod_info->address2 )
  2831.         {
  2832.             table = cod_info->table_select[2] = new_choose_table( ix, cod_info->address2, cod_info->big_values * 2, &s );
  2833.            if( table != 0 )  /* region2 */ 
  2834.                bits += s;
  2835.         }
  2836.     }
  2837.     return bits;
  2838. }
  2839.  
  2840.  
  2841.  
  2842. /*************************************************************************/
  2843. /*            count_bit                                                  */
  2844. /*************************************************************************/
  2845.  
  2846. /*
  2847.  Function: Count the number of bits necessary to code the subregion. 
  2848. */
  2849.  
  2850. int count_bit( int ix[576], unsigned int start, unsigned int end, unsigned int table )
  2851. {
  2852.     unsigned            linbits, ylen;
  2853.     register int        i, sum;
  2854.     register int        x,y;
  2855.     struct huffcodetab *h;
  2856.  
  2857.     if(table==0) return 0;
  2858.  
  2859.     h   = &(ht[table]);
  2860.     sum = 0;
  2861.  
  2862.     ylen    = h->ylen;
  2863.     linbits = h->linbits;
  2864.  
  2865.     if(table>15)
  2866.     { /* ESC-table is used */
  2867.         for(i=start;i<end;i+=2)
  2868.         {
  2869.             x = ix[i];
  2870.             y = ix[i+1];
  2871.             if(x>14)
  2872.             {
  2873.                 x = 15;
  2874.                 sum += linbits;
  2875.             }
  2876.             if(y>14)
  2877.             {
  2878.                 y = 15;
  2879.                 sum += linbits;
  2880.             }
  2881.  
  2882.             sum += h->hlen[(x*ylen)+y];
  2883.  
  2884.             if(x!=0) sum++;
  2885.             if(y!=0) sum++;
  2886.         }
  2887.     }
  2888.     else
  2889.     { /* No ESC-words */
  2890.         for(i=start;i<end;i+=2)
  2891.         {
  2892.             x = ix[i];
  2893.             y = ix[i+1];
  2894.  
  2895.             sum  += h->hlen[(x*ylen)+y];
  2896.  
  2897.             if(x!=0) sum++;
  2898.             if(y!=0) sum++;
  2899.         }
  2900.     }
  2901.  
  2902.     return sum;
  2903. }
  2904.  
  2905.  
  2906.  
  2907. #ifndef HAVE_NINT
  2908. int
  2909. nint( double in )
  2910. {
  2911.     int    temp;
  2912.  
  2913.     if( in < 0 )  temp = (int)(in - 0.5);
  2914.     else    temp = (int)(in + 0.5);
  2915.  
  2916.     return(temp);
  2917. }
  2918.  
  2919. /*
  2920. double
  2921. aint(double in) {
  2922.     return((long) in);
  2923. }
  2924. */
  2925. #endif
  2926.  
  2927.  
  2928.  
  2929. /*
  2930.   Seymour's comment:  Jan 8 1995
  2931.   When mixed_block_flag is set, the low subbands 0-1 undergo the long
  2932.   window transform and are each split into 18 frequency lines, while
  2933.   the remaining 30 subbands undergo the short window transform and are
  2934.   each split into 6 frequency lines. A problem now arises, as neither
  2935.   the short or long scale factor bands apply to this mixed spectrum.
  2936.   The standard resolves this situation by using the first 8 long scale
  2937.   factor bands for the low spectrum and the short scale factor bands
  2938.   in the range of 3 to 11 (inclusive) for the remaining frequency lines.
  2939.   These scale factor bands do not match exactly to the 0-1 subbands
  2940.   for all sampling frequencies (32,44.1 and 48 kHz); however they
  2941.   were designed so that there would not be a frequency gap or overlap
  2942.   at the switch over point. (Note multiply short frequency lines by 3
  2943.   to account for wider frequency line.) 
  2944.   */
  2945.  
  2946. /* Mark Taylor's comment: 4/99:  ISO code cannot produces mixed blocks,
  2947.  * Fhg Code also never seems to use them, so no need to add them
  2948.  * to this code 
  2949.  */
  2950. /*************************************************************************/
  2951. /*            gr_deco                                                    */
  2952. /*************************************************************************/
  2953.  
  2954. void gr_deco( gr_info *cod_info )
  2955. {
  2956.     if ( cod_info->window_switching_flag != 0 && cod_info->block_type == 2 )
  2957.         {
  2958.             cod_info->sfb_lmax = 0; /* No sb*/
  2959.             cod_info->sfb_smax = 0;
  2960.         }
  2961.     else
  2962.     {
  2963.       /* MPEG 1 doesnt use last scalefactor band? */
  2964.         cod_info->sfb_lmax = SFB_LMAX - 1;
  2965.         cod_info->sfb_smax = SFB_SMAX - 1;    /* No sb */
  2966.     }
  2967. }
  2968.  
  2969.  
  2970.  
  2971.  
  2972.  
  2973.  
  2974.  
  2975.  
  2976. /* The following optional code written by Seymour Shlien
  2977.    will speed up the outer_loop code which is called
  2978.    by iteration_loop. When BIN_SEARCH is defined, the
  2979.    outer_loop function precedes the call to the function inner_loop
  2980.    with a call to bin_search gain defined below, which
  2981.    returns a good starting quantizerStepSize.
  2982. */
  2983.  
  2984. int count_bits(ix,cod_info)  
  2985. int  *ix; /*  I576  *ix; */
  2986. gr_info *cod_info;
  2987. {
  2988. int bits,i;
  2989.   for ( i = 0; i < 576; i++ )
  2990.   {
  2991.      if ( ix[i] > 8191 + 14)
  2992.     return 100000;        /* report unsuitable quantizer */
  2993.   }
  2994.   calc_runlen(ix,cod_info);        /*count1,big_values*/
  2995.   bits = count1_bitcount(ix, cod_info); /*count1_table selection*/
  2996.   subdivide(cod_info);            /* bigvalues sfb division */
  2997.   bits += bigv_bitcount(ix,cod_info);    /* bit count */
  2998. /* printf("\nglobal_gain = %f  bits= %d ",cod_info->quantizerStepSize,bits);*/
  2999. return bits;
  3000. }
  3001.  
  3002.  
  3003.  
  3004. int bin_search_StepSize(int desired_rate, double start, int bot, int *ix,
  3005.            double xrs[576], double xrspow[576], gr_info * cod_info)
  3006. {
  3007. int top,next,last;
  3008. int bit;
  3009. top = start;
  3010. next = start;
  3011. do
  3012.   {
  3013.   last = next;
  3014.   next = (top+bot)/2.0;
  3015.   cod_info->quantizerStepSize = next;
  3016.   if (xrpow_flag) {
  3017.     quantize_xrpow(xrspow,ix,cod_info);
  3018.   }  else {
  3019.     quantize(xrs,ix,cod_info);
  3020.   }
  3021.   bit = count_bits(ix,cod_info);
  3022.   if (bit>desired_rate) top = next;
  3023.   else bot = next;
  3024.   // printf("\n%f %f %f %f %d %d",start,next, top,bot,bit,desired_rate);
  3025.   }
  3026.   while ((bit != desired_rate) && abs(last - next) > 1);
  3027. //printf("\n done  %f %d %d",next,bit,desired_rate);
  3028.  
  3029. return bit;
  3030. }
  3031.  
  3032.  
  3033.  
  3034.  
  3035.