src/lib/dl/ext/lame/bitstream.c

   1 /*
   2  *      MP3 bitstream Output interface for LAME
   3  *
   4  *      Copyright (c) 1999-2000 Mark Taylor
   5  *      Copyright (c) 1999-2002 Takehiro Tominaga
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Library General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Library General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Library General Public
  18  * License along with this library; if not, write to the
  19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  *
  22  * $Id: bitstream.c,v 1.97 2011/05/07 16:05:17 rbrito Exp $
  23  */
  24
  25
  26 #ifdef HAVE_CONFIG_H
  27 #include <config.h>
  28 #endif
  29
  30 #include <stdlib.h>
  31 #include <stdio.h>
  32
  33 #include "lame.h"
  34 #include "machine.h"
  35 #include "encoder.h"
  36 #include "util.h"
  37 #include "tables.h"
  38 #include "quantize_pvt.h"
  39 #include "lame_global_flags.h"
  40 #include "gain_analysis.h"
  41 #include "vbrtag.h"
  42 #include "bitstream.h"
  43 #include "tables.h"
  44
  45
  46
  47 /* unsigned int is at least this large:  */
  48 /* we work with ints, so when doing bit manipulation, we limit
  49  * ourselves to MAX_LENGTH-2 just to be on the safe side */
  50 #define MAX_LENGTH      32
  51
  52
  53
  54 #ifdef DEBUG
  55 static int hogege;
  56 #endif
  57
  58
  59
  60 static int
  61 calcFrameLength(SessionConfig_t const *const cfg, int kbps, int pad)
  62 {
  63   return 8 * ((cfg->version + 1) * 72000 * kbps / cfg->samplerate_out + pad);
  64 }
  65
  66
  67 /***********************************************************************
  68  * compute bitsperframe and mean_bits for a layer III frame
  69  **********************************************************************/
  70 int
  71 getframebits(const lame_internal_flags * gfc)
  72 {
  73     SessionConfig_t const *const cfg = &gfc->cfg;
  74     EncResult_t const *const eov = &gfc->ov_enc;
  75     int     bit_rate;
  76
  77     /* get bitrate in kbps [?] */
  78     if (eov->bitrate_index)
  79         bit_rate = bitrate_table[cfg->version][eov->bitrate_index];
  80     else
  81         bit_rate = cfg->avg_bitrate;
  82     /*assert(bit_rate <= 550); */
  83     assert(8 <= bit_rate && bit_rate <= 640);
  84
  85     /* main encoding routine toggles padding on and off */
  86     /* one Layer3 Slot consists of 8 bits */
  87     return calcFrameLength(cfg, bit_rate, eov->padding);
  88 }
  89
  90 int
  91 get_max_frame_buffer_size_by_constraint(SessionConfig_t const * cfg, int constraint)
  92 {
  93     int     maxmp3buf = 0;
  94     if (cfg->avg_bitrate > 320) {
  95         /* in freeformat the buffer is constant */
  96         if (constraint == MDB_STRICT_ISO) {
  97             maxmp3buf = calcFrameLength(cfg, cfg->avg_bitrate, 0);
  98         }
  99         else {
 100             /* maximum allowed bits per granule are 7680 */
 101             maxmp3buf = 7680 * (cfg->version + 1);
 102         }
 103     }
 104     else {
 105         int     max_kbps;
 106         if (cfg->samplerate_out < 16000) {
 107             max_kbps = bitrate_table[cfg->version][8]; /* default: allow 64 kbps (MPEG-2.5) */
 108         }
 109         else {
 110             max_kbps = bitrate_table[cfg->version][14];
 111         }
 112         switch (constraint)
 113         {
 114         default:
 115         case MDB_DEFAULT:
 116             /* Bouvigne suggests this more lax interpretation of the ISO doc instead of using 8*960. */
 117             /* All mp3 decoders should have enough buffer to handle this value: size of a 320kbps 32kHz frame */
 118             maxmp3buf = 8 * 1440;
 119             break;
 120         case MDB_STRICT_ISO:
 121             maxmp3buf = calcFrameLength(cfg, max_kbps, 0);
 122             break;
 123         case MDB_MAXIMUM:
 124             maxmp3buf = 7680 * (cfg->version + 1);
 125             break;
 126         }
 127     }
 128     return maxmp3buf;
 129 }
 130
 131
 132 static void
 133 putheader_bits(lame_internal_flags * gfc)
 134 {
 135     SessionConfig_t const *const cfg = &gfc->cfg;
 136     EncStateVar_t *const esv = &gfc->sv_enc;
 137     Bit_stream_struc *bs = &gfc->bs;
 138 #ifdef DEBUG
 139     hogege += cfg->sideinfo_len * 8;
 140 #endif
 141     memcpy(&bs->buf[bs->buf_byte_idx], esv->header[esv->w_ptr].buf, cfg->sideinfo_len);
 142     bs->buf_byte_idx += cfg->sideinfo_len;
 143     bs->totbit += cfg->sideinfo_len * 8;
 144     esv->w_ptr = (esv->w_ptr + 1) & (MAX_HEADER_BUF - 1);
 145 }
 146
 147
 148
 149
 150 /*write j bits into the bit stream */
 151 inline static void
 152 putbits2(lame_internal_flags * gfc, int val, int j)
 153 {
 154     EncStateVar_t const *const esv = &gfc->sv_enc;
 155     Bit_stream_struc *bs;
 156     bs = &gfc->bs;
 157
 158     assert(j < MAX_LENGTH - 2);
 159
 160     while (j > 0) {
 161         int     k;
 162         if (bs->buf_bit_idx == 0) {
 163             bs->buf_bit_idx = 8;
 164             bs->buf_byte_idx++;
 165             assert(bs->buf_byte_idx < BUFFER_SIZE);
 166             assert(esv->header[esv->w_ptr].write_timing >= bs->totbit);
 167             if (esv->header[esv->w_ptr].write_timing == bs->totbit) {
 168                 putheader_bits(gfc);
 169             }
 170             bs->buf[bs->buf_byte_idx] = 0;
 171         }
 172
 173         k = Min(j, bs->buf_bit_idx);
 174         j -= k;
 175
 176         bs->buf_bit_idx -= k;
 177
 178         assert(j < MAX_LENGTH); /* 32 too large on 32 bit machines */
 179         assert(bs->buf_bit_idx < MAX_LENGTH);
 180
 181         bs->buf[bs->buf_byte_idx] |= ((val >> j) << bs->buf_bit_idx);
 182         bs->totbit += k;
 183     }
 184 }
 185
 186 /*write j bits into the bit stream, ignoring frame headers */
 187 inline static void
 188 putbits_noheaders(lame_internal_flags * gfc, int val, int j)
 189 {
 190     Bit_stream_struc *bs;
 191     bs = &gfc->bs;
 192
 193     assert(j < MAX_LENGTH - 2);
 194
 195     while (j > 0) {
 196         int     k;
 197         if (bs->buf_bit_idx == 0) {
 198             bs->buf_bit_idx = 8;
 199             bs->buf_byte_idx++;
 200             assert(bs->buf_byte_idx < BUFFER_SIZE);
 201             bs->buf[bs->buf_byte_idx] = 0;
 202         }
 203
 204         k = Min(j, bs->buf_bit_idx);
 205         j -= k;
 206
 207         bs->buf_bit_idx -= k;
 208
 209         assert(j < MAX_LENGTH); /* 32 too large on 32 bit machines */
 210         assert(bs->buf_bit_idx < MAX_LENGTH);
 211
 212         bs->buf[bs->buf_byte_idx] |= ((val >> j) << bs->buf_bit_idx);
 213         bs->totbit += k;
 214     }
 215 }
 216
 217
 218 /*
 219   Some combinations of bitrate, Fs, and stereo make it impossible to stuff
 220   out a frame using just main_data, due to the limited number of bits to
 221   indicate main_data_length. In these situations, we put stuffing bits into
 222   the ancillary data...
 223 */
 224
 225 inline static void
 226 drain_into_ancillary(lame_internal_flags * gfc, int remainingBits)
 227 {
 228     SessionConfig_t const *const cfg = &gfc->cfg;
 229     EncStateVar_t *const esv = &gfc->sv_enc;
 230     int     i;
 231     assert(remainingBits >= 0);
 232
 233     if (remainingBits >= 8) {
 234         putbits2(gfc, 0x4c, 8);
 235         remainingBits -= 8;
 236     }
 237     if (remainingBits >= 8) {
 238         putbits2(gfc, 0x41, 8);
 239         remainingBits -= 8;
 240     }
 241     if (remainingBits >= 8) {
 242         putbits2(gfc, 0x4d, 8);
 243         remainingBits -= 8;
 244     }
 245     if (remainingBits >= 8) {
 246         putbits2(gfc, 0x45, 8);
 247         remainingBits -= 8;
 248     }
 249
 250     if (remainingBits >= 32) {
 251         const char *const version = get_lame_short_version();
 252         if (remainingBits >= 32)
 253             for (i = 0; i < (int) strlen(version) && remainingBits >= 8; ++i) {
 254                 remainingBits -= 8;
 255                 putbits2(gfc, version[i], 8);
 256             }
 257     }
 258
 259     for (; remainingBits >= 1; remainingBits -= 1) {
 260         putbits2(gfc, esv->ancillary_flag, 1);
 261         esv->ancillary_flag ^= !cfg->disable_reservoir;
 262     }
 263
 264     assert(remainingBits == 0);
 265
 266 }
 267
 268 /*write N bits into the header */
 269 inline static void
 270 writeheader(lame_internal_flags * gfc, int val, int j)
 271 {
 272     EncStateVar_t *const esv = &gfc->sv_enc;
 273     int     ptr = esv->header[esv->h_ptr].ptr;
 274
 275     while (j > 0) {
 276         int const k = Min(j, 8 - (ptr & 7));
 277         j -= k;
 278         assert(j < MAX_LENGTH); /* >> 32  too large for 32 bit machines */
 279         esv->header[esv->h_ptr].buf[ptr >> 3]
 280             |= ((val >> j)) << (8 - (ptr & 7) - k);
 281         ptr += k;
 282     }
 283     esv->header[esv->h_ptr].ptr = ptr;
 284 }
 285
 286
 287 static int
 288 CRC_update(int value, int crc)
 289 {
 290     int     i;
 291     value <<= 8;
 292     for (i = 0; i < 8; i++) {
 293         value <<= 1;
 294         crc <<= 1;
 295
 296         if (((crc ^ value) & 0x10000))
 297             crc ^= CRC16_POLYNOMIAL;
 298     }
 299     return crc;
 300 }
 301
 302
 303 void
 304 CRC_writeheader(lame_internal_flags const *gfc, char *header)
 305 {
 306     SessionConfig_t const *const cfg = &gfc->cfg;
 307     int     crc = 0xffff;    /* (jo) init crc16 for error_protection */
 308     int     i;
 309
 310     crc = CRC_update(((unsigned char *) header)[2], crc);
 311     crc = CRC_update(((unsigned char *) header)[3], crc);
 312     for (i = 6; i < cfg->sideinfo_len; i++) {
 313         crc = CRC_update(((unsigned char *) header)[i], crc);
 314     }
 315
 316     header[4] = crc >> 8;
 317     header[5] = crc & 255;
 318 }
 319
 320 inline static void
 321 encodeSideInfo2(lame_internal_flags * gfc, int bitsPerFrame)
 322 {
 323     SessionConfig_t const *const cfg = &gfc->cfg;
 324     EncResult_t const *const eov = &gfc->ov_enc;
 325     EncStateVar_t *const esv = &gfc->sv_enc;
 326     III_side_info_t *l3_side;
 327     int     gr, ch;
 328
 329     l3_side = &gfc->l3_side;
 330     esv->header[esv->h_ptr].ptr = 0;
 331     memset(esv->header[esv->h_ptr].buf, 0, cfg->sideinfo_len);
 332     if (cfg->samplerate_out < 16000)
 333         writeheader(gfc, 0xffe, 12);
 334     else
 335         writeheader(gfc, 0xfff, 12);
 336     writeheader(gfc, (cfg->version), 1);
 337     writeheader(gfc, 4 - 3, 2);
 338     writeheader(gfc, (!cfg->error_protection), 1);
 339     writeheader(gfc, (eov->bitrate_index), 4);
 340     writeheader(gfc, (cfg->samplerate_index), 2);
 341     writeheader(gfc, (eov->padding), 1);
 342     writeheader(gfc, (cfg->extension), 1);
 343     writeheader(gfc, (cfg->mode), 2);
 344     writeheader(gfc, (eov->mode_ext), 2);
 345     writeheader(gfc, (cfg->copyright), 1);
 346     writeheader(gfc, (cfg->original), 1);
 347     writeheader(gfc, (cfg->emphasis), 2);
 348     if (cfg->error_protection) {
 349         writeheader(gfc, 0, 16); /* dummy */
 350     }
 351
 352     if (cfg->version == 1) {
 353         /* MPEG1 */
 354         assert(l3_side->main_data_begin >= 0);
 355         writeheader(gfc, (l3_side->main_data_begin), 9);
 356
 357         if (cfg->channels_out == 2)
 358             writeheader(gfc, l3_side->private_bits, 3);
 359         else
 360             writeheader(gfc, l3_side->private_bits, 5);
 361
 362         for (ch = 0; ch < cfg->channels_out; ch++) {
 363             int     band;
 364             for (band = 0; band < 4; band++) {
 365                 writeheader(gfc, l3_side->scfsi[ch][band], 1);
 366             }
 367         }
 368
 369         for (gr = 0; gr < 2; gr++) {
 370             for (ch = 0; ch < cfg->channels_out; ch++) {
 371                 gr_info *const gi = &l3_side->tt[gr][ch];
 372                 writeheader(gfc, gi->part2_3_length + gi->part2_length, 12);
 373                 writeheader(gfc, gi->big_values / 2, 9);
 374                 writeheader(gfc, gi->global_gain, 8);
 375                 writeheader(gfc, gi->scalefac_compress, 4);
 376
 377                 if (gi->block_type != NORM_TYPE) {
 378                     writeheader(gfc, 1, 1); /* window_switching_flag */
 379                     writeheader(gfc, gi->block_type, 2);
 380                     writeheader(gfc, gi->mixed_block_flag, 1);
 381
 382                     if (gi->table_select[0] == 14)
 383                         gi->table_select[0] = 16;
 384                     writeheader(gfc, gi->table_select[0], 5);
 385                     if (gi->table_select[1] == 14)
 386                         gi->table_select[1] = 16;
 387                     writeheader(gfc, gi->table_select[1], 5);
 388
 389                     writeheader(gfc, gi->subblock_gain[0], 3);
 390                     writeheader(gfc, gi->subblock_gain[1], 3);
 391                     writeheader(gfc, gi->subblock_gain[2], 3);
 392                 }
 393                 else {
 394                     writeheader(gfc, 0, 1); /* window_switching_flag */
 395                     if (gi->table_select[0] == 14)
 396                         gi->table_select[0] = 16;
 397                     writeheader(gfc, gi->table_select[0], 5);
 398                     if (gi->table_select[1] == 14)
 399                         gi->table_select[1] = 16;
 400                     writeheader(gfc, gi->table_select[1], 5);
 401                     if (gi->table_select[2] == 14)
 402                         gi->table_select[2] = 16;
 403                     writeheader(gfc, gi->table_select[2], 5);
 404
 405                     assert(0 <= gi->region0_count && gi->region0_count < 16);
 406                     assert(0 <= gi->region1_count && gi->region1_count < 8);
 407                     writeheader(gfc, gi->region0_count, 4);
 408                     writeheader(gfc, gi->region1_count, 3);
 409                 }
 410                 writeheader(gfc, gi->preflag, 1);
 411                 writeheader(gfc, gi->scalefac_scale, 1);
 412                 writeheader(gfc, gi->count1table_select, 1);
 413             }
 414         }
 415     }
 416     else {
 417         /* MPEG2 */
 418         assert(l3_side->main_data_begin >= 0);
 419         writeheader(gfc, (l3_side->main_data_begin), 8);
 420         writeheader(gfc, l3_side->private_bits, cfg->channels_out);
 421
 422         gr = 0;
 423         for (ch = 0; ch < cfg->channels_out; ch++) {
 424             gr_info *const gi = &l3_side->tt[gr][ch];
 425             writeheader(gfc, gi->part2_3_length + gi->part2_length, 12);
 426             writeheader(gfc, gi->big_values / 2, 9);
 427             writeheader(gfc, gi->global_gain, 8);
 428             writeheader(gfc, gi->scalefac_compress, 9);
 429
 430             if (gi->block_type != NORM_TYPE) {
 431                 writeheader(gfc, 1, 1); /* window_switching_flag */
 432                 writeheader(gfc, gi->block_type, 2);
 433                 writeheader(gfc, gi->mixed_block_flag, 1);
 434
 435                 if (gi->table_select[0] == 14)
 436                     gi->table_select[0] = 16;
 437                 writeheader(gfc, gi->table_select[0], 5);
 438                 if (gi->table_select[1] == 14)
 439                     gi->table_select[1] = 16;
 440                 writeheader(gfc, gi->table_select[1], 5);
 441
 442                 writeheader(gfc, gi->subblock_gain[0], 3);
 443                 writeheader(gfc, gi->subblock_gain[1], 3);
 444                 writeheader(gfc, gi->subblock_gain[2], 3);
 445             }
 446             else {
 447                 writeheader(gfc, 0, 1); /* window_switching_flag */
 448                 if (gi->table_select[0] == 14)
 449                     gi->table_select[0] = 16;
 450                 writeheader(gfc, gi->table_select[0], 5);
 451                 if (gi->table_select[1] == 14)
 452                     gi->table_select[1] = 16;
 453                 writeheader(gfc, gi->table_select[1], 5);
 454                 if (gi->table_select[2] == 14)
 455                     gi->table_select[2] = 16;
 456                 writeheader(gfc, gi->table_select[2], 5);
 457
 458                 assert(0 <= gi->region0_count && gi->region0_count < 16);
 459                 assert(0 <= gi->region1_count && gi->region1_count < 8);
 460                 writeheader(gfc, gi->region0_count, 4);
 461                 writeheader(gfc, gi->region1_count, 3);
 462             }
 463
 464             writeheader(gfc, gi->scalefac_scale, 1);
 465             writeheader(gfc, gi->count1table_select, 1);
 466         }
 467     }
 468
 469     if (cfg->error_protection) {
 470         /* (jo) error_protection: add crc16 information to header */
 471         CRC_writeheader(gfc, esv->header[esv->h_ptr].buf);
 472     }
 473
 474     {
 475         int const old = esv->h_ptr;
 476         assert(esv->header[old].ptr == cfg->sideinfo_len * 8);
 477
 478         esv->h_ptr = (old + 1) & (MAX_HEADER_BUF - 1);
 479         esv->header[esv->h_ptr].write_timing = esv->header[old].write_timing + bitsPerFrame;
 480
 481         if (esv->h_ptr == esv->w_ptr) {
 482             /* yikes! we are out of header buffer space */
 483             ERRORF(gfc, "Error: MAX_HEADER_BUF too small in bitstream.c \n");
 484         }
 485
 486     }
 487 }
 488
 489
 490 inline static int
 491 huffman_coder_count1(lame_internal_flags * gfc, gr_info const *gi)
 492 {
 493     /* Write count1 area */
 494     struct huffcodetab const *const h = &ht[gi->count1table_select + 32];
 495     int     i, bits = 0;
 496 #ifdef DEBUG
 497     int     gegebo = gfc->bs.totbit;
 498 #endif
 499
 500     int const *ix = &gi->l3_enc[gi->big_values];
 501     FLOAT const *xr = &gi->xr[gi->big_values];
 502     assert(gi->count1table_select < 2);
 503
 504     for (i = (gi->count1 - gi->big_values) / 4; i > 0; --i) {
 505         int     huffbits = 0;
 506         int     p = 0, v;
 507
 508         v = ix[0];
 509         if (v) {
 510             p += 8;
 511             if (xr[0] < 0.0f)
 512                 huffbits++;
 513             assert(v <= 1);
 514         }
 515
 516         v = ix[1];
 517         if (v) {
 518             p += 4;
 519             huffbits *= 2;
 520             if (xr[1] < 0.0f)
 521                 huffbits++;
 522             assert(v <= 1);
 523         }
 524
 525         v = ix[2];
 526         if (v) {
 527             p += 2;
 528             huffbits *= 2;
 529             if (xr[2] < 0.0f)
 530                 huffbits++;
 531             assert(v <= 1);
 532         }
 533
 534         v = ix[3];
 535         if (v) {
 536             p++;
 537             huffbits *= 2;
 538             if (xr[3] < 0.0f)
 539                 huffbits++;
 540             assert(v <= 1);
 541         }
 542
 543         ix += 4;
 544         xr += 4;
 545         putbits2(gfc, huffbits + h->table[p], h->hlen[p]);
 546         bits += h->hlen[p];
 547     }
 548 #ifdef DEBUG
 549     DEBUGF(gfc, "count1: real: %ld counted:%d (bigv %d count1len %d)\n",
 550            gfc->bs.totbit - gegebo, gi->count1bits, gi->big_values, gi->count1);
 551 #endif
 552     return bits;
 553 }
 554
 555
 556
 557 /*
 558   Implements the pseudocode of page 98 of the IS
 559   */
 560 inline static int
 561 Huffmancode(lame_internal_flags * const gfc, const unsigned int tableindex,
 562             int start, int end, gr_info const *gi)
 563 {
 564     struct huffcodetab const *const h = &ht[tableindex];
 565     unsigned int const linbits = h->xlen;
 566     int     i, bits = 0;
 567
 568     assert(tableindex < 32u);
 569     if (!tableindex)
 570         return bits;
 571
 572     for (i = start; i < end; i += 2) {
 573         int16_t  cbits = 0;
 574         uint16_t xbits = 0;
 575         unsigned int xlen = h->xlen;
 576         unsigned int ext = 0;
 577         unsigned int x1 = gi->l3_enc[i];
 578         unsigned int x2 = gi->l3_enc[i + 1];
 579
 580         assert(gi->l3_enc[i] >= 0);
 581         assert(gi->l3_enc[i+1] >= 0);
 582
 583         if (x1 != 0u) {
 584             if (gi->xr[i] < 0.0f)
 585                 ext++;
 586             cbits--;
 587         }
 588
 589         if (tableindex > 15u) {
 590             /* use ESC-words */
 591             if (x1 >= 15u) {
 592                 uint16_t const linbits_x1 = x1 - 15u;
 593                 assert(linbits_x1 <= h->linmax);
 594                 ext |= linbits_x1 << 1u;
 595                 xbits = linbits;
 596                 x1 = 15u;
 597             }
 598
 599             if (x2 >= 15u) {
 600                 uint16_t const linbits_x2 = x2 - 15u;
 601                 assert(linbits_x2 <= h->linmax);
 602                 ext <<= linbits;
 603                 ext |= linbits_x2;
 604                 xbits += linbits;
 605                 x2 = 15u;
 606             }
 607             xlen = 16;
 608         }
 609
 610         if (x2 != 0u) {
 611             ext <<= 1;
 612             if (gi->xr[i + 1] < 0.0f)
 613                 ext++;
 614             cbits--;
 615         }
 616
 617         assert((x1 | x2) < 16u);
 618
 619         x1 = x1 * xlen + x2;
 620         xbits -= cbits;
 621         cbits += h->hlen[x1];
 622
 623         assert(cbits <= MAX_LENGTH);
 624         assert(xbits <= MAX_LENGTH);
 625
 626         putbits2(gfc, h->table[x1], cbits);
 627         putbits2(gfc, (int)ext, xbits);
 628         bits += cbits + xbits;
 629     }
 630     return bits;
 631 }
 632
 633 /*
 634   Note the discussion of huffmancodebits() on pages 28
 635   and 29 of the IS, as well as the definitions of the side
 636   information on pages 26 and 27.
 637   */
 638 static int
 639 ShortHuffmancodebits(lame_internal_flags * gfc, gr_info const *gi)
 640 {
 641     int     bits;
 642     int     region1Start;
 643
 644     region1Start = 3 * gfc->scalefac_band.s[3];
 645     if (region1Start > gi->big_values)
 646         region1Start = gi->big_values;
 647
 648     /* short blocks do not have a region2 */
 649     bits = Huffmancode(gfc, gi->table_select[0], 0, region1Start, gi);
 650     bits += Huffmancode(gfc, gi->table_select[1], region1Start, gi->big_values, gi);
 651     return bits;
 652 }
 653
 654 static int
 655 LongHuffmancodebits(lame_internal_flags * gfc, gr_info const *gi)
 656 {
 657     unsigned int i;
 658     int     bigvalues, bits;
 659     int     region1Start, region2Start;
 660
 661     bigvalues = gi->big_values;
 662     assert(0 <= bigvalues && bigvalues <= 576);
 663
 664     assert(gi->region0_count >= -1);
 665     assert(gi->region1_count >= -1);
 666     i = gi->region0_count + 1;
 667     assert((size_t) i < dimension_of(gfc->scalefac_band.l));
 668     region1Start = gfc->scalefac_band.l[i];
 669     i += gi->region1_count + 1;
 670     assert((size_t) i < dimension_of(gfc->scalefac_band.l));
 671     region2Start = gfc->scalefac_band.l[i];
 672
 673     if (region1Start > bigvalues)
 674         region1Start = bigvalues;
 675
 676     if (region2Start > bigvalues)
 677         region2Start = bigvalues;
 678
 679     bits = Huffmancode(gfc, gi->table_select[0], 0, region1Start, gi);
 680     bits += Huffmancode(gfc, gi->table_select[1], region1Start, region2Start, gi);
 681     bits += Huffmancode(gfc, gi->table_select[2], region2Start, bigvalues, gi);
 682     return bits;
 683 }
 684
 685 inline static int
 686 writeMainData(lame_internal_flags * const gfc)
 687 {
 688     SessionConfig_t const *const cfg = &gfc->cfg;
 689     III_side_info_t const *const l3_side = &gfc->l3_side;
 690     int     gr, ch, sfb, data_bits, tot_bits = 0;
 691
 692     if (cfg->version == 1) {
 693         /* MPEG 1 */
 694         for (gr = 0; gr < 2; gr++) {
 695             for (ch = 0; ch < cfg->channels_out; ch++) {
 696                 gr_info const *const gi = &l3_side->tt[gr][ch];
 697                 int const slen1 = slen1_tab[gi->scalefac_compress];
 698                 int const slen2 = slen2_tab[gi->scalefac_compress];
 699                 data_bits = 0;
 700 #ifdef DEBUG
 701                 hogege = gfc->bs.totbit;
 702 #endif
 703                 for (sfb = 0; sfb < gi->sfbdivide; sfb++) {
 704                     if (gi->scalefac[sfb] == -1)
 705                         continue; /* scfsi is used */
 706                     putbits2(gfc, gi->scalefac[sfb], slen1);
 707                     data_bits += slen1;
 708                 }
 709                 for (; sfb < gi->sfbmax; sfb++) {
 710                     if (gi->scalefac[sfb] == -1)
 711                         continue; /* scfsi is used */
 712                     putbits2(gfc, gi->scalefac[sfb], slen2);
 713                     data_bits += slen2;
 714                 }
 715                 assert(data_bits == gi->part2_length);
 716
 717                 if (gi->block_type == SHORT_TYPE) {
 718                     data_bits += ShortHuffmancodebits(gfc, gi);
 719                 }
 720                 else {
 721                     data_bits += LongHuffmancodebits(gfc, gi);
 722                 }
 723                 data_bits += huffman_coder_count1(gfc, gi);
 724 #ifdef DEBUG
 725                 DEBUGF(gfc, "<%ld> ", gfc->bs.totbit - hogege);
 726 #endif
 727                 /* does bitcount in quantize.c agree with actual bit count? */
 728                 assert(data_bits == gi->part2_3_length + gi->part2_length);
 729                 tot_bits += data_bits;
 730             }           /* for ch */
 731         }               /* for gr */
 732     }
 733     else {
 734         /* MPEG 2 */
 735         gr = 0;
 736         for (ch = 0; ch < cfg->channels_out; ch++) {
 737             gr_info const *const gi = &l3_side->tt[gr][ch];
 738             int     i, sfb_partition, scale_bits = 0;
 739             assert(gi->sfb_partition_table);
 740             data_bits = 0;
 741 #ifdef DEBUG
 742             hogege = gfc->bs.totbit;
 743 #endif
 744             sfb = 0;
 745             sfb_partition = 0;
 746
 747             if (gi->block_type == SHORT_TYPE) {
 748                 for (; sfb_partition < 4; sfb_partition++) {
 749                     int const sfbs = gi->sfb_partition_table[sfb_partition] / 3;
 750                     int const slen = gi->slen[sfb_partition];
 751                     for (i = 0; i < sfbs; i++, sfb++) {
 752                         putbits2(gfc, Max(gi->scalefac[sfb * 3 + 0], 0), slen);
 753                         putbits2(gfc, Max(gi->scalefac[sfb * 3 + 1], 0), slen);
 754                         putbits2(gfc, Max(gi->scalefac[sfb * 3 + 2], 0), slen);
 755                         scale_bits += 3 * slen;
 756                     }
 757                 }
 758                 data_bits += ShortHuffmancodebits(gfc, gi);
 759             }
 760             else {
 761                 for (; sfb_partition < 4; sfb_partition++) {
 762                     int const sfbs = gi->sfb_partition_table[sfb_partition];
 763                     int const slen = gi->slen[sfb_partition];
 764                     for (i = 0; i < sfbs; i++, sfb++) {
 765                         putbits2(gfc, Max(gi->scalefac[sfb], 0), slen);
 766                         scale_bits += slen;
 767                     }
 768                 }
 769                 data_bits += LongHuffmancodebits(gfc, gi);
 770             }
 771             data_bits += huffman_coder_count1(gfc, gi);
 772 #ifdef DEBUG
 773             DEBUGF(gfc, "<%ld> ", gfc->bs.totbit - hogege);
 774 #endif
 775             /* does bitcount in quantize.c agree with actual bit count? */
 776             assert(data_bits == gi->part2_3_length);
 777             assert(scale_bits == gi->part2_length);
 778             tot_bits += scale_bits + data_bits;
 779         }               /* for ch */
 780     }                   /* for gf */
 781     return tot_bits;
 782 }                       /* main_data */
 783
 784
 785
 786 /* compute the number of bits required to flush all mp3 frames
 787    currently in the buffer.  This should be the same as the
 788    reservoir size.  Only call this routine between frames - i.e.
 789    only after all headers and data have been added to the buffer
 790    by format_bitstream().
 791
 792    Also compute total_bits_output =
 793        size of mp3 buffer (including frame headers which may not
 794        have yet been send to the mp3 buffer) +
 795        number of bits needed to flush all mp3 frames.
 796
 797    total_bytes_output is the size of the mp3 output buffer if
 798    lame_encode_flush_nogap() was called right now.
 799
 800  */
 801 int
 802 compute_flushbits(const lame_internal_flags * gfc, int *total_bytes_output)
 803 {
 804     SessionConfig_t const *const cfg = &gfc->cfg;
 805     EncStateVar_t const *const esv = &gfc->sv_enc;
 806     int     flushbits, remaining_headers;
 807     int     bitsPerFrame;
 808     int     last_ptr, first_ptr;
 809     first_ptr = esv->w_ptr; /* first header to add to bitstream */
 810     last_ptr = esv->h_ptr - 1; /* last header to add to bitstream */
 811     if (last_ptr == -1)
 812         last_ptr = MAX_HEADER_BUF - 1;
 813
 814     /* add this many bits to bitstream so we can flush all headers */
 815     flushbits = esv->header[last_ptr].write_timing - gfc->bs.totbit;
 816     *total_bytes_output = flushbits;
 817
 818     if (flushbits >= 0) {
 819         /* if flushbits >= 0, some headers have not yet been written */
 820         /* reduce flushbits by the size of the headers */
 821         remaining_headers = 1 + last_ptr - first_ptr;
 822         if (last_ptr < first_ptr)
 823             remaining_headers = 1 + last_ptr - first_ptr + MAX_HEADER_BUF;
 824         flushbits -= remaining_headers * 8 * cfg->sideinfo_len;
 825     }
 826
 827
 828     /* finally, add some bits so that the last frame is complete
 829      * these bits are not necessary to decode the last frame, but
 830      * some decoders will ignore last frame if these bits are missing
 831      */
 832     bitsPerFrame = getframebits(gfc);
 833     flushbits += bitsPerFrame;
 834     *total_bytes_output += bitsPerFrame;
 835     /* round up:   */
 836     if (*total_bytes_output % 8)
 837         *total_bytes_output = 1 + (*total_bytes_output / 8);
 838     else
 839         *total_bytes_output = (*total_bytes_output / 8);
 840     *total_bytes_output += gfc->bs.buf_byte_idx + 1;
 841
 842
 843     if (flushbits < 0) {
 844 #if 0
 845         /* if flushbits < 0, this would mean that the buffer looks like:
 846          * (data...)  last_header  (data...)  (extra data that should not be here...)
 847          */
 848         DEBUGF(gfc, "last header write_timing = %i \n", esv->header[last_ptr].write_timing);
 849         DEBUGF(gfc, "first header write_timing = %i \n", esv->header[first_ptr].write_timing);
 850         DEBUGF(gfc, "bs.totbit:                 %i \n", gfc->bs.totbit);
 851         DEBUGF(gfc, "first_ptr, last_ptr        %i %i \n", first_ptr, last_ptr);
 852         DEBUGF(gfc, "remaining_headers =        %i \n", remaining_headers);
 853         DEBUGF(gfc, "bitsperframe:              %i \n", bitsPerFrame);
 854         DEBUGF(gfc, "sidelen:                   %i \n", cfg->sideinfo_len);
 855 #endif
 856         ERRORF(gfc, "strange error flushing buffer ... \n");
 857     }
 858     return flushbits;
 859 }
 860
 861
 862 void
 863 flush_bitstream(lame_internal_flags * gfc)
 864 {
 865     EncStateVar_t *const esv = &gfc->sv_enc;
 866     III_side_info_t *l3_side;
 867     int     nbytes;
 868     int     flushbits;
 869     int     last_ptr = esv->h_ptr - 1; /* last header to add to bitstream */
 870     if (last_ptr == -1)
 871         last_ptr = MAX_HEADER_BUF - 1;
 872     l3_side = &gfc->l3_side;
 873
 874
 875     if ((flushbits = compute_flushbits(gfc, &nbytes)) < 0)
 876         return;
 877     drain_into_ancillary(gfc, flushbits);
 878
 879     /* check that the 100% of the last frame has been written to bitstream */
 880     assert(esv->header[last_ptr].write_timing + getframebits(gfc)
 881            == gfc->bs.totbit);
 882
 883     /* we have padded out all frames with ancillary data, which is the
 884        same as filling the bitreservoir with ancillary data, so : */
 885     esv->ResvSize = 0;
 886     l3_side->main_data_begin = 0;
 887 }
 888
 889
 890
 891
 892 void
 893 add_dummy_byte(lame_internal_flags * gfc, unsigned char val, unsigned int n)
 894 {
 895     EncStateVar_t *const esv = &gfc->sv_enc;
 896     int     i;
 897
 898     while (n-- > 0u) {
 899         putbits_noheaders(gfc, val, 8);
 900
 901         for (i = 0; i < MAX_HEADER_BUF; ++i)
 902             esv->header[i].write_timing += 8;
 903     }
 904 }
 905
 906
 907 /*
 908   format_bitstream()
 909
 910   This is called after a frame of audio has been quantized and coded.
 911   It will write the encoded audio to the bitstream. Note that
 912   from a layer3 encoder's perspective the bit stream is primarily
 913   a series of main_data() blocks, with header and side information
 914   inserted at the proper locations to maintain framing. (See Figure A.7
 915   in the IS).
 916   */
 917 int
 918 format_bitstream(lame_internal_flags * gfc)
 919 {
 920     SessionConfig_t const *const cfg = &gfc->cfg;
 921     EncStateVar_t *const esv = &gfc->sv_enc;
 922     int     bits, nbytes;
 923     III_side_info_t *l3_side;
 924     int     bitsPerFrame;
 925     l3_side = &gfc->l3_side;
 926
 927     bitsPerFrame = getframebits(gfc);
 928     drain_into_ancillary(gfc, l3_side->resvDrain_pre);
 929
 930     encodeSideInfo2(gfc, bitsPerFrame);
 931     bits = 8 * cfg->sideinfo_len;
 932     bits += writeMainData(gfc);
 933     drain_into_ancillary(gfc, l3_side->resvDrain_post);
 934     bits += l3_side->resvDrain_post;
 935
 936     l3_side->main_data_begin += (bitsPerFrame - bits) / 8;
 937
 938     /* compare number of bits needed to clear all buffered mp3 frames
 939      * with what we think the resvsize is: */
 940     if (compute_flushbits(gfc, &nbytes) != esv->ResvSize) {
 941         ERRORF(gfc, "Internal buffer inconsistency. flushbits <> ResvSize");
 942     }
 943
 944
 945     /* compare main_data_begin for the next frame with what we
 946      * think the resvsize is: */
 947     if ((l3_side->main_data_begin * 8) != esv->ResvSize) {
 948         ERRORF(gfc, "bit reservoir error: \n"
 949                "l3_side->main_data_begin: %i \n"
 950                "Resvoir size:             %i \n"
 951                "resv drain (post)         %i \n"
 952                "resv drain (pre)          %i \n"
 953                "header and sideinfo:      %i \n"
 954                "data bits:                %i \n"
 955                "total bits:               %i (remainder: %i) \n"
 956                "bitsperframe:             %i \n",
 957                8 * l3_side->main_data_begin,
 958                esv->ResvSize,
 959                l3_side->resvDrain_post,
 960                l3_side->resvDrain_pre,
 961                8 * cfg->sideinfo_len,
 962                bits - l3_side->resvDrain_post - 8 * cfg->sideinfo_len,
 963                bits, bits % 8, bitsPerFrame);
 964
 965         ERRORF(gfc, "This is a fatal error.  It has several possible causes:");
 966         ERRORF(gfc, "90%%  LAME compiled with buggy version of gcc using advanced optimizations");
 967         ERRORF(gfc, " 9%%  Your system is overclocked");
 968         ERRORF(gfc, " 1%%  bug in LAME encoding library");
 969
 970         esv->ResvSize = l3_side->main_data_begin * 8;
 971     };
 972     assert(gfc->bs.totbit % 8 == 0);
 973
 974     if (gfc->bs.totbit > 1000000000) {
 975         /* to avoid totbit overflow, (at 8h encoding at 128kbs) lets reset bit counter */
 976         int     i;
 977         for (i = 0; i < MAX_HEADER_BUF; ++i)
 978             esv->header[i].write_timing -= gfc->bs.totbit;
 979         gfc->bs.totbit = 0;
 980     }
 981
 982
 983     return 0;
 984 }
 985
 986
 987 static int
 988 do_gain_analysis(lame_internal_flags * gfc, unsigned char* buffer, int minimum)
 989 {
 990     SessionConfig_t const *const cfg = &gfc->cfg;
 991     RpgStateVar_t const *const rsv = &gfc->sv_rpg;
 992     RpgResult_t *const rov = &gfc->ov_rpg;
 993 #ifdef DECODE_ON_THE_FLY
 994     if (cfg->decode_on_the_fly) { /* decode the frame */
 995         sample_t pcm_buf[2][1152];
 996         int     mp3_in = minimum;
 997         int     samples_out = -1;
 998
 999         /* re-synthesis to pcm.  Repeat until we get a samples_out=0 */
1000         while (samples_out != 0) {
1001
1002             samples_out = hip_decode1_unclipped(gfc->hip, buffer, mp3_in, pcm_buf[0], pcm_buf[1]);
1003             /* samples_out = 0:  need more data to decode
1004              * samples_out = -1:  error.  Lets assume 0 pcm output
1005              * samples_out = number of samples output */
1006
1007             /* set the lenght of the mp3 input buffer to zero, so that in the
1008              * next iteration of the loop we will be querying mpglib about
1009              * buffered data */
1010             mp3_in = 0;
1011
1012             if (samples_out == -1) {
1013                 /* error decoding. Not fatal, but might screw up
1014                  * the ReplayGain tag. What should we do? Ignore for now */
1015                 samples_out = 0;
1016             }
1017             if (samples_out > 0) {
1018                 /* process the PCM data */
1019
1020                 /* this should not be possible, and indicates we have
1021                  * overflown the pcm_buf buffer */
1022                 assert(samples_out <= 1152);
1023
1024                 if (cfg->findPeakSample) {
1025                     int     i;
1026                     /* FIXME: is this correct? maybe Max(fabs(pcm),PeakSample) */
1027                     for (i = 0; i < samples_out; i++) {
1028                         if (pcm_buf[0][i] > rov->PeakSample)
1029                             rov->PeakSample = pcm_buf[0][i];
1030                         else if (-pcm_buf[0][i] > rov->PeakSample)
1031                             rov->PeakSample = -pcm_buf[0][i];
1032                     }
1033                     if (cfg->channels_out > 1)
1034                         for (i = 0; i < samples_out; i++) {
1035                             if (pcm_buf[1][i] > rov->PeakSample)
1036                                 rov->PeakSample = pcm_buf[1][i];
1037                             else if (-pcm_buf[1][i] > rov->PeakSample)
1038                                 rov->PeakSample = -pcm_buf[1][i];
1039                         }
1040                 }
1041
1042                 if (cfg->findReplayGain)
1043                     if (AnalyzeSamples
1044                         (rsv->rgdata, pcm_buf[0], pcm_buf[1], samples_out,
1045                          cfg->channels_out) == GAIN_ANALYSIS_ERROR)
1046                         return -6;
1047
1048             }       /* if (samples_out>0) */
1049         }           /* while (samples_out!=0) */
1050     }               /* if (gfc->decode_on_the_fly) */
1051 #endif
1052     return minimum;
1053 }
1054
1055 static int
1056 do_copy_buffer(lame_internal_flags * gfc, unsigned char *buffer, int size)
1057 {
1058     Bit_stream_struc *const bs = &gfc->bs;
1059     int const minimum = bs->buf_byte_idx + 1;
1060     if (minimum <= 0)
1061         return 0;
1062     if (size != 0 && minimum > size)
1063         return -1;      /* buffer is too small */
1064     memcpy(buffer, bs->buf, minimum);
1065     bs->buf_byte_idx = -1;
1066     bs->buf_bit_idx = 0;
1067     return minimum;
1068 }
1069
1070 /* copy data out of the internal MP3 bit buffer into a user supplied
1071    unsigned char buffer.
1072
1073    mp3data=0      indicates data in buffer is an id3tags and VBR tags
1074    mp3data=1      data is real mp3 frame data.
1075
1076
1077 */
1078 int
1079 copy_buffer(lame_internal_flags * gfc, unsigned char *buffer, int size, int mp3data)
1080 {
1081     int const minimum = do_copy_buffer(gfc, buffer, size);
1082     if (minimum > 0 && mp3data) {
1083         UpdateMusicCRC(&gfc->nMusicCRC, buffer, minimum);
1084
1085         /** sum number of bytes belonging to the mp3 stream
1086          *  this info will be written into the Xing/LAME header for seeking
1087          */
1088         gfc->VBR_seek_table.nBytesWritten += minimum;
1089
1090         return do_gain_analysis(gfc, buffer, minimum);
1091     }                   /* if (mp3data) */
1092     return minimum;
1093 }
1094
1095
1096 void
1097 init_bit_stream_w(lame_internal_flags * gfc)
1098 {
1099     EncStateVar_t *const esv = &gfc->sv_enc;
1100
1101     esv->h_ptr = esv->w_ptr = 0;
1102     esv->header[esv->h_ptr].write_timing = 0;
1103
1104     gfc->bs.buf = (unsigned char *) malloc(BUFFER_SIZE);
1105     gfc->bs.buf_size = BUFFER_SIZE;
1106     gfc->bs.buf_byte_idx = -1;
1107     gfc->bs.buf_bit_idx = 0;
1108     gfc->bs.totbit = 0;
1109 }
1110
1111 /* end of bitstream.c */