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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > mpeg/mp3 > 查看源码
loop.c
资源名称：bladeenc-0.90.0-src.zip　[点击查看]
上传用户：bjsgzm
上传日期：2007-01-08
资源大小：256k
文件大小：50k
源码类别：

mpeg/mp3

开发平台：

Visual C++

loop.c：源码内容
  1. /*
  2. (c) Copyright 1998, 1999 - Tord Jansson
  3. =======================================
  5. This file is part of the BladeEnc MP3 Encoder, based on
  6. ISO's reference code for MPEG Layer 3 compression, and might
  7. contain smaller or larger sections that are directly taken
  8. from ISO's reference code.
  10. All changes to the ISO reference code herein are either
  11. copyrighted by Tord Jansson (tord.jansson@swipnet.se)
  12. or sublicensed to Tord Jansson by a third party.
  14. BladeEnc is free software; you can redistribute this file
  15. and/or modify it under the terms of the GNU Lesser General Public
  16. License as published by the Free Software Foundation; either
  17. version 2.1 of the License, or (at your option) any later version.
  19. */
  21. #include <stdio.h>
  22. #include <stdlib.h>
  23. #include <math.h>
  24. #include <assert.h>
  25. #include "system.h"
  26. #include "l3side.h"
  27. #include "loop.h"
  28. #include "huffman.h"
  29. #include "l3bitstream.h"
  30. #include "reservoir.h"
  31. #include "loop-pvt.h"
  34. int bin_search_StepSize(int desired_rate, double start, int ix[576],
  35.            double xrs[576], gr_info * cod_info);
  36. int count_bits();
  37. float worst_xfsf_to_xmin_ratio();
  39. int optimized_calculations_tj( int * abs_ix, gr_info *cod_info );
  40. int bigv_bitcount_tj( int * abs_ix, gr_info *gi );
  42. /*
  43.   Here are MPEG1 Table B.8 and MPEG2 Table B.1
  44.   -- Layer III scalefactor bands.
  45.   Index into this using a method such as:
  46.     idx  = fr_ps->header->sampling_frequency
  47.            + (fr_ps->header->version * 3)
  48. */
  50. struct scalefac_struct sfBandIndex[3] =
  51. {
  52.   { /* Table B.8.b: 44.1 kHz */
  53.     {0,4,8,12,16,20,24,30,36,44,52,62,74,90,110,134,162,196,238,288,342,418,576},
  54.     {0,4,8,12,16,22,30,40,52,66,84,106,136,192}
  55.   },
  56.   { /* Table B.8.c: 48 kHz */
  57.     {0,4,8,12,16,20,24,30,36,42,50,60,72,88,106,128,156,190,230,276,330,384,576},
  58.     {0,4,8,12,16,22,28,38,50,64,80,100,126,192}
  59.   },
  60.   { /* Table B.8.a: 32 kHz */
  61.     {0,4,8,12,16,20,24,30,36,44,54,66,82,102,126,156,194,240,296,364,448,550,576},
  62.     {0,4,8,12,16,22,30,42,58,78,104,138,180,192}
  63.   }
  64. };
  66. /*
  67.   The following table is used to implement the scalefactor
  68.   partitioning for MPEG2 as described in section
  69.   2.4.3.2 of the IS. The indexing corresponds to the
  70.   way the tables are presented in the IS:
  72.   [table_number][row_in_table][column of nr_of_sfb]
  73. */
  74. static unsigned nr_of_sfb_block[6][3][4] =
  75. {
  76.   {
  77.     {6, 5, 5, 5},
  78.     {9, 9, 9, 9},
  79.     {6, 9, 9, 9}
  80.   },
  81.   {
  82.     {6, 5, 7, 3},
  83.     {9, 9, 12, 6},
  84.     {6, 9, 12, 6}
  85.   },
  86.   {
  87.     {11, 10, 0, 0},
  88.     {18, 18, 0, 0},
  89.     {15,18,0,0}
  90.   },
  91.   {
  92.     {7, 7, 7, 0},
  93.     {12, 12, 12, 0},
  94.     {6, 15, 12, 0}
  95.   },
  96.   {
  97.     {6, 6, 6, 3},
  98.     {12, 9, 9, 6},
  99.     {6, 12, 9, 6}
  100.   },
  101.   {
  102.     {8, 8, 5, 0},
  103.     {15,12,9,0},
  104.     {6,18,9,0}
  105.   }
  106. };
  109. /* Table B.6: layer3 preemphasis */
  110. int  pretab[21] =
  111. {
  112.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  113.     1, 1, 1, 1, 2, 2, 3, 3, 3, 2
  114. };
  116. /* This is the scfsi_band table from 2.4.2.7 of the IS */
  117. int scfsi_band_long[5] = { 0, 6, 11, 16, 21 };
  119. int *scalefac_band_long  = &sfBandIndex[0].l[0];
  120. int *scalefac_band_short = &sfBandIndex[0].s[0];
  124. int fInit_iteration_loop;
  125. int fInit_huffman_read_flag; 
  127. int tjBitOverflow1;
  128. int tjBitOverflow2;
  131. void fixStatic_loop( void )
  132. {
  133. scalefac_band_long  = &sfBandIndex[0].l[0];
  134. scalefac_band_short = &sfBandIndex[0].s[0];
  135. }
  139. /************************************************************************/
  140. /*  iteration_loop()                                                    */
  141. /************************************************************************/
  142. void
  143. iteration_loop( double pe[][2], double xr_org[2][2][576], III_psy_ratio *ratio,
  144. III_side_info_t *l3_side, int l3_enc[2][2][576],
  145. int mean_bits, int stereo, double xr_dec[2][2][576],
  146. III_scalefac_t *scalefac, frame_params *fr_ps,
  147. int ancillary_pad, int bitsPerFrame ) 
  148. {
  149.   III_psy_xmin l3_xmin;
  150.   gr_info *cod_info;
  151.   layer *info;
  152.   int *main_data_begin;
  154.   int max_bits;
  155.   int ch, gr, sfb, i, mode_gr;
  157.   double xr[2][2][576];
  158.   I576  *ix;
  160.   main_data_begin = &l3_side->main_data_begin;
  161.   l3_side->resvDrain = 0;
  163.   if ( !fInit_iteration_loop )
  164.   {
  165. *main_data_begin = 0;
  166. fInit_iteration_loop = 1;
  167.   }
  169.   info = fr_ps->header;
  170.   mode_gr = 2;
  172.   scalefac_band_long  = &sfBandIndex[info->sampling_frequency].l[0];
  173.   scalefac_band_short = &sfBandIndex[info->sampling_frequency].s[0];
  175.   /* reading huffman code table */
  176.   if (fInit_huffman_read_flag == 0) 
  177. {
  178.     read_huffcodetab();
  179.     fInit_huffman_read_flag++;
  180.   }
  183.   for ( gr = 0; gr < mode_gr; gr++ )
  184.   {
  185.     for ( ch = 0; ch < stereo; ch++ )
  186. {
  187.       for ( i = 0; i < 576; i++ ) 
  188.         xr[gr][ch][i] = xr_org[gr][ch][i];
  189. }
  190.   }
  192.   ResvFrameBegin( fr_ps, l3_side, mean_bits, bitsPerFrame );
  194.   for ( gr = 0; gr < mode_gr; gr++ )
  195.   {
  196.     for ( ch = 0; ch < stereo; ch++ )
  197.     {
  198.       ix = (I576 *) l3_enc[gr][ch];
  199.       cod_info = (gr_info *) &(l3_side->gr[gr].ch[ch]);
  200.       gr_deco(cod_info);
  201.       calc_xmin( xr, ratio, cod_info, &l3_xmin, gr, ch );
  204.       calc_scfsi( xr[gr][ch], l3_side, &l3_xmin, ch, gr );
  206.       /* calculation of number of available bit( per granule ) */
  207.   max_bits = ResvMaxBits( fr_ps, l3_side, &pe[gr][ch], mean_bits );
  208.   
  209.       /* reset of iteration variables */
  211.       for ( sfb = 0; sfb < 21; sfb++ )
  212.         scalefac->l[gr][ch][sfb] = 0;
  213.       for ( sfb = 0; sfb < 13; sfb++ )
  214.         for ( i = 0; i < 3; i++ )
  215.           scalefac->s[gr][ch][sfb][i] = 0;
  217.   for ( i = 0; i < 4; i++ )
  218. cod_info->slen[i] = 0;
  219.   cod_info->sfb_partition_table = &nr_of_sfb_block[0][0][0];
  221.       cod_info->part2_3_length    = 0;
  222.       cod_info->big_values        = 0;
  223.       cod_info->count1            = 0;
  224.       cod_info->scalefac_compress = 0;
  225.       cod_info->table_select[0]   = 0;
  226.       cod_info->table_select[1]   = 0;
  227.       cod_info->table_select[2]   = 0;
  228.       cod_info->subblock_gain[0]  = 0;
  229.       cod_info->subblock_gain[1]  = 0;
  230.       cod_info->subblock_gain[2]  = 0;
  231.       cod_info->region0_count     = 0;
  232.       cod_info->region1_count     = 0;
  233.       cod_info->part2_length      = 0;
  234.       cod_info->preflag           = 0;
  235.       cod_info->scalefac_scale    = 0;
  236.       cod_info->quantizerStepSize = 0.0;
  237.       cod_info->count1table_select= 0;
  238.           
  239.       /* all spectral values zero ? */
  240.       if ( xr_max(xr[gr][ch]) != 0.0 )
  241.       {
  242.         cod_info->quantizerStepSize = (double) quantanf_init( xr[gr][ch] );
  243.         cod_info->part2_3_length = outer_loop( xr, max_bits, &l3_xmin,
  244.                                                l3_enc, fr_ps, scalefac,
  245.                                                gr, ch, l3_side );
  246.       }
  247. ResvAdjust( fr_ps, cod_info, l3_side, mean_bits );
  249. cod_info->global_gain = nint( cod_info->quantizerStepSize + 210.0 );
  250. /* assert( cod_info->global_gain < 256 ); */
  251.     } /* for ch */
  252.   } /* for gr */
  253.   ResvFrameEnd( fr_ps, l3_side, mean_bits );
  254. }
  258. /************************************************************************/
  259. /*  quantanf_init                                                       */
  260. /************************************************************************/
  261. int quantanf_init( double xr[576] )
  262. /* Function: Calculate the first quantization step quantanf.       */
  263. {
  264.     int i, tp = 0;
  265.     double system_const, minlimit;
  266.     double sfm = 0.0, sum1 = 0.0, sum2 = 0.0;
  267.     
  268.     system_const = 8.0;
  269.     minlimit = -100.0;
  271.     for ( i = 0; i < 576; i++ )
  272.     {
  273.         if ( xr[i] != 0 )
  274. {
  275.             double tpd = xr[i] * xr[i];
  276.             sum1 += log( tpd );
  277.             sum2 += tpd;
  278.         }
  279.     }
  280.     if ( sum2 != 0.0 )
  281.     {
  282.         sfm = exp( sum1 / 576.0 ) / (sum2 / 576.0);
  283.         tp = nint( system_const * log(sfm) );
  284. if ( tp < minlimit )
  285.     tp = minlimit;
  286.     }
  287.       return(tp-70.0); /* SS 19-12-96. Starting value of
  288.                           global_gain or quantizerStepSize 
  289.                           has to be reduced for iteration_loop
  290.                        */
  291. }
  298. /************************************************************************/
  299. /*  outer_loop                                                          */
  300. /************************************************************************/
  301. /*  Function: The outer iteration loop controls the masking conditions  */
  302. /*  of all scalefactorbands. It computes the best scalefac and          */
  303. /*  global gain. This module calls the inner iteration loop             */
  304. /************************************************************************/
  305. int outer_loop(
  306.   double xr[2][2][576],     /*  magnitudes of the spectral values */
  307.   int max_bits,
  308.   III_psy_xmin  *l3_xmin,   /* the allowed distortion of the scalefactor */
  309.   int l3_enc[2][2][576],    /* vector of quantized values ix(0..575) */
  310.   frame_params *fr_ps,
  311.   III_scalefac_t *scalefac, /* scalefactors */
  312.   int gr, int ch, III_side_info_t *l3_side )
  313. {
  314.   int status ;
  315.   int scalesave_l[CBLIMIT], scalesave_s[CBLIMIT][3];
  316.   int sfb, bits, huff_bits, save_preflag, save_compress;
  317.   double xfsf[4][CBLIMIT];
  318.   int i, over, iteration;
  322.   double *xrs; 
  323.   int *ix;  
  324.   gr_info *cod_info = &l3_side->gr[gr].ch[ch].tt;
  326.  
  328. xrs = (double *) &(xr[gr][ch][0]); 
  329. ix  = (int *) &(l3_enc[gr][ch][0]);
  331.   iteration = 0;
  332.   do 
  333.   {
  334. iteration += 1;
  335. cod_info->part2_length = part2_length( scalefac, fr_ps, gr, ch, l3_side );
  336.     huff_bits = max_bits - cod_info->part2_length;
  338. if(iteration == 1)
  339.     {
  340. bin_search_StepSize(max_bits,cod_info->quantizerStepSize,
  341.         ix,xrs,cod_info); /* speeds things up a bit */
  342.     }
  344.     bits = inner_loop( &xr[gr][ch][0], &l3_enc[gr][ch][0], huff_bits, cod_info );
  346.     calc_noise( &xr[gr][ch][0], &l3_enc[gr][ch][0], cod_info, xfsf ); /* distortion calculation */
  348.     for ( sfb = 0; sfb < CBLIMIT; sfb++ ) /* save scaling factors */
  349.       scalesave_l[sfb] = scalefac->l[gr][ch][sfb];
  351.     for ( sfb = 0; sfb < SFB_SMAX; sfb++ )
  352.       for ( i = 0; i < 3; i++ )
  353.         scalesave_s[sfb][i] = scalefac->s[gr][ch][sfb][i];
  355.     save_preflag  = cod_info->preflag;
  356.     save_compress = cod_info->scalefac_compress;
  358.     preemphasis( &xr[gr][ch][0], xfsf, l3_xmin, gr, ch, l3_side );
  362.     over = amp_scalefac_bands( &xr[gr][ch][0], xfsf, l3_xmin,
  363.                                l3_side, scalefac, gr, ch, iteration );
  365.   if ( (status = loop_break(scalefac, cod_info, gr, ch)) == 0 )
  366. {
  367. status = scale_bitcount( scalefac, cod_info, gr, ch );
  368. }
  370.   }
  371.   while ( (status == 0) && (over > 0) );
  373.   cod_info->preflag = save_preflag;
  374.   cod_info->scalefac_compress = save_compress;
  376.   for ( sfb = 0; sfb < 21; sfb++ )
  377.     scalefac->l[gr][ch][sfb] = scalesave_l[sfb];    
  379.   for ( i = 0; i < 3; i++ )
  380.     for ( sfb = 0; sfb < 12; sfb++ )
  381.       scalefac->s[gr][ch][sfb][i] = scalesave_s[sfb][i];    
  383.   cod_info->part2_length   = part2_length( scalefac, fr_ps, gr, ch, l3_side );
  384.   cod_info->part2_3_length = cod_info->part2_length + bits;
  386.   return cod_info->part2_3_length;
  387. }
  392. /***************************************************************************
  393. *         inner_loop                                                      *
  394. ***************************************************************************
  395. * The code selects the best quantizerStepSize for a particular set
  396. * of scalefacs                                                            */
  397.  
  400. int inner_loop( double* xrs, int *ix, int max_bits, gr_info *cod_info )
  401. {
  402.     int bits;
  405.     cod_info->quantizerStepSize -= 1.0;
  406.     do
  407.     {
  408. do
  409.         {
  410. cod_info->quantizerStepSize += 1.0;
  411. tjBitOverflow2 = FALSE;
  412. quantize_tj( xrs, ix, cod_info );
  413.         }
  414.         while ( tjBitOverflow2 == TRUE ); /* within table range? */
  416. bits = optimized_calculations_tj( ix, cod_info );
  417.         subdivide( cod_info );  /* bigvalues sfb division */
  418.         bigv_tab_select_tj( ix, cod_info );  /* codebook selection*/
  419.         bits += bigv_bitcount_tj( ix, cod_info );  /* bit count */
  421.     }
  422.     while ( bits > max_bits );
  424.     return bits;
  425. }
  429. /***************************************************************************/ 
  430. /*        calc_scfsi                                                       */ 
  431. /***************************************************************************/ 
  432. /* calculation of the scalefactor select information ( scfsi )        */
  434. void calc_scfsi( double  xr[576], III_side_info_t *l3_side,
  435.     III_psy_xmin *l3_xmin, int ch, int gr )
  436. {
  437.     static int en_tot[2][2]; /* ch,gr */
  438.     static int en[2][2][21];
  439.     static int xm[2][2][21];
  440.     static int xrmax[2][2];
  442.     int en_tot_krit        = 10;
  443.     int en_dif_krit        = 100;
  444.     int en_scfsi_band_krit = 10;
  445.     int xm_scfsi_band_krit = 10;
  447.     int scfsi_band;
  448.     unsigned scfsi_set;
  450.     int sfb, start, end, i;
  451.     int condition = 0;
  452.     double temp, log2 = log( 2.0 );
  453.     gr_info *cod_info = &l3_side->gr[gr].ch[ch].tt;
  455.     xrmax[gr][ch] = xr_max( xr );
  456.     scfsi_set = 0;
  458.     /* the total energy of the granule */    
  459.     for ( temp = 0.0, i = 0; i < 576; i++ )
  460.         temp += xr[i] * xr[i];
  461.     if ( temp == 0.0 )
  462.         en_tot[gr][ch] = 0.0;
  463.     else
  464.         en_tot[gr][ch] = log( temp ) / log2 ;
  466.     /* the energy of each scalefactor band, en */
  467.     /* the allowed distortion of each scalefactor band, xm */
  469.     if ( cod_info->window_switching_flag == 0 ||
  470.          cod_info->block_type != 2 )
  471.         for ( sfb = 0; sfb < 21; sfb++ )
  472.         {
  473.             start = scalefac_band_long[ sfb ];
  474.             end   = scalefac_band_long[ sfb+1 ];
  476.             for ( temp = 0.0, i = start; i < end; i++ )
  477.                 temp += xr[i] * xr[i];
  478.             if ( temp == 0.0 )
  479.                 en[gr][ch][sfb] = 0.0;
  480.             else
  481.                 en[gr][ch][sfb] = log( temp )/ log2;
  483.             if ( l3_xmin->l[gr][ch][sfb] == 0.0 )
  484.                 xm[gr][ch][sfb] = 0.0;
  485.             else
  486.                 xm[gr][ch][sfb] = log( l3_xmin->l[gr][ch][sfb] ) / log2;
  487.         }
  488.     if ( gr == 1 )
  489.     {
  490.         int gr2, tp;
  492.         for ( gr2 = 0; gr2 < 2; gr2++ )
  493.         {
  494.             /* The spectral values are not all zero */
  495.             if ( xrmax[ch][gr2] != 0.0 )
  496.                 condition++;
  497.             /* None of the granules contains short blocks */
  498.             if ( (cod_info->window_switching_flag == 0) ||
  499.                  (cod_info->block_type != 2) )
  500.                 condition++;
  501.         }
  502.         if ( abs(en_tot[0] - en_tot[1]) < en_tot_krit )
  503.             condition++;
  504.         for ( tp = 0, sfb = 0; sfb < 21; sfb++ ) 
  505.             tp += abs( en[ch][0][sfb] - en[ch][1][sfb] );
  506.         if ( tp < en_dif_krit ) 
  507.             condition++;
  509.         if ( condition == 6 )
  510.         {
  511.             for ( scfsi_band = 0; scfsi_band < 4; scfsi_band++ )
  512.             {
  513.                 int sum0 = 0, sum1 = 0;
  514.                 l3_side->scfsi[ch][scfsi_band] = 0;
  515.                 start = scfsi_band_long[scfsi_band];
  516.                 end   = scfsi_band_long[scfsi_band+1];
  517.                 for ( sfb = start; sfb < end; sfb++ )
  518.                 { 
  519.                     sum0 += abs( en[ch][0][sfb] - en[ch][1][sfb] );
  520.                     sum1 += abs( xm[ch][0][sfb] - xm[ch][1][sfb] );
  521.                 }
  523.                 if ( sum0 < en_scfsi_band_krit && sum1 < xm_scfsi_band_krit )
  524. {
  525.                     l3_side->scfsi[ch][scfsi_band] = 1;
  526.     scfsi_set |= (1 << scfsi_band);
  527. }
  528.                 else
  529.                     l3_side->scfsi[ch][scfsi_band] = 0;
  530.             } /* for scfsi_band */
  531.         } /* if condition == 6 */
  532.         else
  533.             for ( scfsi_band = 0; scfsi_band < 4; scfsi_band++ )
  534.                 l3_side->scfsi[ch][scfsi_band] = 0;
  535.     } /* if gr == 1 */
  536. }
  540. /***************************************************************************/ 
  541. /*        part2_length                                                     */ 
  542. /***************************************************************************/ 
  544. /* calculates the number of bits needed to encode the scalefacs in the     */
  545. /* main data block                                                         */
  547. int part2_length( III_scalefac_t *scalefac, frame_params *fr_ps,
  548.       int gr, int ch, III_side_info_t *si )
  549. {
  550.   int slen1, slen2, bits;
  551.   gr_info *gi = &si->gr[gr].ch[ch].tt;
  554. static int slen1_tab[16] = { 0, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4 };
  555. static int slen2_tab[16] = { 0, 1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 2, 3 };
  557.   bits = 0;
  560. slen1 = slen1_tab[ gi->scalefac_compress ];
  561. slen2 = slen2_tab[ gi->scalefac_compress ];
  563. if ( (gi->window_switching_flag == 1) && (gi->block_type == 2) )
  564. {
  565.   if ( gi->mixed_block_flag )
  566.   {
  567. bits += (8 * slen1) + (9 * slen1) + (18 * slen2);
  568.   }
  569.   else
  570.   {
  571. bits += (18 * slen1) + (18 * slen2);
  572.   }
  573. }
  574. else
  575. {
  576.   if ( (gr == 0) || (si->scfsi[ch][0] == 0) )
  577. bits += (6 * slen1);
  579.   if ( (gr == 0) || (si->scfsi[ch][1] == 0) )
  580. bits += (5 * slen1);
  582.   if ( (gr == 0) || (si->scfsi[ch][2] == 0) )
  583. bits += (5 * slen2);
  585.   if ( (gr == 0) || (si->scfsi[ch][3] == 0) )
  586. bits += (5 * slen2);
  587. }
  588.     return bits;
  589. }
  593. /*************************************************************************/
  594. /*            scale_bitcount                                             */
  595. /*************************************************************************/
  598. /* Also calculates the number of bits necessary to code the scalefactors. */
  600. int scale_bitcount( III_scalefac_t *scalefac, gr_info *cod_info,
  601. int gr, int ch )
  602. {
  603.     int i, k, sfb, max_slen1 = 0, max_slen2 = 0, /*a, b, */ ep = 2;
  606.     static int slen1[16] = { 0, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4 };
  607.     static int slen2[16] = { 0, 1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 2, 3 };
  608.     static int pow2[5]   = { 1, 2, 4, 8, 16 };
  610.     if ( cod_info->window_switching_flag != 0 && cod_info->block_type == 2 )
  611.     {
  612.         if ( cod_info->mixed_block_flag == 0 ) 
  613.         {
  614.             /* a = 18; b = 18;  */
  615.             for ( i = 0; i < 3; i++ )
  616.             {
  617.                 for ( sfb = 0; sfb < 6; sfb++ )
  618.                     if ( scalefac->s[gr][ch][sfb][i] > max_slen1 )
  619.                         max_slen1 = scalefac->s[gr][ch][sfb][i];
  620.                 for (sfb = 6; sfb < 12; sfb++ )
  621.                     if ( scalefac->s[gr][ch][sfb][i] > max_slen2 )
  622.                         max_slen2 = scalefac->s[gr][ch][sfb][i];
  623.             }
  624.         }
  625.         else
  626.         {/* mixed_block_flag = 1 */
  627.             /* a = 17; b = 18;  */
  628.             for ( sfb = 0; sfb < 8; sfb++ )
  629.                 if ( scalefac->l[gr][ch][sfb] > max_slen1 )
  630.                     max_slen1 = scalefac->l[gr][ch][sfb];
  631.             for ( i = 0; i < 3; i++ )
  632.             {
  633.                 for ( sfb = 3; sfb < 6; sfb++ )
  634.                     if ( scalefac->s[gr][ch][sfb][i] > max_slen1 )
  635.                         max_slen1 = scalefac->s[gr][ch][sfb][i];
  636.                 for ( sfb = 6; sfb < 12; sfb++ )
  637.                     if ( scalefac->s[gr][ch][sfb][i] > max_slen2 )
  638.                         max_slen2 = scalefac->s[gr][ch][sfb][i];
  639.             }
  640.         }
  642.     }
  643.     else
  644.     { /* block_type == 1,2,or 3 */
  645.         /* a = 11; b = 10;   */
  646.         for ( sfb = 0; sfb < 11; sfb++ )
  647.             if ( scalefac->l[gr][ch][sfb] > max_slen1 )
  648.                 max_slen1 = scalefac->l[gr][ch][sfb];
  649.         for ( sfb = 11; sfb < 21; sfb++ )
  650.             if ( scalefac->l[gr][ch][sfb] > max_slen2 )
  651.                 max_slen2 = scalefac->l[gr][ch][sfb];
  652.     }
  654.     for ( k = 0; k < 16; k++ )
  655.     {
  656.         if ( (max_slen1 < pow2[slen1[k]]) && (max_slen2 < pow2[slen2[k]]) )
  657.         { 
  658.             ep = 0;
  659.             break;
  660.         } 
  661.     }
  663.     if ( ep == 0 )
  664.         cod_info->scalefac_compress = k;
  665.     return ep;
  666. }
  669. double noisePowTab[8191+15];
  672. void genNoisePowTab( void )
  673. {
  674. int i;
  676. for( i = 0 ; i < 8191+15 ; i++ )
  677. noisePowTab[i] = pow( i, 4.0/3.0 );
  678. }
  681. /*************************************************************************/
  682. /*            calc_noise                                                 */
  683. /*************************************************************************/
  685. /*   Function: Calculate the distortion introduced by the quantization   */
  686. /*   in each scale factor band.                                          */
  688. void calc_noise( double xr[576], int ix[576], gr_info *cod_info,
  689.     double xfsf[4][CBLIMIT] )
  690. {
  691.   int start, end, l, i;
  692. unsigned int sfb;
  693.   double sum,step,bw;
  695.   D192_3 *xr_s;
  696.   I192_3 *ix_s;
  698.   xr_s = (D192_3 *) xr;
  699.   ix_s = (I192_3 *) ix;
  701.   step = pow( 2.0, (cod_info->quantizerStepSize) * 0.25 );
  702.   for ( sfb = 0; sfb < cod_info->sfb_lmax; sfb++ )
  703.   {
  704.     start = scalefac_band_long[ sfb ];
  705.     end   = scalefac_band_long[ sfb+1 ];
  706. bw = end - start;
  708.     for ( sum = 0.0, l = start; l < end; l++ )
  709.     {
  710.       double temp;
  711.       temp = fabs( xr[l] ) - noisePowTab[ix[l]] * step;
  712.       sum += temp * temp; 
  713.     }
  714.     xfsf[0][sfb] = sum / bw;
  715.   }
  717.   for ( i = 0; i < 3; i++ )
  718.   {
  719.     for ( sfb = cod_info->sfb_smax; sfb < 12; sfb++ )
  720.     {
  721.       start = scalefac_band_short[ sfb ];
  722.       end   = scalefac_band_short[ sfb+1 ];
  723. bw = end - start;
  724.       
  725.       for ( sum = 0.0, l = start; l < end; l++ )
  726.       {
  727.         double temp;
  728.         temp = fabs( (*xr_s)[l][i] ) - noisePowTab[(*ix_s)[l][i]] * step;
  729.         sum += temp * temp;
  730.       }       
  731.       xfsf[i+1][sfb] = sum / bw;
  732.     }
  733.   }
  734. }
  739. /*************************************************************************/
  740. /*            calc_xmin                                                  */
  741. /*************************************************************************/
  743. /*
  744.   Calculate the allowed distortion for each scalefactor band,
  745.   as determined by the psychoacoustic model.
  746.   xmin(sb) = ratio(sb) * en(sb) / bw(sb)
  747. */
  749. void calc_xmin( double xr[2][2][576], III_psy_ratio *ratio,
  750.    gr_info *cod_info, III_psy_xmin *l3_xmin,
  751.    int gr, int ch )
  752. {
  753.     int start, end, l, b;
  754. uint sfb;
  755.     double en, bw;
  757.     D192_3 *xr_s;
  759.     xr_s = (D192_3 *) xr[gr][ch] ;
  761.     for ( sfb = cod_info->sfb_smax; sfb < SFB_SMAX - 1; sfb++ )
  762.     {
  763.         start = scalefac_band_short[ sfb ];
  764.         end   = scalefac_band_short[ sfb + 1 ];
  765. bw = end - start;
  766.         for ( b = 0; b < 3; b++ )
  767.         {
  768.             for ( en = 0.0, l = start; l < end; l++ )
  769.                 en += (*xr_s)[l][b] * (*xr_s)[l][b];
  770.             l3_xmin->s[gr][ch][sfb][b] = ratio->s[gr][ch][sfb][b] * en / bw;
  771.         }
  772.     }
  774.     for ( sfb = 0; sfb < cod_info->sfb_lmax; sfb++ )
  775.     {
  776.         start = scalefac_band_long[ sfb ];
  777.         end   = scalefac_band_long[ sfb+1 ];
  778. bw = end - start;
  780.         for ( en = 0.0, l = start; l < end; l++ )
  781.             en += xr[gr][ch][l] * xr[gr][ch][l];
  782.         l3_xmin->l[gr][ch][sfb] = ratio->l[gr][ch][sfb] * en / bw;
  783.     }
  784. }
  788. /*************************************************************************/
  789. /*            loop_break                                                 */
  790. /*************************************************************************/
  792. /*  Function: Returns zero if there is a scalefac which has not been
  793.     amplified. Otherwise it returns one. 
  794. */
  796. int loop_break( III_scalefac_t *scalefac, gr_info *cod_info,
  797.     int gr, int ch )
  798. {
  799.     uint i, sfb;
  801.     for ( sfb = 0; sfb < cod_info->sfb_lmax; sfb++ )
  802.         if ( scalefac->l[gr][ch][sfb] == 0 )
  803.             return 0;
  805.     for ( sfb = cod_info->sfb_smax; sfb < 12; sfb++ )
  806.         for ( i = 0; i < 3; i++ )
  807.             if ( scalefac->s[gr][ch][sfb][i] == 0 )
  808.                 return 0;
  809.     return 1;
  810. }
  814. /*************************************************************************/
  815. /*            preemphasis                                                */
  816. /*************************************************************************/
  818. /*
  819.   See ISO 11172-3  section  C.1.5.4.3.4
  820. */
  822. void preemphasis( double xr[576], double xfsf[4][CBLIMIT],
  823.      III_psy_xmin  *l3_xmin,
  824.      int gr, int ch, III_side_info_t *l3_side )
  825. {
  826.   int i, start, end, scfsi_band, over;
  827. uint sfb;
  828.   double ifqstep;
  829.   gr_info *cod_info = &l3_side->gr[gr].ch[ch].tt;
  830. double mulval;
  832.   if ( gr == 1 )
  833.   {
  834. /*
  835. If the second granule is being coded and scfsi is active in
  836. at least one scfsi_band, the preemphasis in the second granule
  837. is set equal to the setting in the first granule
  838. */
  839. for ( scfsi_band = 0; scfsi_band < 4; scfsi_band++ )
  840. if ( l3_side->scfsi[ch][scfsi_band] )
  841. {
  842. cod_info->preflag = l3_side->gr[0].ch[ch].tt.preflag;
  843. return;
  844. }
  846.   }
  848.   /*
  849.     Preemphasis is switched on if in all the upper four scalefactor
  850.     bands the actual distortion exceeds the threshold after the
  851.     first call of the inner loop
  852.   */
  853.   if ( cod_info->block_type != 2 && cod_info->preflag == 0 )
  854.   {
  855. over = 0;
  856. for ( sfb = 17; sfb < 21; sfb++ )
  857. if ( xfsf[0][sfb] > l3_xmin->l[gr][ch][sfb] )
  858. over++;
  860. if (over == 4 )
  861. {
  862. cod_info->preflag = 1;
  863. ifqstep = ( cod_info->scalefac_scale == 0 ) ? sqrt(2.)
  864. : pow( 2.0, (0.5 * (1.0 + (double) cod_info->scalefac_scale)) );
  866. for ( sfb = 0; sfb < cod_info->sfb_lmax; sfb++ )
  867. {
  868. l3_xmin->l[gr][ch][sfb] *= pow( ifqstep, 2.0 * (double) pretab[sfb] );
  869. start = scalefac_band_long[ sfb ];
  870. end   = scalefac_band_long[ sfb+1 ];
  872. mulval = pow( ifqstep, (double) pretab[sfb] );
  873. for( i = start; i < end; i++ )
  874. xr[i] *= mulval;
  875. }
  876. }
  877.   }
  878. }
  881. /*************************************************************************/
  882. /*            amp_scalefac_bands                                         */
  883. /*************************************************************************/
  885. /* 
  886.   Amplify the scalefactor bands that violate the masking threshold.
  887.   See ISO 11172-3 Section C.1.5.4.3.5
  888. */
  890. int amp_scalefac_bands( double xr[576], double xfsf[4][CBLIMIT],
  891.     III_psy_xmin *l3_xmin, III_side_info_t *l3_side,
  892.     III_scalefac_t *scalefac,
  893.     int gr, int ch, int iteration )
  894. {
  895.   int start, end, l, i, scfsi_band, over = 0;
  896. uint sfb;
  897.   double ifqstep, ifqstep2;
  898.   D192_3 *xr_s;
  899.   gr_info *cod_info, *gr0;
  900.   int copySF, preventSF;
  901.   cod_info = &l3_side->gr[gr].ch[ch].tt;
  902.   gr0      = &l3_side->gr[0].ch[ch].tt;
  905.   xr_s = (D192_3 *) xr;
  906.   copySF = 0;
  907.   preventSF = 0;
  909.   if ( cod_info->scalefac_scale == 0 )
  910. ifqstep = 1.414213562; /* sqrt( 2.0 ); */
  911.   else
  912. ifqstep = pow( 2.0, 0.5 * (1.0 + (double) cod_info->scalefac_scale) );
  914.   if ( gr == 1 )
  915.   {
  916. for ( scfsi_band = 0; scfsi_band < 4; scfsi_band++ )
  917.     if ( l3_side->scfsi[ch][scfsi_band] )
  918.     {
  919. if ( gr0->scalefac_scale == 0 )
  921. ifqstep = 1.414213562; /* sqrt( 2.0 ); */
  922. else
  923. ifqstep = pow( 2.0, 0.5 * (1.0 + (double) gr0->scalefac_scale) );
  925. if ( iteration == 1 )
  926. copySF = 1;
  927. else
  928.     preventSF = 1;
  929. break;
  930.     }
  932.   }
  934.   ifqstep2 = ifqstep * ifqstep;
  935.   scfsi_band = 0;
  936.     
  937.   for ( sfb = 0; sfb < cod_info->sfb_lmax; sfb++ )
  938.   {
  939. if ( copySF || preventSF )
  940. {
  941.     if ( (int) sfb == scfsi_band_long[scfsi_band + 1] )
  942. scfsi_band += 1;
  943.     if ( l3_side->scfsi[ch][scfsi_band] )
  944.     {
  945. if ( copySF )
  946.     scalefac->l[gr][ch][sfb] = scalefac->l[0][ch][sfb];
  947. continue;
  948.     }
  949. }     
  950. if ( xfsf[0][sfb] > l3_xmin->l[gr][ch][sfb] )
  951. {
  952.     over++;
  953.     l3_xmin->l[gr][ch][sfb] *= ifqstep2;
  954.     scalefac->l[gr][ch][sfb]++;
  955.     start = scalefac_band_long[sfb];
  956.     end   = scalefac_band_long[sfb+1];
  957.     for ( l = start; l < end; l++ )
  958. xr[l] *= ifqstep;
  959. }
  960.   }
  962.   for ( i = 0; i < 3; i++ )
  963.     for ( sfb = cod_info->sfb_smax; sfb < 12; sfb++ )
  964.       if ( xfsf[i+1][sfb] > l3_xmin->s[gr][ch][sfb][i] )
  965.       {
  966.         over++;
  967.         l3_xmin->s[gr][ch][sfb][i] *= ifqstep2;
  968.         scalefac->s[gr][ch][sfb][i]++;
  969.         start = scalefac_band_short[sfb];
  970.         end   = scalefac_band_short[sfb+1];
  971.         for ( l = start; l < end; l++ )
  972.             (*xr_s)[l][i] *= ifqstep;
  973.       }
  974.   return over;
  975. }
  980. /*************************************************************************/
  981. /*            quantize                                                   */
  982. /*************************************************************************/
  984. /*
  985.   Function: Quantization of the vector xr ( -> ix)
  986. */
  991. extern unsigned short bladeTablesh[];
  992. extern float bladeTablefloat[];
  995. /*____ bladTabValue() _________________________________________________________*/
  997. int __inline bladTabValue( float in )
  998. {
  999.   int in2 = *((int *) &in);
  1000.   int in1;
  1001.   int retVal;
  1002.   
  1003.   if( in2 >= 0x48213ba6 ) {
  1004.     int i;
  1005.     i = nint( pow( in, 0.75) - 0.0946 );
  1006.     if( i > 8192 ) {
  1007.         tjBitOverflow1 = TRUE;
  1009.         if( i > 8191 + 14 )
  1010.             tjBitOverflow2 = TRUE;
  1011.     }
  1012.     return i;
  1013.   }
  1014.   in1 = in2 - 0x3effff7a;
  1015.   if( in1 < 0 )
  1016.       return 0;
  1017.   retVal = bladeTablesh[in1>>10];
  1018.   if( retVal & (1<<15) ) {
  1019.     int *pTabEntry = (int *)bladeTablefloat;
  1020.     retVal &= 0x7fff;
  1021.     if( in2 < pTabEntry[retVal] ) {
  1022.         retVal--;
  1023.     }
  1024.   }
  1026.   return retVal;
  1027. }
  1031. /*____ quantize_tj() __________________________________________________________*/
  1033. void quantize_tj( double xr[576], int ix[576], gr_info *cod_info )
  1034. {
  1035.   int i, b, l_end, s_start;
  1036.   double quantizerStepSize;
  1038. double mulVal;
  1039. float x,y;
  1041.   D192_3 *xr_s;
  1042.   I192_3 *ix_s;
  1044.   xr_s = (D192_3 *) xr;
  1045.   ix_s = (I192_3 *) ix;
  1047.   quantizerStepSize = (double) cod_info->quantizerStepSize;
  1049.   if ( cod_info->quantizerStepSize == 0.0 )
  1050. mulVal = 1.0;
  1051.   else
  1052. mulVal = 1.0 / pow ( 2.0, quantizerStepSize * 0.25 );
  1054.   if ( cod_info->window_switching_flag != 0 && cod_info->block_type == 2 )
  1055. if ( cod_info->mixed_block_flag == 0 )
  1056. {
  1057. l_end = 0;
  1058. s_start = 0;
  1059. }
  1060. else
  1061. {
  1062. l_end = 18 * 2;
  1063. s_start = 6 * 2;
  1064. }
  1065.   else
  1066.   {
  1067. l_end = 576;
  1068. s_start = 192;
  1069.   }
  1071.   for ( i = 0; i < l_end; i+=2 )
  1072. {
  1073. /* ix[i] = nint( pow(fabs(xr[i]) * mulVal, 0.75) - 0.0946 ); */
  1074. x = fabs(xr[i])*mulVal;
  1075. y = fabs(xr[i+1])*mulVal;
  1076. ix[i] = bladTabValue( x );
  1077. ix[i+1] = bladTabValue( y );
  1078.   }
  1082. /*  for ( ; i < 576; i++ )
  1083. ix[i] = 0; */
  1084.   if( i<576 )
  1085.      memset( &ix[i], 0, (576-i) * sizeof(ix[0]) );
  1088.   if ( s_start < 192 )
  1089. for ( b = 0; b < 3; b++ )
  1090. {
  1091. mulVal = 1.0 / pow( 2.0, (quantizerStepSize + 8.0 * (double) cod_info->subblock_gain[b]) * 0.25 );
  1092. for ( i = s_start; i < 192; i++ )
  1093. {
  1094. /* (*ix_s)[i][b] = nint( pow(fabs((*xr_s)[i][b]) * mulVal, 0.75) - 0.0946 ); */
  1095. (*ix_s)[i][b] = bladTabValue(fabs((*xr_s)[i][b]) * mulVal);
  1096. }
  1097. }
  1098. }
  1102. /*************************************************************************/
  1103. /*            ix_max                                                     */
  1104. /*************************************************************************/
  1106. /*
  1107.   Function: Calculate the maximum of ix from 0 to 575
  1108. */
  1111. int ix_max_tj( int abs_ix[576], unsigned int begin, unsigned int end )
  1112. {
  1113.     uint i;
  1114. int  max = 0;
  1116.     for ( i = begin; i < end; i++ )
  1117.     {
  1118.         if ( abs_ix[i] > max )
  1119.             max = abs_ix[i];
  1120.     }
  1121.     return max;
  1122. }
  1126. /*************************************************************************/
  1127. /*            xr_max                                                     */
  1128. /*************************************************************************/
  1130. /*
  1131.   Function: Calculate the maximum of xr[576]  from 0 to 575
  1132. */
  1134. double xr_max( double xr[576] )
  1135. {
  1136.     uint i;
  1137.     double max = 0.0, temp;
  1139.     for ( i = 0; i < 576/4; i+=4 )
  1140.       if( (temp = fabs(xr[i])) > max )
  1141.      max = temp;
  1142.       if( (temp = fabs(xr[i+1])) > max )
  1143.      max = temp;
  1144.       if( (temp = fabs(xr[i+2])) > max )
  1145.      max = temp;
  1146.       if( (temp = fabs(xr[i+3])) > max )
  1147.      max = temp;
  1148.     return max;
  1149. }
  1153. /*        Noiseless coding  -- Huffman coding   */
  1156. /*************************************************************************/
  1157. /*            calc_runlen                                                */
  1158. /*************************************************************************/
  1160. /*
  1161. Function: Calculation of rzero, count1, big_values
  1162. (Partitions ix into big values, quadruples and zeros).
  1164. */
  1166. void calc_runlen( int ix[576], gr_info *cod_info )
  1167. {
  1168.   int i;
  1170.   if ( cod_info->window_switching_flag && (cod_info->block_type == 2) )
  1171.   {  /* short blocks */
  1172.     cod_info->count1 = 0;
  1173.     cod_info->big_values = 288;
  1174.   }
  1175.   else
  1176.   {
  1177.     for ( i = 576; i > 1; i -= 2 )
  1178.       if ( (ix[i-1] | ix[i-2]) != 0 )
  1179.         break;
  1180.       
  1181.     cod_info->count1 = 0 ;
  1182.     for ( ; i > 3; i -= 4 )
  1183. if ( (ix[i-1] | ix[i-2] | ix[i-3] | ix[i-4]) <= 1 )
  1184.         cod_info->count1++;
  1185.       else
  1187.         break;
  1188.       
  1189.     cod_info->big_values = i/2;
  1190.   }
  1191. }
  1195. /*************************************************************************/
  1196. /*            count1_bitcount                                            */
  1197. /*************************************************************************/
  1199. /*
  1200.   Determines the number of bits to encode the quadruples.
  1201. */
  1203. int count1_bitcount( int ix[ 576 ], gr_info *cod_info )
  1204. {
  1205.     int abs_and_sign( int *x );
  1207.     uint k;
  1208.     int i, p, bitsum_count1;
  1209.     int v, w, x, y, signbits;
  1210.     int sum0 = 0, sum1 = 0;
  1212.     for ( i = cod_info->big_values * 2, k = 0; k < cod_info->count1; i += 4, k++ )
  1213.     {
  1214.         v = ix[ i ];
  1215.         w = ix[ i + 1 ];
  1216.         x = ix[ i + 2 ];
  1217.         y = ix[ i + 3 ];
  1218.         
  1219.         p = v + (w << 1) + (x << 2) + (y << 3);
  1220.         
  1221. signbits = v + w + x + y;
  1223.         sum0 += signbits;
  1224.         sum1 += signbits;
  1226.         sum0 += ht[ 32 ].hlen[ p ];
  1227.         sum1 += ht[ 33 ].hlen[ p ];
  1228.     }
  1230.     if ( sum0 < sum1 )
  1231.     {
  1232.         bitsum_count1 = sum0;
  1233.         cod_info->count1table_select = 0;
  1234.     }
  1235.     else
  1236.     {
  1237.         bitsum_count1 = sum1;
  1238.         cod_info->count1table_select = 1;
  1239.     }
  1240.     return( bitsum_count1 );
  1241. }
  1243. int optimized_calculations_tj( int * abs_ix, gr_info *cod_info )
  1244. {
  1245. uint k;
  1246.   int p, i, bitsum_count1;
  1247.   int v, w, x, y, signbits;
  1248.   int sum0 = 0, sum1 = 0;
  1250.     
  1251.   if ( cod_info->window_switching_flag && (cod_info->block_type == 2) )
  1252.   {  /* short blocks */
  1253.     cod_info->count1 = 0;
  1255.     cod_info->big_values = 288;
  1256.   }
  1257.   else
  1258.   {
  1259.     for ( i = 576; i > 1; i -= 2 )
  1260.       if ( (abs_ix[i-1] | abs_ix[i-2]) != 0 )
  1261.         break;
  1262.       
  1263.     cod_info->count1 = 0 ;
  1264.     for ( ; i > 3; i -= 4 )
  1265. if ( (abs_ix[i-1] | abs_ix[i-2] | abs_ix[i-3] | abs_ix[i-4]) <= 1 )
  1266. {
  1267. cod_info->count1++;
  1268. }
  1269. else
  1270.         break;
  1271.       
  1272.     cod_info->big_values = i/2;
  1273.   }
  1275. /*===================*/
  1277. for ( i = cod_info->big_values * 2, k = 0; k < cod_info->count1; i += 4, k++ )
  1278.   {
  1279.       v = abs_ix[ i ];
  1280.       w = abs_ix[ i + 1 ];
  1281.       x = abs_ix[ i + 2 ];
  1282.       y = abs_ix[ i + 3 ];
  1283.       
  1284.       p = v + (w << 1) + (x << 2) + (y << 3);
  1285.       
  1286. signbits = v + w + x + y;
  1287.       
  1288.       sum0 += signbits;
  1289.       sum1 += signbits;
  1291.       sum0 += ht[ 32 ].hlen[ p ];
  1292.       sum1 += ht[ 33 ].hlen[ p ];
  1293.   }
  1295.   if ( sum0 < sum1 )
  1296.   {
  1297.       bitsum_count1 = sum0;
  1298.       cod_info->count1table_select = 0;
  1299.   }
  1300.   else
  1301.   {
  1302.       bitsum_count1 = sum1;
  1303.       cod_info->count1table_select = 1;
  1304.   }
  1305.   return( bitsum_count1 );
  1306. }
  1311. struct
  1312. {
  1313.     unsigned region0_count;
  1314.     unsigned region1_count;
  1315. } subdv_table[ 23 ] =
  1316. {
  1317. {0, 0}, /* 0 bands */
  1318. {0, 0}, /* 1 bands */
  1319. {0, 0}, /* 2 bands */
  1320. {0, 0}, /* 3 bands */
  1321. {0, 0}, /* 4 bands */
  1322. {0, 1}, /* 5 bands */
  1323. {1, 1}, /* 6 bands */
  1324. {1, 1}, /* 7 bands */
  1325. {1, 2}, /* 8 bands */
  1326. {2, 2}, /* 9 bands */
  1327. {2, 3}, /* 10 bands */
  1328. {2, 3}, /* 11 bands */
  1329. {3, 4}, /* 12 bands */
  1330. {3, 4}, /* 13 bands */
  1331. {3, 4}, /* 14 bands */
  1332. {4, 5}, /* 15 bands */
  1333. {4, 5}, /* 16 bands */
  1334. {4, 6}, /* 17 bands */
  1335. {5, 6}, /* 18 bands */
  1336. {5, 6}, /* 19 bands */
  1337. {5, 7}, /* 20 bands */
  1338. {6, 7}, /* 21 bands */
  1339. {6, 7}, /* 22 bands */
  1340. };
  1345. /*************************************************************************/
  1346. /*            subdivide                                                  */
  1347. /*************************************************************************/
  1349. /* presumable subdivides the bigvalue region which will
  1350.    use separate Huffman tables.
  1351. */
  1354. void subdivide( gr_info *cod_info )
  1355. {
  1356.     int scfb_anz = 0;
  1357.     int bigvalues_region;
  1358.     
  1359.     if ( cod_info->big_values == 0 )
  1360.     { /* no big_values region */
  1361.         cod_info->region0_count = 0;
  1362.         cod_info->region1_count = 0;
  1363.     }
  1364.     else
  1365.     {
  1366.         bigvalues_region = 2 * cod_info->big_values;
  1368.         if ( (cod_info->window_switching_flag == 0) )
  1369.         { /* long blocks */
  1370.             int thiscount, index;
  1371.             /* Calculate scfb_anz */
  1372.             while ( scalefac_band_long[scfb_anz] < bigvalues_region )
  1373.                 scfb_anz++;
  1374. /*            assert( scfb_anz < 23 ); */
  1376.             cod_info->region0_count = subdv_table[scfb_anz].region0_count;
  1377.             thiscount = cod_info->region0_count;
  1378.             index = thiscount + 1;
  1379.             while ( thiscount && (scalefac_band_long[index] > bigvalues_region) )
  1380.             {
  1381.                 thiscount -= 1;
  1382.                 index -= 1;
  1383.             }
  1384.             cod_info->region0_count = thiscount;
  1387.             cod_info->region1_count = subdv_table[scfb_anz].region1_count;
  1388.             index = cod_info->region0_count + cod_info->region1_count + 2;
  1389.             thiscount = cod_info->region1_count;
  1390.             while ( thiscount && (scalefac_band_long[index] > bigvalues_region) )
  1391.             {
  1392.                 thiscount -= 1;
  1393.                 index -= 1;
  1394.             }
  1395.             cod_info->region1_count = thiscount;
  1396.             cod_info->address1 = scalefac_band_long[cod_info->region0_count+1];
  1397.             cod_info->address2 = scalefac_band_long[cod_info->region0_count
  1398.                                                     + cod_info->region1_count + 2 ];
  1399.             cod_info->address3 = bigvalues_region;
  1400.         }
  1401.         else
  1402.         {
  1403.             if ( (cod_info->block_type == 2) && (cod_info->mixed_block_flag == 0) )
  1404.             { 
  1405.                 cod_info->region0_count =  8;
  1406.                 cod_info->region1_count =  36;
  1407.                 cod_info->address1 = 36;
  1408.                 cod_info->address2 = bigvalues_region;
  1409.                 cod_info->address3 = 0;  
  1410.             }
  1411.             else
  1412.             {
  1413.                 cod_info->region0_count = 7;
  1414.                 cod_info->region1_count = 13;
  1415.                 cod_info->address1 = scalefac_band_long[cod_info->region0_count+1];
  1416.                 cod_info->address2 = bigvalues_region;
  1417.                 cod_info->address3 = 0;
  1418.             }
  1419.         }
  1420.     }
  1421. }
  1426. /*************************************************************************/
  1427. /*            bigv_tab_select                                            */
  1428. /*************************************************************************/
  1430. /* Function: Select huffman code tables for bigvalues regions */
  1433. void bigv_tab_select_tj( int abs_ix[576], gr_info *cod_info )
  1434. {
  1435.   /* int max; */
  1437.   cod_info->table_select[0] = 0;
  1438.   cod_info->table_select[1] = 0;
  1439.   cod_info->table_select[2] = 0;
  1440.     
  1441.   if ( cod_info->window_switching_flag && (cod_info->block_type == 2) )
  1442.   {
  1443.     /*
  1444.       Within each scalefactor band, data is given for successive
  1445.       time windows, beginning with window 0 and ending with window 2.
  1446.       Within each window, the quantized values are then arranged in
  1447.       order of increasing frequency...
  1448.       */
  1449.     int sfb, window, line, start, end, max1, max2, x, y;
  1450.     int *pmax;
  1451. int tMax;
  1453.     max1 = max2 = 0;
  1456.     for ( sfb = 0; sfb < 13; sfb++ )
  1457.     {
  1458.       start = scalefac_band_short[ sfb ];
  1459.       end   = scalefac_band_short[ sfb+1 ];
  1460.       
  1461.       if ( start < 12 )
  1462.         pmax = &max1;
  1463.       else
  1464.         pmax = &max2;
  1466.       tMax = * pmax;
  1468.       for ( window = 0; window < 3; window++ )
  1469.         for ( line = start; line < end; line += 2 )
  1470.         {
  1471.           x = abs_ix[ (line * 3) + window ];
  1472.           y = abs_ix[ ((line + 1) * 3) + window ];
  1474.           if( x > tMax )
  1475. tMax = x;
  1477. if( y > tMax )
  1478. tMax = y;
  1479.         }
  1481. * pmax = tMax;
  1482. }
  1483.     cod_info->table_select[0] = choose_table( max1 );
  1484.     cod_info->table_select[1] = choose_table( max2 );
  1485.   }
  1486.   else
  1487.   {
  1488.     if ( cod_info->address1 > 0 )
  1489.       cod_info->table_select[0] = new_choose_table_tj( abs_ix, 0, cod_info->address1 );
  1491.     if ( cod_info->address2 > cod_info->address1 )
  1492.       cod_info->table_select[1] = new_choose_table_tj( abs_ix, cod_info->address1, cod_info->address2 );
  1494.     if ( cod_info->big_values * 2 > cod_info->address2 )
  1495.       cod_info->table_select[2] = new_choose_table_tj( abs_ix, cod_info->address2, cod_info->big_values * 2 );
  1496.   }
  1497. }
  1502. /*************************************************************************/
  1503. /*            new_choose table                                           */
  1504. /*************************************************************************/
  1506. /*
  1507.   Choose the Huffman table that will encode ix[begin..end] with
  1508.   the fewest bits.
  1510.   Note: This code contains knowledge about the sizes and characteristics
  1511.   of the Huffman tables as defined in the IS (Table B.7), and will not work
  1512.   with any arbitrary tables.
  1513. */
  1516. int new_choose_table_tj( int abs_ix[576], unsigned int begin, unsigned int end )
  1517. {
  1518. uint max;
  1519.   int i;
  1520.   int choice[ 2 ];
  1521.   int sum[ 2 ];
  1523.   max = ix_max_tj( abs_ix, begin, end );
  1525.   if ( max == 0 )
  1526.     return 0;
  1527.     
  1529.   choice[ 0 ] = 0;
  1530.   choice[ 1 ] = 0;
  1532.   if ( max < 15 )
  1533.   {
  1534.     for ( i = 0; i < 14; i++ )
  1535.       if ( ht[i].xlen > max )
  1536.     {
  1537. choice[ 0 ] = i;
  1538.         break;
  1539.     }
  1540. /* assert( choice[0] ); */
  1542. sum[ 0 ] = count_bit_tj( abs_ix, begin, end, choice[0] );
  1544. switch ( choice[0] )
  1545. {
  1546. case 2:
  1547. sum[ 1 ] = count_bit_tj( abs_ix, begin, end, 3 );
  1548. if ( sum[1] <= sum[0] )
  1549. choice[ 0 ] = 3;
  1550. break;
  1552. case 5:
  1553. sum[ 1 ] = count_bit_tj( abs_ix, begin, end, 6 );
  1554. if ( sum[1] <= sum[0] )
  1555. choice[ 0 ] = 6;
  1556. break;
  1558. case 7:
  1559. sum[ 1 ] = count_bit_tj( abs_ix, begin, end, 8 );
  1560. if ( sum[1] <= sum[0] )
  1561. {
  1562. choice[ 0 ] = 8;
  1563. sum[ 0 ] = sum[ 1 ];
  1564. }
  1565. sum[ 1 ] = count_bit_tj( abs_ix, begin, end, 9 );
  1566. if ( sum[1] <= sum[0] )
  1567. choice[ 0 ] = 9;
  1568. break;
  1570. case 10:
  1571. sum[ 1 ] = count_bit_tj( abs_ix, begin, end, 11 );
  1572. if ( sum[1] <= sum[0] )
  1573. {
  1574. choice[ 0 ] = 11;
  1575. sum[ 0 ] = sum[ 1 ];
  1576. }
  1577. sum[ 1 ] = count_bit_tj( abs_ix, begin, end, 12 );
  1578. if ( sum[1] <= sum[0] )
  1579. choice[ 0 ] = 12;
  1580. break;
  1582. case 13:
  1583. sum[ 1 ] = count_bit_tj( abs_ix, begin, end, 15 );
  1584. if ( sum[1] <= sum[0] )
  1585. choice[ 0 ] = 15;
  1586. break;
  1588. default:
  1590. break;
  1591. }
  1592.   }
  1593.   else
  1594.   {
  1595. /* try tables with linbits */
  1596. max -= 15;
  1598. for ( i = 15; i < 24; i++ )
  1599. {
  1600.     if ( ht[i].linmax >= max )
  1601.     {
  1602. choice[ 0 ] = i;
  1603. break;
  1604.     }
  1605. }
  1606. for ( i = 24; i < 32; i++ )
  1607. {
  1608.     if ( ht[i].linmax >= max )
  1609.   {
  1610. choice[ 1 ] = i;
  1611. break;
  1612.     }
  1613. }
  1614. /* assert( choice[0] );
  1615. assert( choice[1] ); */
  1617. sum[ 0 ] = count_bit_tj( abs_ix, begin, end, choice[0] );
  1618. sum[ 1 ] = count_bit_tj( abs_ix, begin, end, choice[1] );
  1619. if ( sum[1] < sum[0] )
  1620.     choice[ 0 ] = choice[ 1 ];
  1621.   }
  1622.   return choice[ 0 ];
  1623. }
  1627. /*************************************************************************/
  1628. /*            choose table                                               */
  1629. /*************************************************************************/
  1631. int choose_table( int max )
  1632. {
  1633.     int  i, choice;
  1635.     if ( max == 0 )
  1636.         return 0;
  1637.     
  1638. max = abs( max );
  1639.     choice = 0;
  1641.     if ( max < 15 )
  1642.     {
  1643.       for ( i = 0; i < 15; i++ )
  1644.       {
  1645.         if ( ht[i].xlen > max )
  1646.         {
  1647. choice = i;
  1648. break;
  1649.         }
  1650.       }
  1651.     }
  1652.     else
  1653.     {
  1654. max -= 15;
  1655. for (i = 15; i < 32; i++ )
  1656. {
  1657.      if ( ht[i].linmax >= max )
  1658.      {
  1659. choice = i;
  1660. break;
  1661.      }
  1662. }
  1663.     }
  1664.     return choice;
  1665. }
  1668. /*************************************************************************/
  1669. /*            bigv_bitcount                                              */
  1670. /*************************************************************************/
  1672. /*
  1673. Function: Count the number of bits necessary to code the bigvalues region.
  1674. */
  1677. int bigv_bitcount_tj( int * abs_ix, gr_info *gi )
  1678. {
  1679.   int bits = 0;
  1680.     
  1681.   if ( gi->window_switching_flag && gi->block_type == 2 )
  1682.   {
  1683.     /*
  1684.       Within each scalefactor band, data is given for successive
  1685.       time windows, beginning with window 0 and ending with window 2.
  1686.       Within each window, the quantized values are then arranged in
  1687.       order of increasing frequency...
  1688.       */
  1689.     int sfb, window, line, start, end;
  1690.     I192_3 *ix_s;
  1692.     if ( gi->mixed_block_flag )
  1693.     {
  1694.       unsigned int table;
  1696.       if ( (table = gi->table_select[0]) != 0 )
  1697.           bits += count_bit_tj( abs_ix, 0, gi->address1, table );
  1698.       sfb = 2;
  1699.     }
  1700.     else
  1701.       sfb = 0;
  1703.     ix_s = (I192_3 *) &abs_ix[0];
  1705.     for ( ; sfb < 13; sfb++ )
  1706.     {
  1707.       unsigned tableindex = 100;
  1708. unsigned idx;
  1709. struct huffcodetab *h;
  1711.       start = scalefac_band_short[ sfb ];
  1713.       end   = scalefac_band_short[ sfb+1 ];
  1715.       if ( start < 12 )
  1716.         tableindex = gi->table_select[ 0 ];
  1717.       else
  1718.         tableindex = gi->table_select[ 1 ];
  1719. /*      assert( tableindex < 32 ); */
  1721. if ( tableindex != 0 )
  1722. {
  1723. h = &(ht[tableindex]);
  1725. for ( window = 0; window < 3; window++ )
  1726. for ( line = start; line < end; line += 2 )
  1727. {
  1728. int x = (*ix_s)[line][window];
  1729. int y = (*ix_s)[line + 1][window];
  1731. if ( tableindex > 15 )
  1732. { /* ESC-table is used */
  1733. if ( x > 14 )
  1734. {
  1735. x = 15;
  1736. bits += h->linbits;
  1737. }
  1738. if ( y > 14 )
  1739. {
  1740. y = 15;
  1741. bits += h->linbits;
  1742. }
  1744. }
  1746. idx = (x * h->ylen) + y;
  1747. bits += h->hlen[ idx ];
  1750. if ( x != 0 )
  1751. bits += 1;
  1753. if ( y != 0 )
  1754. bits += 1;
  1756. }
  1757. }
  1758.     }
  1759.   }
  1760.   else
  1761.   {
  1762. unsigned int table;
  1763.   
  1764. if( (table=gi->table_select[0]) != 0 )  /* region0 */ 
  1765. bits += count_bit_tj(abs_ix, 0, gi->address1, table );
  1766. if( (table=gi->table_select[1]) != 0 )  /* region1 */ 
  1767. bits += count_bit_tj(abs_ix, gi->address1, gi->address2, table );
  1768. if( (table=gi->table_select[2]) != 0 )  /* region2 */ 
  1769. bits += count_bit_tj(abs_ix, gi->address2, gi->address3, table );
  1770. }
  1771.   return bits;
  1772. }
  1776. /*************************************************************************/
  1777. /*            count_bit                                                  */
  1778. /*************************************************************************/
  1780. /*
  1781.  Function: Count the number of bits necessary to code the subregion. 
  1782. */
  1785. int count_bit_tj( int abs_ix[576], unsigned int start, unsigned int end, unsigned int table )
  1786. {
  1787.     int i, sum;
  1788. unsigned idx;
  1789. struct huffcodetab *h;
  1790. int x, y;
  1792. if ( table == 0 )
  1793. return 0;
  1795. h = &(ht[table]);
  1797.     sum = 0;
  1798. if( table > 15 )
  1799. {
  1800. for ( i = start; i < end; i += 2 )
  1801. {
  1802. x = abs_ix[i];
  1803. y = abs_ix[i+1];
  1805. if ( x > 14 )
  1806. {
  1808. x = 15;
  1809. sum += h->linbits;
  1810. }
  1811. if ( y > 14 )
  1812. {
  1813. y = 15;
  1814. sum += h->linbits;
  1815. }
  1817. idx = (x * h->ylen) + y;
  1818. sum += h->hlen[ idx ] + ( x != 0 ) + ( y != 0 );
  1819. }
  1820. }
  1821. else
  1822. {
  1823. for ( i = start; i < end; i += 2 )
  1824. {
  1825. x = abs_ix[i];
  1826. y = abs_ix[i+1];
  1828. idx = (x * h->ylen) + y;
  1829. sum += h->hlen[ idx ] + ( x != 0 ) + ( y != 0 );
  1830. }
  1831. }
  1834.     return sum;
  1835. }
  1839. #ifndef HAVE_NINT
  1840. int
  1841. nint( double in )
  1842. {
  1843.     int    temp;
  1845.     if( in < 0 )  temp = (int)(in - 0.5);
  1846.     else    temp = (int)(in + 0.5);
  1848.     return(temp);
  1849. }
  1851. double
  1853. aint(double in) {
  1854. return((int) in);
  1855. }
  1856. #endif
  1863. /*************************************************************************/
  1864. /*            gr_deco                                                    */
  1865. /*************************************************************************/
  1867. void gr_deco( gr_info *cod_info )
  1868. {
  1869.     if ( cod_info->window_switching_flag != 0 && cod_info->block_type == 2 )
  1870.         if ( cod_info->mixed_block_flag == 0 )
  1871.         {
  1872.             cod_info->sfb_lmax = 0; /* No sb*/
  1873.             cod_info->sfb_smax = 0;
  1874.         }
  1875.         else
  1876.         {
  1877.             cod_info->sfb_lmax = 8;
  1878.             cod_info->sfb_smax = 3;
  1879.         }
  1880.     else
  1881.     {
  1882.         cod_info->sfb_lmax = SFB_LMAX - 1;
  1883.         cod_info->sfb_smax = SFB_SMAX - 1;    /* No sb */
  1884.     }
  1885. }
  1891. /* The following optional code written by Seymour Shlien
  1892.    will speed up the outer_loop code which is called
  1893.    by iteration_loop. When BIN_SEARCH is defined, the
  1894.    outer_loop function precedes the call to the function inner_loop
  1895.    with a call to bin_search gain defined below, which
  1896.    returns a good starting quantizerStepSize.
  1897. */
  1899. int count_bits( int * ix,gr_info * cod_info)
  1900. {
  1901. int bits;
  1902.   calc_runlen(ix,cod_info); /*rzero,count1,big_values*/
  1903.   bits = count1_bitcount(ix, cod_info); /*count1_table selection*/
  1904.   subdivide(cod_info); /* bigvalues sfb division */
  1905.   bigv_tab_select_tj(ix,cod_info); /* codebook selection*/
  1906.   bits += bigv_bitcount_tj(ix,cod_info); /* bit count */
  1907. return bits;
  1909. }
  1913. int bin_search_StepSize(int desired_rate, double start, int *ix,
  1914.            double xrs[576], gr_info * cod_info)
  1915. {
  1916. double top,bot,next,last;
  1917. int bit;
  1918. top = start;
  1919. bot = 200;
  1920. next = start;
  1921. do
  1922.   {
  1923. last = next;
  1924. next = aint((top+bot)/2.0);
  1925. cod_info->quantizerStepSize = next;
  1926. tjBitOverflow1 = FALSE;
  1927. quantize_tj(xrs,ix,cod_info);
  1928. if( tjBitOverflow1 == TRUE )
  1929.   bit = 100000;
  1930. else
  1931.   bit = count_bits(ix,cod_info);
  1932. if (bit>desired_rate) 
  1933. top = next;
  1934. else 
  1935. bot = next;
  1936.   }
  1937.   while ((bit != desired_rate) && fabs(last - next) > 1.0);
  1938. return next;
  1939. }