lib/lame/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  */
  21
  22 /* $Id: takehiro.c,v 1.2 2006/02/09 16:56:23 kramm Exp $ */
  23
  24 #include <stdlib.h>
  25 #include "config_static.h"
  26
  27 #include <assert.h>
  28 #include "util.h"
  29 #include "l3side.h"
  30 #include "tables.h"
  31 #include "quantize_pvt.h"
  32
  33 #ifdef WITH_DMALLOC
  34 #include <dmalloc.h>
  35 #endif
  36
  37 static const struct
  38 {
  39     const int region0_count;
  40     const int region1_count;
  41 } subdv_table[ 23 ] =
  42 {
  43 {0, 0}, /* 0 bands */
  44 {0, 0}, /* 1 bands */
  45 {0, 0}, /* 2 bands */
  46 {0, 0}, /* 3 bands */
  47 {0, 0}, /* 4 bands */
  48 {0, 1}, /* 5 bands */
  49 {1, 1}, /* 6 bands */
  50 {1, 1}, /* 7 bands */
  51 {1, 2}, /* 8 bands */
  52 {2, 2}, /* 9 bands */
  53 {2, 3}, /* 10 bands */
  54 {2, 3}, /* 11 bands */
  55 {3, 4}, /* 12 bands */
  56 {3, 4}, /* 13 bands */
  57 {3, 4}, /* 14 bands */
  58 {4, 5}, /* 15 bands */
  59 {4, 5}, /* 16 bands */
  60 {4, 6}, /* 17 bands */
  61 {5, 6}, /* 18 bands */
  62 {5, 6}, /* 19 bands */
  63 {5, 7}, /* 20 bands */
  64 {6, 7}, /* 21 bands */
  65 {6, 7}, /* 22 bands */
  66 };
  67
  68
  69
  70
  71 /*************************************************************************/
  72 /*            ix_max                                                     */
  73 /*************************************************************************/
  74
  75 int
  76 ix_max(const int *ix, const int *end)
  77 {
  78     int max1 = 0, max2 = 0;
  79
  80     do {
  81         int x1 = *ix++;
  82         int x2 = *ix++;
  83         if (max1 < x1)
  84             max1 = x1;
  85
  86         if (max2 < x2)
  87             max2 = x2;
  88     } while (ix < end);
  89     if (max1 < max2)
  90         max1 = max2;
  91     return max1;
  92 }
  93
  94
  95
  96
  97
  98
  99
 100
 101 int
 102 count_bit_ESC(
 103     const int *       ix,
 104     const int * const end,
 105           int         t1,
 106     const int         t2,
 107           int * const s )
 108 {
 109     /* ESC-table is used */
 110     int linbits = ht[t1].xlen * 65536 + ht[t2].xlen;
 111     int sum = 0, sum2;
 112
 113     do {
 114         int x = *ix++;
 115         int y = *ix++;
 116
 117         if (x != 0) {
 118             if (x > 14) {
 119                 x = 15;
 120                 sum += linbits;
 121             }
 122             x *= 16;
 123         }
 124
 125         if (y != 0) {
 126             if (y > 14) {
 127                 y = 15;
 128                 sum += linbits;
 129             }
 130             x += y;
 131         }
 132
 133         sum += largetbl[x];
 134     } while (ix < end);
 135
 136     sum2 = sum & 0xffff;
 137     sum >>= 16;
 138
 139     if (sum > sum2) {
 140         sum = sum2;
 141         t1 = t2;
 142     }
 143
 144     *s += sum;
 145     return t1;
 146 }
 147
 148
 149 inline static int
 150 count_bit_noESC(const int * ix, const int * const end, int * const s)
 151 {
 152     /* No ESC-words */
 153     int sum1 = 0;
 154     const char *hlen1 = ht[1].hlen;
 155
 156     do {
 157         int x = ix[0] * 2 + ix[1];
 158         ix += 2;
 159         sum1 += hlen1[x];
 160     } while (ix < end);
 161
 162     *s += sum1;
 163     return 1;
 164 }
 165
 166
 167
 168 inline static int
 169 count_bit_noESC_from2(
 170     const int *       ix,
 171     const int * const end,
 172           int         t1,
 173           int * const s )
 174 {
 175     /* No ESC-words */
 176     unsigned int sum = 0, sum2;
 177     const int xlen = ht[t1].xlen;
 178     const unsigned int *hlen;
 179     if (t1 == 2)
 180         hlen = table23;
 181     else
 182         hlen = table56;
 183
 184     do {
 185         int x = ix[0] * xlen + ix[1];
 186         ix += 2;
 187         sum += hlen[x];
 188     } while (ix < end);
 189
 190     sum2 = sum & 0xffff;
 191     sum >>= 16;
 192
 193     if (sum > sum2) {
 194         sum = sum2;
 195         t1++;
 196     }
 197
 198     *s += sum;
 199     return t1;
 200 }
 201
 202
 203 inline static int
 204 count_bit_noESC_from3(
 205     const int *       ix,
 206     const int * const end,
 207           int         t1,
 208           int * const s )
 209 {
 210     /* No ESC-words */
 211     int sum1 = 0;
 212     int sum2 = 0;
 213     int sum3 = 0;
 214     const int xlen = ht[t1].xlen;
 215     const char *hlen1 = ht[t1].hlen;
 216     const char *hlen2 = ht[t1+1].hlen;
 217     const char *hlen3 = ht[t1+2].hlen;
 218     int t;
 219
 220     do {
 221         int x = ix[0] * xlen + ix[1];
 222         ix += 2;
 223         sum1 += hlen1[x];
 224         sum2 += hlen2[x];
 225         sum3 += hlen3[x];
 226     } while (ix < end);
 227
 228     t = t1;
 229     if (sum1 > sum2) {
 230         sum1 = sum2;
 231         t++;
 232     }
 233     if (sum1 > sum3) {
 234         sum1 = sum3;
 235         t = t1+2;
 236     }
 237     *s += sum1;
 238
 239     return t;
 240 }
 241
 242
 243 /*************************************************************************/
 244 /*            choose table                                               */
 245 /*************************************************************************/
 246
 247 /*
 248   Choose the Huffman table that will encode ix[begin..end] with
 249   the fewest bits.
 250
 251   Note: This code contains knowledge about the sizes and characteristics
 252   of the Huffman tables as defined in the IS (Table B.7), and will not work
 253   with any arbitrary tables.
 254 */
 255
 256 static int choose_table_nonMMX(
 257     const int *       ix,
 258     const int * const end,
 259           int * const s )
 260 {
 261     int max;
 262     int choice, choice2;
 263     static const int huf_tbl_noESC[] = {
 264         1, 2, 5, 7, 7,10,10,13,13,13,13,13,13,13,13 /* char not enough ? */
 265     };
 266
 267     max = ix_max(ix, end);
 268
 269     switch (max) {
 270     case 0:
 271         return max;
 272
 273     case 1:
 274         return count_bit_noESC(ix, end, s);
 275
 276     case 2:
 277     case 3:
 278         return count_bit_noESC_from2(ix, end, huf_tbl_noESC[max - 1], s);
 279
 280     case 4: case 5: case 6:
 281     case 7: case 8: case 9:
 282     case 10: case 11: case 12:
 283     case 13: case 14: case 15:
 284         return count_bit_noESC_from3(ix, end, huf_tbl_noESC[max - 1], s);
 285
 286     default:
 287         /* try tables with linbits */
 288         if (max > IXMAX_VAL) {
 289             *s = LARGE_BITS;
 290             return -1;
 291         }
 292         max -= 15;
 293         for (choice2 = 24; choice2 < 32; choice2++) {
 294             if (ht[choice2].linmax >= max) {
 295                 break;
 296             }
 297         }
 298
 299         for (choice = choice2 - 8; choice < 24; choice++) {
 300             if (ht[choice].linmax >= max) {
 301                 break;
 302             }
 303         }
 304         return count_bit_ESC(ix, end, choice, choice2, s);
 305     }
 306 }
 307
 308
 309
 310 /*************************************************************************/
 311 /*            count_bit                                                  */
 312 /*************************************************************************/
 313
 314 int count_bits(
 315           lame_internal_flags * const gfc,
 316           int     * const ix,
 317     const FLOAT8  * const xr,
 318           gr_info * const gi)
 319 {
 320     int bits = 0;
 321     int i, a1, a2;
 322     /* since quantize_xrpow uses table lookup, we need to check this first: */
 323     FLOAT8 w = (IXMAX_VAL) / IPOW20(gi->global_gain);
 324     for ( i = 0; i < 576; i++ )  {
 325         if (xr[i] > w)
 326             return LARGE_BITS;
 327     }
 328
 329     if (gfc->quantization)
 330         quantize_xrpow(xr, ix, IPOW20(gi->global_gain));
 331     else
 332         quantize_xrpow_ISO(xr, ix, IPOW20(gi->global_gain));
 333
 334     if (gfc->noise_shaping_amp==3) {
 335       int sfb;
 336       // 0.634521682242439 = 0.5946*2**(.5*0.1875)
 337       FLOAT8 roundfac = 0.634521682242439 / IPOW20(gi->global_gain+gi->scalefac_scale);
 338       i = 0;
 339       for (sfb = 0; sfb < gi->sfb_lmax; sfb++) {
 340         int end;
 341         if (!gfc->pseudohalf.l[sfb])
 342           continue;
 343
 344         end   = gfc->scalefac_band.l[sfb+1];
 345         for (; i < end; i++)
 346           if (xr[i] < roundfac)
 347             ix[i] = 0;
 348       }
 349
 350       for (sfb = gi->sfb_smin; sfb < SBPSY_s; sfb++) {
 351         int start, end, win;
 352         start = gfc->scalefac_band.s[sfb];
 353         end   = gfc->scalefac_band.s[sfb+1];
 354         for (win = 0; win < 3; win++) {
 355           int j;
 356           if (!gfc->pseudohalf.s[sfb][win])
 357             continue;
 358           for (j = start; j < end; j++, i++)
 359             if (xr[i] < roundfac)
 360               ix[i] = 0;
 361         }
 362       }
 363     }
 364
 365
 366
 367
 368
 369
 370     i=576;
 371     /* Determine count1 region */
 372     for (; i > 1; i -= 2)
 373         if (ix[i - 1] | ix[i - 2])
 374             break;
 375     gi->count1 = i;
 376
 377     /* Determines the number of bits to encode the quadruples. */
 378     a1 = a2 = 0;
 379     for (; i > 3; i -= 4) {
 380         int p;
 381         /* hack to check if all values <= 1 */
 382         if ((unsigned int)(ix[i-1] | ix[i-2] | ix[i-3] | ix[i-4]) > 1)
 383             break;
 384
 385         p = ((ix[i-4] * 2 + ix[i-3]) * 2 + ix[i-2]) * 2 + ix[i-1];
 386         a1 += t32l[p];
 387         a2 += t33l[p];
 388     }
 389
 390     bits = a1;
 391     gi->count1table_select = 0;
 392     if (a1 > a2) {
 393         bits = a2;
 394         gi->count1table_select = 1;
 395     }
 396
 397     gi->count1bits = bits;
 398     gi->big_values = i;
 399     if (i == 0)
 400         return bits;
 401
 402     if (gi->block_type == SHORT_TYPE) {
 403       a1=3*gfc->scalefac_band.s[3];
 404       if (a1 > gi->big_values) a1 = gi->big_values;
 405       a2 = gi->big_values;
 406
 407     }else if (gi->block_type == NORM_TYPE) {
 408         assert(i <= 576); /* bv_scf has 576 entries (0..575) */
 409         a1 = gi->region0_count = gfc->bv_scf[i-2];
 410         a2 = gi->region1_count = gfc->bv_scf[i-1];
 411
 412         assert(a1+a2+2 < SBPSY_l);
 413         a2 = gfc->scalefac_band.l[a1 + a2 + 2];
 414         a1 = gfc->scalefac_band.l[a1 + 1];
 415         if (a2 < i)
 416           gi->table_select[2] = gfc->choose_table(ix + a2, ix + i, &bits);
 417
 418     } else {
 419         gi->region0_count = 7;
 420         /*gi->region1_count = SBPSY_l - 7 - 1;*/
 421         gi->region1_count = SBMAX_l -1 - 7 - 1;
 422         a1 = gfc->scalefac_band.l[7 + 1];
 423         a2 = i;
 424         if (a1 > a2) {
 425             a1 = a2;
 426         }
 427     }
 428
 429
 430     /* have to allow for the case when bigvalues < region0 < region1 */
 431     /* (and region0, region1 are ignored) */
 432     a1 = Min(a1,i);
 433     a2 = Min(a2,i);
 434
 435     assert( a1 >= 0 );
 436     assert( a2 >= 0 );
 437
 438     /* Count the number of bits necessary to code the bigvalues region. */
 439     if (0 < a1)
 440       gi->table_select[0] = gfc->choose_table(ix, ix + a1, &bits);
 441     if (a1 < a2)
 442       gi->table_select[1] = gfc->choose_table(ix + a1, ix + a2, &bits);
 443     return bits;
 444 }
 445
 446 /***********************************************************************
 447   re-calculate the best scalefac_compress using scfsi
 448   the saved bits are kept in the bit reservoir.
 449  **********************************************************************/
 450
 451
 452 inline static void
 453 recalc_divide_init(
 454     const lame_internal_flags * const gfc,
 455           gr_info         cod_info,
 456           int     * const ix,
 457           int             r01_bits[],
 458           int             r01_div [],
 459           int             r0_tbl  [],
 460           int             r1_tbl  [] )
 461 {
 462     int r0, r1, bigv, r0t, r1t, bits;
 463
 464     bigv = cod_info.big_values;
 465
 466     for (r0 = 0; r0 <= 7 + 15; r0++) {
 467         r01_bits[r0] = LARGE_BITS;
 468     }
 469
 470     for (r0 = 0; r0 < 16; r0++) {
 471         int a1 = gfc->scalefac_band.l[r0 + 1], r0bits;
 472         if (a1 >= bigv)
 473             break;
 474         r0bits = cod_info.part2_length;
 475         r0t = gfc->choose_table(ix, ix + a1, &r0bits);
 476
 477         for (r1 = 0; r1 < 8; r1++) {
 478             int a2 = gfc->scalefac_band.l[r0 + r1 + 2];
 479             if (a2 >= bigv)
 480                 break;
 481
 482             bits = r0bits;
 483             r1t = gfc->choose_table(ix + a1, ix + a2, &bits);
 484             if (r01_bits[r0 + r1] > bits) {
 485                 r01_bits[r0 + r1] = bits;
 486                 r01_div[r0 + r1] = r0;
 487                 r0_tbl[r0 + r1] = r0t;
 488                 r1_tbl[r0 + r1] = r1t;
 489             }
 490         }
 491     }
 492 }
 493
 494 inline static void
 495 recalc_divide_sub(
 496     const lame_internal_flags * const gfc,
 497     const gr_info         cod_info2,
 498           gr_info * const gi,
 499     const int     * const ix,
 500     const int             r01_bits[],
 501     const int             r01_div [],
 502     const int             r0_tbl  [],
 503     const int             r1_tbl  [] )
 504 {
 505     int bits, r2, a2, bigv, r2t;
 506
 507     bigv = cod_info2.big_values;
 508
 509     for (r2 = 2; r2 < SBMAX_l + 1; r2++) {
 510         a2 = gfc->scalefac_band.l[r2];
 511         if (a2 >= bigv)
 512             break;
 513
 514         bits = r01_bits[r2 - 2] + cod_info2.count1bits;
 515         if (gi->part2_3_length <= bits)
 516             break;
 517
 518         r2t = gfc->choose_table(ix + a2, ix + bigv, &bits);
 519         if (gi->part2_3_length <= bits)
 520             continue;
 521
 522         memcpy(gi, &cod_info2, sizeof(gr_info));
 523         gi->part2_3_length = bits;
 524         gi->region0_count = r01_div[r2 - 2];
 525         gi->region1_count = r2 - 2 - r01_div[r2 - 2];
 526         gi->table_select[0] = r0_tbl[r2 - 2];
 527         gi->table_select[1] = r1_tbl[r2 - 2];
 528         gi->table_select[2] = r2t;
 529     }
 530 }
 531
 532
 533
 534
 535 void best_huffman_divide(
 536     const lame_internal_flags * const gfc,
 537           gr_info * const gi,
 538           int     * const ix )
 539 {
 540     int i, a1, a2;
 541     gr_info cod_info2;
 542
 543     int r01_bits[7 + 15 + 1];
 544     int r01_div[7 + 15 + 1];
 545     int r0_tbl[7 + 15 + 1];
 546     int r1_tbl[7 + 15 + 1];
 547
 548
 549     /* SHORT BLOCK stuff fails for MPEG2 */
 550     if (gi->block_type == SHORT_TYPE && gfc->mode_gr==1)
 551           return;
 552
 553
 554     memcpy(&cod_info2, gi, sizeof(gr_info));
 555     if (gi->block_type == NORM_TYPE) {
 556         recalc_divide_init(gfc, cod_info2, ix, r01_bits,r01_div,r0_tbl,r1_tbl);
 557         recalc_divide_sub(gfc, cod_info2, gi, ix, r01_bits,r01_div,r0_tbl,r1_tbl);
 558     }
 559
 560     i = cod_info2.big_values;
 561     if (i == 0 || (unsigned int)(ix[i-2] | ix[i-1]) > 1)
 562         return;
 563
 564     i = gi->count1 + 2;
 565     if (i > 576)
 566         return;
 567
 568     /* Determines the number of bits to encode the quadruples. */
 569     memcpy(&cod_info2, gi, sizeof(gr_info));
 570     cod_info2.count1 = i;
 571     a1 = a2 = 0;
 572
 573     assert(i <= 576);
 574
 575     for (; i > cod_info2.big_values; i -= 4) {
 576         int p = ((ix[i-4] * 2 + ix[i-3]) * 2 + ix[i-2]) * 2 + ix[i-1];
 577         a1 += t32l[p];
 578         a2 += t33l[p];
 579     }
 580     cod_info2.big_values = i;
 581
 582     cod_info2.count1table_select = 0;
 583     if (a1 > a2) {
 584         a1 = a2;
 585         cod_info2.count1table_select = 1;
 586     }
 587
 588     cod_info2.count1bits = a1;
 589     cod_info2.part2_3_length = a1 + cod_info2.part2_length;
 590
 591     if (cod_info2.block_type == NORM_TYPE)
 592         recalc_divide_sub(gfc, cod_info2, gi, ix, r01_bits,r01_div,r0_tbl,r1_tbl);
 593     else {
 594         /* Count the number of bits necessary to code the bigvalues region. */
 595         a1 = gfc->scalefac_band.l[7 + 1];
 596         if (a1 > i) {
 597             a1 = i;
 598         }
 599         if (a1 > 0)
 600           cod_info2.table_select[0] =
 601             gfc->choose_table(ix, ix + a1, (int *)&cod_info2.part2_3_length);
 602         if (i > a1)
 603           cod_info2.table_select[1] =
 604             gfc->choose_table(ix + a1, ix + i, (int *)&cod_info2.part2_3_length);
 605         if (gi->part2_3_length > cod_info2.part2_3_length)
 606             memcpy(gi, &cod_info2, sizeof(gr_info));
 607     }
 608 }
 609
 610 static const int slen1_n[16] = { 1, 1, 1, 1, 8, 2, 2, 2, 4, 4, 4, 8, 8, 8,16,16 };
 611 static const int slen2_n[16] = { 1, 2, 4, 8, 1, 2, 4, 8, 2, 4, 8, 2, 4, 8, 4, 8 };
 612
 613 void
 614 scfsi_calc(int ch,
 615            III_side_info_t *l3_side,
 616            III_scalefac_t scalefac[2][2])
 617 {
 618     int i, s1, s2, c1, c2;
 619     int sfb;
 620     gr_info *gi = &l3_side->gr[1].ch[ch].tt;
 621
 622     static const int scfsi_band[5] = { 0, 6, 11, 16, 21 };
 623 #if 0
 624     static const int slen1_n[16] = { 0, 1, 1, 1, 8, 2, 2, 2, 4, 4, 4, 8, 8, 8,16,16 };
 625     static const int slen2_n[16] = { 0, 2, 4, 8, 1, 2, 4, 8, 2, 4, 8, 2, 4, 8, 4, 8 };
 626 #endif
 627
 628     for (i = 0; i < 4; i++)
 629         l3_side->scfsi[ch][i] = 0;
 630
 631     for (i = 0; i < (sizeof(scfsi_band) / sizeof(int)) - 1; i++) {
 632         for (sfb = scfsi_band[i]; sfb < scfsi_band[i + 1]; sfb++) {
 633             if (scalefac[0][ch].l[sfb] != scalefac[1][ch].l[sfb])
 634                 break;
 635         }
 636         if (sfb == scfsi_band[i + 1]) {
 637             for (sfb = scfsi_band[i]; sfb < scfsi_band[i + 1]; sfb++) {
 638                 scalefac[1][ch].l[sfb] = -1;
 639             }
 640             l3_side->scfsi[ch][i] = 1;
 641         }
 642     }
 643
 644     s1 = c1 = 0;
 645     for (sfb = 0; sfb < 11; sfb++) {
 646         if (scalefac[1][ch].l[sfb] < 0)
 647             continue;
 648         c1++;
 649         if (s1 < scalefac[1][ch].l[sfb])
 650             s1 = scalefac[1][ch].l[sfb];
 651     }
 652
 653     s2 = c2 = 0;
 654     for (; sfb < SBPSY_l; sfb++) {
 655         if (scalefac[1][ch].l[sfb] < 0)
 656             continue;
 657         c2++;
 658         if (s2 < scalefac[1][ch].l[sfb])
 659             s2 = scalefac[1][ch].l[sfb];
 660     }
 661
 662     for (i = 0; i < 16; i++) {
 663         if (s1 < slen1_n[i] && s2 < slen2_n[i]) {
 664             int c = slen1_tab[i] * c1 + slen2_tab[i] * c2;
 665             if (gi->part2_length > c) {
 666                 gi->part2_length = c;
 667                 gi->scalefac_compress = i;
 668             }
 669         }
 670     }
 671 }
 672
 673 /*
 674 Find the optimal way to store the scalefactors.
 675 Only call this routine after final scalefactors have been
 676 chosen and the channel/granule will not be re-encoded.
 677  */
 678 void best_scalefac_store(
 679     const lame_internal_flags *gfc,
 680     const int             gr,
 681     const int             ch,
 682           int             l3_enc[2][2][576],
 683           III_side_info_t * const l3_side,
 684           III_scalefac_t          scalefac[2][2] )
 685 {
 686
 687     /* use scalefac_scale if we can */
 688     gr_info *gi = &l3_side->gr[gr].ch[ch].tt;
 689     int sfb,i,j,j2,l,start,end;
 690
 691     /* remove scalefacs from bands with ix=0.  This idea comes
 692      * from the AAC ISO docs.  added mt 3/00 */
 693     /* check if l3_enc=0 */
 694     for ( sfb = 0; sfb < gi->sfb_lmax; sfb++ ) {
 695       if (scalefac[gr][ch].l[sfb]>0) {
 696         start = gfc->scalefac_band.l[ sfb ];
 697         end   = gfc->scalefac_band.l[ sfb+1 ];
 698         for ( l = start; l < end; l++ ) if (l3_enc[gr][ch][l]!=0) break;
 699         if (l==end) scalefac[gr][ch].l[sfb]=0;
 700       }
 701     }
 702     for ( j=0, sfb = gi->sfb_smin; sfb < SBPSY_s; sfb++ ) {
 703         start = gfc->scalefac_band.s[ sfb ];
 704         end   = gfc->scalefac_band.s[ sfb+1 ];
 705         for ( i = 0; i < 3; i++ ) {
 706           if (scalefac[gr][ch].s[sfb][i]>0) {
 707             j2 = j;
 708             for ( l = start; l < end; l++ )
 709               if (l3_enc[gr][ch][j2++ /*3*l+i*/]!=0) break;
 710             if (l==end) scalefac[gr][ch].s[sfb][i]=0;
 711           }
 712           j += end-start;
 713         }
 714     }
 715
 716
 717     gi->part2_3_length -= gi->part2_length;
 718     if (!gi->scalefac_scale && !gi->preflag) {
 719         int b, s = 0;
 720         for (sfb = 0; sfb < gi->sfb_lmax; sfb++) {
 721             s |= scalefac[gr][ch].l[sfb];
 722         }
 723
 724         for (sfb = gi->sfb_smin; sfb < SBPSY_s; sfb++) {
 725             for (b = 0; b < 3; b++) {
 726                 s |= scalefac[gr][ch].s[sfb][b];
 727             }
 728         }
 729
 730         if (!(s & 1) && s != 0) {
 731             for (sfb = 0; sfb < gi->sfb_lmax; sfb++) {
 732                 scalefac[gr][ch].l[sfb] /= 2;
 733             }
 734             for (sfb = gi->sfb_smin; sfb < SBPSY_s; sfb++) {
 735                 for (b = 0; b < 3; b++) {
 736                     scalefac[gr][ch].s[sfb][b] /= 2;
 737                 }
 738             }
 739
 740             gi->scalefac_scale = 1;
 741             gi->part2_length = 99999999;
 742             if (gfc->mode_gr == 2) {
 743                 scale_bitcount(&scalefac[gr][ch], gi);
 744             } else {
 745                 scale_bitcount_lsf(gfc,&scalefac[gr][ch], gi);
 746             }
 747         }
 748     }
 749
 750
 751     for ( i = 0; i < 4; i++ )
 752       l3_side->scfsi[ch][i] = 0;
 753
 754     if (gfc->mode_gr==2 && gr == 1
 755         && l3_side->gr[0].ch[ch].tt.block_type != SHORT_TYPE
 756         && l3_side->gr[1].ch[ch].tt.block_type != SHORT_TYPE) {
 757         scfsi_calc(ch, l3_side, scalefac);
 758     }
 759     gi->part2_3_length += gi->part2_length;
 760 }
 761
 762
 763 /* number of bits used to encode scalefacs */
 764
 765 /* 18*slen1_tab[i] + 18*slen2_tab[i] */
 766 static const int scale_short[16] = {
 767     0, 18, 36, 54, 54, 36, 54, 72, 54, 72, 90, 72, 90, 108, 108, 126 };
 768
 769 /* 17*slen1_tab[i] + 18*slen2_tab[i] */
 770 static const int scale_mixed[16] = {
 771     0, 18, 36, 54, 51, 35, 53, 71, 52, 70, 88, 69, 87, 105, 104, 122 };
 772
 773 /* 11*slen1_tab[i] + 10*slen2_tab[i] */
 774 static const int scale_long[16] = {
 775     0, 10, 20, 30, 33, 21, 31, 41, 32, 42, 52, 43, 53, 63, 64, 74 };
 776
 777
 778 /*************************************************************************/
 779 /*            scale_bitcount                                             */
 780 /*************************************************************************/
 781
 782 /* Also calculates the number of bits necessary to code the scalefactors. */
 783
 784 int scale_bitcount(
 785     III_scalefac_t * const scalefac, gr_info * const cod_info)
 786 {
 787     int i, k, sfb, max_slen1 = 0, max_slen2 = 0, ep = 2;
 788
 789     /* maximum values */
 790     const int *tab;
 791
 792
 793     if ( cod_info->block_type == SHORT_TYPE ) {
 794         tab = scale_short;
 795         if (cod_info->mixed_block_flag) {
 796             tab = scale_mixed;
 797             for ( sfb = 0 ; sfb < cod_info->sfb_lmax; sfb++ )
 798                 if (max_slen1 < scalefac->l[sfb])
 799                     max_slen1 = scalefac->l[sfb];
 800         }
 801
 802         for ( i = 0; i < 3; i++ ) {
 803             for ( sfb = cod_info->sfb_smin; sfb < 6; sfb++ )
 804                 if (max_slen1 < scalefac->s[sfb][i])
 805                     max_slen1 = scalefac->s[sfb][i];
 806             for (sfb = 6; sfb < SBPSY_s; sfb++ )
 807                 if (max_slen2 < scalefac->s[sfb][i])
 808                     max_slen2 = scalefac->s[sfb][i];
 809         }
 810     }
 811     else
 812     { /* block_type == 1,2,or 3 */
 813         tab = scale_long;
 814         for ( sfb = 0; sfb < 11; sfb++ )
 815             if ( scalefac->l[sfb] > max_slen1 )
 816                 max_slen1 = scalefac->l[sfb];
 817
 818         if (!cod_info->preflag) {
 819             for ( sfb = 11; sfb < SBPSY_l; sfb++ )
 820                 if (scalefac->l[sfb] < pretab[sfb])
 821                     break;
 822
 823             if (sfb == SBPSY_l) {
 824                 cod_info->preflag = 1;
 825                 for ( sfb = 11; sfb < SBPSY_l; sfb++ )
 826                     scalefac->l[sfb] -= pretab[sfb];
 827             }
 828         }
 829
 830         for ( sfb = 11; sfb < SBPSY_l; sfb++ )
 831             if ( scalefac->l[sfb] > max_slen2 )
 832                 max_slen2 = scalefac->l[sfb];
 833     }
 834
 835
 836     /* from Takehiro TOMINAGA <tominaga@isoternet.org> 10/99
 837      * loop over *all* posible values of scalefac_compress to find the
 838      * one which uses the smallest number of bits.  ISO would stop
 839      * at first valid index */
 840     cod_info->part2_length = LARGE_BITS;
 841     for ( k = 0; k < 16; k++ )
 842     {
 843         if ( (max_slen1 < slen1_n[k]) && (max_slen2 < slen2_n[k]) &&
 844              (cod_info->part2_length > tab[k])) {
 845           cod_info->part2_length=tab[k];
 846           cod_info->scalefac_compress=k;
 847           ep=0;  /* we found a suitable scalefac_compress */
 848         }
 849     }
 850     return ep;
 851 }
 852
 853
 854
 855 /*
 856   table of largest scalefactor values for MPEG2
 857 */
 858 static const int max_range_sfac_tab[6][4] =
 859 {
 860  { 15, 15, 7,  7},
 861  { 15, 15, 7,  0},
 862  { 7,  3,  0,  0},
 863  { 15, 31, 31, 0},
 864  { 7,  7,  7,  0},
 865  { 3,  3,  0,  0}
 866 };
 867
 868
 869
 870
 871 /*************************************************************************/
 872 /*            scale_bitcount_lsf                                         */
 873 /*************************************************************************/
 874
 875 /* Also counts the number of bits to encode the scalefacs but for MPEG 2 */
 876 /* Lower sampling frequencies  (24, 22.05 and 16 kHz.)                   */
 877
 878 /*  This is reverse-engineered from section 2.4.3.2 of the MPEG2 IS,     */
 879 /* "Audio Decoding Layer III"                                            */
 880
 881 int scale_bitcount_lsf(const lame_internal_flags *gfc,
 882     const III_scalefac_t * const scalefac, gr_info * const cod_info)
 883 {
 884     int table_number, row_in_table, partition, nr_sfb, window, over;
 885     int i, sfb, max_sfac[ 4 ];
 886     const int *partition_table;
 887
 888     /*
 889       Set partition table. Note that should try to use table one,
 890       but do not yet...
 891     */
 892     if ( cod_info->preflag )
 893         table_number = 2;
 894     else
 895         table_number = 0;
 896
 897     for ( i = 0; i < 4; i++ )
 898         max_sfac[i] = 0;
 899
 900     if ( cod_info->block_type == SHORT_TYPE )
 901     {
 902             row_in_table = 1;
 903             partition_table = &nr_of_sfb_block[table_number][row_in_table][0];
 904             for ( sfb = 0, partition = 0; partition < 4; partition++ )
 905             {
 906                 nr_sfb = partition_table[ partition ] / 3;
 907                 for ( i = 0; i < nr_sfb; i++, sfb++ )
 908                     for ( window = 0; window < 3; window++ )
 909                         if ( scalefac->s[sfb][window] > max_sfac[partition] )
 910                             max_sfac[partition] = scalefac->s[sfb][window];
 911             }
 912     }
 913     else
 914     {
 915         row_in_table = 0;
 916         partition_table = &nr_of_sfb_block[table_number][row_in_table][0];
 917         for ( sfb = 0, partition = 0; partition < 4; partition++ )
 918         {
 919             nr_sfb = partition_table[ partition ];
 920             for ( i = 0; i < nr_sfb; i++, sfb++ )
 921                 if ( scalefac->l[sfb] > max_sfac[partition] )
 922                     max_sfac[partition] = scalefac->l[sfb];
 923         }
 924     }
 925
 926     for ( over = 0, partition = 0; partition < 4; partition++ )
 927     {
 928         if ( max_sfac[partition] > max_range_sfac_tab[table_number][partition] )
 929             over++;
 930     }
 931     if ( !over )
 932     {
 933         /*
 934           Since no bands have been over-amplified, we can set scalefac_compress
 935           and slen[] for the formatter
 936         */
 937         static const int log2tab[] = { 0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4 };
 938
 939         int slen1, slen2, slen3, slen4;
 940
 941         cod_info->sfb_partition_table = nr_of_sfb_block[table_number][row_in_table];
 942         for ( partition = 0; partition < 4; partition++ )
 943             cod_info->slen[partition] = log2tab[max_sfac[partition]];
 944
 945         /* set scalefac_compress */
 946         slen1 = cod_info->slen[ 0 ];
 947         slen2 = cod_info->slen[ 1 ];
 948         slen3 = cod_info->slen[ 2 ];
 949         slen4 = cod_info->slen[ 3 ];
 950
 951         switch ( table_number )
 952         {
 953           case 0:
 954             cod_info->scalefac_compress = (((slen1 * 5) + slen2) << 4)
 955                 + (slen3 << 2)
 956                 + slen4;
 957             break;
 958
 959           case 1:
 960             cod_info->scalefac_compress = 400
 961                 + (((slen1 * 5) + slen2) << 2)
 962                 + slen3;
 963             break;
 964
 965           case 2:
 966             cod_info->scalefac_compress = 500 + (slen1 * 3) + slen2;
 967             break;
 968
 969           default:
 970             ERRORF(gfc,"intensity stereo not implemented yet\n" );
 971             break;
 972         }
 973     }
 974 #ifdef DEBUG
 975     if ( over )
 976         ERRORF(gfc, "---WARNING !! Amplification of some bands over limits\n" );
 977 #endif
 978     if (!over) {
 979       assert( cod_info->sfb_partition_table );
 980       cod_info->part2_length=0;
 981       for ( partition = 0; partition < 4; partition++ )
 982         cod_info->part2_length += cod_info->slen[partition] * cod_info->sfb_partition_table[partition];
 983     }
 984     return over;
 985 }
 986
 987
 988
 989 void huffman_init(lame_internal_flags * const gfc)
 990 {
 991     int i;
 992
 993     gfc->choose_table = choose_table_nonMMX;
 994
 995 #ifdef MMX_choose_table
 996     if (gfc->CPU_features.MMX) {
 997         extern int choose_table_MMX(const int *ix, const int *end, int *s);
 998         gfc->choose_table = choose_table_MMX;
 999     }
1000 #endif
1001
1002     for (i = 2; i <= 576; i += 2) {
1003         int scfb_anz = 0, index;
1004         while (gfc->scalefac_band.l[++scfb_anz] < i)
1005             ;
1006
1007         index = subdv_table[scfb_anz].region0_count;
1008         while (gfc->scalefac_band.l[index + 1] > i)
1009             index--;
1010
1011         if (index < 0) {
1012           /* this is an indication that everything is going to
1013              be encoded as region0:  bigvalues < region0 < region1
1014              so lets set region0, region1 to some value larger
1015              than bigvalues */
1016           index = subdv_table[scfb_anz].region0_count;
1017         }
1018
1019         gfc->bv_scf[i-2] = index;
1020
1021         index = subdv_table[scfb_anz].region1_count;
1022         while (gfc->scalefac_band.l[index + gfc->bv_scf[i-2] + 2] > i)
1023             index--;
1024
1025         if (index < 0) {
1026           index = subdv_table[scfb_anz].region1_count;
1027         }
1028
1029         gfc->bv_scf[i-1] = index;
1030     }
1031 }