/* * MP3 bitstream Output interface for LAME * * Copyright (c) 1999-2000 Mark Taylor * Copyright (c) 1999-2002 Takehiro Tominaga * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Library General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the * Free Software Foundation, Inc., 59 Temple Place - Suite 330, * Boston, MA 02111-1307, USA. * * $Id: BitStream.java,v 1.23 2011/05/24 22:02:42 kenchis Exp $ */ package mp3; import java.util.Arrays; import mpg.MPGLib; public class BitStream { private static final int CRC16_POLYNOMIAL = 0x8005; /* * we work with ints, so when doing bit manipulation, we limit ourselves to * MAX_LENGTH-2 just to be on the safe side */ private static final int MAX_LENGTH = 32; GainAnalysis ga; MPGLib mpg; Version ver; VBRTag vbr; public final void setModules(GainAnalysis ga, MPGLib mpg, Version ver, VBRTag vbr) { this.ga = ga; this.mpg = mpg; this.ver = ver; this.vbr = vbr; } /** * Bit stream buffer. */ private byte[] buf; /** * Bit counter of bit stream. */ private int totbit; /** * Pointer to top byte in buffer. */ private int bufByteIdx; /** * Pointer to top bit of top byte in buffer. */ private int bufBitIdx; /** * compute bitsperframe and mean_bits for a layer III frame */ public final int getframebits(final LameGlobalFlags gfp) { final LameInternalFlags gfc = gfp.internal_flags; int bit_rate; /* get bitrate in kbps [?] */ if (gfc.bitrate_index != 0) bit_rate = Tables.bitrate_table[gfp.version][gfc.bitrate_index]; else bit_rate = gfp.brate; assert (8 <= bit_rate && bit_rate <= 640); /* main encoding routine toggles padding on and off */ /* one Layer3 Slot consists of 8 bits */ return 8 * ((gfp.version + 1) * 72000 * bit_rate / gfp.out_samplerate + gfc.padding); } private void putheader_bits(final LameInternalFlags gfc) { System.arraycopy(gfc.header[gfc.w_ptr].buf, 0, buf, bufByteIdx, gfc.sideinfo_len); bufByteIdx += gfc.sideinfo_len; totbit += gfc.sideinfo_len * 8; gfc.w_ptr = (gfc.w_ptr + 1) & (LameInternalFlags.MAX_HEADER_BUF - 1); } /** * write j bits into the bit stream */ private void putbits2(final LameInternalFlags gfc, final int val, int j) { assert (j < MAX_LENGTH - 2); while (j > 0) { int k; if (bufBitIdx == 0) { bufBitIdx = 8; bufByteIdx++; assert (bufByteIdx < Lame.LAME_MAXMP3BUFFER); assert (gfc.header[gfc.w_ptr].write_timing >= totbit); if (gfc.header[gfc.w_ptr].write_timing == totbit) { putheader_bits(gfc); } buf[bufByteIdx] = 0; } k = Math.min(j, bufBitIdx); j -= k; bufBitIdx -= k; assert (j < MAX_LENGTH); /* 32 too large on 32 bit machines */ assert (bufBitIdx < MAX_LENGTH); buf[bufByteIdx] |= ((val >> j) << bufBitIdx); totbit += k; } } /** * write j bits into the bit stream, ignoring frame headers */ private void putbits_noheaders(final LameInternalFlags gfc, final int val, int j) { assert (j < MAX_LENGTH - 2); while (j > 0) { int k; if (bufBitIdx == 0) { bufBitIdx = 8; bufByteIdx++; assert (bufByteIdx < Lame.LAME_MAXMP3BUFFER); buf[bufByteIdx] = 0; } k = Math.min(j, bufBitIdx); j -= k; bufBitIdx -= k; assert (j < MAX_LENGTH); /* 32 too large on 32 bit machines */ assert (bufBitIdx < MAX_LENGTH); buf[bufByteIdx] |= ((val >> j) << bufBitIdx); totbit += k; } } /** * Some combinations of bitrate, Fs, and stereo make it impossible to stuff * out a frame using just main_data, due to the limited number of bits to * indicate main_data_length. In these situations, we put stuffing bits into * the ancillary data... */ private void drain_into_ancillary(final LameGlobalFlags gfp, int remainingBits) { final LameInternalFlags gfc = gfp.internal_flags; int i; assert (remainingBits >= 0); if (remainingBits >= 8) { putbits2(gfc, 0x4c, 8); remainingBits -= 8; } if (remainingBits >= 8) { putbits2(gfc, 0x41, 8); remainingBits -= 8; } if (remainingBits >= 8) { putbits2(gfc, 0x4d, 8); remainingBits -= 8; } if (remainingBits >= 8) { putbits2(gfc, 0x45, 8); remainingBits -= 8; } if (remainingBits >= 32) { final String version = ver.getLameShortVersion(); if (remainingBits >= 32) for (i = 0; i < version.length() && remainingBits >= 8; ++i) { remainingBits -= 8; putbits2(gfc, version.charAt(i), 8); } } for (; remainingBits >= 1; remainingBits -= 1) { putbits2(gfc, gfc.ancillary_flag, 1); gfc.ancillary_flag ^= (!gfp.disable_reservoir ? 1 : 0); } assert (remainingBits == 0); } /** * write N bits into the header */ private void writeheader(final LameInternalFlags gfc, final int val, int j) { int ptr = gfc.header[gfc.h_ptr].ptr; while (j > 0) { final int k = Math.min(j, 8 - (ptr & 7)); j -= k; assert (j < MAX_LENGTH); /* >> 32 too large for 32 bit machines */ gfc.header[gfc.h_ptr].buf[ptr >> 3] |= ((val >> j)) << (8 - (ptr & 7) - k); ptr += k; } gfc.header[gfc.h_ptr].ptr = ptr; } private int CRC_update(int value, int crc) { value <<= 8; for (int i = 0; i < 8; i++) { value <<= 1; crc <<= 1; if ((((crc ^ value) & 0x10000) != 0)) crc ^= CRC16_POLYNOMIAL; } return crc; } public final void CRC_writeheader(final LameInternalFlags gfc, final byte[] header) { int crc = 0xffff; /* (jo) init crc16 for error_protection */ crc = CRC_update(header[2] & 0xff, crc); crc = CRC_update(header[3] & 0xff, crc); for (int i = 6; i < gfc.sideinfo_len; i++) { crc = CRC_update(header[i] & 0xff, crc); } header[4] = (byte) (crc >> 8); header[5] = (byte) (crc & 255); } private void encodeSideInfo2(final LameGlobalFlags gfp, final int bitsPerFrame) { final LameInternalFlags gfc = gfp.internal_flags; IIISideInfo l3_side; int gr, ch; l3_side = gfc.l3_side; gfc.header[gfc.h_ptr].ptr = 0; Arrays.fill(gfc.header[gfc.h_ptr].buf, 0, gfc.sideinfo_len, (byte) 0); if (gfp.out_samplerate < 16000) writeheader(gfc, 0xffe, 12); else writeheader(gfc, 0xfff, 12); writeheader(gfc, (gfp.version), 1); writeheader(gfc, 4 - 3, 2); writeheader(gfc, (!gfp.error_protection ? 1 : 0), 1); writeheader(gfc, (gfc.bitrate_index), 4); writeheader(gfc, (gfc.samplerate_index), 2); writeheader(gfc, (gfc.padding), 1); writeheader(gfc, (gfp.extension), 1); writeheader(gfc, (gfp.mode.ordinal()), 2); writeheader(gfc, (gfc.mode_ext), 2); writeheader(gfc, (gfp.copyright), 1); writeheader(gfc, (gfp.original), 1); writeheader(gfc, (gfp.emphasis), 2); if (gfp.error_protection) { writeheader(gfc, 0, 16); /* dummy */ } if (gfp.version == 1) { /* MPEG1 */ assert (l3_side.main_data_begin >= 0); writeheader(gfc, (l3_side.main_data_begin), 9); if (gfc.channels_out == 2) writeheader(gfc, l3_side.private_bits, 3); else writeheader(gfc, l3_side.private_bits, 5); for (ch = 0; ch < gfc.channels_out; ch++) { int band; for (band = 0; band < 4; band++) { writeheader(gfc, l3_side.scfsi[ch][band], 1); } } for (gr = 0; gr < 2; gr++) { for (ch = 0; ch < gfc.channels_out; ch++) { final GrInfo gi = l3_side.tt[gr][ch]; writeheader(gfc, gi.part2_3_length + gi.part2_length, 12); writeheader(gfc, gi.big_values / 2, 9); writeheader(gfc, gi.global_gain, 8); writeheader(gfc, gi.scalefac_compress, 4); if (gi.block_type != Encoder.NORM_TYPE) { writeheader(gfc, 1, 1); /* window_switching_flag */ writeheader(gfc, gi.block_type, 2); writeheader(gfc, gi.mixed_block_flag, 1); if (gi.table_select[0] == 14) gi.table_select[0] = 16; writeheader(gfc, gi.table_select[0], 5); if (gi.table_select[1] == 14) gi.table_select[1] = 16; writeheader(gfc, gi.table_select[1], 5); writeheader(gfc, gi.subblock_gain[0], 3); writeheader(gfc, gi.subblock_gain[1], 3); writeheader(gfc, gi.subblock_gain[2], 3); } else { writeheader(gfc, 0, 1); /* window_switching_flag */ if (gi.table_select[0] == 14) gi.table_select[0] = 16; writeheader(gfc, gi.table_select[0], 5); if (gi.table_select[1] == 14) gi.table_select[1] = 16; writeheader(gfc, gi.table_select[1], 5); if (gi.table_select[2] == 14) gi.table_select[2] = 16; writeheader(gfc, gi.table_select[2], 5); assert (0 <= gi.region0_count && gi.region0_count < 16); assert (0 <= gi.region1_count && gi.region1_count < 8); writeheader(gfc, gi.region0_count, 4); writeheader(gfc, gi.region1_count, 3); } writeheader(gfc, gi.preflag, 1); writeheader(gfc, gi.scalefac_scale, 1); writeheader(gfc, gi.count1table_select, 1); } } } else { /* MPEG2 */ assert (l3_side.main_data_begin >= 0); writeheader(gfc, (l3_side.main_data_begin), 8); writeheader(gfc, l3_side.private_bits, gfc.channels_out); gr = 0; for (ch = 0; ch < gfc.channels_out; ch++) { final GrInfo gi = l3_side.tt[gr][ch]; writeheader(gfc, gi.part2_3_length + gi.part2_length, 12); writeheader(gfc, gi.big_values / 2, 9); writeheader(gfc, gi.global_gain, 8); writeheader(gfc, gi.scalefac_compress, 9); if (gi.block_type != Encoder.NORM_TYPE) { writeheader(gfc, 1, 1); /* window_switching_flag */ writeheader(gfc, gi.block_type, 2); writeheader(gfc, gi.mixed_block_flag, 1); if (gi.table_select[0] == 14) gi.table_select[0] = 16; writeheader(gfc, gi.table_select[0], 5); if (gi.table_select[1] == 14) gi.table_select[1] = 16; writeheader(gfc, gi.table_select[1], 5); writeheader(gfc, gi.subblock_gain[0], 3); writeheader(gfc, gi.subblock_gain[1], 3); writeheader(gfc, gi.subblock_gain[2], 3); } else { writeheader(gfc, 0, 1); /* window_switching_flag */ if (gi.table_select[0] == 14) gi.table_select[0] = 16; writeheader(gfc, gi.table_select[0], 5); if (gi.table_select[1] == 14) gi.table_select[1] = 16; writeheader(gfc, gi.table_select[1], 5); if (gi.table_select[2] == 14) gi.table_select[2] = 16; writeheader(gfc, gi.table_select[2], 5); assert (0 <= gi.region0_count && gi.region0_count < 16); assert (0 <= gi.region1_count && gi.region1_count < 8); writeheader(gfc, gi.region0_count, 4); writeheader(gfc, gi.region1_count, 3); } writeheader(gfc, gi.scalefac_scale, 1); writeheader(gfc, gi.count1table_select, 1); } } if (gfp.error_protection) { /* (jo) error_protection: add crc16 information to header */ CRC_writeheader(gfc, gfc.header[gfc.h_ptr].buf); } { final int old = gfc.h_ptr; assert (gfc.header[old].ptr == gfc.sideinfo_len * 8); gfc.h_ptr = (old + 1) & (LameInternalFlags.MAX_HEADER_BUF - 1); gfc.header[gfc.h_ptr].write_timing = gfc.header[old].write_timing + bitsPerFrame; if (gfc.h_ptr == gfc.w_ptr) { /* yikes! we are out of header buffer space */ System.err .println("Error: MAX_HEADER_BUF too small in bitstream.c \n"); } } } private int huffman_coder_count1(final LameInternalFlags gfc, final GrInfo gi) { /* Write count1 area */ final HuffCodeTab h = Tables.ht[gi.count1table_select + 32]; int i, bits = 0; int ix = gi.big_values; int xr = gi.big_values; assert (gi.count1table_select < 2); for (i = (gi.count1 - gi.big_values) / 4; i > 0; --i) { int huffbits = 0; int p = 0, v; v = gi.l3_enc[ix + 0]; if (v != 0) { p += 8; if (gi.xr[xr + 0] < 0) huffbits++; assert (v <= 1); } v = gi.l3_enc[ix + 1]; if (v != 0) { p += 4; huffbits *= 2; if (gi.xr[xr + 1] < 0) huffbits++; assert (v <= 1); } v = gi.l3_enc[ix + 2]; if (v != 0) { p += 2; huffbits *= 2; if (gi.xr[xr + 2] < 0) huffbits++; assert (v <= 1); } v = gi.l3_enc[ix + 3]; if (v != 0) { p++; huffbits *= 2; if (gi.xr[xr + 3] < 0) huffbits++; assert (v <= 1); } ix += 4; xr += 4; putbits2(gfc, huffbits + h.table[p], h.hlen[p]); bits += h.hlen[p]; } return bits; } /** * Implements the pseudocode of page 98 of the IS */ private int Huffmancode(final LameInternalFlags gfc, final int tableindex, final int start, final int end, final GrInfo gi) { final HuffCodeTab h = Tables.ht[tableindex]; int bits = 0; assert (tableindex < 32); if (0 == tableindex) return bits; for (int i = start; i < end; i += 2) { int cbits = 0; int xbits = 0; final int linbits = h.xlen; int xlen = h.xlen; int ext = 0; int x1 = gi.l3_enc[i]; int x2 = gi.l3_enc[i + 1]; if (x1 != 0) { if (gi.xr[i] < 0) ext++; cbits--; } if (tableindex > 15) { /* use ESC-words */ if (x1 > 14) { final int linbits_x1 = x1 - 15; assert (linbits_x1 <= h.linmax); ext |= linbits_x1 << 1; xbits = linbits; x1 = 15; } if (x2 > 14) { final int linbits_x2 = x2 - 15; assert (linbits_x2 <= h.linmax); ext <<= linbits; ext |= linbits_x2; xbits += linbits; x2 = 15; } xlen = 16; } if (x2 != 0) { ext <<= 1; if (gi.xr[i + 1] < 0) ext++; cbits--; } assert ((x1 | x2) < 16); x1 = x1 * xlen + x2; xbits -= cbits; cbits += h.hlen[x1]; assert (cbits <= MAX_LENGTH); assert (xbits <= MAX_LENGTH); putbits2(gfc, h.table[x1], cbits); putbits2(gfc, ext, xbits); bits += cbits + xbits; } return bits; } /** * Note the discussion of huffmancodebits() on pages 28 and 29 of the IS, as * well as the definitions of the side information on pages 26 and 27. */ private int ShortHuffmancodebits(final LameInternalFlags gfc, final GrInfo gi) { int region1Start = 3 * gfc.scalefac_band.s[3]; if (region1Start > gi.big_values) region1Start = gi.big_values; /* short blocks do not have a region2 */ int bits = Huffmancode(gfc, gi.table_select[0], 0, region1Start, gi); bits += Huffmancode(gfc, gi.table_select[1], region1Start, gi.big_values, gi); return bits; } private int LongHuffmancodebits(final LameInternalFlags gfc, final GrInfo gi) { int bigvalues, bits; int region1Start, region2Start; bigvalues = gi.big_values; assert (0 <= bigvalues && bigvalues <= 576); int i = gi.region0_count + 1; assert (0 <= i); assert (i < gfc.scalefac_band.l.length); region1Start = gfc.scalefac_band.l[i]; i += gi.region1_count + 1; assert (0 <= i); assert (i < gfc.scalefac_band.l.length); region2Start = gfc.scalefac_band.l[i]; if (region1Start > bigvalues) region1Start = bigvalues; if (region2Start > bigvalues) region2Start = bigvalues; bits = Huffmancode(gfc, gi.table_select[0], 0, region1Start, gi); bits += Huffmancode(gfc, gi.table_select[1], region1Start, region2Start, gi); bits += Huffmancode(gfc, gi.table_select[2], region2Start, bigvalues, gi); return bits; } private int writeMainData(final LameGlobalFlags gfp) { int gr, ch, sfb, data_bits, tot_bits = 0; final LameInternalFlags gfc = gfp.internal_flags; final IIISideInfo l3_side = gfc.l3_side; if (gfp.version == 1) { /* MPEG 1 */ for (gr = 0; gr < 2; gr++) { for (ch = 0; ch < gfc.channels_out; ch++) { final GrInfo gi = l3_side.tt[gr][ch]; final int slen1 = Takehiro.slen1_tab[gi.scalefac_compress]; final int slen2 = Takehiro.slen2_tab[gi.scalefac_compress]; data_bits = 0; for (sfb = 0; sfb < gi.sfbdivide; sfb++) { if (gi.scalefac[sfb] == -1) continue; /* scfsi is used */ putbits2(gfc, gi.scalefac[sfb], slen1); data_bits += slen1; } for (; sfb < gi.sfbmax; sfb++) { if (gi.scalefac[sfb] == -1) continue; /* scfsi is used */ putbits2(gfc, gi.scalefac[sfb], slen2); data_bits += slen2; } assert (data_bits == gi.part2_length); if (gi.block_type == Encoder.SHORT_TYPE) { data_bits += ShortHuffmancodebits(gfc, gi); } else { data_bits += LongHuffmancodebits(gfc, gi); } data_bits += huffman_coder_count1(gfc, gi); /* does bitcount in quantize.c agree with actual bit count? */ assert (data_bits == gi.part2_3_length + gi.part2_length); tot_bits += data_bits; } /* for ch */ } /* for gr */ } else { /* MPEG 2 */ gr = 0; for (ch = 0; ch < gfc.channels_out; ch++) { final GrInfo gi = l3_side.tt[gr][ch]; int i, sfb_partition, scale_bits = 0; assert (gi.sfb_partition_table != null); data_bits = 0; sfb = 0; sfb_partition = 0; if (gi.block_type == Encoder.SHORT_TYPE) { for (; sfb_partition < 4; sfb_partition++) { final int sfbs = gi.sfb_partition_table[sfb_partition] / 3; final int slen = gi.slen[sfb_partition]; for (i = 0; i < sfbs; i++, sfb++) { putbits2(gfc, Math.max(gi.scalefac[sfb * 3 + 0], 0), slen); putbits2(gfc, Math.max(gi.scalefac[sfb * 3 + 1], 0), slen); putbits2(gfc, Math.max(gi.scalefac[sfb * 3 + 2], 0), slen); scale_bits += 3 * slen; } } data_bits += ShortHuffmancodebits(gfc, gi); } else { for (; sfb_partition < 4; sfb_partition++) { final int sfbs = gi.sfb_partition_table[sfb_partition]; final int slen = gi.slen[sfb_partition]; for (i = 0; i < sfbs; i++, sfb++) { putbits2(gfc, Math.max(gi.scalefac[sfb], 0), slen); scale_bits += slen; } } data_bits += LongHuffmancodebits(gfc, gi); } data_bits += huffman_coder_count1(gfc, gi); /* does bitcount in quantize.c agree with actual bit count? */ assert (data_bits == gi.part2_3_length); assert (scale_bits == gi.part2_length); tot_bits += scale_bits + data_bits; } /* for ch */ } /* for gf */ return tot_bits; } /* main_data */ public static class TotalBytes { public int total; } /* * compute the number of bits required to flush all mp3 frames currently in * the buffer. This should be the same as the reservoir size. Only call this * routine between frames - i.e. only after all headers and data have been * added to the buffer by format_bitstream(). * * Also compute total_bits_output = size of mp3 buffer (including frame * headers which may not have yet been send to the mp3 buffer) + number of * bits needed to flush all mp3 frames. * * total_bytes_output is the size of the mp3 output buffer if * lame_encode_flush_nogap() was called right now. */ private int compute_flushbits(final LameGlobalFlags gfp, final TotalBytes total_bytes_output) { final LameInternalFlags gfc = gfp.internal_flags; int flushbits, remaining_headers; int bitsPerFrame; int last_ptr, first_ptr; first_ptr = gfc.w_ptr; /* first header to add to bitstream */ last_ptr = gfc.h_ptr - 1; /* last header to add to bitstream */ if (last_ptr == -1) last_ptr = LameInternalFlags.MAX_HEADER_BUF - 1; /* add this many bits to bitstream so we can flush all headers */ flushbits = gfc.header[last_ptr].write_timing - totbit; total_bytes_output.total = flushbits; if (flushbits >= 0) { /* if flushbits >= 0, some headers have not yet been written */ /* reduce flushbits by the size of the headers */ remaining_headers = 1 + last_ptr - first_ptr; if (last_ptr < first_ptr) remaining_headers = 1 + last_ptr - first_ptr + LameInternalFlags.MAX_HEADER_BUF; flushbits -= remaining_headers * 8 * gfc.sideinfo_len; } /* * finally, add some bits so that the last frame is complete these bits * are not necessary to decode the last frame, but some decoders will * ignore last frame if these bits are missing */ bitsPerFrame = getframebits(gfp); flushbits += bitsPerFrame; total_bytes_output.total += bitsPerFrame; /* round up: */ if ((total_bytes_output.total % 8) != 0) total_bytes_output.total = 1 + (total_bytes_output.total / 8); else total_bytes_output.total = (total_bytes_output.total / 8); total_bytes_output.total += bufByteIdx + 1; if (flushbits < 0) { System.err.println("strange error flushing buffer ... \n"); } return flushbits; } public final void flush_bitstream(final LameGlobalFlags gfp) { final LameInternalFlags gfc = gfp.internal_flags; IIISideInfo l3_side; int flushbits; int last_ptr = gfc.h_ptr - 1; /* last header to add to bitstream */ if (last_ptr == -1) last_ptr = LameInternalFlags.MAX_HEADER_BUF - 1; l3_side = gfc.l3_side; if ((flushbits = compute_flushbits(gfp, new TotalBytes())) < 0) return; drain_into_ancillary(gfp, flushbits); /* check that the 100% of the last frame has been written to bitstream */ assert (gfc.header[last_ptr].write_timing + getframebits(gfp) == totbit); /* * we have padded out all frames with ancillary data, which is the same * as filling the bitreservoir with ancillary data, so : */ gfc.ResvSize = 0; l3_side.main_data_begin = 0; /* save the ReplayGain value */ if (gfc.findReplayGain) { final float RadioGain = (float) ga.GetTitleGain(gfc.rgdata); assert (NEQ(RadioGain, GainAnalysis.GAIN_NOT_ENOUGH_SAMPLES)); gfc.RadioGain = (int) Math.floor(RadioGain * 10.0 + 0.5); /* round to nearest */ } /* find the gain and scale change required for no clipping */ if (gfc.findPeakSample) { gfc.noclipGainChange = (int) Math.ceil(Math .log10(gfc.PeakSample / 32767.0) * 20.0 * 10.0); /* round up */ if (gfc.noclipGainChange > 0) { /* clipping occurs */ if (EQ(gfp.scale, 1.0f) || EQ(gfp.scale, 0.0f)) gfc.noclipScale = (float) (Math .floor((32767.0 / gfc.PeakSample) * 100.0f) / 100.0f); /* round down */ else { /* * the user specified his own scaling factor. We could * suggest the scaling factor of * (32767.0/gfp.PeakSample)*(gfp.scale) but it's usually * very inaccurate. So we'd rather not advice him on the * scaling factor. */ gfc.noclipScale = -1; } } else /* no clipping */ gfc.noclipScale = -1; } } public final void add_dummy_byte(final LameGlobalFlags gfp, final int val, int n) { final LameInternalFlags gfc = gfp.internal_flags; int i; while (n-- > 0) { putbits_noheaders(gfc, val, 8); for (i = 0; i < LameInternalFlags.MAX_HEADER_BUF; ++i) gfc.header[i].write_timing += 8; } } /** * This is called after a frame of audio has been quantized and coded. It * will write the encoded audio to the bitstream. Note that from a layer3 * encoder's perspective the bit stream is primarily a series of main_data() * blocks, with header and side information inserted at the proper locations * to maintain framing. (See Figure A.7 in the IS). */ public final int format_bitstream(final LameGlobalFlags gfp) { final LameInternalFlags gfc = gfp.internal_flags; IIISideInfo l3_side; l3_side = gfc.l3_side; int bitsPerFrame = getframebits(gfp); drain_into_ancillary(gfp, l3_side.resvDrain_pre); encodeSideInfo2(gfp, bitsPerFrame); int bits = 8 * gfc.sideinfo_len; bits += writeMainData(gfp); drain_into_ancillary(gfp, l3_side.resvDrain_post); bits += l3_side.resvDrain_post; l3_side.main_data_begin += (bitsPerFrame - bits) / 8; /* * compare number of bits needed to clear all buffered mp3 frames with * what we think the resvsize is: */ if (compute_flushbits(gfp, new TotalBytes()) != gfc.ResvSize) { System.err .println("Internal buffer inconsistency. flushbits <> ResvSize"); } /* * compare main_data_begin for the next frame with what we think the * resvsize is: */ if ((l3_side.main_data_begin * 8) != gfc.ResvSize) { System.err.printf("bit reservoir error: \n" + "l3_side.main_data_begin: %d \n" + "Resvoir size: %d \n" + "resv drain (post) %d \n" + "resv drain (pre) %d \n" + "header and sideinfo: %d \n" + "data bits: %d \n" + "total bits: %d (remainder: %d) \n" + "bitsperframe: %d \n", 8 * l3_side.main_data_begin, gfc.ResvSize, l3_side.resvDrain_post, l3_side.resvDrain_pre, 8 * gfc.sideinfo_len, bits - l3_side.resvDrain_post - 8 * gfc.sideinfo_len, bits, bits % 8, bitsPerFrame); System.err .println("This is a fatal error. It has several possible causes:"); System.err .println("90%% LAME compiled with buggy version of gcc using advanced optimizations"); System.err.println(" 9%% Your system is overclocked"); System.err.println(" 1%% bug in LAME encoding library"); gfc.ResvSize = l3_side.main_data_begin * 8; } ; assert (totbit % 8 == 0); if (totbit > 1000000000) { /* * to avoid totbit overflow, (at 8h encoding at 128kbs) lets reset * bit counter */ int i; for (i = 0; i < LameInternalFlags.MAX_HEADER_BUF; ++i) gfc.header[i].write_timing -= totbit; totbit = 0; } return 0; } /** * 
	 * copy data out of the internal MP3 bit buffer into a user supplied
	 * 	   unsigned char buffer.
	 * 
	 * 	   mp3data=0      indicates data in buffer is an id3tags and VBR tags
	 * 	   mp3data=1      data is real mp3 frame data.
	 *
*/ public final int copy_buffer(final LameInternalFlags gfc, final byte[] buffer, final int bufferPos, final int size, final int mp3data) { final int minimum = bufByteIdx + 1; if (minimum <= 0) return 0; if (size != 0 && minimum > size) { /* buffer is too small */ return -1; } System.arraycopy(buf, 0, buffer, bufferPos, minimum); bufByteIdx = -1; bufBitIdx = 0; if (mp3data != 0) { int[] crc = new int[1]; crc[0] = gfc.nMusicCRC; vbr.updateMusicCRC(crc, buffer, bufferPos, minimum); gfc.nMusicCRC = crc[0]; /** * sum number of bytes belonging to the mp3 stream this info will be * written into the Xing/LAME header for seeking */ if (minimum > 0) { gfc.VBR_seek_table.nBytesWritten += minimum; } if (gfc.decode_on_the_fly) { /* decode the frame */ float pcm_buf[][] = new float[2][1152]; int mp3_in = minimum; int samples_out = -1; int i; /* re-synthesis to pcm. Repeat until we get a samples_out=0 */ while (samples_out != 0) { samples_out = mpg.hip_decode1_unclipped(gfc.hip, buffer, bufferPos, mp3_in, pcm_buf[0], pcm_buf[1]); /* * samples_out = 0: need more data to decode samples_out = * -1: error. Lets assume 0 pcm output samples_out = number * of samples output */ /* * set the lenght of the mp3 input buffer to zero, so that * in the next iteration of the loop we will be querying * mpglib about buffered data */ mp3_in = 0; if (samples_out == -1) { /* * error decoding. Not fatal, but might screw up the * ReplayGain tag. What should we do? Ignore for now */ samples_out = 0; } if (samples_out > 0) { /* process the PCM data */ /* * this should not be possible, and indicates we have * overflown the pcm_buf buffer */ assert (samples_out <= 1152); if (gfc.findPeakSample) { for (i = 0; i < samples_out; i++) { if (pcm_buf[0][i] > gfc.PeakSample) gfc.PeakSample = pcm_buf[0][i]; else if (-pcm_buf[0][i] > gfc.PeakSample) gfc.PeakSample = -pcm_buf[0][i]; } if (gfc.channels_out > 1) for (i = 0; i < samples_out; i++) { if (pcm_buf[1][i] > gfc.PeakSample) gfc.PeakSample = pcm_buf[1][i]; else if (-pcm_buf[1][i] > gfc.PeakSample) gfc.PeakSample = -pcm_buf[1][i]; } } if (gfc.findReplayGain) if (ga.AnalyzeSamples(gfc.rgdata, pcm_buf[0], 0, pcm_buf[1], 0, samples_out, gfc.channels_out) == GainAnalysis.GAIN_ANALYSIS_ERROR) return -6; } /* if (samples_out>0) */ } /* while (samples_out!=0) */ } /* if (gfc.decode_on_the_fly) */ } /* if (mp3data) */ return minimum; } public final void init_bit_stream_w(final LameInternalFlags gfc) { buf = new byte[Lame.LAME_MAXMP3BUFFER]; gfc.h_ptr = gfc.w_ptr = 0; gfc.header[gfc.h_ptr].write_timing = 0; bufByteIdx = -1; bufBitIdx = 0; totbit = 0; } // From machine.h public static boolean EQ(float a, float b) { return (Math.abs(a) > Math.abs(b)) ? (Math.abs((a) - (b)) <= (Math .abs(a) * 1e-6f)) : (Math.abs((a) - (b)) <= (Math.abs(b) * 1e-6f)); } public static boolean NEQ(float a, float b) { return !EQ(a, b); } }