lib/lame/bitstream.c

   1 /*
   2  *      MP3 bitstream Output interface for LAME
   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  * $Id: bitstream.c,v 1.3 2006/02/09 16:56:23 kramm Exp $
  22  */
  23
  24
  25 #include <stdlib.h>
  26 #include "config_static.h"
  27
  28 #include <stdlib.h>
  29 #include <assert.h>
  30 #include <stdio.h>
  31 #include "tables.h"
  32 #include "bitstream.h"
  33 #include "quantize.h"
  34 #include "quantize_pvt.h"
  35 #include "version.h"
  36 #include "VbrTag.h"
  37
  38 #ifdef WITH_DMALLOC
  39 #include <dmalloc.h>
  40 #endif
  41
  42 /* This is the scfsi_band table from 2.4.2.7 of the IS */
  43 const int scfsi_band[5] = { 0, 6, 11, 16, 21 };
  44
  45
  46 /* unsigned int is at least this large:  */
  47 /* we work with ints, so when doing bit manipulation, we limit
  48  * ourselves to MAX_LENGTH-2 just to be on the safe side */
  49 #define MAX_LENGTH      32
  50
  51
  52
  53 #ifdef DEBUG
  54 static int hoge, hogege;
  55 #endif
  56
  57
  58
  59
  60
  61 void putheader_bits(lame_internal_flags *gfc,int w_ptr)
  62 {
  63     Bit_stream_struc *bs;
  64     bs = &gfc->bs;
  65 #ifdef DEBUG
  66     hoge += gfc->sideinfo_len * 8;
  67     hogege += gfc->sideinfo_len * 8;
  68 #endif
  69     memcpy(&bs->buf[bs->buf_byte_idx], gfc->header[gfc->w_ptr].buf,
  70            gfc->sideinfo_len);
  71     bs->buf_byte_idx += gfc->sideinfo_len;
  72     bs->totbit += gfc->sideinfo_len * 8;
  73     gfc->w_ptr = (gfc->w_ptr + 1) & (MAX_HEADER_BUF - 1);
  74 }
  75
  76
  77
  78
  79 /*write j bits into the bit stream */
  80 inline static void
  81 putbits2(lame_global_flags *gfp, int val, int j)
  82 {
  83     lame_internal_flags *gfc=gfp->internal_flags;
  84     Bit_stream_struc *bs;
  85     bs = &gfc->bs;
  86
  87     assert(j < MAX_LENGTH-2);
  88
  89     while (j > 0) {
  90         int k;
  91         if (bs->buf_bit_idx == 0) {
  92             bs->buf_bit_idx = 8;
  93             bs->buf_byte_idx++;
  94             assert(bs->buf_byte_idx < BUFFER_SIZE);
  95             assert(gfc->header[gfc->w_ptr].write_timing >= bs->totbit);
  96             if (gfc->header[gfc->w_ptr].write_timing == bs->totbit) {
  97               putheader_bits(gfc,gfc->w_ptr);
  98             }
  99             bs->buf[bs->buf_byte_idx] = 0;
 100         }
 101
 102         k = Min(j, bs->buf_bit_idx);
 103         j -= k;
 104
 105         bs->buf_bit_idx -= k;
 106
 107         assert (j < MAX_LENGTH); /* 32 too large on 32 bit machines */
 108         assert (bs->buf_bit_idx < MAX_LENGTH);
 109
 110         bs->buf[bs->buf_byte_idx] |= ((val >> j) << bs->buf_bit_idx);
 111         bs->totbit += k;
 112     }
 113 }
 114
 115 /*write j bits into the bit stream, ignoring frame headers */
 116 inline static void
 117 putbits_noheaders(lame_global_flags *gfp, int val, int j)
 118 {
 119     lame_internal_flags *gfc=gfp->internal_flags;
 120     Bit_stream_struc *bs;
 121     bs = &gfc->bs;
 122
 123     assert(j < MAX_LENGTH-2);
 124
 125     while (j > 0) {
 126         int k;
 127         if (bs->buf_bit_idx == 0) {
 128             bs->buf_bit_idx = 8;
 129             bs->buf_byte_idx++;
 130             assert(bs->buf_byte_idx < BUFFER_SIZE);
 131             bs->buf[bs->buf_byte_idx] = 0;
 132         }
 133
 134         k = Min(j, bs->buf_bit_idx);
 135         j -= k;
 136
 137         bs->buf_bit_idx -= k;
 138
 139         assert (j < MAX_LENGTH); /* 32 too large on 32 bit machines */
 140         assert (bs->buf_bit_idx < MAX_LENGTH);
 141
 142         bs->buf[bs->buf_byte_idx] |= ((val >> j) << bs->buf_bit_idx);
 143         bs->totbit += k;
 144     }
 145 }
 146
 147
 148 /*
 149   Some combinations of bitrate, Fs, and stereo make it impossible to stuff
 150   out a frame using just main_data, due to the limited number of bits to
 151   indicate main_data_length. In these situations, we put stuffing bits into
 152   the ancillary data...
 153 */
 154
 155 inline static void
 156 drain_into_ancillary(lame_global_flags *gfp,int remainingBits)
 157 {
 158     lame_internal_flags *gfc=gfp->internal_flags;
 159     int i;
 160     assert(remainingBits >= 0);
 161
 162     if (remainingBits >= 8) {
 163       putbits2(gfp,0x4c,8);
 164       remainingBits -= 8;
 165     }
 166     if (remainingBits >= 8) {
 167       putbits2(gfp,0x41,8);
 168       remainingBits -= 8;
 169     }
 170     if (remainingBits >= 8) {
 171       putbits2(gfp,0x4d,8);
 172       remainingBits -= 8;
 173     }
 174     if (remainingBits >= 8) {
 175       putbits2(gfp,0x45,8);
 176       remainingBits -= 8;
 177     }
 178
 179     if (remainingBits >= 32) {
 180       const char *version = get_lame_short_version ();
 181       if (remainingBits >= 32)
 182         for (i=0; i<(int)strlen(version) && remainingBits >=8 ; ++i) {
 183           remainingBits -= 8;
 184           putbits2(gfp,version[i],8);
 185         }
 186     }
 187
 188     for (; remainingBits >= 1; remainingBits -= 1 ) {
 189         putbits2 ( gfp, gfc->ancillary_flag, 1 );
 190         gfc->ancillary_flag ^= 1;
 191     }
 192
 193     assert (remainingBits == 0);
 194
 195 }
 196
 197 /*write N bits into the header */
 198 inline static void
 199 writeheader(lame_internal_flags *gfc,int val, int j)
 200 {
 201     int ptr = gfc->header[gfc->h_ptr].ptr;
 202
 203     while (j > 0) {
 204         int k = Min(j, 8 - (ptr & 7));
 205         j -= k;
 206         assert (j < MAX_LENGTH); /* >> 32  too large for 32 bit machines */
 207         gfc->header[gfc->h_ptr].buf[ptr >> 3]
 208             |= ((val >> j)) << (8 - (ptr & 7) - k);
 209         ptr += k;
 210     }
 211     gfc->header[gfc->h_ptr].ptr = ptr;
 212 }
 213
 214
 215 static int
 216 CRC_update(int value, int crc)
 217 {
 218     int i;
 219     value <<= 8;
 220     for (i = 0; i < 8; i++) {
 221         value <<= 1;
 222         crc <<= 1;
 223
 224         if (((crc ^ value) & 0x10000))
 225             crc ^= CRC16_POLYNOMIAL;
 226     }
 227     return crc;
 228 }
 229
 230
 231 void
 232 CRC_writeheader(lame_internal_flags *gfc, char *header)
 233 {
 234     int crc = 0xffff; /* (jo) init crc16 for error_protection */
 235     int i;
 236
 237     crc = CRC_update(((unsigned char*)header)[2], crc);
 238     crc = CRC_update(((unsigned char*)header)[3], crc);
 239     for (i = 6; i < gfc->sideinfo_len; i++) {
 240         crc = CRC_update(((unsigned char*)header)[i], crc);
 241     }
 242
 243     header[4] = crc >> 8;
 244     header[5] = crc & 255;
 245 }
 246
 247 inline static void
 248 encodeSideInfo2(lame_global_flags *gfp,int bitsPerFrame)
 249 {
 250     lame_internal_flags *gfc=gfp->internal_flags;
 251     III_side_info_t *l3_side;
 252     int gr, ch;
 253
 254     l3_side = &gfc->l3_side;
 255     gfc->header[gfc->h_ptr].ptr = 0;
 256     memset(gfc->header[gfc->h_ptr].buf, 0, gfc->sideinfo_len);
 257     if (gfp->out_samplerate < 16000)
 258       writeheader(gfc,0xffe,                12);
 259     else
 260       writeheader(gfc,0xfff,                12);
 261     writeheader(gfc,(gfp->version),            1);
 262     writeheader(gfc,4 - 3,                 2);
 263     writeheader(gfc,(!gfp->error_protection),  1);
 264     writeheader(gfc,(gfc->bitrate_index),      4);
 265     writeheader(gfc,(gfc->samplerate_index),   2);
 266     writeheader(gfc,(gfc->padding),            1);
 267     writeheader(gfc,(gfp->extension),          1);
 268     writeheader(gfc,(gfp->mode),               2);
 269     writeheader(gfc,(gfc->mode_ext),           2);
 270     writeheader(gfc,(gfp->copyright),          1);
 271     writeheader(gfc,(gfp->original),           1);
 272     writeheader(gfc,(gfp->emphasis),           2);
 273     if (gfp->error_protection) {
 274         writeheader(gfc,0, 16); /* dummy */
 275     }
 276
 277     if (gfp->version == 1) {
 278         /* MPEG1 */
 279         assert(l3_side->main_data_begin >= 0);
 280         writeheader(gfc,(l3_side->main_data_begin), 9);
 281
 282         if (gfc->channels_out == 2)
 283             writeheader(gfc,l3_side->private_bits, 3);
 284         else
 285             writeheader(gfc,l3_side->private_bits, 5);
 286
 287         for (ch = 0; ch < gfc->channels_out; ch++) {
 288             int band;
 289             for (band = 0; band < 4; band++) {
 290                 writeheader(gfc,l3_side->scfsi[ch][band], 1);
 291             }
 292         }
 293
 294         for (gr = 0; gr < 2; gr++) {
 295             for (ch = 0; ch < gfc->channels_out; ch++) {
 296                 gr_info *gi = &l3_side->gr[gr].ch[ch].tt;
 297                 writeheader(gfc,gi->part2_3_length,       12);
 298                 writeheader(gfc,gi->big_values / 2,        9);
 299                 writeheader(gfc,gi->global_gain,           8);
 300                 writeheader(gfc,gi->scalefac_compress,     4);
 301                 writeheader(gfc,gi->window_switching_flag, 1);
 302
 303                 if (gi->window_switching_flag) {
 304                     writeheader(gfc,gi->block_type,       2);
 305                     writeheader(gfc,gi->mixed_block_flag, 1);
 306
 307                     if (gi->table_select[0] == 14)
 308                         gi->table_select[0] = 16;
 309                     writeheader(gfc,gi->table_select[0],  5);
 310                     if (gi->table_select[1] == 14)
 311                         gi->table_select[1] = 16;
 312                     writeheader(gfc,gi->table_select[1],  5);
 313
 314                     writeheader(gfc,gi->subblock_gain[0], 3);
 315                     writeheader(gfc,gi->subblock_gain[1], 3);
 316                     writeheader(gfc,gi->subblock_gain[2], 3);
 317                 } else {
 318                     assert(gi->block_type == NORM_TYPE);
 319                     if (gi->table_select[0] == 14)
 320                         gi->table_select[0] = 16;
 321                     writeheader(gfc,gi->table_select[0], 5);
 322                     if (gi->table_select[1] == 14)
 323                         gi->table_select[1] = 16;
 324                     writeheader(gfc,gi->table_select[1], 5);
 325                     if (gi->table_select[2] == 14)
 326                         gi->table_select[2] = 16;
 327                     writeheader(gfc,gi->table_select[2], 5);
 328
 329                     assert(gi->region0_count < 16U);
 330                     assert(gi->region1_count < 8U);
 331                     writeheader(gfc,gi->region0_count, 4);
 332                     writeheader(gfc,gi->region1_count, 3);
 333                 }
 334                 writeheader(gfc,gi->preflag,            1);
 335                 writeheader(gfc,gi->scalefac_scale,     1);
 336                 writeheader(gfc,gi->count1table_select, 1);
 337             }
 338         }
 339     } else {
 340         /* MPEG2 */
 341         assert(l3_side->main_data_begin >= 0);
 342         writeheader(gfc,(l3_side->main_data_begin), 8);
 343         writeheader(gfc,l3_side->private_bits, gfc->channels_out);
 344
 345         gr = 0;
 346         for (ch = 0; ch < gfc->channels_out; ch++) {
 347             gr_info *gi = &l3_side->gr[gr].ch[ch].tt;
 348             writeheader(gfc,gi->part2_3_length,       12);
 349             writeheader(gfc,gi->big_values / 2,        9);
 350             writeheader(gfc,gi->global_gain,           8);
 351             writeheader(gfc,gi->scalefac_compress,     9);
 352             writeheader(gfc,gi->window_switching_flag, 1);
 353
 354             if (gi->window_switching_flag) {
 355                 writeheader(gfc,gi->block_type,       2);
 356                 writeheader(gfc,gi->mixed_block_flag, 1);
 357
 358                 if (gi->table_select[0] == 14)
 359                     gi->table_select[0] = 16;
 360                 writeheader(gfc,gi->table_select[0],  5);
 361                 if (gi->table_select[1] == 14)
 362                     gi->table_select[1] = 16;
 363                 writeheader(gfc,gi->table_select[1],  5);
 364
 365                 writeheader(gfc,gi->subblock_gain[0], 3);
 366                 writeheader(gfc,gi->subblock_gain[1], 3);
 367                 writeheader(gfc,gi->subblock_gain[2], 3);
 368             } else {
 369                 if (gi->table_select[0] == 14)
 370                     gi->table_select[0] = 16;
 371                 writeheader(gfc,gi->table_select[0], 5);
 372                 if (gi->table_select[1] == 14)
 373                     gi->table_select[1] = 16;
 374                 writeheader(gfc,gi->table_select[1], 5);
 375                 if (gi->table_select[2] == 14)
 376                     gi->table_select[2] = 16;
 377                 writeheader(gfc,gi->table_select[2], 5);
 378
 379                 assert(gi->region0_count < 16U);
 380                 assert(gi->region1_count < 8U);
 381                 writeheader(gfc,gi->region0_count, 4);
 382                 writeheader(gfc,gi->region1_count, 3);
 383             }
 384
 385             writeheader(gfc,gi->scalefac_scale,     1);
 386             writeheader(gfc,gi->count1table_select, 1);
 387         }
 388     }
 389
 390     if (gfp->error_protection) {
 391         /* (jo) error_protection: add crc16 information to header */
 392         CRC_writeheader(gfc, gfc->header[gfc->h_ptr].buf);
 393     }
 394
 395     {
 396         int old = gfc->h_ptr;
 397         assert(gfc->header[old].ptr == gfc->sideinfo_len * 8);
 398
 399         gfc->h_ptr = (old + 1) & (MAX_HEADER_BUF - 1);
 400         gfc->header[gfc->h_ptr].write_timing =
 401             gfc->header[old].write_timing + bitsPerFrame;
 402
 403         if (gfc->h_ptr == gfc->w_ptr) {
 404           /* yikes! we are out of header buffer space */
 405           ERRORF(gfc,"Error: MAX_HEADER_BUF too small in bitstream.c \n");
 406         }
 407
 408     }
 409 }
 410
 411
 412 inline static int
 413 huffman_coder_count1(lame_global_flags *gfp,int *ix, gr_info *gi)
 414 {
 415 #ifdef DEBUG
 416     lame_internal_flags *gfc = gfp->internal_flags;
 417 #endif
 418     /* Write count1 area */
 419     const struct huffcodetab *h = &ht[gi->count1table_select + 32];
 420     int i,bits=0;
 421 #ifdef DEBUG
 422     int gegebo = gfc->bs.totbit;
 423 #endif
 424
 425     ix += gi->big_values;
 426     assert(gi->count1table_select < 2);
 427
 428
 429     for (i = (gi->count1 - gi->big_values) / 4; i > 0; --i) {
 430         int huffbits = 0;
 431         int p = 0, v;
 432
 433         v = ix[0];
 434         if (v) {
 435             p += 8;
 436             if (v < 0)
 437                 huffbits++;
 438             assert(-1 <= v && v <= 1);
 439         }
 440
 441         v = ix[1];
 442         if (v) {
 443             p += 4;
 444             huffbits *= 2;
 445             if (v < 0)
 446                 huffbits++;
 447             assert(-1 <= v && v <= 1);
 448         }
 449
 450         v = ix[2];
 451         if (v) {
 452             p += 2;
 453             huffbits *= 2;
 454             if (v < 0)
 455                 huffbits++;
 456             assert(-1 <= v && v <= 1);
 457         }
 458
 459         v = ix[3];
 460         if (v) {
 461             p++;
 462             huffbits *= 2;
 463             if (v < 0)
 464                 huffbits++;
 465             assert(-1 <= v && v <= 1);
 466         }
 467
 468         ix += 4;
 469         putbits2(gfp,huffbits + h->table[p], h->hlen[p]);
 470         bits += h->hlen[p];
 471     }
 472 #ifdef DEBUG
 473     DEBUGF(gfc,"%ld %d %d %d\n",gfc->bs.totbit -gegebo, gi->count1bits, gi->big_values, gi->count1);
 474 #endif
 475     return bits;
 476 }
 477
 478
 479
 480 /*
 481   Implements the pseudocode of page 98 of the IS
 482   */
 483
 484 inline static int
 485 HuffmanCode ( lame_global_flags* const gfp, const int table_select, int x1, int x2 )
 486 {
 487     const struct huffcodetab* h = ht + table_select;
 488     int  code    = 0;
 489     int  cbits   = 0;
 490     int  xbits   = 0;
 491     int  sgn_x1  = 0;
 492     int  sgn_x2  = 0;
 493     int  linbits = h->xlen;
 494     int  xlen    = h->xlen;
 495     int  ext;
 496
 497     assert ( table_select > 0 );
 498
 499     if (x1 < 0) {
 500         sgn_x1++;
 501         x1 = -x1;
 502     }
 503
 504     if (x2 < 0) {
 505         sgn_x2++;
 506         x2 = -x2;
 507     }
 508
 509     ext     = sgn_x1;
 510
 511     if (table_select > 15) {
 512         /* use ESC-words */
 513         if (x1 > 14) {
 514             int linbits_x1 = x1 - 15;
 515             assert ( linbits_x1 <= h->linmax );
 516             ext   |= linbits_x1 << 1;
 517             xbits  = linbits;
 518             x1     = 15;
 519         }
 520
 521         if (x2 > 14) {
 522             int linbits_x2 = x2 - 15;
 523             assert ( linbits_x2 <= h->linmax );
 524             ext  <<= linbits;
 525             ext   |= linbits_x2;
 526             xbits += linbits;
 527             x2     = 15;
 528         }
 529         xlen = 16;
 530     }
 531
 532     if (x1 != 0) {
 533         cbits--;
 534     }
 535
 536     if (x2 != 0) {
 537         ext <<= 1;
 538         ext  |= sgn_x2;
 539         cbits--;
 540     }
 541
 542     xbits -= cbits;
 543
 544     assert ( (x1|x2) < 16u );
 545
 546     x1 = x1 * xlen + x2;
 547
 548     code   = h->table [x1];
 549     cbits += h->hlen  [x1];
 550
 551     assert ( cbits <= MAX_LENGTH );
 552     assert ( xbits <= MAX_LENGTH );
 553
 554     putbits2 ( gfp, code, cbits );
 555     putbits2 ( gfp, ext,  xbits );
 556
 557     return cbits + xbits;
 558 }
 559
 560 static int
 561 Huffmancodebits(lame_global_flags *gfp, int tableindex, int start, int end, int *ix)
 562 {
 563     int i,bits;
 564
 565     assert(tableindex < 32);
 566     if (!tableindex) return 0;
 567
 568     bits=0;
 569     for (i = start; i < end; i += 2) {
 570       bits +=HuffmanCode(gfp,tableindex, ix[i], ix[i + 1]);
 571     }
 572     return bits;
 573 }
 574
 575
 576
 577 /*
 578   Note the discussion of huffmancodebits() on pages 28
 579   and 29 of the IS, as well as the definitions of the side
 580   information on pages 26 and 27.
 581   */
 582 static int
 583 ShortHuffmancodebits(lame_global_flags *gfp,int *ix, gr_info *gi)
 584 {
 585     lame_internal_flags *gfc=gfp->internal_flags;
 586     int bits;
 587     int region1Start;
 588
 589     region1Start = 3*gfc->scalefac_band.s[3];
 590     if (region1Start > gi->big_values)
 591         region1Start = gi->big_values;
 592
 593     /* short blocks do not have a region2 */
 594     bits  = Huffmancodebits(gfp,gi->table_select[0], 0, region1Start, ix);
 595     bits += Huffmancodebits(gfp,gi->table_select[1], region1Start, gi->big_values, ix);
 596     return bits;
 597 }
 598
 599 static int
 600 LongHuffmancodebits(lame_global_flags *gfp,int *ix, gr_info *gi)
 601 {
 602     lame_internal_flags *gfc=gfp->internal_flags;
 603     int i, bigvalues,bits=0;
 604     int region1Start, region2Start;
 605
 606     bigvalues = gi->big_values;
 607     assert(0 <= bigvalues && bigvalues <= 576);
 608
 609     i = gi->region0_count + 1;
 610     assert(i < 23);
 611     region1Start = gfc->scalefac_band.l[i];
 612     i += gi->region1_count + 1;
 613     assert(i < 23);
 614     region2Start = gfc->scalefac_band.l[i];
 615
 616     if (region1Start > bigvalues)
 617         region1Start = bigvalues;
 618
 619     if (region2Start > bigvalues)
 620         region2Start = bigvalues;
 621
 622     bits +=Huffmancodebits(gfp,gi->table_select[0], 0, region1Start, ix);
 623     bits +=Huffmancodebits(gfp,gi->table_select[1], region1Start, region2Start, ix);
 624     bits +=Huffmancodebits(gfp,gi->table_select[2], region2Start, bigvalues, ix);
 625     return bits;
 626 }
 627
 628 inline static int
 629 writeMainData ( lame_global_flags * const gfp,
 630         int              l3_enc   [2] [2] [576],
 631         III_scalefac_t   scalefac [2] [2] )
 632 {
 633     int gr, ch, sfb,data_bits,scale_bits,tot_bits=0;
 634     lame_internal_flags *gfc=gfp->internal_flags;
 635     III_side_info_t *l3_side;
 636
 637     l3_side = &gfc->l3_side;
 638     if (gfp->version == 1) {
 639         /* MPEG 1 */
 640         for (gr = 0; gr < 2; gr++) {
 641             for (ch = 0; ch < gfc->channels_out; ch++) {
 642                 gr_info *gi = &l3_side->gr[gr].ch[ch].tt;
 643                 int slen1 = slen1_tab[gi->scalefac_compress];
 644                 int slen2 = slen2_tab[gi->scalefac_compress];
 645                 data_bits=0;
 646                 scale_bits=0;
 647
 648 #ifdef DEBUG
 649                 hogege = gfc->bs.totbit;
 650 #endif
 651                 if (gi->block_type == SHORT_TYPE) {
 652                     for (sfb = 0; sfb < SBPSY_s; sfb++) {
 653                         int slen = sfb < 6 ? slen1 : slen2;
 654
 655                         assert(scalefac[gr][ch].s[sfb][0]>=0);
 656                         assert(scalefac[gr][ch].s[sfb][1]>=0);
 657                         assert(scalefac[gr][ch].s[sfb][2]>=0);
 658
 659                         putbits2(gfp,scalefac[gr][ch].s[sfb][0], slen);
 660                         putbits2(gfp,scalefac[gr][ch].s[sfb][1], slen);
 661                         putbits2(gfp,scalefac[gr][ch].s[sfb][2], slen);
 662                         scale_bits += 3*slen;
 663                     }
 664                     data_bits += ShortHuffmancodebits(gfp,l3_enc[gr][ch], gi);
 665                 } else {
 666                     int i;
 667                     for (i = 0; i < sizeof(scfsi_band) / sizeof(int) - 1;
 668                          i++) {
 669                         if (gr != 0 && l3_side->scfsi[ch][i])
 670                             continue;
 671
 672                         for (sfb = scfsi_band[i]; sfb < scfsi_band[i + 1];
 673                              sfb++) {
 674
 675                             assert(scalefac[gr][ch].l[sfb]>=0);
 676                             putbits2(gfp,scalefac[gr][ch].l[sfb],
 677                                     sfb < 11 ? slen1 : slen2);
 678                             scale_bits += sfb < 11 ? slen1 : slen2;
 679                         }
 680                     }
 681                     data_bits +=LongHuffmancodebits(gfp,l3_enc[gr][ch], gi);
 682                 }
 683                 data_bits +=huffman_coder_count1(gfp,l3_enc[gr][ch], gi);
 684 #ifdef DEBUG
 685                 DEBUGF(gfc,"<%ld> ", gfc->bs.totbit-hogege);
 686 #endif
 687                 /* does bitcount in quantize.c agree with actual bit count?*/
 688                 assert(data_bits==gi->part2_3_length-gi->part2_length);
 689                 assert(scale_bits==gi->part2_length);
 690                 tot_bits += scale_bits + data_bits;
 691
 692             } /* for ch */
 693         } /* for gr */
 694     } else {
 695         /* MPEG 2 */
 696         gr = 0;
 697         for (ch = 0; ch < gfc->channels_out; ch++) {
 698             gr_info *gi = &l3_side->gr[gr].ch[ch].tt;
 699             int i, sfb_partition;
 700             assert(gi->sfb_partition_table);
 701             data_bits = 0;
 702             scale_bits=0;
 703
 704             sfb = 0;
 705             sfb_partition = 0;
 706             if (gi->block_type == SHORT_TYPE) {
 707                 for (; sfb_partition < 4; sfb_partition++) {
 708                     int sfbs = gi->sfb_partition_table[sfb_partition] / 3;
 709                     int slen = gi->slen[sfb_partition];
 710                     for (i = 0; i < sfbs; i++, sfb++) {
 711                         putbits2(gfp,Max(scalefac[gr][ch].s[sfb][0], 0U), slen);
 712                         putbits2(gfp,Max(scalefac[gr][ch].s[sfb][1], 0U), slen);
 713                         putbits2(gfp,Max(scalefac[gr][ch].s[sfb][2], 0U), slen);
 714                         scale_bits += 3*slen;
 715                     }
 716                 }
 717                 data_bits += ShortHuffmancodebits(gfp,l3_enc[gr][ch], gi);
 718             } else {
 719                 for (; sfb_partition < 4; sfb_partition++) {
 720                     int sfbs = gi->sfb_partition_table[sfb_partition];
 721                     int slen = gi->slen[sfb_partition];
 722                     for (i = 0; i < sfbs; i++, sfb++) {
 723                         putbits2(gfp,Max(scalefac[gr][ch].l[sfb], 0U), slen);
 724                         scale_bits += slen;
 725                     }
 726                 }
 727                 data_bits +=LongHuffmancodebits(gfp,l3_enc[gr][ch], gi);
 728             }
 729             data_bits +=huffman_coder_count1(gfp,l3_enc[gr][ch], gi);
 730
 731             /* does bitcount in quantize.c agree with actual bit count?*/
 732             assert(data_bits==gi->part2_3_length-gi->part2_length);
 733             assert(scale_bits==gi->part2_length);
 734             tot_bits += scale_bits + data_bits;
 735         } /* for ch */
 736     } /* for gf */
 737     return tot_bits;
 738 } /* main_data */
 739
 740
 741
 742 /* compute the number of bits required to flush all mp3 frames
 743    currently in the buffer.  This should be the same as the
 744    reservoir size.  Only call this routine between frames - i.e.
 745    only after all headers and data have been added to the buffer
 746    by format_bitstream().
 747
 748    Also compute total_bits_output =
 749        size of mp3 buffer (including frame headers which may not
 750        have yet been send to the mp3 buffer) +
 751        number of bits needed to flush all mp3 frames.
 752
 753    total_bytes_output is the size of the mp3 output buffer if
 754    lame_encode_flush_nogap() was called right now.
 755
 756  */
 757 int
 758 compute_flushbits( const lame_global_flags * gfp, int *total_bytes_output )
 759 {
 760   lame_internal_flags *gfc=gfp->internal_flags;
 761   int flushbits,remaining_headers;
 762   int bitsPerFrame, mean_bits;
 763   int last_ptr,first_ptr;
 764   first_ptr=gfc->w_ptr;           /* first header to add to bitstream */
 765   last_ptr = gfc->h_ptr - 1;   /* last header to add to bitstream */
 766   if (last_ptr==-1) last_ptr=MAX_HEADER_BUF-1;
 767
 768   /* add this many bits to bitstream so we can flush all headers */
 769   flushbits = gfc->header[last_ptr].write_timing - gfc->bs.totbit;
 770   *total_bytes_output=flushbits;
 771
 772   if (flushbits >= 0) {
 773     /* if flushbits >= 0, some headers have not yet been written */
 774     /* reduce flushbits by the size of the headers */
 775     remaining_headers= 1+last_ptr - first_ptr;
 776     if (last_ptr < first_ptr)
 777       remaining_headers= 1+last_ptr - first_ptr + MAX_HEADER_BUF;
 778     flushbits -= remaining_headers*8*gfc->sideinfo_len;
 779   }
 780
 781
 782   /* finally, add some bits so that the last frame is complete
 783    * these bits are not necessary to decode the last frame, but
 784    * some decoders will ignore last frame if these bits are missing
 785    */
 786   getframebits(gfp,&bitsPerFrame,&mean_bits);
 787   flushbits += bitsPerFrame;
 788   *total_bytes_output += bitsPerFrame;
 789   // round up:
 790   if (*total_bytes_output % 8)
 791       *total_bytes_output = 1 + (*total_bytes_output/8);
 792   else
 793       *total_bytes_output = (*total_bytes_output/8);
 794   *total_bytes_output +=  gfc->bs.buf_byte_idx + 1;
 795
 796
 797   if (flushbits<0) {
 798 #if 0
 799     /* if flushbits < 0, this would mean that the buffer looks like:
 800      * (data...)  last_header  (data...)  (extra data that should not be here...)
 801      */
 802     DEBUGF(gfc,"last header write_timing = %i \n",gfc->header[last_ptr].write_timing);
 803     DEBUGF(gfc,"first header write_timing = %i \n",gfc->header[first_ptr].write_timing);
 804     DEBUGF(gfc,"bs.totbit:                 %i \n",gfc->bs.totbit);
 805     DEBUGF(gfc,"first_ptr, last_ptr        %i %i \n",first_ptr,last_ptr);
 806     DEBUGF(gfc,"remaining_headers =        %i \n",remaining_headers);
 807     DEBUGF(gfc,"bitsperframe:              %i \n",bitsPerFrame);
 808     DEBUGF(gfc,"sidelen:                   %i \n",gfc->sideinfo_len);
 809 #endif
 810 //    ERRORF(gfc,"strange error flushing buffer ... \n");
 811   }
 812   return flushbits;
 813 }
 814
 815
 816
 817 void
 818 flush_bitstream(lame_global_flags *gfp)
 819 {
 820   lame_internal_flags *gfc=gfp->internal_flags;
 821   III_side_info_t *l3_side;
 822   int nbytes;
 823   int flushbits;
 824   int bitsPerFrame, mean_bits;
 825   int last_ptr,first_ptr;
 826   first_ptr=gfc->w_ptr;           /* first header to add to bitstream */
 827   last_ptr = gfc->h_ptr - 1;   /* last header to add to bitstream */
 828   if (last_ptr==-1) last_ptr=MAX_HEADER_BUF-1;
 829   l3_side = &gfc->l3_side;
 830
 831
 832   if ((flushbits = compute_flushbits(gfp,&nbytes)) < 0) return;
 833   drain_into_ancillary(gfp,flushbits);
 834
 835   /* check that the 100% of the last frame has been written to bitstream */
 836   getframebits(gfp,&bitsPerFrame,&mean_bits);
 837   assert (gfc->header[last_ptr].write_timing + bitsPerFrame  == gfc->bs.totbit);
 838
 839   /* we have padded out all frames with ancillary data, which is the
 840      same as filling the bitreservoir with ancillary data, so : */
 841   gfc->ResvSize=0;
 842   l3_side->main_data_begin = 0;
 843
 844 }
 845
 846
 847
 848
 849 void  add_dummy_byte ( lame_global_flags* const gfp, unsigned char val )
 850 {
 851   lame_internal_flags *gfc = gfp->internal_flags;
 852   int i;
 853
 854   putbits_noheaders(gfp,val,8);
 855
 856   for (i=0 ; i< MAX_HEADER_BUF ; ++i)
 857     gfc->header[i].write_timing += 8;
 858 }
 859
 860
 861 /*
 862   format_bitstream()
 863
 864   This is called after a frame of audio has been quantized and coded.
 865   It will write the encoded audio to the bitstream. Note that
 866   from a layer3 encoder's perspective the bit stream is primarily
 867   a series of main_data() blocks, with header and side information
 868   inserted at the proper locations to maintain framing. (See Figure A.7
 869   in the IS).
 870   */
 871 int
 872 format_bitstream(lame_global_flags *gfp, int bitsPerFrame,
 873       int              l3_enc[2][2][576],
 874         III_scalefac_t   scalefac[2][2] )
 875 {
 876     lame_internal_flags *gfc=gfp->internal_flags;
 877     int bits,nbytes;
 878     III_side_info_t *l3_side;
 879     l3_side = &gfc->l3_side;
 880
 881     drain_into_ancillary(gfp,l3_side->resvDrain_pre);
 882
 883     encodeSideInfo2(gfp,bitsPerFrame);
 884     bits = 8*gfc->sideinfo_len;
 885     bits+=writeMainData(gfp,l3_enc,scalefac);
 886     drain_into_ancillary(gfp,l3_side->resvDrain_post);
 887     bits += l3_side->resvDrain_post;
 888
 889     l3_side->main_data_begin += (bitsPerFrame-bits)/8;
 890
 891     /* compare number of bits needed to clear all buffered mp3 frames
 892      * with what we think the resvsize is: */
 893     if (compute_flushbits(gfp,&nbytes) != gfc->ResvSize) {
 894         ERRORF(gfc,"Internal buffer inconsistency. flushbits <> ResvSize");
 895     }
 896
 897
 898     /* compare main_data_begin for the next frame with what we
 899      * think the resvsize is: */
 900     if ((l3_side->main_data_begin * 8) != gfc->ResvSize ) {
 901       ERRORF(gfc,"bit reservoir error: \n"
 902              "l3_side->main_data_begin: %i \n"
 903              "Resvoir size:             %i \n"
 904              "resv drain (post)         %i \n"
 905              "resv drain (pre)          %i \n"
 906              "header and sideinfo:      %i \n"
 907              "data bits:                %i \n"
 908              "total bits:               %i (remainder: %i) \n"
 909              "bitsperframe:             %i \n",
 910
 911              8*l3_side->main_data_begin,
 912              gfc->ResvSize,
 913              l3_side->resvDrain_post,
 914              l3_side->resvDrain_pre,
 915              8*gfc->sideinfo_len,
 916              bits-l3_side->resvDrain_post-8*gfc->sideinfo_len,
 917              bits, bits % 8,
 918              bitsPerFrame
 919       );
 920
 921       gfc->ResvSize = l3_side->main_data_begin*8;
 922     };
 923     assert(gfc->bs.totbit % 8 == 0);
 924
 925     if (gfc->bs.totbit > 1000000000  ) {
 926       /* to avoid totbit overflow, (at 8h encoding at 128kbs) lets reset bit counter*/
 927       int i;
 928       for (i=0 ; i< MAX_HEADER_BUF ; ++i)
 929         gfc->header[i].write_timing -= gfc->bs.totbit;
 930       gfc->bs.totbit=0;
 931     }
 932
 933
 934     return 0;
 935 }
 936
 937
 938
 939
 940
 941 /* copy data out of the internal MP3 bit buffer into a user supplied
 942    unsigned char buffer.
 943
 944    mp3data=0      indicates data in buffer is an id3tags and VBR tags
 945    mp3data=1      data is real mp3 frame data.
 946
 947
 948 */
 949 int copy_buffer(lame_internal_flags *gfc,unsigned char *buffer,int size,int mp3data)
 950 {
 951     Bit_stream_struc *bs=&gfc->bs;
 952     int minimum = bs->buf_byte_idx + 1;
 953     if (minimum <= 0) return 0;
 954     if (size!=0 && minimum>size) return -1; /* buffer is too small */
 955     memcpy(buffer,bs->buf,minimum);
 956     bs->buf_byte_idx = -1;
 957     bs->buf_bit_idx = 0;
 958
 959     if (mp3data) {
 960         UpdateMusicCRC(&gfc->nMusicCRC,buffer,minimum);
 961     }
 962     return minimum;
 963 }
 964
 965
 966 void init_bit_stream_w(lame_internal_flags *gfc)
 967 {
 968    gfc->bs.buf = (unsigned char *)       malloc(BUFFER_SIZE);
 969    gfc->bs.buf_size = BUFFER_SIZE;
 970
 971    gfc->h_ptr = gfc->w_ptr = 0;
 972    gfc->header[gfc->h_ptr].write_timing = 0;
 973    gfc->bs.buf_byte_idx = -1;
 974    gfc->bs.buf_bit_idx = 0;
 975    gfc->bs.totbit = 0;
 976 }
 977
 978 /* end of bitstream.c */