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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
takehiro.c
资源名称：NETVIDEO.rar　[点击查看]
上传用户：sun1608
上传日期：2007-02-02
资源大小：6116k
文件大小：16k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

takehiro.c：源码内容
  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.  */
  23. #include "util.h"
  24. #include "l3side.h"
  25. #include "tables.h"
  26. #include "quantize-pvt.h"
  31. struct
  32. {
  33.     unsigned region0_count;
  34.     unsigned region1_count;
  35. } subdv_table[ 23 ] =
  36. {
  37. {0, 0}, /* 0 bands */
  38. {0, 0}, /* 1 bands */
  39. {0, 0}, /* 2 bands */
  40. {0, 0}, /* 3 bands */
  41. {0, 0}, /* 4 bands */
  42. {0, 1}, /* 5 bands */
  43. {1, 1}, /* 6 bands */
  44. {1, 1}, /* 7 bands */
  45. {1, 2}, /* 8 bands */
  46. {2, 2}, /* 9 bands */
  47. {2, 3}, /* 10 bands */
  48. {2, 3}, /* 11 bands */
  49. {3, 4}, /* 12 bands */
  50. {3, 4}, /* 13 bands */
  51. {3, 4}, /* 14 bands */
  52. {4, 5}, /* 15 bands */
  53. {4, 5}, /* 16 bands */
  54. {4, 6}, /* 17 bands */
  55. {5, 6}, /* 18 bands */
  56. {5, 6}, /* 19 bands */
  57. {5, 7}, /* 20 bands */
  58. {6, 7}, /* 21 bands */
  59. {6, 7}, /* 22 bands */
  60. };
  63. /*************************************************************************/
  64. /*       ix_max  */
  65. /*************************************************************************/
  67.  static int ix_max(int *ix, int *end)
  68. {
  69.     int max = 0;
  71.     while (ix < end) {
  72. int x =  *ix++;
  73. if (max < x) 
  74.     max = x;
  76. x = *ix++;
  77. if (max < x) 
  78.     max = x;
  79.     }
  80.     return max;
  81. }
  84. /*************************************************************************/
  85. /*       count_bit  */
  86. /*************************************************************************/
  88. /*
  89.  Function: Count the number of bits necessary to code the subregion. 
  90. */
  92. static int cb_esc_buf[288];
  93. static int cb_esc_sign;
  94. static int *cb_esc_end;
  95. static const int huf_tbl_noESC[15] = {
  96.     1, 2, 5, 7, 7,10,10,13,13,13,13,13,13,13,13
  97. };
  99.  static int
  100. count_bit_ESC(int *ix, int *end, int t1, int t2, int *s)
  101. {
  102.     /* ESC-table is used */
  103.     int linbits1 = ht[t1].xlen;
  104.     int linbits2 = ht[t2].xlen;
  105.     int sum = 0;
  106.     int sum1 = 0;
  107.     int sum2 = 0;
  109.     while (ix < end) {
  110. int x = *ix++;
  111. int y = *ix++;
  113. if (x != 0) {
  114.     sum++;
  115.     if (x > 14) {
  116. x = 15;
  117. sum1 += linbits1;
  118. sum2 += linbits2;
  119.     }
  120.     x *= 16;
  121. }
  123. if (y != 0) {
  124.     sum++;
  125.     if (y > 14) {
  126. y = 15;
  127. sum1 += linbits1;
  128. sum2 += linbits2;
  129.     }
  130.     x += y;
  131. }
  133. sum1 += ht[16].hlen[x];
  134. sum2 += ht[24].hlen[x];
  135.     }
  137.     if (sum1 > sum2)  {
  138. sum1 = sum2;
  139. t1 = t2;
  140.     }
  142.     *s += sum + sum1;
  143.     return t1;
  144. }
  146.  static int
  147. count_bit_noESC(int *ix, int *end, unsigned int table) 
  148. {
  149.     /* No ESC-words */
  150.     int sum = 0, sign = 0;
  151.     unsigned char *hlen = ht[table].hlen;
  152.     int *p = cb_esc_buf;
  154.     do {
  155. int x = *ix++;
  156. int y = *ix++;
  157. if (x != 0) {
  158.     sign++;
  159.     x *= 16;
  160. }
  162. if (y != 0) {
  163.     sign++;
  164.     x += y;
  165. }
  167. *p++ = x;
  168. sum += hlen[x];
  169.     } while (ix < end);
  171.     cb_esc_sign = sign;
  172.     cb_esc_end = p;
  173.     return sum + sign;
  174. }
  178.  static int
  179. count_bit_noESC2(unsigned int table) 
  180. {
  181.     /* No ESC-words */
  182.     int sum = cb_esc_sign;
  183.     int *p = cb_esc_buf;
  185.     do {
  186. sum += ht[table].hlen[*p++];
  187.     } while (p < cb_esc_end);
  189.     return sum;
  190. }
  194.  static int
  195. count_bit_short_ESC(int *ix, int *end, int t1, int t2, int *s)
  196. {
  197.     /* ESC-table is used */
  198.     int linbits1 = ht[t1].xlen;
  199.     int linbits2 = ht[t2].xlen;
  200.     int sum = 0;
  201.     int sum1 = 0;
  202.     int sum2 = 0;
  204.     do {
  205. int i;
  206. for (i = 0; i < 3; i++) {
  207.     int y = *(ix + 3);
  208.     int x = *ix++;
  210.     if (x != 0) {
  211. sum++;
  212. if (x > 14) {
  213.     x = 15;
  214.     sum1 += linbits1;
  215.     sum2 += linbits2;
  216. }
  217. x *= 16;
  218.     }
  220.     if (y != 0) {
  221. sum++;
  222. if (y > 14) {
  223.     y = 15;
  224.     sum1 += linbits1;
  225.     sum2 += linbits2;
  226. }
  227. x += y;
  228.     }
  230.     sum1 += ht[16].hlen[x];
  231.     sum2 += ht[24].hlen[x];
  232. }
  233. ix += 3;
  234.     } while (ix < end);
  236.     if (sum1 > sum2)  {
  237. sum1 = sum2;
  238. t1 = t2;
  239.     }
  241.     *s += sum + sum1;
  242.     return t1;
  243. }
  247.  static int
  248. count_bit_short_noESC(int *ix, int *end, unsigned int table) 
  249. {
  250.     /* No ESC-words */
  251.     int sum = 0, sign = 0;
  252.     unsigned char *hlen = ht[table].hlen;
  253.     int *p = cb_esc_buf;
  255.     do {
  256. int i;
  257. for (i = 0; i < 3; i++) {
  258.     int y = *(ix + 3);
  259.     int x = *ix++;
  260.     if (x != 0) {
  261. sign++;
  262. x *= 16;
  263.     }
  265.     if (y != 0) {
  266. sign++;
  267. x += y;
  268.     }
  270.     *p++ = x;
  271.     sum += hlen[x];
  272. }
  273. ix += 3;
  274.     } while (ix < end);
  276.     cb_esc_sign = sign;
  277.     cb_esc_end = p;
  278.     return sum + sign;
  279. }
  283. /*************************************************************************/
  284. /*       new_choose table  */
  285. /*************************************************************************/
  287. /*
  288.   Choose the Huffman table that will encode ix[begin..end] with
  289.   the fewest bits.
  291.   Note: This code contains knowledge about the sizes and characteristics
  292.   of the Huffman tables as defined in the IS (Table B.7), and will not work
  293.   with any arbitrary tables.
  294. */
  296. static int choose_table(int *ix, int *end, int *s)
  297. {
  298.     int max;
  299.     int choice0, sum0;
  300.     int choice1, sum1;
  302.     max = ix_max(ix, end);
  304.     if (max > IXMAX_VAL) {
  305.         *s = 100000;
  306.         return -1;
  307.     }
  309.     if (max <= 15)  {
  310. if (max == 0) {
  311.     return 0;
  312. }
  313. /* try tables with no linbits */
  314. choice0 = huf_tbl_noESC[max - 1];
  315. sum0 = count_bit_noESC(ix, end, choice0);
  316. choice1 = choice0;
  318. switch (choice0) {
  319. case 7:
  320. case 10:
  321.     choice1++;
  322.     sum1 = count_bit_noESC2(choice1);
  323.     if (sum0 > sum1) {
  324. sum0 = sum1;
  325. choice0 = choice1;
  326.     }
  327.     /*fall*/
  328. case 2:
  329. case 5:
  330.     choice1++;
  331.     sum1 = count_bit_noESC2(choice1);
  332.     if (sum0 > sum1) {
  333. sum0 = sum1;
  334. choice0 = choice1;
  335.     }
  336.     break;
  338. case 13:
  339.     choice1 += 2;
  340.     sum1 = count_bit_noESC2(choice1);
  341.     if (sum0 > sum1) {
  342. sum0 = sum1;
  343. choice0 = choice1;
  344.     }
  345.     break;
  347. default:
  348.     break;
  349. }
  350. *s += sum0;
  351.     } else {
  352. /* try tables with linbits */
  353. max -= 15;
  355. for (choice1 = 24; choice1 < 32; choice1++) {
  356.     if ((int)ht[choice1].linmax >= max) {
  357. break;
  358.     }
  359. }
  361. for (choice0 = choice1 - 8; choice0 < 24; choice0++) {
  362.     if ((int)ht[choice0].linmax >= max) {
  363. break;
  364.     }
  365. }
  367. choice0 = count_bit_ESC(ix, end, choice0, choice1, s);
  368.     }
  370.     return choice0;
  371. }
  373. static int choose_table_short(int *ix, int *end, int * s)
  374. {
  375.     int max;
  376.     int choice0, sum0;
  377.     int choice1, sum1;
  379.     max = ix_max(ix, end);
  381.     if (max > IXMAX_VAL) {
  382.         *s = 100000;
  383.         return -1;
  384.     }
  386.     if (max <= 15)  {
  387. if (max == 0) {
  388.     return 0;
  389. }
  390. /* try tables with no linbits */
  391. choice0 = huf_tbl_noESC[max - 1];
  392. sum0 = count_bit_short_noESC(ix, end, choice0);
  393. choice1 = choice0;
  395. switch (choice0) {
  396. case 7:
  397. case 10:
  398.     choice1++;
  399.     sum1 = count_bit_noESC2(choice1);
  400.     if (sum0 > sum1) {
  401. sum0 = sum1;
  402. choice0 = choice1;
  403.     }
  404.     /*fall*/
  405. case 2:
  406. case 5:
  407.     choice1++;
  408.     sum1 = count_bit_noESC2(choice1);
  409.     if (sum0 > sum1) {
  410. sum0 = sum1;
  411. choice0 = choice1;
  412.     }
  413.     break;
  415. case 13:
  416.     choice1 += 2;
  417.     sum1 = count_bit_noESC2(choice1);
  418.     if (sum0 > sum1) {
  419. sum0 = sum1;
  420. choice0 = choice1;
  421.     }
  422.     break;
  424. default:
  425.     break;
  426. }
  427. *s += sum0;
  428.     } else {
  429. /* try tables with linbits */
  430. max -= 15;
  431. for (choice1 = 24; choice1 < 32; choice1++) {
  432.     if ((int)ht[choice1].linmax >= max) {
  433. break;
  434.     }
  435. }
  437. for (choice0 = choice1 - 8; choice0 < 24; choice0++) {
  438.     if ((int)ht[choice0].linmax >= max) {
  439. break;
  440. }
  441. }
  442. choice0 = count_bit_short_ESC(ix, end, choice0, choice1, s);
  443.     }
  445.     return choice0;
  446. }
  450. static int count_bits_long(int ix[576], gr_info *gi)
  451. {
  452.     int i, a1, a2;
  453.     int bits = 0;
  455.     i=576;
  456.     for (; i > 1; i -= 2) 
  457. if (ix[i - 1] | ix[i - 2])
  458.     break;
  460.     /* Determines the number of bits to encode the quadruples. */
  461.     gi->count1 = i;
  462.     a1 = 0;
  463.     for (; i > 3; i -= 4) {
  464. int p, v;
  465. if ((unsigned int)(ix[i-1] | ix[i-2] | ix[i-3] | ix[i-4]) > 1)
  466.     break;
  468. v = ix[i-1];
  469. p = v;
  470. bits += v;
  472. v = ix[i-2];
  473. if (v != 0) {
  474.     p += 2;
  475.     bits++;
  476. }
  478. v = ix[i-3];
  479. if (v != 0) {
  480.     p += 4;
  481.     bits++;
  482. }
  484. v = ix[i-4];
  485. if (v != 0) {
  486.     p += 8;
  487.     bits++;
  488. }
  490. a1 += ht[32].hlen[p];
  491.     }
  492.     a2 = gi->count1 - i;
  493.     if (a1 < a2) {
  494. bits += a1;
  495. gi->count1table_select = 0;
  496.     } else {
  497. bits += a2;
  498. gi->count1table_select = 1;
  499.     }
  501.     gi->count1bits = bits;
  502.     gi->big_values = i;
  503.     if (i == 0)
  504. return bits;
  506.     if (gi->block_type == NORM_TYPE) {
  507. int index;
  508. int scfb_anz = 0;
  510. while (scalefac_band.l[++scfb_anz] < i) 
  511.     ;
  512. index = subdv_table[scfb_anz].region0_count;
  513. while (scalefac_band.l[index + 1] > i)
  514.     index--;
  515. gi->region0_count = index;
  517. index = subdv_table[scfb_anz].region1_count;
  518. while (scalefac_band.l[index + gi->region0_count + 2] > i)
  519.     index--;
  520. gi->region1_count = index;
  522. a1 = scalefac_band.l[gi->region0_count + 1];
  523. a2 = scalefac_band.l[index + gi->region0_count + 2];
  524. gi->table_select[2] = choose_table(ix + a2, ix + i, &bits);
  526.     } else {
  527. gi->region0_count = 7;
  528. /*gi->region1_count = SBPSY_l - 7 - 1;*/
  529. gi->region1_count = SBMAX_l -1 - 7 - 1;
  530. a1 = scalefac_band.l[7 + 1];
  531. a2 = i;
  532. if (a1 > a2) {
  533.     a1 = a2;
  534. }
  535.     }
  537.     /* Count the number of bits necessary to code the bigvalues region. */
  538.     gi->table_select[0] = choose_table(ix, ix + a1, &bits);
  539.     gi->table_select[1] = choose_table(ix + a1, ix + a2, &bits);
  540.     return bits;
  541. }
  546. int count_bits(lame_global_flags *gfp,int *ix, FLOAT8 *xr, gr_info *cod_info)  
  547. {
  548.   int bits=0,i;
  549.   /* since quantize_xrpow uses table lookup, we need to check this first: */
  550.   FLOAT8 w = (IXMAX_VAL) / IPOW20(cod_info->global_gain);
  551.   for ( i = 0; i < 576; i++ )  {
  552.     if (xr[i] > w)
  553.       return 100000;
  554.   }
  555.   if (gfp->quantization) 
  556.     quantize_xrpow(xr, ix, cod_info);
  557.   else
  558.     quantize_xrpow_ISO(xr, ix, cod_info);
  562.   if (cod_info->block_type==SHORT_TYPE) {
  563.     cod_info->table_select[0] = choose_table_short(ix, ix + 36, &bits);
  564.     cod_info->table_select[1] = choose_table_short(ix + 36, ix + 576, &bits);
  565.     cod_info->big_values = 288;
  566.   }else{
  567.     bits=count_bits_long(ix, cod_info);
  568.     cod_info->count1 = (cod_info->count1 - cod_info->big_values) / 4;
  569.     cod_info->big_values /= 2;
  570.   }
  571.   return bits;
  573. }
  575. void best_huffman_divide(int gr, int ch, gr_info *gi, int *ix)
  576. {
  577.     int *bits, r0, r1, a1, a2, bigv;
  578.     int r1_bits;
  579.     int r3_bits[7 + 15 + 2 + 1];
  580.     int r3_tbl[7 + 15 + 2 + 1];
  581.     gr_info cod_info;
  583.     memcpy(&cod_info, gi, sizeof(gr_info));
  584.     bigv = cod_info.big_values * 2;
  585.     bits = (int *) &cod_info.part2_3_length;
  587.     for (r0 = 2; r0 < SBMAX_l + 1; r0++) {
  588. a2 = scalefac_band.l[r0];
  589. if (a2 > bigv)
  590.     break;
  592. r3_bits[r0] = cod_info.count1bits + cod_info.part2_length;
  593. r3_tbl[r0] = choose_table(ix + a2, ix + bigv, &r3_bits[r0]);
  594.     }
  595.     for (; r0 <= 7 + 15 + 2; r0++) {
  596. r3_bits[r0] = 100000;
  597.     }
  599.     for (r0 = 0; r0 < 16; r0++) {
  600. a1 = scalefac_band.l[r0 + 1];
  601. if (a1 > bigv)
  602.     break;
  603. cod_info.region0_count = r0;
  604. r1_bits = 0;
  605. cod_info.table_select[0] = choose_table(ix, ix + a1, &r1_bits);
  606. if ((int)gi->part2_3_length < r1_bits)
  607.     break;
  609. for (r1 = 0; r1 < 8; r1++) {
  610.     *bits = r1_bits + r3_bits[r0 + r1 + 2];
  611.     if ((int)gi->part2_3_length < *bits)
  612. continue;
  614.     a2 = scalefac_band.l[r0 + r1 + 2];
  616.     cod_info.table_select[1] = choose_table(ix + a1, ix + a2, bits);
  617.     if ((int)gi->part2_3_length < *bits)
  618. continue;
  620.     cod_info.region1_count = r1;
  621.     cod_info.table_select[2] = r3_tbl[r0 + r1 + 2];
  622.     memcpy(gi, &cod_info, sizeof(gr_info));
  623. }
  624.     }
  625. }
  627. static void
  628. scfsi_calc(int ch,
  629.    III_side_info_t *l3_side,
  630.    III_scalefac_t scalefac[2][2])
  631. {
  632.     int i, s1, s2, c1, c2;
  633.     int sfb;
  634.     gr_info *gi = &l3_side->gr[1].ch[ch].tt;
  636.     static const int scfsi_band[5] = { 0, 6, 11, 16, 21 };
  638.     static const int slen1_n[16] = { 0, 1, 1, 1, 8, 2, 2, 2, 4, 4, 4, 8, 8, 8,16,16 };
  639.     static const int slen2_n[16] = { 0, 2, 4, 8, 1, 2, 4, 8, 2, 4, 8, 2, 4, 8, 4, 8 };
  641.     static const int slen1_tab[16] = { 0, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4 };
  642.     static const int slen2_tab[16] = { 0, 1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 2, 3 };
  644.     for (i = 0; i < 4; i++) 
  645. l3_side->scfsi[ch][i] = 0;
  647.     for (i = 0; i < (int)(sizeof(scfsi_band) / sizeof(int)) - 1; i++) {
  648. for (sfb = scfsi_band[i]; sfb < scfsi_band[i + 1]; sfb++) {
  649.     if (scalefac[0][ch].l[sfb] != scalefac[1][ch].l[sfb])
  650. break;
  651. }
  652. if (sfb == scfsi_band[i + 1]) {
  653.     for (sfb = scfsi_band[i]; sfb < scfsi_band[i + 1]; sfb++) {
  654. scalefac[1][ch].l[sfb] = -1;
  655.     }
  656.     l3_side->scfsi[ch][i] = 1;
  657. }
  658.     }
  660.     s1 = c1 = 0;
  661.     for (sfb = 0; sfb < 11; sfb++) {
  662. if (scalefac[1][ch].l[sfb] < 0)
  663.     continue;
  664. c1++;
  665. if (s1 < scalefac[1][ch].l[sfb])
  666.     s1 = scalefac[1][ch].l[sfb];
  667.     }
  669.     s2 = c2 = 0;
  670.     for (; sfb < SBPSY_l; sfb++) {
  671. if (scalefac[1][ch].l[sfb] < 0)
  672.     continue;
  673. c2++;
  674. if (s2 < scalefac[1][ch].l[sfb])
  675.     s2 = scalefac[1][ch].l[sfb];
  676.     }
  677.     for (i = 0; i < 16; i++) {
  678. if (s1 < slen1_n[i] && s2 < slen2_n[i]) {
  679.     int c = slen1_tab[i] * c1 + slen2_tab[i] * c2;
  680.     if ((int)gi->part2_length > c) {
  681. gi->part2_length = c;
  682. gi->scalefac_compress = i;
  683.     }
  684. }
  685.     }
  686. }
  688. void best_scalefac_store(lame_global_flags *gfp,int gr, int ch,
  689.  int l3_enc[2][2][576],
  690.  III_side_info_t *l3_side,
  691.  III_scalefac_t scalefac[2][2])
  692. {
  693.     /* use scalefac_scale if we can */
  694.     gr_info *gi = &l3_side->gr[gr].ch[ch].tt;
  696.     /* remove scalefacs from bands with ix=0.  This idea comes
  697.      * from the AAC ISO docs.  added mt 3/00 */
  698.     int sfb,i,l,start,end;
  699.     /* check if l3_enc=0 */
  700.     for ( sfb = 0; sfb < gi->sfb_lmax; sfb++ ) {
  701.       if (scalefac[gr][ch].l[sfb]>0) { 
  702. start = scalefac_band.l[ sfb ];
  703. end   = scalefac_band.l[ sfb+1 ];
  704. for ( l = start; l < end; l++ ) if (l3_enc[gr][ch][l]!=0) break;
  705. if (l==end) scalefac[gr][ch].l[sfb]=0;
  706.       }
  707.     }
  708.     for ( i = 0; i < 3; i++ ) {
  709.       for ( sfb = gi->sfb_smax; sfb < SBPSY_s; sfb++ ) {
  710. if (scalefac[gr][ch].s[sfb][i]>0) {
  711.   start = scalefac_band.s[ sfb ];
  712.   end   = scalefac_band.s[ sfb+1 ];
  713.   for ( l = start; l < end; l++ ) 
  714.     if (l3_enc[gr][ch][3*l+i]!=0) break;
  715.   if (l==end) scalefac[gr][ch].s[sfb][i]=0;
  716.         }
  717.       }
  718.     }
  721.     gi->part2_3_length -= gi->part2_length;
  722.     if (!gi->scalefac_scale && !gi->preflag) {
  723. u_int sfb;
  724. int b, s = 0;
  725. for (sfb = 0; sfb < gi->sfb_lmax; sfb++) {
  726.     s |= scalefac[gr][ch].l[sfb];
  727. }
  729. for (sfb = gi->sfb_smax; sfb < SBPSY_s; sfb++) {
  730.     for (b = 0; b < 3; b++) {
  731. s |= scalefac[gr][ch].s[sfb][b];
  732.     }
  733. }
  735. if (!(s & 1) && s != 0) {
  736.     for (sfb = 0; sfb < gi->sfb_lmax; sfb++) {
  737. scalefac[gr][ch].l[sfb] /= 2;
  738.     }
  739.     for (sfb = gi->sfb_smax; sfb < SBPSY_s; sfb++) {
  740. for (b = 0; b < 3; b++) {
  741.     scalefac[gr][ch].s[sfb][b] /= 2;
  742. }
  743.     }
  745.     gi->scalefac_scale = 1;
  746.     gi->part2_length = 99999999;
  747.     if (gfp->mode_gr == 2) {
  748.         scale_bitcount(&scalefac[gr][ch], gi);
  749.     } else {
  750. scale_bitcount_lsf(&scalefac[gr][ch], gi);
  751.     }
  752. }
  753.     }
  755.     if (gfp->mode_gr == 2 && gr == 1
  756. && l3_side->gr[0].ch[ch].tt.block_type != SHORT_TYPE
  757. && l3_side->gr[1].ch[ch].tt.block_type != SHORT_TYPE
  758. && l3_side->gr[0].ch[ch].tt.scalefac_scale
  759. == l3_side->gr[1].ch[ch].tt.scalefac_scale
  760. && l3_side->gr[0].ch[ch].tt.preflag
  761. == l3_side->gr[1].ch[ch].tt.preflag) {
  762.        scfsi_calc(ch, l3_side, scalefac);
  763.     }
  764.     gi->part2_3_length += gi->part2_length;
  765. }