home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 2000 #5 / Amiga Plus CD - 2000 - No. 5.iso / Tools / Dev / lame_src / takehiro.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-01-01  |  17.3 KB  |  772 lines
  1. /*
  2.  *    MP3 huffman table selecting and bit counting
  3.  *
  4.  *    Copyright (c) 1999 Takehiro TOMINAGA
  5.  *
  6.  * This library is free software; you can redistribute it and/or
  7.  * modify it under the terms of the GNU Library General Public
  8.  * License as published by the Free Software Foundation; either
  9.  * version 2 of the License, or (at your option) any later version.
  10.  *
  11.  * This library is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.     See the GNU
  14.  * Library General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU Library General Public
  17.  * License along with this library; if not, write to the
  18.  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19.  * Boston, MA 02111-1307, USA.
  20.  */
  21.  
  22. #include <assert.h>
  23. #include "util.h"
  24. #include "l3side.h"
  25. #include "tables.h"
  26. #include "quantize-pvt.h"
  27.  
  28. struct
  29. {
  30.     unsigned region0_count;
  31.     unsigned region1_count;
  32. } subdv_table[ 23 ] =
  33. {
  34. {0, 0}, /* 0 bands */
  35. {0, 0}, /* 1 bands */
  36. {0, 0}, /* 2 bands */
  37. {0, 0}, /* 3 bands */
  38. {0, 0}, /* 4 bands */
  39. {0, 1}, /* 5 bands */
  40. {1, 1}, /* 6 bands */
  41. {1, 1}, /* 7 bands */
  42. {1, 2}, /* 8 bands */
  43. {2, 2}, /* 9 bands */
  44. {2, 3}, /* 10 bands */
  45. {2, 3}, /* 11 bands */
  46. {3, 4}, /* 12 bands */
  47. {3, 4}, /* 13 bands */
  48. {3, 4}, /* 14 bands */
  49. {4, 5}, /* 15 bands */
  50. {4, 5}, /* 16 bands */
  51. {4, 6}, /* 17 bands */
  52. {5, 6}, /* 18 bands */
  53. {5, 6}, /* 19 bands */
  54. {5, 7}, /* 20 bands */
  55. {6, 7}, /* 21 bands */
  56. {6, 7}, /* 22 bands */
  57. };
  58.  
  59.  
  60. unsigned int largetbl[16*16];
  61. unsigned int table23[3*3];
  62. unsigned int table56[4*4];
  63.  
  64. #ifdef MMX_choose_table
  65. unsigned long long tableABC[16*8];
  66. unsigned long long tableDEF[16*16];
  67. #define table789 (tableABC+9)
  68.  
  69. unsigned long long linbits32[13];
  70. unsigned short choose_table_H[13];
  71.  
  72. extern int choose_table_MMX(int *ix, int *end, int *s);
  73. #define choose_table(a,b,c) (assert(a<b),choose_table_MMX(a,b,c))
  74. #else
  75. /*************************************************************************/
  76. /*          ix_max                             */
  77. /*************************************************************************/
  78.  
  79. int ix_max(int *ix, int *end)
  80. {
  81.     int max1 = 0, max2 = 0;
  82.  
  83.     do {
  84.     int x1 = *ix++;
  85.     int x2 = *ix++;
  86.     if (max1 < x1) 
  87.         max1 = x1;
  88.  
  89.     if (max2 < x2) 
  90.         max2 = x2;
  91.     } while (ix < end);
  92.     if (max1 < max2) 
  93.     max1 = max2;
  94.     return max1;
  95. }
  96.  
  97.  
  98.  
  99.  
  100.  
  101.  
  102.  
  103.  
  104. int
  105. count_bit_ESC(int *ix, int *end, int t1, int t2, int *s)
  106. {
  107.     /* ESC-table is used */
  108.     int linbits = ht[t1].xlen * 65536 + ht[t2].xlen;
  109.     unsigned int sum = 0, sum2;
  110.  
  111.     do {
  112.     int x = *ix++;
  113.     int y = *ix++;
  114.  
  115.     if (x != 0) {
  116.         if (x > 14) {
  117.         x = 15;
  118.         sum += linbits;
  119.         }
  120.         x *= 16;
  121.     }
  122.  
  123.     if (y != 0) {
  124.         if (y > 14) {
  125.         y = 15;
  126.         sum += linbits;
  127.         }
  128.         x += y;
  129.     }
  130.  
  131.     sum += largetbl[x];
  132.     } while (ix < end);
  133.  
  134.     sum2 = sum & 0xffff;
  135.     sum >>= 16;
  136.  
  137.     if (sum > sum2) {
  138.     sum = sum2;
  139.     t1 = t2;
  140.     }
  141.  
  142.     *s += sum;
  143.     return t1;
  144. }
  145.  
  146.  
  147. INLINE static int
  148. count_bit_noESC(int *ix, int *end, int *s)
  149. {
  150.     /* No ESC-words */
  151.     int    sum1 = 0;
  152.     const unsigned char *hlen1 = ht[1].hlen;
  153.  
  154.     do {
  155.     int x = ix[0] * 2 + ix[1];
  156.     ix += 2;
  157.     sum1 += hlen1[x];
  158.     } while (ix < end);
  159.  
  160.     *s += sum1;
  161.     return 1;
  162. }
  163.  
  164.  
  165.  
  166. INLINE static int
  167. count_bit_noESC_from2(int *ix, int *end, int t1, int *s)
  168. {
  169.     /* No ESC-words */
  170.     unsigned int sum = 0, sum2;
  171.     const unsigned int xlen = ht[t1].xlen;
  172.     unsigned int *hlen;
  173.     if (t1 == 2)
  174.     hlen = table23;
  175.     else
  176.     hlen = table56;
  177.  
  178.     do {
  179.     int x = ix[0] * xlen + ix[1];
  180.     ix += 2;
  181.     sum += hlen[x];
  182.     } while (ix < end);
  183.  
  184.     sum2 = sum & 0xffff;
  185.     sum >>= 16;
  186.  
  187.     if (sum > sum2) {
  188.     sum = sum2;
  189.     t1++;
  190.     }
  191.  
  192.     *s += sum;
  193.     return t1;
  194. }
  195.  
  196.  
  197. INLINE static int
  198. count_bit_noESC_from3(int *ix, int *end, int t1, int *s)
  199. {
  200.     /* No ESC-words */
  201.     int    sum1 = 0;
  202.     int    sum2 = 0;
  203.     int    sum3 = 0;
  204.     const unsigned int xlen = ht[t1].xlen;
  205.     const unsigned char *hlen1 = ht[t1].hlen;
  206.     const unsigned char *hlen2 = ht[t1+1].hlen;
  207.     const unsigned char *hlen3 = ht[t1+2].hlen;
  208.     int t;
  209.  
  210.     do {
  211.     int x = ix[0] * xlen + ix[1];
  212.     ix += 2;
  213.     sum1 += hlen1[x];
  214.     sum2 += hlen2[x];
  215.     sum3 += hlen3[x];
  216.     } while (ix < end);
  217.  
  218.     t = t1;
  219.     if (sum1 > sum2) {
  220.     sum1 = sum2;
  221.     t++;
  222.     }
  223.     if (sum1 > sum3) {
  224.     sum1 = sum3;
  225.     t = t1+2;
  226.     }
  227.     *s += sum1;
  228.  
  229.     return t;
  230. }
  231.  
  232.  
  233. /*************************************************************************/
  234. /*          choose table                         */
  235. /*************************************************************************/
  236.  
  237. /*
  238.   Choose the Huffman table that will encode ix[begin..end] with
  239.   the fewest bits.
  240.  
  241.   Note: This code contains knowledge about the sizes and characteristics
  242.   of the Huffman tables as defined in the IS (Table B.7), and will not work
  243.   with any arbitrary tables.
  244. */
  245.  
  246. static int choose_table(int *ix, int *end, int *s)
  247. {
  248.     unsigned int max;
  249.     int choice, choice2;
  250.     static const int huf_tbl_noESC[] = {
  251.     1, 2, 5, 7, 7,10,10,13,13,13,13,13,13,13,13
  252.     };
  253.  
  254.     max = ix_max(ix, end);
  255.  
  256.     switch (max) {
  257.     case 0:
  258.     return (int)max;
  259.  
  260.     case 1:
  261.     return count_bit_noESC(ix, end, s);
  262.  
  263.     case 2:
  264.     case 3:
  265.     return count_bit_noESC_from2(ix, end, huf_tbl_noESC[max - 1], s);
  266.  
  267.     case 4: case 5: case 6:
  268.     case 7: case 8: case 9:
  269.     case 10: case 11: case 12:
  270.     case 13: case 14: case 15:
  271.     return count_bit_noESC_from3(ix, end, huf_tbl_noESC[max - 1], s);
  272.  
  273.     default:
  274.     /* try tables with linbits */
  275.     if (max > IXMAX_VAL) {
  276.         *s = LARGE_BITS;
  277.         return -1;
  278.     }
  279.     max -= 15;
  280.     for (choice2 = 24; choice2 < 32; choice2++) {
  281.         if (ht[choice2].linmax >= max) {
  282.         break;
  283.         }
  284.     }
  285.  
  286.     for (choice = choice2 - 8; choice < 24; choice++) {
  287.         if (ht[choice].linmax >= max) {
  288.         break;
  289.         }
  290.     }
  291.     return count_bit_ESC(ix, end, choice, choice2, s);
  292.     }
  293. }
  294. #endif
  295.  
  296. /*************************************************************************/
  297. /*          count_bit                             */
  298. /*************************************************************************/
  299.  
  300. /*
  301.  Function: Count the number of bits necessary to code the subregion. 
  302. */
  303.  
  304.  
  305. int count_bits_long(lame_internal_flags *gfc, int ix[576], gr_info *gi)
  306. {
  307.     int i, a1, a2;
  308.     int bits = 0;
  309.  
  310.     i=576;
  311.     /* Determine count1 region */
  312.     for (; i > 1; i -= 2) 
  313.     if (ix[i - 1] | ix[i - 2])
  314.         break;
  315.     gi->count1 = i;
  316.  
  317.  
  318.     /* Determines the number of bits to encode the quadruples. */
  319.     a1 = a2 = 0;
  320.     for (; i > 3; i -= 4) {
  321.     int p;
  322.     if ((unsigned int)(ix[i-1] | ix[i-2] | ix[i-3] | ix[i-4]) > 1)
  323.         break;
  324.  
  325.     p = ((ix[i-4] * 2 + ix[i-3]) * 2 + ix[i-2]) * 2 + ix[i-1];
  326.     a1 += t32l[p];
  327.     a2 += t33l[p];
  328.     }
  329.  
  330.     bits = a1;
  331.     gi->count1table_select = 0;
  332.     if (a1 > a2) {
  333.     bits = a2;
  334.     gi->count1table_select = 1;
  335.     }
  336.  
  337.     gi->count1bits = bits;
  338.     gi->big_values = i;
  339.     if (i == 0 )
  340.     return bits;
  341.  
  342.     if (gi->block_type == SHORT_TYPE) {
  343.       a1=3*gfc->scalefac_band.s[3];
  344.       if (a1 > gi->big_values) a1 = gi->big_values;
  345.       a2 = gi->big_values;
  346.  
  347.     }else if (gi->block_type == NORM_TYPE) {
  348.     int index;
  349.     int scfb_anz = 0;
  350.  
  351.     while (gfc->scalefac_band.l[++scfb_anz] < i) 
  352.         ;
  353.     index = subdv_table[scfb_anz].region0_count;
  354.     while (gfc->scalefac_band.l[index + 1] > i)
  355.         index--;
  356.     gi->region0_count = index;
  357.  
  358.     index = subdv_table[scfb_anz].region1_count;
  359.     while (gfc->scalefac_band.l[index + gi->region0_count + 2] > i)
  360.         index--;
  361.     gi->region1_count = index;
  362.  
  363.     a1 = gfc->scalefac_band.l[gi->region0_count + 1];
  364.     a2 = gfc->scalefac_band.l[index + gi->region0_count + 2];
  365.     if (a2 < i)
  366.       gi->table_select[2] = choose_table(ix + a2, ix + i, &bits);
  367.  
  368.     } else {
  369.     gi->region0_count = 7;
  370.     /*gi->region1_count = SBPSY_l - 7 - 1;*/
  371.     gi->region1_count = SBMAX_l -1 - 7 - 1;
  372.     a1 = gfc->scalefac_band.l[7 + 1];
  373.     a2 = i;
  374.     if (a1 > a2) {
  375.         a1 = a2;
  376.     }
  377.     }
  378.  
  379.     /* Count the number of bits necessary to code the bigvalues region. */
  380.     if (0 < a1)
  381.       gi->table_select[0] = choose_table(ix, ix + a1, &bits);
  382.     if (a1 < a2)
  383.       gi->table_select[1] = choose_table(ix + a1, ix + a2, &bits);
  384.     return bits;
  385. }
  386.  
  387.  
  388.  
  389.  
  390.  
  391. int count_bits(lame_global_flags *gfp,int *ix, FLOAT8 *xr, gr_info *cod_info)  
  392. {
  393.   lame_internal_flags *gfc=gfp->internal_flags;
  394.  
  395.   int bits=0,i;
  396.   /* since quantize_xrpow uses table lookup, we need to check this first: */
  397.   FLOAT8 w = (IXMAX_VAL) / IPOW20(cod_info->global_gain);
  398.   for ( i = 0; i < 576; i++ )  {
  399.     if (xr[i] > w)
  400.       return LARGE_BITS;
  401.   }
  402.  
  403. #ifdef ASM_QUANTIZE
  404.   if (gfc->quantization) 
  405.     quantize_xrpow_ASM(xr, ix, cod_info->global_gain);
  406.   else
  407.     quantize_xrpow_ISO_ASM(xr, ix, cod_info->global_gain);
  408. #else
  409.   if (gfc->quantization) 
  410.     quantize_xrpow(xr, ix, cod_info);
  411.   else
  412.     quantize_xrpow_ISO(xr, ix, cod_info);
  413. #endif
  414.  
  415.  
  416.   bits=count_bits_long(gfc, ix, cod_info);
  417.  
  418.   return bits;
  419. }
  420.  
  421. /***********************************************************************
  422.   re-calculate the best scalefac_compress using scfsi
  423.   the saved bits are kept in the bit reservoir.
  424.  **********************************************************************/
  425.  
  426.  
  427. INLINE void
  428. recalc_divide_init(lame_internal_flags *gfc, gr_info cod_info, int gr, int ch, int *ix,
  429. int r01_bits[],int r01_div[],int r0_tbl[],int r1_tbl[])
  430. {
  431.     int r0, r1, bigv, r0t, r1t, bits;
  432.  
  433.     bigv = cod_info.big_values;
  434.  
  435.     for (r0 = 0; r0 <= 7 + 15; r0++) {
  436.     r01_bits[r0] = LARGE_BITS;
  437.     }
  438.  
  439.     for (r0 = 0; r0 < 16; r0++) {
  440.     int a1 = gfc->scalefac_band.l[r0 + 1], r0bits;
  441.     if (a1 >= bigv)
  442.         break;
  443.     r0bits = cod_info.part2_length;
  444.     r0t = choose_table(ix, ix + a1, &r0bits);
  445.  
  446.     for (r1 = 0; r1 < 8; r1++) {
  447.         int a2 = gfc->scalefac_band.l[r0 + r1 + 2];
  448.         if (a2 >= bigv)
  449.         break;
  450.  
  451.         bits = r0bits;
  452.         r1t = choose_table(ix + a1, ix + a2, &bits);
  453.         if (r01_bits[r0 + r1] > bits) {
  454.         r01_bits[r0 + r1] = bits;
  455.         r01_div[r0 + r1] = r0;
  456.         r0_tbl[r0 + r1] = r0t;
  457.         r1_tbl[r0 + r1] = r1t;
  458.         }
  459.     }
  460.     }
  461. }
  462.  
  463. INLINE void
  464. recalc_divide_sub(lame_internal_flags *gfc,gr_info cod_info2, int gr, int ch, gr_info *gi, int *ix,
  465. int r01_bits[],int r01_div[],int r0_tbl[],int r1_tbl[])
  466. {
  467.     int bits, r2, a2, bigv, r2t;
  468.  
  469.     bigv = cod_info2.big_values;
  470.  
  471.     for (r2 = 2; r2 < SBMAX_l + 1; r2++) {
  472.     a2 = gfc->scalefac_band.l[r2];
  473.     if (a2 >= bigv) 
  474.         break;
  475.  
  476.     bits = r01_bits[r2 - 2] + cod_info2.count1bits;
  477.     if (gi->part2_3_length <= bits)
  478.         break;
  479.  
  480.     r2t = choose_table(ix + a2, ix + bigv, &bits);
  481.     if (gi->part2_3_length <= bits)
  482.         continue;
  483.  
  484.     memcpy(gi, &cod_info2, sizeof(gr_info));
  485.     gi->part2_3_length = bits;
  486.     gi->region0_count = r01_div[r2 - 2];
  487.     gi->region1_count = r2 - 2 - r01_div[r2 - 2];
  488.     gi->table_select[0] = r0_tbl[r2 - 2];
  489.     gi->table_select[1] = r1_tbl[r2 - 2];
  490.     gi->table_select[2] = r2t;
  491.     }
  492. }
  493.  
  494.  
  495.  
  496.  
  497. void best_huffman_divide(lame_internal_flags *gfc, int gr, int ch, gr_info *gi, int *ix)
  498. {
  499.     int i, a1, a2;
  500.     gr_info cod_info2;
  501.  
  502.     int r01_bits[7 + 15 + 1];
  503.     int r01_div[7 + 15 + 1];
  504.     int r0_tbl[7 + 15 + 1];
  505.     int r1_tbl[7 + 15 + 1];
  506.     memcpy(&cod_info2, gi, sizeof(gr_info));
  507.  
  508.     if (gi->block_type == NORM_TYPE) {
  509.     recalc_divide_init(gfc, cod_info2, gr, ch, ix,r01_bits,r01_div,r0_tbl,r1_tbl);
  510.     recalc_divide_sub(gfc,cod_info2, gr, ch, gi, ix,r01_bits,r01_div,r0_tbl,r1_tbl);
  511.     }
  512.  
  513.     i = cod_info2.big_values;
  514.     if (i == 0 || (unsigned int)(ix[i-2] | ix[i-1]) > 1)
  515.     return;
  516.  
  517.     i = gi->count1 + 2;
  518.     if (i > 576)
  519.     return;
  520.  
  521.     /* Determines the number of bits to encode the quadruples. */
  522.     memcpy(&cod_info2, gi, sizeof(gr_info));
  523.     cod_info2.count1 = i;
  524.     a1 = a2 = 0;
  525.  
  526.     assert(i <= 576);
  527.     
  528.     for (; i > cod_info2.big_values; i -= 4) {
  529.     int p = ((ix[i-4] * 2 + ix[i-3]) * 2 + ix[i-2]) * 2 + ix[i-1];
  530.     a1 += t32l[p];
  531.     a2 += t33l[p];
  532.     }
  533.     cod_info2.big_values = i;
  534.  
  535.     cod_info2.count1table_select = 0;
  536.     if (a1 > a2) {
  537.     a1 = a2;
  538.     cod_info2.count1table_select = 1;
  539.     }
  540.  
  541.     cod_info2.count1bits = a1;
  542.     cod_info2.part2_3_length = a1 + cod_info2.part2_length;
  543.  
  544.     if (cod_info2.block_type == NORM_TYPE)
  545.     recalc_divide_sub(gfc, cod_info2, gr, ch, gi, ix,r01_bits,r01_div,r0_tbl,r1_tbl);
  546.     else {
  547.     /* Count the number of bits necessary to code the bigvalues region. */
  548.     a1 = gfc->scalefac_band.l[7 + 1];
  549.     if (a1 > i) {
  550.         a1 = i;
  551.     }
  552.     if (a1 > 0)
  553.       cod_info2.table_select[0] =
  554.         choose_table(ix, ix + a1, (int *)&cod_info2.part2_3_length);
  555.     if (i > a1)
  556.       cod_info2.table_select[1] =
  557.         choose_table(ix + a1, ix + i, (int *)&cod_info2.part2_3_length);
  558.     if (gi->part2_3_length > cod_info2.part2_3_length)
  559.         memcpy(gi, &cod_info2, sizeof(gr_info));
  560.     }
  561. }
  562.  
  563. void
  564. scfsi_calc(int ch,
  565.        III_side_info_t *l3_side,
  566.        III_scalefac_t scalefac[2][2])
  567. {
  568.     int i, s1, s2, c1, c2;
  569.     int sfb;
  570.     gr_info *gi = &l3_side->gr[1].ch[ch].tt;
  571.  
  572.     static const int scfsi_band[5] = { 0, 6, 11, 16, 21 };
  573.  
  574.     static const int slen1_n[16] = { 0, 1, 1, 1, 8, 2, 2, 2, 4, 4, 4, 8, 8, 8,16,16 };
  575.     static const int slen2_n[16] = { 0, 2, 4, 8, 1, 2, 4, 8, 2, 4, 8, 2, 4, 8, 4, 8 };
  576.  
  577.     for (i = 0; i < 4; i++) 
  578.     l3_side->scfsi[ch][i] = 0;
  579.  
  580.     for (i = 0; i < (int)(sizeof(scfsi_band) / sizeof(int)) - 1; i++) {
  581.     for (sfb = scfsi_band[i]; sfb < scfsi_band[i + 1]; sfb++) {
  582.         if (scalefac[0][ch].l[sfb] != scalefac[1][ch].l[sfb])
  583.         break;
  584.     }
  585.     if (sfb == scfsi_band[i + 1]) {
  586.         for (sfb = scfsi_band[i]; sfb < scfsi_band[i + 1]; sfb++) {
  587.         scalefac[1][ch].l[sfb] = -1;
  588.         }
  589.         l3_side->scfsi[ch][i] = 1;
  590.     }
  591.     }
  592.  
  593.     s1 = c1 = 0;
  594.     for (sfb = 0; sfb < 11; sfb++) {
  595.     if (scalefac[1][ch].l[sfb] < 0)
  596.         continue;
  597.     c1++;
  598.     if (s1 < scalefac[1][ch].l[sfb])
  599.         s1 = scalefac[1][ch].l[sfb];
  600.     }
  601.  
  602.     s2 = c2 = 0;
  603.     for (; sfb < SBPSY_l; sfb++) {
  604.     if (scalefac[1][ch].l[sfb] < 0)
  605.         continue;
  606.     c2++;
  607.     if (s2 < scalefac[1][ch].l[sfb])
  608.         s2 = scalefac[1][ch].l[sfb];
  609.     }
  610.  
  611.     for (i = 0; i < 16; i++) {
  612.     if (s1 < slen1_n[i] && s2 < slen2_n[i]) {
  613.         int c = slen1_tab[i] * c1 + slen2_tab[i] * c2;
  614.         if ((int)gi->part2_length > c) {
  615.         gi->part2_length = c;
  616.         gi->scalefac_compress = i;
  617.         }
  618.     }
  619.     }
  620. }
  621.  
  622. /*
  623. Find the optimal way to store the scalefactors.
  624. Only call this routine after final scalefactors have been
  625. chosen and the channel/granule will not be re-encoded.
  626.  */
  627. void best_scalefac_store(lame_global_flags *gfp,int gr, int ch,
  628.              int l3_enc[2][2][576],
  629.              III_side_info_t *l3_side,
  630.              III_scalefac_t scalefac[2][2])
  631. {
  632.   lame_internal_flags *gfc=gfp->internal_flags;
  633.  
  634.     /* use scalefac_scale if we can */
  635.     gr_info *gi = &l3_side->gr[gr].ch[ch].tt;
  636.     u_int sfb,i,j,j2,l,start,end;
  637.  
  638.     /* remove scalefacs from bands with ix=0.  This idea comes
  639.      * from the AAC ISO docs.  added mt 3/00 */
  640.     /* check if l3_enc=0 */
  641.     for ( sfb = 0; sfb < gi->sfb_lmax; sfb++ ) {
  642.       if (scalefac[gr][ch].l[sfb]>0) { 
  643.     start = gfc->scalefac_band.l[ sfb ];
  644.     end   = gfc->scalefac_band.l[ sfb+1 ];
  645.     for ( l = start; l < end; l++ ) if (l3_enc[gr][ch][l]!=0) break;
  646.     if (l==end) scalefac[gr][ch].l[sfb]=0;
  647.       }
  648.     }
  649.     for ( j=0, sfb = gi->sfb_smax; sfb < SBPSY_s; sfb++ ) {
  650.     start = gfc->scalefac_band.s[ sfb ];
  651.     end   = gfc->scalefac_band.s[ sfb+1 ];
  652.     for ( i = 0; i < 3; i++ ) {
  653.       if (scalefac[gr][ch].s[sfb][i]>0) {
  654.         j2 = j;
  655.         for ( l = start; l < end; l++ ) 
  656.           if (l3_enc[gr][ch][j2++ /*3*l+i*/]!=0) break;
  657.         if (l==end) scalefac[gr][ch].s[sfb][i]=0;
  658.       }
  659.       j += end-start;
  660.     }
  661.     }
  662.  
  663.  
  664.     gi->part2_3_length -= gi->part2_length;
  665.     if (!gi->scalefac_scale && !gi->preflag) {
  666.     int b, s = 0;
  667.     for (sfb = 0; sfb < gi->sfb_lmax; sfb++) {
  668.         s |= scalefac[gr][ch].l[sfb];
  669.     }
  670.  
  671.     for (sfb = gi->sfb_smax; sfb < SBPSY_s; sfb++) {
  672.         for (b = 0; b < 3; b++) {
  673.         s |= scalefac[gr][ch].s[sfb][b];
  674.         }
  675.     }
  676.  
  677.     if (!(s & 1) && s != 0) {
  678.         for (sfb = 0; sfb < gi->sfb_lmax; sfb++) {
  679.         scalefac[gr][ch].l[sfb] /= 2;
  680.         }
  681.         for (sfb = gi->sfb_smax; sfb < SBPSY_s; sfb++) {
  682.         for (b = 0; b < 3; b++) {
  683.             scalefac[gr][ch].s[sfb][b] /= 2;
  684.         }
  685.         }
  686.  
  687.         gi->scalefac_scale = 1;
  688.         gi->part2_length = 99999999;
  689.         if (gfc->mode_gr == 2) {
  690.             scale_bitcount(&scalefac[gr][ch], gi);
  691.         } else {
  692.         scale_bitcount_lsf(&scalefac[gr][ch], gi);
  693.         }
  694.     }
  695.     }
  696.  
  697.  
  698.     for ( i = 0; i < 4; i++ )
  699.       l3_side->scfsi[ch][i] = 0;
  700.  
  701.     if (gfc->mode_gr==2 && gr == 1
  702.     && l3_side->gr[0].ch[ch].tt.block_type != SHORT_TYPE
  703.     && l3_side->gr[1].ch[ch].tt.block_type != SHORT_TYPE) {
  704.           scfsi_calc(ch, l3_side, scalefac);
  705.     }
  706.     gi->part2_3_length += gi->part2_length;
  707. }
  708.  
  709. void huffman_init()
  710. {
  711.     int i;
  712.  
  713.     for (i = 0; i < 16*16; i++) {
  714.     largetbl[i] = (((int)ht[16].hlen[i]) << 16) + ht[24].hlen[i];
  715.     }
  716.  
  717.     for (i = 0; i < 3*3; i++) {
  718.     table23[i] = (((int)ht[2].hlen[i]) << 16) + ht[3].hlen[i];
  719.     }
  720.  
  721.     for (i = 0; i < 4*4; i++) {
  722.     table56[i] = (((int)ht[5].hlen[i]) << 16) + ht[6].hlen[i];
  723.     }
  724. #ifdef MMX_choose_table
  725.     for (i = 0; i < 6; i++) {
  726.     int j;
  727.     for (j = 0; j < 6; j++) {
  728.         table789[i*16+j] =
  729.         (((long long)ht[7].hlen[i*6+j]) << 32) +
  730.         (((long long)ht[8].hlen[i*6+j]) << 16) +
  731.         (((long long)ht[9].hlen[i*6+j]));
  732.     }
  733.     }
  734.  
  735.     for (i = 0; i < 8; i++) {
  736.     int j;
  737.     for (j = 0; j < 8; j++) {
  738.         tableABC[i*16+j] =
  739.         (((long long)ht[10].hlen[i*8+j]) << 32) +
  740.         (((long long)ht[11].hlen[i*8+j]) << 16) +
  741.         (((long long)ht[12].hlen[i*8+j]));
  742.     }
  743.     }
  744.  
  745.     for (i = 0; i < 16*16; i++) {
  746.     tableDEF[i] =
  747.         (((long long)ht[13].hlen[i]) << 32) +
  748.         (((long long)ht[14].hlen[i]) << 16) +
  749.         (((long long)ht[15].hlen[i]));
  750.     }
  751.     for (i = 0; i < 13; i++) {
  752.     int t1, t2;
  753.     for (t2 = 24; t2 < 32; t2++) {
  754.         if (ht[t2].xlen > i) {
  755.         break;
  756.         }
  757.     }
  758.     for (t1 = t2 - 8; t1 < 24; t1++) {
  759.         if (ht[t1].xlen > i) {
  760.         break;
  761.         }
  762.     }
  763.  
  764.     choose_table_H[i] = t1+t2*256;
  765.  
  766.     linbits32[i] =
  767.         ((long long)ht[t1].xlen << 48) + ((long long)ht[t1].xlen << 32) +
  768.         ((long long)ht[t2].xlen << 16) + ((long long)ht[t2].xlen);
  769.     }
  770. #endif
  771. }
  772.