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