开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > mpeg/mp3 > 查看源码
LOOP.C
资源名称：mpeg.zip　[点击查看]
上传用户：njqiyou
上传日期：2007-01-08
资源大小：574k
文件大小：64k
源码类别：

mpeg/mp3

开发平台：

C/C++

LOOP.C：源码内容
  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.  *   date   programmers                comment                        *
  18.  *25. 6.92  Toshiyuki Ishino           Ver 1.0                        *
  19.  *29.10.92  Masahiro Iwadare           Ver 2.0                        *
  20.  *17. 4.93  Masahiro Iwadare           Updated for IS Modification    *
  21.  *04.11.93  Seymour Shlien             Speed up inner loop            *
  22.  *09.09.95  mc@fivebats.com            Several changes for updated IS,*
  23.  *                                     and some MPEG2-LSF support     *
  24.  *20.12.96  seymour.shlien@crc.doc.ca  Fixed some bugs and improved   *
  25.  *                                     the appearance                 *
  26.  *********************************************************************/ 
  28. #include <stdio.h>
  29. #include <stdlib.h>
  30. #include <math.h>
  31. #include <assert.h>
  32. #include "l3side.h"
  33. #include "loop.h"
  34. #include "huffman.h"
  35. #include "l3bitstream.h"
  36. #include "reservoir.h"
  37. #include "loop-pvt.h"
  39. /* #define DEBUG */
  40. /* #define DEBUGSC */
  41. /* #define PERFORM 3 */
  42. /* If PERFORM is defined to some number, then a file encode.log
  43.    is preduced showing the intermediate results produced by the
  44.    outer_loop code for the frame number = PERFORM.
  45. */
  46. #define BIN_SEARCH 
  47. /* for speeding up the iteration_loop algorithm */
  49. #ifdef PERFORM
  50. FILE *log_output;
  51. extern int frameNum;
  52. float worst_xfsf_to_xmin_ratio(III_psy_xmin *l3_xmin, double xfsf[4][CBLIMIT]
  53.                              ,int block_type,int gr,int ch);
  54. #endif
  56. /* New SS 20-12-96 */
  57. #ifdef BIN_SEARCH 
  58. int bin_search_StepSize(int desired_rate, double start, int ix[576],
  59.            double xrs[576], gr_info * cod_info);
  60. int count_bits();
  61. float worst_xfsf_to_xmin_ratio();
  62. #endif
  65. /*
  66.   Here are MPEG1 Table B.8 and MPEG2 Table B.1
  67.   -- Layer III scalefactor bands.
  68.   Index into this using a method such as:
  69.     idx  = fr_ps->header->sampling_frequency
  70.            + (fr_ps->header->version * 3)
  71. */
  73. struct scalefac_struct sfBandIndex[6] =
  74. {
  76.   { /* Table B.2.b: 22.05 kHz */
  77.     {0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576},
  78.     {0,4,8,12,18,24,32,42,56,74,100,132,174,192}
  79.   },
  80.   { /* Table B.2.c: 24 kHz */
  81.     {0,6,12,18,24,30,36,44,54,66,80,96,114,136,162,194,232,278,330,394,464,540,576},
  82.     {0,4,8,12,18,26,36,48,62,80,104,136,180,192}
  83.   },
  84.   { /* Table B.2.a: 16 kHz */
  85.     {0,6,12,18,24,30,36,44,45,66,80,96,116,140,168,200,238,248,336,396,464,522,576},
  86.     {0,4,8,12,18,26,36,48,62,80,104,134,174,192}
  87.   },
  88.   { /* Table B.8.b: 44.1 kHz */
  89.     {0,4,8,12,16,20,24,30,36,44,52,62,74,90,110,134,162,196,238,288,342,418,576},
  90.     {0,4,8,12,16,22,30,40,52,66,84,106,136,192}
  91.   },
  92.   { /* Table B.8.c: 48 kHz */
  93.     {0,4,8,12,16,20,24,30,36,42,50,60,72,88,106,128,156,190,230,276,330,384,576},
  94.     {0,4,8,12,16,22,28,38,50,64,80,100,126,192}
  95.   },
  96.   { /* Table B.8.a: 32 kHz */
  97.     {0,4,8,12,16,20,24,30,36,44,54,66,82,102,126,156,194,240,296,364,448,550,576},
  98.     {0,4,8,12,16,22,30,42,58,78,104,138,180,192}
  99.   }
  100. };
  102. /*
  103.   The following table is used to implement the scalefactor
  104.   partitioning for MPEG2 as described in section
  105.   2.4.3.2 of the IS. The indexing corresponds to the
  106.   way the tables are presented in the IS:
  108.   [table_number][row_in_table][column of nr_of_sfb]
  109. */
  110. static unsigned nr_of_sfb_block[6][3][4] =
  111. {
  112.   {
  113.     {6, 5, 5, 5},
  114.     {9, 9, 9, 9},
  115.     {6, 9, 9, 9}
  116.   },
  117.   {
  118.     {6, 5, 7, 3},
  119.     {9, 9, 12, 6},
  120.     {6, 9, 12, 6}
  121.   },
  122.   {
  123.     {11, 10, 0, 0},
  124.     {18, 18, 0, 0},
  125.     {15,18,0,0}
  126.   },
  127.   {
  128.     {7, 7, 7, 0},
  129.     {12, 12, 12, 0},
  130.     {6, 15, 12, 0}
  131.   },
  132.   {
  133.     {6, 6, 6, 3},
  134.     {12, 9, 9, 6},
  135.     {6, 12, 9, 6}
  136.   },
  137.   {
  138.     {8, 8, 5, 0},
  139.     {15,12,9,0},
  140.     {6,18,9,0}
  141.   }
  142. };
  144. /*
  145.   table of largest scalefactors for MPEG2
  146. */
  147. static unsigned max_sfac_tab[6][4] =
  148. {
  149.     {4, 4, 3, 3},
  150.     {4, 4, 3, 0},
  151.     {3, 2, 0, 0},
  152.     {4, 5, 5, 0},
  153.     {3, 3, 3, 0},
  154.     {2, 2, 0, 0}
  155. };
  157. /* Table B.6: layer3 preemphasis */
  158. int  pretab[21] =
  159. {
  160.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  161.     1, 1, 1, 1, 2, 2, 3, 3, 3, 2
  162. };
  164. /* This is the scfsi_band table from 2.4.2.7 of the IS */
  165. int scfsi_band_long[5] = { 0, 6, 11, 16, 21 };
  167. int *scalefac_band_long  = &sfBandIndex[3].l[0];
  168. int *scalefac_band_short = &sfBandIndex[3].s[0];
  172. /************************************************************************/
  173. /*  iteration_loop()                                                    */
  174. /************************************************************************/
  175. void
  176. iteration_loop( double pe[][2], double xr_org[2][2][576], III_psy_ratio *ratio,
  177. III_side_info_t *l3_side, int l3_enc[2][2][576],
  178. int mean_bits, int stereo, double xr_dec[2][2][576],
  179. III_scalefac_t *scalefac, frame_params *fr_ps,
  180. int ancillary_pad, int bitsPerFrame ) 
  181. {
  182.     static int firstcall = 1;
  183.     III_psy_xmin l3_xmin;
  184.     gr_info *cod_info;
  185.     layer *info;
  186.     int *main_data_begin;
  188.     int max_bits;
  189.     int ch, gr, sfb, i, mode_gr;
  190.     static int huffman_read_flag = 0; 
  192.     double xr[2][2][576];
  193.     I576  *ix;
  195.     main_data_begin = &l3_side->main_data_begin;
  196.     l3_side->resvDrain = 0;
  198.     if ( firstcall )
  199.     {
  200. *main_data_begin = 0;
  201. firstcall = 0;
  202. #ifdef PERFORM
  203. log_output = fopen("encode.log","w");
  204. #endif
  205.     }
  207.     info = fr_ps->header;
  208.     mode_gr = (info->version == 1) ? 2 : 1;
  210.     scalefac_band_long  = &sfBandIndex[info->sampling_frequency + (info->version * 3)].l[0];
  211.     scalefac_band_short = &sfBandIndex[info->sampling_frequency + (info->version * 3)].s[0];
  213.     /* reading huffman code table */
  214.     if (huffman_read_flag == 0) {
  215.         FILE *fi = OpenTableFile( "huffcode" );
  216.         if ( fi == NULL )
  217.             exit( EXIT_FAILURE );
  218.         read_huffcodetab( fi );
  219.         huffman_read_flag++;
  220.         fclose( fi );
  221.     }
  224.     for ( gr = 0; gr < mode_gr; gr++ )
  225.     {
  226.         for ( ch = 0; ch < stereo; ch++ )
  227. {
  228.             for ( i = 0; i < 576; i++ ) 
  229.                 xr[gr][ch][i] = xr_org[gr][ch][i];
  230. }
  231.     }
  233.     ResvFrameBegin( fr_ps, l3_side, mean_bits, bitsPerFrame );
  235.     for ( gr = 0; gr < mode_gr; gr++ )
  236.     {
  237.         for ( ch = 0; ch < stereo; ch++ )
  238.         {
  239.             ix = (I576 *) l3_enc[gr][ch];
  240.             cod_info = (gr_info *) &(l3_side->gr[gr].ch[ch]);
  241.             gr_deco(cod_info);
  242.             calc_xmin( xr, ratio, cod_info, &l3_xmin, gr, ch );
  243.     
  244. #ifdef DEBUG
  245.             printf( "----- start gr[%d] ch[%1d] : block_type=%1d, window_switching_flag=%1d (loop)n",
  246.                     gr,ch, cod_info->block_type, cod_info->window_switching_flag ); 
  247. #endif
  248.     
  249.             if ( info->version == 1 )
  250.                 calc_scfsi( xr[gr][ch], l3_side, &l3_xmin, ch, gr );
  251.     
  252.             /* calculation of number of available bit( per granule ) */
  253.     max_bits = ResvMaxBits( fr_ps, l3_side, &pe[gr][ch], mean_bits );
  254. #ifdef DEBUG
  255.             printf( " max_bits = %d, mean_bits = %d (iteration_loop)n", max_bits, mean_bits ); 
  256. #endif
  257.     
  258.             /* reset of iteration variables */
  259.     
  260.             for ( sfb = 0; sfb < 21; sfb++ )
  261.                 scalefac->l[gr][ch][sfb] = 0;
  262.             for ( sfb = 0; sfb < 13; sfb++ )
  263.                 for ( i = 0; i < 3; i++ )
  264.                     scalefac->s[gr][ch][sfb][i] = 0;
  266.     for ( i = 0; i < 4; i++ )
  267. cod_info->slen[i] = 0;
  268.     cod_info->sfb_partition_table = &nr_of_sfb_block[0][0][0];
  270.             cod_info->part2_3_length    = 0;
  271.             cod_info->big_values        = 0;
  272.             cod_info->count1            = 0;
  273.             cod_info->scalefac_compress = 0;
  274.             cod_info->table_select[0]   = 0;
  275.             cod_info->table_select[1]   = 0;
  276.             cod_info->table_select[2]   = 0;
  277.             cod_info->subblock_gain[0]  = 0;
  278.             cod_info->subblock_gain[1]  = 0;
  279.             cod_info->subblock_gain[2]  = 0;
  280.             cod_info->region0_count     = 0;
  281.             cod_info->region1_count     = 0;
  282.             cod_info->part2_length      = 0;
  283.             cod_info->preflag           = 0;
  284.             cod_info->scalefac_scale    = 0;
  285.             cod_info->quantizerStepSize = 0.0;
  286.             cod_info->count1table_select= 0;
  287.             
  288.             /* all spectral values zero ? */
  289.             if ( fabs(xr_max(xr[gr][ch], 0, 576)) != 0.0 )
  290.             {
  291.                 cod_info->quantizerStepSize =
  292.  (double) quantanf_init( xr[gr][ch] );
  293.                 cod_info->part2_3_length = outer_loop( xr, max_bits, &l3_xmin,
  294.                                                        l3_enc, fr_ps, scalefac,
  295.                                                        gr, ch, l3_side );
  296.             }
  297.     ResvAdjust( fr_ps, cod_info, l3_side, mean_bits );
  299.     cod_info->global_gain = nint( cod_info->quantizerStepSize + 210.0 );
  300.     assert( cod_info->global_gain < 256 );
  301.         } /* for ch */
  302.     } /* for gr */
  303.     ResvFrameEnd( fr_ps, l3_side, mean_bits );
  304. }
  308. /************************************************************************/
  309. /*  quantanf_init                                                       */
  310. /************************************************************************/
  311. int quantanf_init( double xr[576] )
  312. /* Function: Calculate the first quantization step quantanf.       */
  313. {
  314.     int i, tp = 0;
  315.     double system_const, minlimit;
  316.     double sfm = 0.0, sum1 = 0.0, sum2 = 0.0;
  317.     
  318.     system_const = 8.0;
  319.     minlimit = -100.0;
  321.     for ( i = 0; i < 576; i++ )
  322.     {
  323.         if ( xr[i] != 0 )
  324. {
  325.             double tpd = xr[i] * xr[i];
  326.             sum1 += log( tpd );
  327.             sum2 += tpd;
  328.         }
  329.     }
  330.     if ( sum2 != 0.0 )
  331.     {
  332.         sfm = exp( sum1 / 576.0 ) / (sum2 / 576.0);
  333.         tp = nint( system_const * log(sfm) );
  334. if ( tp < minlimit )
  335.     tp = minlimit;
  336. #ifdef DEBUG
  337.         printf(" quantanf = %d (quantanf_init)n",tp );
  338. #endif
  339.     }
  340.       return(tp-70.0); /* SS 19-12-96. Starting value of
  341.                           global_gain or quantizerStepSize 
  342.                           has to be reduced for iteration_loop
  343.                        */
  344. }
  350. /************************************************************************/
  351. /*  outer_loop                                                          */
  352. /************************************************************************/
  353. /*  Function: The outer iteration loop controls the masking conditions  */
  354. /*  of all scalefactorbands. It computes the best scalefac and          */
  355. /*  global gain. This module calls the inner iteration loop             */
  356. /************************************************************************/
  357. int outer_loop(
  358.     double xr[2][2][576],     /*  magnitudes of the spectral values */
  359.     int max_bits,
  360.     III_psy_xmin  *l3_xmin,   /* the allowed distortion of the scalefactor */
  361.     int l3_enc[2][2][576],    /* vector of quantized values ix(0..575) */
  362.     frame_params *fr_ps,
  363.     III_scalefac_t *scalefac, /* scalefactors */
  364.     int gr, int ch, III_side_info_t *l3_side )
  365. {
  366.     int status ;
  367.     int scalesave_l[CBLIMIT], scalesave_s[CBLIMIT][3];
  368.     int sfb, bits, huff_bits, save_preflag, save_compress;
  369.     double xfsf[4][CBLIMIT];
  370.     int i, over, iteration;
  371.     float max_ratio;
  374. /* D576 *xrs; */ /* to eliminate warning messages from gcc compiler */
  375. /* I576 *ix; */  /* replace this code with below. S. Shlien 15-1-97 */
  377.   double *xrs; 
  378.   int *ix;  
  379.   gr_info *cod_info = &l3_side->gr[gr].ch[ch].tt;
  381. /* xrs = (D576 *) &xr[gr][ch][0]; */ 
  382. /* ix  = (I576 *) l3_enc[gr][ch]; */
  383.  
  385. xrs = (double *) &(xr[gr][ch][0]); 
  386. ix  = (int *) &(l3_enc[gr][ch][0]);
  389.     iteration = 0;
  390. #ifdef PERFORM
  391.     if(frameNum == PERFORM)
  392.     fprintf(log_output,"nnframe = %d ch = %d gr= %dn",frameNum,ch,gr);
  393. #endif
  394.     do 
  395.     {
  396. iteration += 1;
  397. cod_info->part2_length = part2_length( scalefac, fr_ps, gr, ch, l3_side );
  398.         huff_bits = max_bits - cod_info->part2_length;
  400. #ifdef BIN_SEARCH
  401. if(iteration == 1)
  402.         {
  403.        bin_search_StepSize(max_bits,cod_info->quantizerStepSize,
  404.           ix,xrs,cod_info); /* speeds things up a bit */
  405.         }
  406. #endif
  407. #ifdef PERFORM
  408. if(frameNum==PERFORM)
  409.           fprintf(log_output,"n    Interim Results %dnn",iteration);
  410.         bits = test_inner_loop( xr, l3_enc, huff_bits, cod_info, gr, ch,
  411.          xfsf,l3_xmin);
  412. #else
  413.         bits = inner_loop( xr, l3_enc, huff_bits, cod_info, gr, ch );
  414. #endif
  416.         calc_noise( &xr[gr][ch][0], &l3_enc[gr][ch][0], cod_info, xfsf ); /* distortion calculation */
  418.         for ( sfb = 0; sfb < CBLIMIT; sfb++ ) /* save scaling factors */
  419.             scalesave_l[sfb] = scalefac->l[gr][ch][sfb];
  421.         for ( sfb = 0; sfb < SFB_SMAX; sfb++ )
  422.             for ( i = 0; i < 3; i++ )
  423.                 scalesave_s[sfb][i] = scalefac->s[gr][ch][sfb][i];
  424.         
  425.         save_preflag  = cod_info->preflag;
  426.         save_compress = cod_info->scalefac_compress;
  428.         preemphasis( &xr[gr][ch][0], xfsf, l3_xmin, gr, ch, l3_side );
  432. #ifdef PERFORM 
  433.     if(frameNum == PERFORM)  
  434.     {
  435.     fprintf(log_output,"nbits = %d  huff_bits= %d ", bits,huff_bits);
  436.     fprintf(log_output," max_bits = %dn",max_bits);
  437.     fprintf(log_output,"Stepsize = %f ",cod_info->quantizerStepSize);
  438.     fprintf(log_output," scale_bits    = %d n", cod_info->part2_length );  
  439.     print_scalefacs(log_output,scalefac,cod_info->block_type,gr,ch);
  440.     /*if (gr==0 && ch==0)
  441.       print_quantized_values(log_output,l3_enc[gr][ch] ,cod_info);*/
  442.     max_ratio = worst_xfsf_to_xmin_ratio(l3_xmin,xfsf,cod_info->block_type,gr,ch);
  443.     fprintf(log_output,"max_ratio = %6.2fn",max_ratio );
  444.     print_ratios(log_output,l3_xmin,xfsf,cod_info->block_type,gr,ch);
  445.     fprintf(log_output,"nn");
  446.     fflush(log_output);
  447.     }
  448. #endif
  449.         over = amp_scalefac_bands( &xr[gr][ch][0], xfsf, l3_xmin,
  450.                                    l3_side, scalefac, gr, ch, iteration );
  452. #if 1
  453.         if ( (status = loop_break(scalefac, cod_info, gr, ch)) == 0 )
  454. {
  455.     if ( fr_ps->header->version == 1 )
  456. status = scale_bitcount( scalefac, cod_info, gr, ch );
  457.     else
  458. status = scale_bitcount_lsf( scalefac, cod_info, gr, ch );
  459. }
  460. #else
  461.         status = loop_break( scalefac, cod_info, gr, ch );
  462. if ( fr_ps->header->version == 1 )
  463.     status += scale_bitcount( scalefac, cod_info, gr, ch );
  464. else
  465.     status += scale_bitcount_lsf( scalefac, cod_info, gr, ch );
  466. #endif
  468.     }
  469.     while ( (status == 0) && (over > 0) );
  471.     cod_info->preflag = save_preflag;
  472.     cod_info->scalefac_compress = save_compress;
  474.     for ( sfb = 0; sfb < 21; sfb++ )
  475.         scalefac->l[gr][ch][sfb] = scalesave_l[sfb];    
  477.     for ( i = 0; i < 3; i++ )
  478.         for ( sfb = 0; sfb < 12; sfb++ )
  479.             scalefac->s[gr][ch][sfb][i] = scalesave_s[sfb][i];    
  481.     cod_info->part2_length   = part2_length( scalefac, fr_ps, gr, ch, l3_side );
  482.     cod_info->part2_3_length = cod_info->part2_length + bits;
  484. #ifdef PERFORM 
  485.     if(frameNum == PERFORM)
  486.     {
  487.     fprintf(log_output,"n  Final Resultsn");
  488.     fprintf(log_output,"bits = %d  huff_bits= %d", bits,huff_bits);
  489.     fprintf(log_output," max_bits = %dn",max_bits);
  490.     fprintf(log_output," Stepsize = %f ",cod_info->quantizerStepSize);
  491.     fprintf(log_output, " scale_bits    = %d n", cod_info->part2_length );  
  492.     max_ratio = worst_xfsf_to_xmin_ratio(l3_xmin,xfsf,cod_info->block_type,gr,ch);
  493.     print_scalefacs(log_output,scalefac,cod_info->block_type,gr,ch);
  494.     fprintf(log_output,"max_ratio = %6.2fn",max_ratio );
  495.     print_ratios(log_output,l3_xmin,xfsf,cod_info->block_type,gr,ch);
  496.     fflush(log_output);
  497.     }
  498. #endif    
  499.     return cod_info->part2_3_length;
  500. }
  505. /***************************************************************************/ 
  506. /*         inner_loop                                                      */ 
  507. /***************************************************************************/ 
  508. /* The code selects the best quantizerStepSize for a particular set
  509. /* of scalefacs                                                            */
  510.  
  511. int
  512. inner_loop( double xr[2][2][576], int l3_enc[2][2][576], int max_bits,
  513.     gr_info *cod_info, int gr, int ch )
  514. {
  515.     int bits, c1bits, bvbits;
  516.     double *xrs;  /*  D576  *xr; */
  517.     int *ix;  /*  I576  *ix; */
  518.     xrs = &xr[gr][ch][0];
  519.     ix = l3_enc[gr][ch];
  521.     assert( max_bits >= 0 );
  522.     cod_info->quantizerStepSize -= 1.0;;
  523.     do
  524.     {
  525.         do
  526.         {
  527.             cod_info->quantizerStepSize += 1.0;
  528.             quantize( xrs, ix, cod_info );
  529.         }
  530.         while ( ix_max(ix, 0, 576) > 8191 + 14 ); /* within table range? */
  532.         calc_runlen( ix, cod_info );  /*rzero,count1,big_values*/
  533.         bits = c1bits = count1_bitcount( ix, cod_info );  /*count1_table selection*/
  534.         subdivide( cod_info );  /* bigvalues sfb division */
  535.         bigv_tab_select( ix, cod_info );  /* codebook selection*/
  536.         bits += bvbits = bigv_bitcount( ix, cod_info );  /* bit count */
  538. #ifdef PERFORM
  539.         if(frameNum == PERFORM)
  540. fprintf(log_output,"StepSize=%f bits = %d huff_bits = %dn",
  541.            cod_info->quantizerStepSize,bits,max_bits);
  542. #endif
  544.     }
  545.     while ( bits > max_bits );
  547.     return bits;
  548. }
  552. /***************************************************************************/ 
  553. /*        calc_scfsi                                                       */ 
  554. /***************************************************************************/ 
  555. /* calculation of the scalefactor select information ( scfsi )        */
  557. void calc_scfsi( double  xr[576], III_side_info_t *l3_side,
  558.     III_psy_xmin *l3_xmin, int ch, int gr )
  559. {
  560.     static int en_tot[2][2]; /* ch,gr */
  561.     static int en[2][2][21];
  562.     static int xm[2][2][21];
  563.     static int xrmax[2][2];
  565.     int en_tot_krit        = 10;
  566.     int en_dif_krit        = 100;
  567.     int en_scfsi_band_krit = 10;
  568.     int xm_scfsi_band_krit = 10;
  570.     int scfsi_band;
  571.     unsigned scfsi_set;
  573.     int sfb, start, end, i;
  574.     int condition = 0;
  575.     double temp, log2 = log( 2.0 );
  576.     gr_info *cod_info = &l3_side->gr[gr].ch[ch].tt;
  578.     xrmax[gr][ch] = xr_max( xr, 0, 576 );
  579.     scfsi_set = 0;
  581.     /* the total energy of the granule */    
  582.     for ( temp = 0.0, i = 0; i < 576; i++ )
  583.         temp += xr[i] * xr[i];
  584.     if ( temp == 0.0 )
  585.         en_tot[gr][ch] = 0.0;
  586.     else
  587.         en_tot[gr][ch] = log( temp ) / log2 ;
  589.     /* the energy of each scalefactor band, en */
  590.     /* the allowed distortion of each scalefactor band, xm */
  592.     if ( cod_info->window_switching_flag == 0 ||
  593.          cod_info->block_type != 2 )
  594.         for ( sfb = 0; sfb < 21; sfb++ )
  595.         {
  596.             start = scalefac_band_long[ sfb ];
  597.             end   = scalefac_band_long[ sfb+1 ];
  599.             for ( temp = 0.0, i = start; i < end; i++ )
  600.                 temp += xr[i] * xr[i];
  601.             if ( temp == 0.0 )
  602.                 en[gr][ch][sfb] = 0.0;
  603.             else
  604.                 en[gr][ch][sfb] = log( temp )/ log2;
  606.             if ( l3_xmin->l[gr][ch][sfb] == 0.0 )
  607.                 xm[gr][ch][sfb] = 0.0;
  608.             else
  609.                 xm[gr][ch][sfb] = log( l3_xmin->l[gr][ch][sfb] ) / log2;
  610.         }
  611.     if ( gr == 1 )
  612.     {
  613.         int gr2, tp;
  615.         for ( gr2 = 0; gr2 < 2; gr2++ )
  616.         {
  617.             /* The spectral values are not all zero */
  618.             if ( xrmax[ch][gr2] != 0.0 )
  619.                 condition++;
  620.             /* None of the granules contains short blocks */
  621.             if ( (cod_info->window_switching_flag == 0) ||
  622.                  (cod_info->block_type != 2) )
  623.                 condition++;
  624.         }
  625.         if ( abs(en_tot[0] - en_tot[1]) < en_tot_krit )
  626.             condition++;
  627.         for ( tp = 0, sfb = 0; sfb < 21; sfb++ ) 
  628.             tp += abs( en[ch][0][sfb] - en[ch][1][sfb] );
  629.         if ( tp < en_dif_krit ) 
  630.             condition++;
  632.         if ( condition == 6 )
  633.         {
  634.             for ( scfsi_band = 0; scfsi_band < 4; scfsi_band++ )
  635.             {
  636.                 int sum0 = 0, sum1 = 0;
  637.                 l3_side->scfsi[ch][scfsi_band] = 0;
  638.                 start = scfsi_band_long[scfsi_band];
  639.                 end   = scfsi_band_long[scfsi_band+1];
  640.                 for ( sfb = start; sfb < end; sfb++ )
  641.                 { 
  642.                     sum0 += abs( en[ch][0][sfb] - en[ch][1][sfb] );
  643.                     sum1 += abs( xm[ch][0][sfb] - xm[ch][1][sfb] );
  644.                 }
  646.                 if ( sum0 < en_scfsi_band_krit && sum1 < xm_scfsi_band_krit )
  647. {
  648.                     l3_side->scfsi[ch][scfsi_band] = 1;
  649.     scfsi_set |= (1 << scfsi_band);
  650. }
  651.                 else
  652.                     l3_side->scfsi[ch][scfsi_band] = 0;
  653.             } /* for scfsi_band */
  654. #ifdef DEBUG
  655.     fprintf( stderr, "calc_scfsi: scfsi_set = 0x%02xn", scfsi_set );
  656. #endif
  657.         } /* if condition == 6 */
  658.         else
  659.             for ( scfsi_band = 0; scfsi_band < 4; scfsi_band++ )
  660.                 l3_side->scfsi[ch][scfsi_band] = 0;
  661.     } /* if gr == 1 */
  662. }
  666. /***************************************************************************/ 
  667. /*        part2_length                                                     */ 
  668. /***************************************************************************/ 
  670. /* calculates the number of bits needed to encode the scalefacs in the     */
  671. /* main data block                                                         */
  673. int part2_length( III_scalefac_t *scalefac, frame_params *fr_ps,
  674.       int gr, int ch, III_side_info_t *si )
  675. {
  676.     int slen1, slen2, slen3, slen4, bits, sfb, window, partition;
  677.     gr_info *gi = &si->gr[gr].ch[ch].tt;
  679.     bits = 0;
  680.     if ( fr_ps->header->version == 1 )
  681.     {
  682. static int slen1_tab[16] = { 0, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4 };
  683. static int slen2_tab[16] = { 0, 1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 2, 3 };
  685. slen1 = slen1_tab[ gi->scalefac_compress ];
  686. slen2 = slen2_tab[ gi->scalefac_compress ];
  688. if ( (gi->window_switching_flag == 1) && (gi->block_type == 2) )
  689. {
  690.     if ( gi->mixed_block_flag )
  691.     {
  692. bits += (8 * slen1) + (9 * slen1) + (18 * slen2);
  693.     }
  694.     else
  695.     {
  696. bits += (18 * slen1) + (18 * slen2);
  697.     }
  698. }
  699. else
  700. {
  701.     if ( (gr == 0) || (si->scfsi[ch][0] == 0) )
  702. bits += (6 * slen1);
  704.     if ( (gr == 0) || (si->scfsi[ch][1] == 0) )
  705. /*  bits += (6 * slen1);  This is wrong SS 19-12-96 */
  706. bits += (5 * slen1);
  708.     if ( (gr == 0) || (si->scfsi[ch][2] == 0) )
  709. /*  bits += (6 * slen1);   This is wrong SS 19-12-96 */
  710. bits += (5 * slen2);
  712.     if ( (gr == 0) || (si->scfsi[ch][3] == 0) )
  713. /* bits += (6 * slen1);   This is wrong SS 19-12-96 */
  714. bits += (5 * slen2);
  715. }
  716.     }
  717.     else
  718.     {   /* MPEG 2 */
  719. assert( gi->sfb_partition_table );
  720. for ( partition = 0; partition < 4; partition++ )
  721.     bits += gi->slen[partition] * gi->sfb_partition_table[partition];
  722.     }
  723.     return bits;
  724. }
  728. /*************************************************************************/
  729. /*            scale_bitcount                                             */
  730. /*************************************************************************/
  732. /* Also calculates the number of bits necessary to code the scalefactors. */
  734. int scale_bitcount( III_scalefac_t *scalefac, gr_info *cod_info,
  735. int gr, int ch )
  736. {
  737.     int i, k, sfb, max_slen1 = 0, max_slen2 = 0, /*a, b, */ ep = 2;
  739.     static int slen1[16] = { 0, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4 };
  740.     static int slen2[16] = { 0, 1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 2, 3 };
  741.     static int pow2[5]   = { 1, 2, 4, 8, 16 };
  743.     if ( cod_info->window_switching_flag != 0 && cod_info->block_type == 2 )
  744.     {
  745.         if ( cod_info->mixed_block_flag == 0 ) 
  746.         {
  747.             /* a = 18; b = 18;  */
  748.             for ( i = 0; i < 3; i++ )
  749.             {
  750.                 for ( sfb = 0; sfb < 6; sfb++ )
  751.                     if ( scalefac->s[gr][ch][sfb][i] > max_slen1 )
  752.                         max_slen1 = scalefac->s[gr][ch][sfb][i];
  753.                 for (sfb = 6; sfb < 12; sfb++ )
  754.                     if ( scalefac->s[gr][ch][sfb][i] > max_slen2 )
  755.                         max_slen2 = scalefac->s[gr][ch][sfb][i];
  756.             }
  757.         }
  758.         else
  759.         {/* mixed_block_flag = 1 */
  760.             /* a = 17; b = 18;  */
  761.             for ( sfb = 0; sfb < 8; sfb++ )
  762.                 if ( scalefac->l[gr][ch][sfb] > max_slen1 )
  763.                     max_slen1 = scalefac->l[gr][ch][sfb];
  764.             for ( i = 0; i < 3; i++ )
  765.             {
  766.                 for ( sfb = 3; sfb < 6; sfb++ )
  767.                     if ( scalefac->s[gr][ch][sfb][i] > max_slen1 )
  768.                         max_slen1 = scalefac->s[gr][ch][sfb][i];
  769.                 for ( sfb = 6; sfb < 12; sfb++ )
  770.                     if ( scalefac->s[gr][ch][sfb][i] > max_slen2 )
  771.                         max_slen2 = scalefac->s[gr][ch][sfb][i];
  772.             }
  773.         }
  774.     }
  775.     else
  776.     { /* block_type == 1,2,or 3 */
  777.         /* a = 11; b = 10;   */
  778.         for ( sfb = 0; sfb < 11; sfb++ )
  779.             if ( scalefac->l[gr][ch][sfb] > max_slen1 )
  780.                 max_slen1 = scalefac->l[gr][ch][sfb];
  781.         for ( sfb = 11; sfb < 21; sfb++ )
  782.             if ( scalefac->l[gr][ch][sfb] > max_slen2 )
  783.                 max_slen2 = scalefac->l[gr][ch][sfb];
  784.     }
  786.     for ( k = 0; k < 16; k++ )
  787.     {
  788.         if ( (max_slen1 < pow2[slen1[k]]) && (max_slen2 < pow2[slen2[k]]) )
  789.         { 
  790.             ep = 0;
  791.             break;
  792.         } 
  793.     }
  795.     if ( ep == 0 )
  796.         cod_info->scalefac_compress = k;
  797. #ifdef DEBUG
  798.     if ( ep != 0 ) 
  799.         printf( "---WARNING !! Amplification of some bands over limitsn" );
  800. #endif
  801.     return ep;
  802. }
  807. /*************************************************************************/
  808. /*            scale_bitcount_lsf                                         */
  809. /*************************************************************************/
  811. /* Also counts the number of bits to encode the scalefacs but for MPEG 2 */ 
  812. /* Lower sampling frequencies  (24, 22.05 and 16 kHz.)                   */
  813.  
  814. /*  This is reverse-engineered from section 2.4.3.2 of the MPEG2 IS,     */
  815. /* "Audio Decoding Layer III"                                            */
  817. int scale_bitcount_lsf( III_scalefac_t *scalefac, gr_info *cod_info,
  818.     int gr, int ch )
  819. {
  820.     int table_number, row_in_table, partition, nr_sfb, window, over;
  821.     int i, k, sfb, max_sfac[ 4 ];
  822.     unsigned *partition_table;
  824.     /*
  825.       Set partition table. Note that should try to use table one,
  826.       but do not yet...
  827.     */
  828.     if ( cod_info->preflag )
  829. table_number = 2;
  830.     else
  831. table_number = 0;
  833.     for ( i = 0; i < 4; i++ )
  834. max_sfac[i] = 0;
  836.     if ( cod_info->window_switching_flag != 0 && cod_info->block_type == 2 )
  837.     {
  838.         if ( cod_info->mixed_block_flag == 0 ) 
  839.         {
  840.     row_in_table = 1;
  841.     partition_table = &nr_of_sfb_block[table_number][row_in_table][0];
  842.     for ( sfb = 0, partition = 0; partition < 4; partition++ )
  843.     {
  844. nr_sfb = partition_table[ partition ] / 3;
  845. for ( i = 0; i < nr_sfb; i++, sfb++ )
  846.     for ( window = 0; window < 3; window++ )
  847. if ( scalefac->s[gr][ch][sfb][window] > max_sfac[partition] )
  848.     max_sfac[partition] = scalefac->s[gr][ch][sfb][window];
  849.     }
  850.         }
  851.         else
  852.         {/* mixed_block_flag = 1 */
  853.     row_in_table = 2;
  854.     partition_table = &nr_of_sfb_block[table_number][row_in_table][0];
  855.     partition = 0;
  856.     nr_sfb = partition_table[ partition ];
  857.     for ( i = 0; i < nr_sfb; i++, sfb++ )
  858. if ( scalefac->l[gr][ch][sfb] > max_sfac[partition] )
  859.     max_sfac[partition] = scalefac->l[gr][ch][sfb];
  860.     
  861.     for ( sfb = 0, partition = 1; partition < 4; partition++ )
  862.     {
  863. nr_sfb = partition_table[ partition ] / 3;
  864. for ( i = 0; i < nr_sfb; i++, sfb++ )
  865.     for ( window = 0; window < 3; window++ )
  866. if ( scalefac->s[gr][ch][sfb][window] > max_sfac[partition] )
  867.     max_sfac[partition] = scalefac->s[gr][ch][sfb][window];
  868.     }
  869.         }
  870.     }
  871.     else
  872.     {
  873. row_in_table = 0;
  874. partition_table = &nr_of_sfb_block[table_number][row_in_table][0];
  875. partition = 0;
  876. for ( sfb = 0, partition = 0; partition < 4; partition++ )
  877. {
  878.     nr_sfb = partition_table[ partition ];
  879.     for ( i = 0; i < nr_sfb; i++, sfb++ )
  880. if ( scalefac->l[gr][ch][sfb] > max_sfac[partition] )
  881.     max_sfac[partition] = scalefac->l[gr][ch][sfb];
  882. }
  883.     }
  885.     for ( over = 0, partition = 0; partition < 4; partition++ )
  886.     {
  887. if ( max_sfac[partition] > max_sfac_tab[table_number][partition] )
  888.     over++;
  889.     }
  890.     if ( !over )
  891.     {
  892. /*
  893.   Since no bands have been over-amplified, we can set scalefac_compress
  894.   and slen[] for the formatter
  895. */
  896. static int log2tab[] = { 0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4 };
  898. unsigned slen1, slen2, slen3, slen4;
  900.         cod_info->sfb_partition_table = &nr_of_sfb_block[table_number][row_in_table][0];
  901. for ( partition = 0; partition < 4; partition++ )
  902.     cod_info->slen[partition] = log2tab[max_sfac[partition]];
  904. /* set scalefac_compress */
  905. slen1 = cod_info->slen[ 0 ];
  906. slen2 = cod_info->slen[ 1 ];
  907. slen3 = cod_info->slen[ 2 ];
  908. slen4 = cod_info->slen[ 3 ];
  910. switch ( table_number )
  911. {
  912.   case 0:
  913.     cod_info->scalefac_compress = (((slen1 * 5) + slen2) << 4)
  914. + (slen3 << 2)
  915. + slen4;
  916.     break;
  918.   case 1:
  919.     cod_info->scalefac_compress = 400
  920. + (((slen1 * 5) + slen2) << 2)
  921. + slen3;
  922.     break;
  924.   case 2:
  925.     cod_info->scalefac_compress = 500 + (slen1 * 3) + slen2;
  926.     break;
  928.   default:
  929.     fprintf( stderr, "intensity stereo not implemented yetn" );
  930.     exit( EXIT_FAILURE );
  931.     break;
  932. }
  933.     }
  934. #ifdef DEBUG
  935.     if ( over ) 
  936.         printf( "---WARNING !! Amplification of some bands over limitsn" );
  937. #endif
  938.     return over;
  939. }
  942. /*************************************************************************/
  943. /*            calc_noise                                                 */
  944. /*************************************************************************/
  946. /*   Function: Calculate the distortion introduced by the quantization   */
  947. /*   in each scale factor band.                                          */
  949. void calc_noise( double xr[576], int ix[576], gr_info *cod_info,
  950.     double xfsf[4][CBLIMIT] )
  951. {
  952.     int start, end, sfb, l, i;
  953.     double sum,step,bw;
  955.     D192_3 *xr_s;
  956.     I192_3 *ix_s;
  958.     xr_s = (D192_3 *) xr;
  959.     ix_s = (I192_3 *) ix;
  961.     step = pow( 2.0, (cod_info->quantizerStepSize) * 0.25 );
  962.     for ( sfb = 0; sfb < cod_info->sfb_lmax; sfb++ )
  963.     {
  964.         start = scalefac_band_long[ sfb ];
  965.         end   = scalefac_band_long[ sfb+1 ];
  966. bw = end - start;
  968.         for ( sum = 0.0, l = start; l < end; l++ )
  969.         {
  970.             double temp;
  971.             temp = fabs( xr[l] ) - pow( (double) ix[l], 4.0 / 3.0 ) * step;
  972.             sum += temp * temp; 
  973.         }
  974.         xfsf[0][sfb] = sum / bw;
  975.     }
  977.     for ( i = 0; i < 3; i++ )
  978.     {
  979.         step = pow( 2.0, (cod_info->quantizerStepSize) * 0.25 ); /* subblock_gain ? */
  980.         for ( sfb = cod_info->sfb_smax; sfb < 12; sfb++ )
  981.         {
  982.             start = scalefac_band_short[ sfb ];
  983.             end   = scalefac_band_short[ sfb+1 ];
  984.     bw = end - start;
  985.             
  986.             for ( sum = 0.0, l = start; l < end; l++ )
  987.             {
  988.                 double temp;
  989.                 temp = fabs( (*xr_s)[l][i] ) - pow( (double) (*ix_s)[l][i], 4.0 / 3.0 ) * step;
  990.                 sum += temp * temp;
  991.             }       
  992.             xfsf[i+1][sfb] = sum / bw;
  993.         }
  994.     }
  995. }
  1000. /*************************************************************************/
  1001. /*            calc_xmin                                                  */
  1002. /*************************************************************************/
  1004. /*
  1005.   Calculate the allowed distortion for each scalefactor band,
  1006.   as determined by the psychoacoustic model.
  1007.   xmin(sb) = ratio(sb) * en(sb) / bw(sb)
  1008. */
  1010. void calc_xmin( double xr[2][2][576], III_psy_ratio *ratio,
  1011.    gr_info *cod_info, III_psy_xmin *l3_xmin,
  1012.    int gr, int ch )
  1013. {
  1014.     int start, end, sfb, l, b;
  1015.     double en, bw;
  1017.     D192_3 *xr_s;
  1019.     xr_s = (D192_3 *) xr[gr][ch] ;
  1021.     for ( sfb = cod_info->sfb_smax; sfb < SFB_SMAX - 1; sfb++ )
  1022.     {
  1023.         start = scalefac_band_short[ sfb ];
  1024.         end   = scalefac_band_short[ sfb + 1 ];
  1025. bw = end - start;
  1026.         for ( b = 0; b < 3; b++ )
  1027.         {
  1028.             for ( en = 0.0, l = start; l < end; l++ )
  1029.                 en += (*xr_s)[l][b] * (*xr_s)[l][b];
  1030.             l3_xmin->s[gr][ch][sfb][b] = ratio->s[gr][ch][sfb][b] * en / bw;
  1031.         }
  1032.     }
  1034.     for ( sfb = 0; sfb < cod_info->sfb_lmax; sfb++ )
  1035.     {
  1036.         start = scalefac_band_long[ sfb ];
  1037.         end   = scalefac_band_long[ sfb+1 ];
  1038. bw = end - start;
  1040.         for ( en = 0.0, l = start; l < end; l++ )
  1041.             en += xr[gr][ch][l] * xr[gr][ch][l];
  1042.         l3_xmin->l[gr][ch][sfb] = ratio->l[gr][ch][sfb] * en / bw;
  1043.     }
  1044. }
  1048. /*************************************************************************/
  1049. /*            loop_break                                                 */
  1050. /*************************************************************************/
  1052. /*  Function: Returns zero if there is a scalefac which has not been
  1053.     amplified. Otherwise it returns one. 
  1054. */
  1056. int loop_break( III_scalefac_t *scalefac, gr_info *cod_info,
  1057.     int gr, int ch )
  1058. {
  1059.     int i, sfb, temp = 1;
  1061.     for ( sfb = 0; sfb < cod_info->sfb_lmax; sfb++ )
  1062.         if ( scalefac->l[gr][ch][sfb] == 0 )
  1063.             temp = 0;
  1065.     for ( sfb = cod_info->sfb_smax; sfb < 12; sfb++ )
  1066.         for ( i = 0; i < 3; i++ )
  1067.             if ( scalefac->s[gr][ch][sfb][i] == 0 )
  1068.                 temp = 0;
  1069. #ifdef DEBUG
  1070.     if ( temp != 0 )
  1071.         printf( "---WARNING !! All scalefactor bands amplifiedn" );
  1072. #endif
  1073.     return temp;
  1074. }
  1078. /*************************************************************************/
  1079. /*            preemphasis                                                */
  1080. /*************************************************************************/
  1082. /*
  1083.   See ISO 11172-3  section  C.1.5.4.3.4
  1084. */
  1086. void preemphasis( double xr[576], double xfsf[4][CBLIMIT],
  1087.      III_psy_xmin  *l3_xmin,
  1088.      int gr, int ch, III_side_info_t *l3_side )
  1089. {
  1090.     int i, sfb, start, end, scfsi_band, over;
  1091.     double ifqstep;
  1092.     gr_info *cod_info = &l3_side->gr[gr].ch[ch].tt;
  1094.     if ( gr == 1 )
  1095.     {
  1096. /*
  1097.   If the second granule is being coded and scfsi is active in
  1098.   at least one scfsi_band, the preemphasis in the second granule
  1099.   is set equal to the setting in the first granule
  1100. */
  1101. for ( scfsi_band = 0; scfsi_band < 4; scfsi_band++ )
  1102.     if ( l3_side->scfsi[ch][scfsi_band] )
  1103.     {
  1104. cod_info->preflag = l3_side->gr[0].ch[ch].tt.preflag;
  1105. return;
  1106.     }
  1108.     }
  1110.     /*
  1111.       Preemphasis is switched on if in all the upper four scalefactor
  1112.       bands the actual distortion exceeds the threshold after the
  1113.       first call of the inner loop
  1114.     */
  1115.     if ( cod_info->block_type != 2 && cod_info->preflag == 0 )
  1116.     {
  1117. over = 0;
  1118. for ( sfb = 17; sfb < 21; sfb++ )
  1119.     if ( xfsf[0][sfb] > l3_xmin->l[gr][ch][sfb] )
  1120. over++;
  1122. if (over == 4 )
  1123. {
  1124.     cod_info->preflag = 1;
  1125.     ifqstep = ( cod_info->scalefac_scale == 0 ) ? sqrt(2.)
  1126. : pow( 2.0, (0.5 * (1.0 + (double) cod_info->scalefac_scale)) );
  1128.     for ( sfb = 0; sfb < cod_info->sfb_lmax; sfb++ )
  1129.     {
  1130. l3_xmin->l[gr][ch][sfb] *= pow( ifqstep, 2.0 * (double) pretab[sfb] );
  1131. start = scalefac_band_long[ sfb ];
  1132. end   = scalefac_band_long[ sfb+1 ];
  1133. for( i = start; i < end; i++ )
  1134.     xr[i] *= pow( ifqstep, (double) pretab[sfb] );
  1135.     }
  1136. }
  1137.     }
  1138. }
  1141. /*************************************************************************/
  1142. /*            amp_scalefac_bands                                         */
  1143. /*************************************************************************/
  1145. /* 
  1146.   Amplify the scalefactor bands that violate the masking threshold.
  1147.   See ISO 11172-3 Section C.1.5.4.3.5
  1148. */
  1150. int amp_scalefac_bands( double xr[576], double xfsf[4][CBLIMIT],
  1151.     III_psy_xmin *l3_xmin, III_side_info_t *l3_side,
  1152.     III_scalefac_t *scalefac,
  1153.     int gr, int ch, int iteration )
  1154. {
  1155.     int start, end, l, sfb, i, scfsi_band, over = 0;
  1156.     double ifqstep, ifqstep2;
  1157.     D192_3 *xr_s;
  1158.     gr_info *cod_info, *gr0;
  1159.     int copySF, preventSF;
  1160.     cod_info = &l3_side->gr[gr].ch[ch].tt;
  1161.     gr0      = &l3_side->gr[0].ch[ch].tt;
  1163.     xr_s = (D192_3 *) xr;
  1164.     copySF = 0;
  1165.     preventSF = 0;
  1167.     if ( cod_info->scalefac_scale == 0 )
  1168. ifqstep = sqrt( 2.0 );
  1169.     else
  1170. ifqstep = pow( 2.0, 0.5 * (1.0 + (double) cod_info->scalefac_scale) );
  1172.     if ( gr == 1 )
  1173.     {
  1174. /*
  1175.   If the second granule is being coded and scfsi is active in at
  1176.   least one scfsi_band...
  1177. */
  1178. for ( scfsi_band = 0; scfsi_band < 4; scfsi_band++ )
  1179.     if ( l3_side->scfsi[ch][scfsi_band] )
  1180.     {
  1181. /*
  1182.   a) ifqstep has to be set similar to the
  1183.    first granule...
  1184. */
  1185. if ( gr0->scalefac_scale == 0 )
  1186.     ifqstep = sqrt( 2.0 );
  1187. else
  1188.     ifqstep = pow( 2.0, 0.5 * (1.0 + (double) gr0->scalefac_scale) );
  1190. if ( iteration == 1 )
  1191. {
  1192.     /*
  1193.       b) If it is the first iteration, the scalefactors
  1194.       of scalefactor bands in which scfsi is enabled
  1195.       must be taken from the first granule
  1196.     */  
  1197.     copySF = 1;
  1198. }
  1199. else
  1200. {
  1201.     /*
  1202.       c) If it is not the first iteration, the amplification
  1203.       must be prevented for scalefactor bands in which
  1204.       scfsi is enabled
  1205.     */
  1206.     preventSF = 1;
  1207. }
  1208. break;
  1209.     }
  1211.     }
  1213.     ifqstep2 = ifqstep * ifqstep;
  1214.     scfsi_band = 0;
  1215.     
  1216.     for ( sfb = 0; sfb < cod_info->sfb_lmax; sfb++ )
  1217.     {
  1218. if ( copySF || preventSF )
  1219. {
  1220.     if ( sfb == scfsi_band_long[scfsi_band + 1] )
  1221. scfsi_band += 1;
  1222.     if ( l3_side->scfsi[ch][scfsi_band] )
  1223.     {
  1224. if ( copySF )
  1225.     scalefac->l[gr][ch][sfb] = scalefac->l[0][ch][sfb];
  1226. continue;
  1227.     }
  1228. }     
  1229. if ( xfsf[0][sfb] > l3_xmin->l[gr][ch][sfb] )
  1230. {
  1231.     over++;
  1232.     l3_xmin->l[gr][ch][sfb] *= ifqstep2;
  1233.     scalefac->l[gr][ch][sfb]++;
  1234.     start = scalefac_band_long[sfb];
  1235.     end   = scalefac_band_long[sfb+1];
  1236.     for ( l = start; l < end; l++ )
  1237. xr[l] *= ifqstep;
  1238. }
  1239.     }
  1241.     /*
  1242.       Note that scfsi is not enabled for frames containing
  1243.       short blocks
  1244.     */
  1245.     for ( i = 0; i < 3; i++ )
  1246.         for ( sfb = cod_info->sfb_smax; sfb < 12; sfb++ )
  1247.             if ( xfsf[i+1][sfb] > l3_xmin->s[gr][ch][sfb][i] )
  1248.             {
  1249.                 over++;
  1250.                 l3_xmin->s[gr][ch][sfb][i] *= ifqstep2;
  1251.                 scalefac->s[gr][ch][sfb][i]++;
  1252. #ifdef DEBUGSC
  1253.                 printf( "cod_info->scalefac[%d][%d] = %d (amp_scale)n",
  1254.                         i,sfb,scalefac->s[gr][ch][sfb][i] );
  1255. #endif
  1256.                 start = scalefac_band_short[sfb];
  1257.                 end   = scalefac_band_short[sfb+1];
  1258.                 for ( l = start; l < end; l++ )
  1259.                     (*xr_s)[l][i] *= ifqstep;
  1260.             }
  1261.     return over;
  1262. }
  1267. /*************************************************************************/
  1268. /*            quantize                                                   */
  1269. /*************************************************************************/
  1271. /*
  1272.   Function: Quantization of the vector xr ( -> ix)
  1273. */
  1275. void quantize( double xr[576], int ix[576], gr_info *cod_info )
  1276. {
  1277.     int i, b, l_end, s_start;
  1278.     double step, quantizerStepSize;
  1280.     D192_3 *xr_s;
  1281.     I192_3 *ix_s;
  1283.     xr_s = (D192_3 *) xr;
  1284.     ix_s = (I192_3 *) ix;
  1286.     quantizerStepSize = (double) cod_info->quantizerStepSize;
  1288.     for ( i = 0; i < 576; i++ )
  1289. ix[i] = 0;
  1291.     if ( cod_info->quantizerStepSize == 0.0 )
  1292. step = 1.0;
  1293.     else
  1294. step = pow ( 2.0, quantizerStepSize * 0.25 );
  1296.     if ( cod_info->window_switching_flag != 0 && cod_info->block_type == 2 )
  1297. if ( cod_info->mixed_block_flag == 0 )
  1298. {
  1299.     l_end = 0;
  1300.     s_start = 0;
  1301. }
  1302. else
  1303. {
  1304.     l_end = 18 * 2;
  1305.     s_start = 6 * 2;
  1306. }
  1307.     else
  1308.     {
  1309. l_end = 576;
  1310. s_start = 192;
  1311.     }
  1313.     for ( i = 0; i < l_end; i++ )
  1314. ix[i] = nint( pow(fabs(xr[i]) / step, 0.75) - 0.0946 );
  1315.     
  1316.     if ( s_start < 192 )
  1317. for ( b = 0; b < 3; b++ )
  1318. {
  1319.     step = pow( 2.0, (quantizerStepSize + 8.0 * (double) cod_info->subblock_gain[b]) * 0.25 );
  1320.     for ( i = s_start; i < 192; i++ )
  1321. (*ix_s)[i][b] = nint( pow(fabs((*xr_s)[i][b]) / step, 0.75) - 0.0946 );
  1322. }
  1323. }
  1328. /*************************************************************************/
  1329. /*            ix_max                                                     */
  1330. /*************************************************************************/
  1332. /*
  1333.   Function: Calculate the maximum of ix from 0 to 575
  1334. */
  1336. int ix_max( int ix[576], unsigned int begin, unsigned int end )
  1337. {
  1338.     int i, max = 0;
  1340.     for ( i = begin; i < end; i++ )
  1341.     {
  1342.         int x = abs( ix[i] );
  1343.         if ( x > max )
  1344.             max = x;
  1345.     }
  1346.     return max;
  1347. }
  1350. /*************************************************************************/
  1351. /*            xr_max                                                     */
  1352. /*************************************************************************/
  1354. /*
  1355.   Function: Calculate the maximum of xr[576]  from 0 to 575
  1356. */
  1358. double xr_max( double xr[576], unsigned int begin, unsigned int end )
  1359. {
  1360.     int i;
  1361.     double max = 0.0, temp;
  1363.     for ( i = begin; i < end; i++ )
  1364.         if( (temp = fabs(xr[i])) > max )
  1365.     max = temp;
  1366.     return max;
  1367. }
  1371. /*        Noiseless coding  -- Huffman coding   */
  1374. /*************************************************************************/
  1375. /*            calc_runlen                                                */
  1376. /*************************************************************************/
  1378. /*
  1379. Function: Calculation of rzero, count1, big_values
  1380. (Partitions ix into big values, quadruples and zeros).
  1381. */
  1383. void calc_runlen( int ix[576], gr_info *cod_info )
  1384. {
  1385.     int i;
  1386.     int rzero = 0; 
  1388.     if ( cod_info->window_switching_flag && (cod_info->block_type == 2) )
  1389.     {  /* short blocks */
  1390.         cod_info->count1 = 0;
  1391.         cod_info->big_values = 288;
  1392.     }
  1393.     else
  1394.     {
  1395.         for ( i = 576; i > 1; i -= 2 )
  1396.             if ( ix[i-1] == 0 && ix[i-2] == 0 )
  1397.                 rzero++;
  1398.             else
  1399.                 break;
  1400.         
  1401.         cod_info->count1 = 0 ;
  1402.         for ( ; i > 3; i -= 4 )
  1403.             if ( abs(ix[i-1]) <= 1
  1404.               && abs(ix[i-2]) <= 1
  1405.               && abs(ix[i-3]) <= 1
  1406.               && abs(ix[i-4]) <= 1 )
  1407.                 cod_info->count1++;
  1408.             else
  1409.                 break;
  1410.         
  1411.         cod_info->big_values = i/2;
  1412.     }
  1413.     assert( (2 * rzero + 4 * cod_info->count1 + 2 * cod_info->big_values) == 576 );
  1414. }
  1418. /*************************************************************************/
  1419. /*            count1_bitcount                                            */
  1420. /*************************************************************************/
  1422. /*
  1423.   Determines the number of bits to encode the quadruples.
  1424. */
  1426. int count1_bitcount( int ix[ 576 ], gr_info *cod_info )
  1427. {
  1428.     int abs_and_sign( int *x );
  1430.     int p, i, k, bitsum_count1;
  1431.     int v, w, x, y, signbits;
  1432.     int sum0 = 0, sum1 = 0;
  1434.     for ( i = cod_info->big_values * 2, k = 0; k < cod_info->count1; i += 4, k++ )
  1435.     {
  1436.         v = ix[ i ];
  1437.         w = ix[ i + 1 ];
  1438.         x = ix[ i + 2 ];
  1439.         y = ix[ i + 3 ];
  1440.         
  1441.         abs_and_sign( &v );
  1442.         abs_and_sign( &w );
  1443.         abs_and_sign( &x );
  1444.         abs_and_sign( &y );
  1446.         p = v + (w << 1) + (x << 2) + (y << 3);
  1447.         
  1448.         signbits = 0;
  1450.         if ( v != 0 )
  1451.             signbits += 1;
  1452.         if ( w != 0 )
  1453.             signbits += 1;
  1454.         if ( x != 0 )
  1455.             signbits += 1;
  1456.         if ( y != 0 )
  1457.             signbits += 1;
  1459.         sum0 += signbits;
  1460.         sum1 += signbits;
  1462.         sum0 += ht[ 32 ].hlen[ p ];
  1463.         sum1 += ht[ 33 ].hlen[ p ];
  1464.     }
  1466.     if ( sum0 < sum1 )
  1467.     {
  1468.         bitsum_count1 = sum0;
  1469.         cod_info->count1table_select = 0;
  1470.     }
  1471.     else
  1472.     {
  1473.         bitsum_count1 = sum1;
  1474.         cod_info->count1table_select = 1;
  1475.     }
  1476.     return( bitsum_count1 );
  1477. }
  1483. struct
  1484. {
  1485.     unsigned region0_count;
  1486.     unsigned region1_count;
  1487. } subdv_table[ 23 ] =
  1488. {
  1489. {0, 0}, /* 0 bands */
  1490. {0, 0}, /* 1 bands */
  1491. {0, 0}, /* 2 bands */
  1492. {0, 0}, /* 3 bands */
  1493. {0, 0}, /* 4 bands */
  1494. {0, 1}, /* 5 bands */
  1495. {1, 1}, /* 6 bands */
  1496. {1, 1}, /* 7 bands */
  1497. {1, 2}, /* 8 bands */
  1498. {2, 2}, /* 9 bands */
  1499. {2, 3}, /* 10 bands */
  1500. {2, 3}, /* 11 bands */
  1501. {3, 4}, /* 12 bands */
  1502. {3, 4}, /* 13 bands */
  1503. {3, 4}, /* 14 bands */
  1504. {4, 5}, /* 15 bands */
  1505. {4, 5}, /* 16 bands */
  1506. {4, 6}, /* 17 bands */
  1507. {5, 6}, /* 18 bands */
  1508. {5, 6}, /* 19 bands */
  1509. {5, 7}, /* 20 bands */
  1510. {6, 7}, /* 21 bands */
  1511. {6, 7}, /* 22 bands */
  1512. };
  1517. /*************************************************************************/
  1518. /*            subdivide                                                  */
  1519. /*************************************************************************/
  1521. /* presumable subdivides the bigvalue region which will
  1522.    use separate Huffman tables.
  1523. */
  1525. void subdivide( gr_info *cod_info )
  1526. {
  1527.     int scfb_anz = 0;
  1528.     int bigvalues_region;
  1529.     
  1530.     if ( cod_info->big_values == 0 )
  1531.     { /* no big_values region */
  1532.         cod_info->region0_count = 0;
  1533.         cod_info->region1_count = 0;
  1534.     }
  1535.     else
  1536.     {
  1537.         bigvalues_region = 2 * cod_info->big_values;
  1539.         if ( (cod_info->window_switching_flag == 0) )
  1540.         { /* long blocks */
  1541.             int thiscount, index;
  1542.             /* Calculate scfb_anz */
  1543.             while ( scalefac_band_long[scfb_anz] < bigvalues_region )
  1544.                 scfb_anz++;
  1545.             assert( scfb_anz < 23 );
  1547.             cod_info->region0_count = subdv_table[scfb_anz].region0_count;
  1548.             thiscount = cod_info->region0_count;
  1549.             index = thiscount + 1;
  1550.             while ( thiscount && (scalefac_band_long[index] > bigvalues_region) )
  1551.             {
  1552.                 thiscount -= 1;
  1553.                 index -= 1;
  1554.             }
  1555.             cod_info->region0_count = thiscount;
  1557.             cod_info->region1_count = subdv_table[scfb_anz].region1_count;
  1558.             index = cod_info->region0_count + cod_info->region1_count + 2;
  1559.             thiscount = cod_info->region1_count;
  1560.             while ( thiscount && (scalefac_band_long[index] > bigvalues_region) )
  1561.             {
  1562.                 thiscount -= 1;
  1563.                 index -= 1;
  1564.             }
  1565.             cod_info->region1_count = thiscount;
  1566.             cod_info->address1 = scalefac_band_long[cod_info->region0_count+1];
  1567.             cod_info->address2 = scalefac_band_long[cod_info->region0_count
  1568.                                                     + cod_info->region1_count + 2 ];
  1569.             cod_info->address3 = bigvalues_region;
  1570.         }
  1571.         else
  1572.         {
  1573.             if ( (cod_info->block_type == 2) && (cod_info->mixed_block_flag == 0) )
  1574.             { 
  1575.                 cod_info->region0_count =  8;
  1576.                 cod_info->region1_count =  36;
  1577.                 cod_info->address1 = 36;
  1578.                 cod_info->address2 = bigvalues_region;
  1579.                 cod_info->address3 = 0;  
  1580.             }
  1581.             else
  1582.             {
  1583.                 cod_info->region0_count = 7;
  1584.                 cod_info->region1_count = 13;
  1585.                 cod_info->address1 = scalefac_band_long[cod_info->region0_count+1];
  1586.                 cod_info->address2 = bigvalues_region;
  1587.                 cod_info->address3 = 0;
  1588.             }
  1589.         }
  1590.     }
  1591. }
  1596. /*************************************************************************/
  1597. /*            bigv_tab_select                                            */
  1598. /*************************************************************************/
  1600. /*
  1601. /*  Function: Select huffman code tables for bigvalues regions 
  1602. */
  1604. void bigv_tab_select( int ix[576], gr_info *cod_info )
  1605. {
  1606.     /* int max; */
  1608.     cod_info->table_select[0] = 0;
  1609.     cod_info->table_select[1] = 0;
  1610.     cod_info->table_select[2] = 0;
  1611.     
  1612.     if ( cod_info->window_switching_flag && (cod_info->block_type == 2) )
  1613.     {
  1614.         /*
  1615.           Within each scalefactor band, data is given for successive
  1616.           time windows, beginning with window 0 and ending with window 2.
  1617.           Within each window, the quantized values are then arranged in
  1618.           order of increasing frequency...
  1619.           */
  1620.         int sfb, window, line, start, end, max1, max2, x, y;
  1621.         int region1Start;
  1622.         int *pmax;
  1624.         region1Start = 12;
  1625.         max1 = max2 = 0;
  1627.         for ( sfb = 0; sfb < 13; sfb++ )
  1628.         {
  1629.             start = scalefac_band_short[ sfb ];
  1630.             end   = scalefac_band_short[ sfb+1 ];
  1631.             
  1632.             if ( start < region1Start )
  1633.                 pmax = &max1;
  1634.             else
  1635.                 pmax = &max2;
  1636.             
  1637.             for ( window = 0; window < 3; window++ )
  1638.                 for ( line = start; line < end; line += 2 )
  1639.                 {
  1640.                     assert( line >= 0 );
  1641.                     assert( line < 576 );
  1642.                     x = abs( ix[ (line * 3) + window ] );
  1643.                     y = abs( ix[ ((line + 1) * 3) + window ]);
  1644.                     *pmax = *pmax > x ? *pmax : x;
  1645.                     *pmax = *pmax > y ? *pmax : y;
  1646.                 }
  1647.         }
  1648.         cod_info->table_select[0] = choose_table( max1 );
  1649.         cod_info->table_select[1] = choose_table( max2 );
  1650.     }
  1651.     else
  1652.     {
  1653.         if ( cod_info->address1 > 0 )
  1654.             cod_info->table_select[0] = new_choose_table( ix, 0, cod_info->address1 );
  1656.         if ( cod_info->address2 > cod_info->address1 )
  1657.             cod_info->table_select[1] = new_choose_table( ix, cod_info->address1, cod_info->address2 );
  1659.         if ( cod_info->big_values * 2 > cod_info->address2 )
  1660.             cod_info->table_select[2] = new_choose_table( ix, cod_info->address2, cod_info->big_values * 2 );
  1661.     }
  1662. }
  1667. /*************************************************************************/
  1668. /*            new_choose table                                           */
  1669. /*************************************************************************/
  1671. /*
  1672.   Choose the Huffman table that will encode ix[begin..end] with
  1673.   the fewest bits.
  1675.   Note: This code contains knowledge about the sizes and characteristics
  1676.   of the Huffman tables as defined in the IS (Table B.7), and will not work
  1677.   with any arbitrary tables.
  1678. */
  1680. int new_choose_table( int ix[576], unsigned int begin, unsigned int end )
  1681. {
  1682.     int i, max;
  1683.     int choice[ 2 ];
  1684.     int sum[ 2 ];
  1686.     max = ix_max( ix, begin, end );
  1688.     if ( max == 0 )
  1689.         return 0;
  1690.     
  1691.     max = abs( max );
  1693.     choice[ 0 ] = 0;
  1694.     choice[ 1 ] = 0;
  1696.     if ( max < 15 )
  1697.     {
  1698. /* try tables with no linbits */
  1699.         for ( i = 0; i < 14; i++ )
  1700.             if ( ht[i].xlen > max )
  1701.     {
  1702. choice[ 0 ] = i;
  1703.                 break;
  1704.     }
  1705. assert( choice[0] );
  1707. sum[ 0 ] = count_bit( ix, begin, end, choice[0] );
  1709. switch ( choice[0] )
  1710. {
  1711.   case 2:
  1712.     sum[ 1 ] = count_bit( ix, begin, end, 3 );
  1713.     if ( sum[1] <= sum[0] )
  1714. choice[ 0 ] = 3;
  1715.     break;
  1717.   case 5:
  1718.     sum[ 1 ] = count_bit( ix, begin, end, 6 );
  1719.     if ( sum[1] <= sum[0] )
  1720. choice[ 0 ] = 6;
  1721.     break;
  1723.   case 7:
  1724.     sum[ 1 ] = count_bit( ix, begin, end, 8 );
  1725.     if ( sum[1] <= sum[0] )
  1726.     {
  1727. choice[ 0 ] = 8;
  1728. sum[ 0 ] = sum[ 1 ];
  1729.     }
  1730.     sum[ 1 ] = count_bit( ix, begin, end, 9 );
  1731.     if ( sum[1] <= sum[0] )
  1732. choice[ 0 ] = 9;
  1733.     break;
  1735.   case 10:
  1736.     sum[ 1 ] = count_bit( ix, begin, end, 11 );
  1737.     if ( sum[1] <= sum[0] )
  1738.     {
  1739. choice[ 0 ] = 11;
  1740. sum[ 0 ] = sum[ 1 ];
  1741.     }
  1742.     sum[ 1 ] = count_bit( ix, begin, end, 12 );
  1743.     if ( sum[1] <= sum[0] )
  1744. choice[ 0 ] = 12;
  1745.     break;
  1747.   case 13:
  1748.     sum[ 1 ] = count_bit( ix, begin, end, 15 );
  1749.     if ( sum[1] <= sum[0] )
  1750. choice[ 0 ] = 15;
  1751.     break;
  1753.   default:
  1754.     break;
  1755. }
  1756.     }
  1757.     else
  1758.     {
  1759. /* try tables with linbits */
  1760. max -= 15;
  1762. for ( i = 15; i < 24; i++ )
  1763. {
  1764.     if ( ht[i].linmax >= max )
  1765.     {
  1766. choice[ 0 ] = i;
  1767. break;
  1768.     }
  1769. }
  1770. for ( i = 24; i < 32; i++ )
  1771. {
  1772.     if ( ht[i].linmax >= max )
  1773.     {
  1774. choice[ 1 ] = i;
  1775. break;
  1776.     }
  1777. }
  1778. assert( choice[0] );
  1779. assert( choice[1] );
  1781. sum[ 0 ] = count_bit( ix, begin, end, choice[0] );
  1782. sum[ 1 ] = count_bit( ix, begin, end, choice[1] );
  1783. if ( sum[1] < sum[0] )
  1784.     choice[ 0 ] = choice[ 1 ];
  1785.     }
  1786.     return choice[ 0 ];
  1787. }
  1791. /*************************************************************************/
  1792. /*            choose table                                               */
  1793. /*************************************************************************/
  1795. int choose_table( int max )
  1796. {
  1797.     int  i, choice;
  1799.     if ( max == 0 )
  1800.         return 0;
  1801.     
  1802.     max = abs( max );    
  1803.     choice = 0;
  1805.     if ( max < 15 )
  1806.     {
  1807.         for ( i = 0; i < 15; i++ )
  1808.         {
  1809.             if ( ht[i].xlen > max )
  1810.             {
  1811. choice = i;
  1812. break;
  1813.             }
  1814.         }
  1815.     }
  1816.     else
  1817.     {
  1818. max -= 15;
  1819. for (i = 15; i < 32; i++ )
  1820. {
  1821.     if ( ht[i].linmax >= max )
  1822.     {
  1823. choice = i;
  1824. break;
  1825.     }
  1826. }
  1827.     }
  1828.     assert( choice );
  1829.     return choice;
  1830. }
  1833. /*************************************************************************/
  1834. /*            bigv_bitcount                                              */
  1835. /*************************************************************************/
  1837. /*
  1838. Function: Count the number of bits necessary to code the bigvalues region.
  1839. */
  1841. int bigv_bitcount( int ix[576], gr_info *gi )
  1842. {
  1843.     int bits = 0;
  1844.     
  1845.     if ( gi->window_switching_flag && gi->block_type == 2 )
  1846.     {
  1847.         /*
  1848.           Within each scalefactor band, data is given for successive
  1849.           time windows, beginning with window 0 and ending with window 2.
  1850.           Within each window, the quantized values are then arranged in
  1851.           order of increasing frequency...
  1852.           */
  1853.         int sfb, window, line, start, end;
  1854.         I192_3 *ix_s;
  1856.         if ( gi->mixed_block_flag )
  1857.         {
  1858.             unsigned int table;
  1860.             if ( (table = gi->table_select[0]) != 0 )
  1861.                 bits += count_bit( ix, 0, gi->address1, table );
  1862.             sfb = 2;
  1863.         }
  1864.         else
  1865.             sfb = 0;
  1867.         ix_s = (I192_3 *) &ix[0];
  1869.         for ( ; sfb < 13; sfb++ )
  1870.         {
  1871.             unsigned tableindex = 100;
  1873.             start = scalefac_band_short[ sfb ];
  1874.             end   = scalefac_band_short[ sfb+1 ];
  1876.             if ( start < 12 )
  1877.                 tableindex = gi->table_select[ 0 ];
  1878.             else
  1879.                 tableindex = gi->table_select[ 1 ];
  1880.             assert( tableindex < 32 );
  1882.             for ( window = 0; window < 3; window++ )
  1883.                 for ( line = start; line < end; line += 2 )
  1884.                 {
  1885.                     unsigned int code, ext;
  1886.                     int cbits, xbits;
  1887.                     int x = (*ix_s)[line][window];
  1888.                     int y = (*ix_s)[line + 1][window];
  1889.                     bits += HuffmanCode( tableindex, x, y, &code, &ext, &cbits, &xbits );
  1890.                 }
  1891.         }
  1892.     }
  1893.     else
  1894.     {
  1895.         unsigned int table;
  1896.         
  1897.         if( (table=gi->table_select[0]) != 0 )  /* region0 */ 
  1898.             bits += count_bit(ix, 0, gi->address1, table );
  1899.         if( (table=gi->table_select[1]) != 0 )  /* region1 */ 
  1900.             bits += count_bit(ix, gi->address1, gi->address2, table );
  1901.         if( (table=gi->table_select[2]) != 0 )  /* region2 */ 
  1902.             bits += count_bit(ix, gi->address2, gi->address3, table );
  1903.     }
  1904.     return bits;
  1905. }
  1909. /*************************************************************************/
  1910. /*            count_bit                                                  */
  1911. /*************************************************************************/
  1913. /*
  1914.  Function: Count the number of bits necessary to code the subregion. 
  1915. */
  1917. int count_bit( int ix[576], unsigned int start, unsigned int end, unsigned int table )
  1918. {
  1919.     int i, sum;
  1921.     sum = 0;
  1922.     for ( i = start; i < end; i += 2 )
  1923.     {
  1924.         unsigned int code, ext;
  1925.         int cbits, xbits;
  1926.         sum += HuffmanCode( table, ix[i], ix[i+1], &code, &ext, &cbits, &xbits );
  1927.     }
  1928.     return sum;
  1929. }
  1933. #ifndef HAVE_NINT
  1934. int
  1935. nint( double in )
  1936. {
  1937.     int    temp;
  1939.     if( in < 0 )  temp = (int)(in - 0.5);
  1940.     else    temp = (int)(in + 0.5);
  1942.     return(temp);
  1943. }
  1945. double
  1946. aint(double in) {
  1947. return((long) in);
  1948. }
  1949. #endif
  1953. /*
  1954.   Seymour's comment:  Jan 8 1995
  1955.   When mixed_block_flag is set, the low subbands 0-1 undergo the long
  1956.   window transform and are each split into 18 frequency lines, while
  1957.   the remaining 30 subbands undergo the short window transform and are
  1958.   each split into 6 frequency lines. A problem now arises, as neither
  1959.   the short or long scale factor bands apply to this mixed spectrum.
  1960.   The standard resolves this situation by using the first 8 long scale
  1961.   factor bands for the low spectrum and the short scale factor bands
  1962.   in the range of 3 to 11 (inclusive) for the remaining frequency lines.
  1963.   These scale factor bands do not match exactly to the 0-1 subbands
  1964.   for all sampling frequencies (32,44.1 and 48 kHz); however they
  1965.   were designed so that there would not be a frequency gap or overlap
  1966.   at the switch over point. (Note multiply short frequency lines by 3
  1967.   to account for wider frequency line.) 
  1968.   */
  1972. /*************************************************************************/
  1973. /*            gr_deco                                                    */
  1974. /*************************************************************************/
  1976. void gr_deco( gr_info *cod_info )
  1977. {
  1978.     if ( cod_info->window_switching_flag != 0 && cod_info->block_type == 2 )
  1979.         if ( cod_info->mixed_block_flag == 0 )
  1980.         {
  1981.             cod_info->sfb_lmax = 0; /* No sb*/
  1982.             cod_info->sfb_smax = 0;
  1983.         }
  1984.         else
  1985.         {
  1986.             cod_info->sfb_lmax = 8;
  1987.             cod_info->sfb_smax = 3;
  1988.         }
  1989.     else
  1990.     {
  1991.         cod_info->sfb_lmax = SFB_LMAX - 1;
  1992.         cod_info->sfb_smax = SFB_SMAX - 1;    /* No sb */
  1993.     }
  1994. }
  2003. /* The following optional code written by Seymour Shlien
  2004.    will speed up the outer_loop code which is called
  2005.    by iteration_loop. When BIN_SEARCH is defined, the
  2006.    outer_loop function precedes the call to the function inner_loop
  2007.    with a call to bin_search gain defined below, which
  2008.    returns a good starting quantizerStepSize.
  2009. */
  2011. #if defined(BIN_SEARCH) || defined(PERFORM) 
  2012. int count_bits(ix,cod_info)  
  2013. int  *ix; /*  I576  *ix; */
  2014. gr_info *cod_info;
  2015. {
  2016. int bits,max;
  2017.   calc_runlen(ix,cod_info); /*rzero,count1,big_values*/
  2018.   max = ix_max( ix, 0,576);
  2019.   if(max > 8192) return 100000;         /* report unsuitable quantizer */
  2020.   bits = count1_bitcount(ix, cod_info); /*count1_table selection*/
  2021.   subdivide(cod_info); /* bigvalues sfb division */
  2022.   bigv_tab_select(ix,cod_info); /* codebook selection*/
  2023.   bits += bigv_bitcount(ix,cod_info); /* bit count */
  2024. /* printf("nglobal_gain = %f  bits= %d ",cod_info->quantizerStepSize,bits);*/
  2025. return bits;
  2026. }
  2027. #endif
  2030. #ifdef BIN_SEARCH
  2032. int bin_search_StepSize(int desired_rate, double start, int *ix,
  2033.            double xrs[576], gr_info * cod_info)
  2034. {
  2035. double top,bot,next,last;
  2036. int bit;
  2037. top = start;
  2038. bot = 200;
  2039. next = start;
  2040. do
  2041.   {
  2042.   last = next;
  2043.   next = aint((top+bot)/2.0);
  2044.   cod_info->quantizerStepSize = next;
  2045.   quantize(xrs,ix,cod_info);
  2046.   bit = count_bits(ix,cod_info);
  2047.   if (bit>desired_rate) top = next;
  2048.   else bot = next;
  2049. /*  printf("n%f %f %f %d %d",next, top,bot,bit,desired_rate);*/
  2050.   }
  2051.   while ((bit != desired_rate) && fabs(last - next) > 1.0);
  2052. return next;
  2053. }
  2055. #endif
  2060. #ifdef PERFORM
  2062. /* The following code is used for exposing some problems with
  2063.    the outer_loop code. PERFORM should be defined to the
  2064.    frame number you wish to have additional output recorded
  2065.    in the file encode.log  - Seymour Shlien 14-Jan-97
  2066. */
  2068. /*
  2069. float worst_xfsf_to_xmin_ratio(l3_xmin,xfsf,block_type,gr,ch)
  2070. double xfsf[4][CBLIMIT];
  2071. III_psy_xmin *l3_xmin;
  2072. int block_type,gr,ch;
  2073. */
  2074. float worst_xfsf_to_xmin_ratio(III_psy_xmin *l3_xmin, double xfsf[4][CBLIMIT]
  2075.                              ,int block_type,int gr,int ch)
  2077. {
  2078. float ratio,maxratio;
  2079. int i,j;
  2080. maxratio =-100.0;
  2081. if (block_type != 2)
  2082.   for(i=0;i<21;i++)
  2083.     {
  2084.     ratio = 10.*log10(xfsf[0][i] /l3_xmin->l[gr][ch][i]);
  2085.     if (ratio > maxratio) maxratio = ratio;
  2086.     }
  2087. else
  2088.   {
  2089.   for(j=0;j<3;j++)
  2090. /* for(i = cod_info->sfb_smax; i <SFB_SMAX; i++) */
  2091.      for(i = 0; i <11; i++)
  2092.     {
  2093.     ratio = 10.*log10(xfsf[j+1][i] /l3_xmin->s[gr][ch][i][j]);
  2094.     if (ratio > maxratio) maxratio = ratio;
  2095.     }
  2096.   }
  2097. return maxratio;
  2098. }
  2099.  
  2101. print_ratios(handle_out,l3_xmin,xfsf,block_type,gr,ch)
  2102. FILE *handle_out;
  2103. double xfsf[4][CBLIMIT];
  2104. III_psy_xmin *l3_xmin;
  2105. int gr,ch;
  2106. int block_type;
  2107. {
  2108. float ratio;
  2109. int i,j;
  2110. if(block_type !=2)
  2111.  for (i=0;i<21;i++)
  2112.   {
  2113.    ratio = 100.0; /* signals undefined value in output */
  2114.    if(l3_xmin->l[gr][ch][i] >1.0e-20)
  2115.      ratio = 10.*log10(xfsf[0][i] /l3_xmin->l[gr][ch][i]);
  2116.    fprintf(handle_out,"%6.2f ",ratio);
  2117.    if(i%5==4) fprintf(handle_out,"n");
  2118.   }
  2119. else
  2120.   
  2121.   for(j=0;j<3;j++)
  2122.    { fprintf(handle_out,"n  block %dn",j);
  2123.      for(i = 0; i <11; i++)
  2124.       {
  2125.       ratio = 10.*log10(xfsf[j+1][i] /l3_xmin->s[gr][ch][i][j]);
  2126.       fprintf(handle_out,"%6.2f ",ratio);
  2127.       if(i%5==4) fprintf(handle_out,"n");
  2128.       }
  2129.    }
  2130. fprintf(handle_out,"n");
  2131. }
  2134. print_scalefacs(handle_out,scalefac,block_type,gr,ch)
  2135. FILE *handle_out;
  2136. III_scalefac_t *scalefac;
  2137. int gr,ch;
  2138. int block_type;
  2139. {
  2140. int sfb,j;
  2142. if(block_type !=2)
  2143.  for ( sfb = 0; sfb < 21; sfb++ )
  2144.    {
  2145.    fprintf(handle_out,"%6d ", scalefac->l[gr][ch][sfb]);    
  2146.    if(sfb%5==4) fprintf(handle_out,"n");
  2147.    }
  2148. else
  2149.  for (j=0;j<3;j++)
  2150.   {
  2151.   fprintf(handle_out,"n block %dn",j);
  2152.   for (sfb=0;sfb<11;sfb++)
  2153.    {
  2154.    fprintf(handle_out,"%6d ",scalefac->s[gr][ch][sfb][j]);
  2155.    if(sfb%5==4) fprintf(handle_out,"n");
  2156.    }
  2157.   }
  2158. fprintf(handle_out,"n");
  2159. }
  2162. print_quantized_values(FILE *handle, int ix[576], gr_info *cod_info)
  2163. {
  2164. int sfb,start,end,i,bw;
  2165. for (sfb=0;sfb<cod_info->sfb_lmax;sfb++)
  2166.   {
  2167.   start = scalefac_band_long[sfb];
  2168.   end = scalefac_band_long[sfb+1];
  2169.   bw = end - start;
  2170.   fprintf(handle,"scalefac band %d from %d to %dn",sfb,start,end);
  2171.   for (i=0;i<bw;i++)
  2172.     {
  2173.     fprintf(handle,"%8d",ix[start+i]);
  2174.     if(i%5==4) fprintf(handle,"n");
  2175.     }
  2176.   fprintf(handle,"n");
  2177.   }
  2178. }
  2181. test_inner_loop(double xr[2][2][576], int l3_enc[2][2][576], int max_bits,
  2182.             gr_info *cod_info, int gr, int ch, double xfsf[4][CBLIMIT], 
  2183.             III_psy_xmin  *l3_xmin) 
  2184. {
  2185.     int bits, c1bits, bvbits;
  2186.     double *xrs;  /*  D576  *xr; */
  2187.     int *ix;  /*  I576  *ix; */
  2188.     xrs = &xr[gr][ch][0];
  2189.     ix = l3_enc[gr][ch];
  2190.  
  2191.     assert( max_bits >= 0 );
  2192.     cod_info->quantizerStepSize -= 1.0;;
  2193.     do
  2194.     {
  2195.         do
  2196.         {
  2197.             cod_info->quantizerStepSize += 1.0;
  2198.             quantize( xrs, ix, cod_info );
  2199.         }  
  2200.         while ( ix_max(ix, 0, 576) > 8191 + 14 ); /* within table range? */
  2201.  
  2202.     bits = count_bits(ix,cod_info);       
  2204.         if(frameNum == PERFORM)
  2205.         {
  2206.           fprintf(log_output,"StepSize=%f bits = %d huff_bits = %dn",
  2207.             cod_info->quantizerStepSize,bits,max_bits);
  2208.           calc_noise( &xr[gr][ch][0], &l3_enc[gr][ch][0], cod_info, xfsf );
  2209.                                              /* distortion calculation */
  2210.           print_ratios(log_output,l3_xmin,xfsf,cod_info->block_type,gr,ch);
  2211.           fprintf(log_output,"nn");
  2212.           }
  2214.     }
  2215.     while ( bits > max_bits );
  2216.  
  2217.     return bits;
  2218. }
  2219.  
  2220. #endif PERFORM