+ * for (i = 0; i < 16*16; i++) [
+ * largetbl[i] = ((ht[16].hlen[i]) << 16) + ht[24].hlen[i];
+ * ]
+ *
+ *
+ */
+Tables$1.largetbl = [
+ 0x010004, 0x050005, 0x070007, 0x090008, 0x0a0009, 0x0a000a, 0x0b000a, 0x0b000b,
+ 0x0c000b, 0x0c000c, 0x0c000c, 0x0d000c, 0x0d000c, 0x0d000c, 0x0e000d, 0x0a000a,
+ 0x040005, 0x060006, 0x080007, 0x090008, 0x0a0009, 0x0b000a, 0x0b000a, 0x0b000b,
+ 0x0c000b, 0x0c000b, 0x0c000c, 0x0d000c, 0x0e000c, 0x0d000c, 0x0e000c, 0x0a000a,
+ 0x070007, 0x080007, 0x090008, 0x0a0009, 0x0b0009, 0x0b000a, 0x0c000a, 0x0c000b,
+ 0x0d000b, 0x0c000b, 0x0d000b, 0x0d000c, 0x0d000c, 0x0e000c, 0x0e000d, 0x0b0009,
+ 0x090008, 0x090008, 0x0a0009, 0x0b0009, 0x0b000a, 0x0c000a, 0x0c000a, 0x0c000b,
+ 0x0d000b, 0x0d000b, 0x0e000b, 0x0e000c, 0x0e000c, 0x0f000c, 0x0f000c, 0x0c0009,
+ 0x0a0009, 0x0a0009, 0x0b0009, 0x0b000a, 0x0c000a, 0x0c000a, 0x0d000a, 0x0d000b,
+ 0x0d000b, 0x0e000b, 0x0e000c, 0x0e000c, 0x0f000c, 0x0f000c, 0x0f000d, 0x0b0009,
+ 0x0a000a, 0x0a0009, 0x0b000a, 0x0b000a, 0x0c000a, 0x0d000a, 0x0d000b, 0x0e000b,
+ 0x0d000b, 0x0e000b, 0x0e000c, 0x0f000c, 0x0f000c, 0x0f000c, 0x10000c, 0x0c0009,
+ 0x0b000a, 0x0b000a, 0x0b000a, 0x0c000a, 0x0d000a, 0x0d000b, 0x0d000b, 0x0d000b,
+ 0x0e000b, 0x0e000c, 0x0e000c, 0x0e000c, 0x0f000c, 0x0f000c, 0x10000d, 0x0c0009,
+ 0x0b000b, 0x0b000a, 0x0c000a, 0x0c000a, 0x0d000b, 0x0d000b, 0x0d000b, 0x0e000b,
+ 0x0e000c, 0x0f000c, 0x0f000c, 0x0f000c, 0x0f000c, 0x11000d, 0x11000d, 0x0c000a,
+ 0x0b000b, 0x0c000b, 0x0c000b, 0x0d000b, 0x0d000b, 0x0d000b, 0x0e000b, 0x0e000b,
+ 0x0f000b, 0x0f000c, 0x0f000c, 0x0f000c, 0x10000c, 0x10000d, 0x10000d, 0x0c000a,
+ 0x0c000b, 0x0c000b, 0x0c000b, 0x0d000b, 0x0d000b, 0x0e000b, 0x0e000b, 0x0f000c,
+ 0x0f000c, 0x0f000c, 0x0f000c, 0x10000c, 0x0f000d, 0x10000d, 0x0f000d, 0x0d000a,
+ 0x0c000c, 0x0d000b, 0x0c000b, 0x0d000b, 0x0e000b, 0x0e000c, 0x0e000c, 0x0e000c,
+ 0x0f000c, 0x10000c, 0x10000c, 0x10000d, 0x11000d, 0x11000d, 0x10000d, 0x0c000a,
+ 0x0d000c, 0x0d000c, 0x0d000b, 0x0d000b, 0x0e000b, 0x0e000c, 0x0f000c, 0x10000c,
+ 0x10000c, 0x10000c, 0x10000c, 0x10000d, 0x10000d, 0x0f000d, 0x10000d, 0x0d000a,
+ 0x0d000c, 0x0e000c, 0x0e000c, 0x0e000c, 0x0e000c, 0x0f000c, 0x0f000c, 0x0f000c,
+ 0x0f000c, 0x11000c, 0x10000d, 0x10000d, 0x10000d, 0x10000d, 0x12000d, 0x0d000a,
+ 0x0f000c, 0x0e000c, 0x0e000c, 0x0e000c, 0x0f000c, 0x0f000c, 0x10000c, 0x10000c,
+ 0x10000d, 0x12000d, 0x11000d, 0x11000d, 0x11000d, 0x13000d, 0x11000d, 0x0d000a,
+ 0x0e000d, 0x0f000c, 0x0d000c, 0x0e000c, 0x10000c, 0x10000c, 0x0f000c, 0x10000d,
+ 0x10000d, 0x11000d, 0x12000d, 0x11000d, 0x13000d, 0x11000d, 0x10000d, 0x0d000a,
+ 0x0a0009, 0x0a0009, 0x0a0009, 0x0b0009, 0x0b0009, 0x0c0009, 0x0c0009, 0x0c0009,
+ 0x0d0009, 0x0d0009, 0x0d0009, 0x0d000a, 0x0d000a, 0x0d000a, 0x0d000a, 0x0a0006
+];
+/**
+ *
+ * for (i = 0; i < 3*3; i++) [
+ * table23[i] = ((ht[2].hlen[i]) << 16) + ht[3].hlen[i];
+ * ]
+ *
+ *
+ */
+Tables$1.table23 = [
+ 0x010002, 0x040003, 0x070007,
+ 0x040004, 0x050004, 0x070007,
+ 0x060006, 0x070007, 0x080008
+];
+
+/**
+ *
+ * for (i = 0; i < 4*4; i++) [
+ * table56[i] = ((ht[5].hlen[i]) << 16) + ht[6].hlen[i];
+ * ]
+ *
+ *
+ */
+Tables$1.table56 = [
+ 0x010003, 0x040004, 0x070006, 0x080008, 0x040004, 0x050004, 0x080006, 0x090007,
+ 0x070005, 0x080006, 0x090007, 0x0a0008, 0x080007, 0x080007, 0x090008, 0x0a0009
+];
+
+Tables$1.bitrate_table = [
+ [0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, -1], /* MPEG 2 */
+ [0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, -1], /* MPEG 1 */
+ [0, 8, 16, 24, 32, 40, 48, 56, 64, -1, -1, -1, -1, -1, -1, -1], /* MPEG 2.5 */
+];
+
+/**
+ * MPEG 2, MPEG 1, MPEG 2.5.
+ */
+Tables$1.samplerate_table = [
+ [22050, 24000, 16000, -1],
+ [44100, 48000, 32000, -1],
+ [11025, 12000, 8000, -1],
+];
+
+/**
+ * This is the scfsi_band table from 2.4.2.7 of the IS.
+ */
+Tables$1.scfsi_band = [0, 6, 11, 16, 21];
+
+var Tables_1 = Tables$1;
+
+var VbrMode$19 = common.VbrMode;
+var Float$19 = common.Float;
+var Util$19 = common.Util;
+var new_float$19 = common.new_float;
+var new_int$19 = common.new_int;
+var assert$19 = common.assert;
+
+
+
+
+
+QuantizePVT$1.Q_MAX = (256 + 1);
+QuantizePVT$1.Q_MAX2 = 116;
+QuantizePVT$1.LARGE_BITS = 100000;
+QuantizePVT$1.IXMAX_VAL = 8206;
+
+function QuantizePVT$1() {
+
+ var tak = null;
+ var rv = null;
+ var psy = null;
+
+ this.setModules = function (_tk, _rv, _psy) {
+ tak = _tk;
+ rv = _rv;
+ psy = _psy;
+ };
+
+ function POW20(x) {
+ assert$19(0 <= (x + QuantizePVT$1.Q_MAX2) && x < QuantizePVT$1.Q_MAX);
+ return pow20[x + QuantizePVT$1.Q_MAX2];
+ }
+
+ this.IPOW20 = function (x) {
+ assert$19(0 <= x && x < QuantizePVT$1.Q_MAX);
+ return ipow20[x];
+ };
+
+ /**
+ * smallest such that 1.0+DBL_EPSILON != 1.0
+ */
+ var DBL_EPSILON = 2.2204460492503131e-016;
+
+ /**
+ * ix always <= 8191+15. see count_bits()
+ */
+ var IXMAX_VAL = QuantizePVT$1.IXMAX_VAL;
+
+ var PRECALC_SIZE = (IXMAX_VAL + 2);
+
+ var Q_MAX = QuantizePVT$1.Q_MAX;
+
+
+ /**
+ *
+ * minimum possible number of
+ * -cod_info.global_gain + ((scalefac[] + (cod_info.preflag ? pretab[sfb] : 0))
+ * << (cod_info.scalefac_scale + 1)) + cod_info.subblock_gain[cod_info.window[sfb]] * 8;
+ *
+ * for long block, 0+((15+3)<<2) = 18*4 = 72
+ * for short block, 0+(15<<2)+7*8 = 15*4+56 = 116
+ *
+ */
+ var Q_MAX2 = QuantizePVT$1.Q_MAX2;
+
+ var LARGE_BITS = QuantizePVT$1.LARGE_BITS;
+
+
+ /**
+ * Assuming dynamic range=96dB, this value should be 92
+ */
+ var NSATHSCALE = 100;
+
+ /**
+ * The following table is used to implement the scalefactor partitioning for
+ * MPEG2 as described in section 2.4.3.2 of the IS. The indexing corresponds
+ * to the way the tables are presented in the IS:
+ *
+ * [table_number][row_in_table][column of nr_of_sfb]
+ */
+ this.nr_of_sfb_block = [
+ [[6, 5, 5, 5], [9, 9, 9, 9], [6, 9, 9, 9]],
+ [[6, 5, 7, 3], [9, 9, 12, 6], [6, 9, 12, 6]],
+ [[11, 10, 0, 0], [18, 18, 0, 0], [15, 18, 0, 0]],
+ [[7, 7, 7, 0], [12, 12, 12, 0], [6, 15, 12, 0]],
+ [[6, 6, 6, 3], [12, 9, 9, 6], [6, 12, 9, 6]],
+ [[8, 8, 5, 0], [15, 12, 9, 0], [6, 18, 9, 0]]];
+
+ /**
+ * Table B.6: layer3 preemphasis
+ */
+ var pretab = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1,
+ 2, 2, 3, 3, 3, 2, 0];
+ this.pretab = pretab;
+
+ /**
+ * Here are MPEG1 Table B.8 and MPEG2 Table B.1 -- Layer III scalefactor
+ * bands. + * Index into this using a method such as:
+ * idx = fr_ps.header.sampling_frequency + (fr_ps.header.version * 3) + */ + this.sfBandIndex = [ + // Table B.2.b: 22.05 kHz + new ScaleFac_1([0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464, + 522, 576], + [0, 4, 8, 12, 18, 24, 32, 42, 56, 74, 100, 132, 174, 192] + , [0, 0, 0, 0, 0, 0, 0] // sfb21 pseudo sub bands + , [0, 0, 0, 0, 0, 0, 0] // sfb12 pseudo sub bands + ), + /* Table B.2.c: 24 kHz */ /* docs: 332. mpg123(broken): 330 */ + new ScaleFac_1([0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 114, 136, 162, 194, 232, 278, 332, 394, 464, + 540, 576], + [0, 4, 8, 12, 18, 26, 36, 48, 62, 80, 104, 136, 180, 192] + , [0, 0, 0, 0, 0, 0, 0] /* sfb21 pseudo sub bands */ + , [0, 0, 0, 0, 0, 0, 0] /* sfb12 pseudo sub bands */ + ), + /* Table B.2.a: 16 kHz */ + new ScaleFac_1([0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464, + 522, 576], + [0, 4, 8, 12, 18, 26, 36, 48, 62, 80, 104, 134, 174, 192] + , [0, 0, 0, 0, 0, 0, 0] /* sfb21 pseudo sub bands */ + , [0, 0, 0, 0, 0, 0, 0] /* sfb12 pseudo sub bands */ + ), + /* Table B.8.b: 44.1 kHz */ + new ScaleFac_1([0, 4, 8, 12, 16, 20, 24, 30, 36, 44, 52, 62, 74, 90, 110, 134, 162, 196, 238, 288, 342, 418, + 576], + [0, 4, 8, 12, 16, 22, 30, 40, 52, 66, 84, 106, 136, 192] + , [0, 0, 0, 0, 0, 0, 0] /* sfb21 pseudo sub bands */ + , [0, 0, 0, 0, 0, 0, 0] /* sfb12 pseudo sub bands */ + ), + /* Table B.8.c: 48 kHz */ + new ScaleFac_1([0, 4, 8, 12, 16, 20, 24, 30, 36, 42, 50, 60, 72, 88, 106, 128, 156, 190, 230, 276, 330, 384, + 576], + [0, 4, 8, 12, 16, 22, 28, 38, 50, 64, 80, 100, 126, 192] + , [0, 0, 0, 0, 0, 0, 0] /* sfb21 pseudo sub bands */ + , [0, 0, 0, 0, 0, 0, 0] /* sfb12 pseudo sub bands */ + ), + /* Table B.8.a: 32 kHz */ + new ScaleFac_1([0, 4, 8, 12, 16, 20, 24, 30, 36, 44, 54, 66, 82, 102, 126, 156, 194, 240, 296, 364, 448, 550, + 576], + [0, 4, 8, 12, 16, 22, 30, 42, 58, 78, 104, 138, 180, 192] + , [0, 0, 0, 0, 0, 0, 0] /* sfb21 pseudo sub bands */ + , [0, 0, 0, 0, 0, 0, 0] /* sfb12 pseudo sub bands */ + ), + /* MPEG-2.5 11.025 kHz */ + new ScaleFac_1([0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464, + 522, 576], + [0 / 3, 12 / 3, 24 / 3, 36 / 3, 54 / 3, 78 / 3, 108 / 3, 144 / 3, 186 / 3, 240 / 3, 312 / 3, + 402 / 3, 522 / 3, 576 / 3] + , [0, 0, 0, 0, 0, 0, 0] /* sfb21 pseudo sub bands */ + , [0, 0, 0, 0, 0, 0, 0] /* sfb12 pseudo sub bands */ + ), + /* MPEG-2.5 12 kHz */ + new ScaleFac_1([0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464, + 522, 576], + [0 / 3, 12 / 3, 24 / 3, 36 / 3, 54 / 3, 78 / 3, 108 / 3, 144 / 3, 186 / 3, 240 / 3, 312 / 3, + 402 / 3, 522 / 3, 576 / 3] + , [0, 0, 0, 0, 0, 0, 0] /* sfb21 pseudo sub bands */ + , [0, 0, 0, 0, 0, 0, 0] /* sfb12 pseudo sub bands */ + ), + /* MPEG-2.5 8 kHz */ + new ScaleFac_1([0, 12, 24, 36, 48, 60, 72, 88, 108, 132, 160, 192, 232, 280, 336, 400, 476, 566, 568, 570, + 572, 574, 576], + [0 / 3, 24 / 3, 48 / 3, 72 / 3, 108 / 3, 156 / 3, 216 / 3, 288 / 3, 372 / 3, 480 / 3, 486 / 3, + 492 / 3, 498 / 3, 576 / 3] + , [0, 0, 0, 0, 0, 0, 0] /* sfb21 pseudo sub bands */ + , [0, 0, 0, 0, 0, 0, 0] /* sfb12 pseudo sub bands */ + ) + ]; + + var pow20 = new_float$19(Q_MAX + Q_MAX2 + 1); + var ipow20 = new_float$19(Q_MAX); + var pow43 = new_float$19(PRECALC_SIZE); + + var adj43 = new_float$19(PRECALC_SIZE); + this.adj43 = adj43; + + /** + *
+ * compute the ATH for each scalefactor band cd range: 0..96db + * + * Input: 3.3kHz signal 32767 amplitude (3.3kHz is where ATH is smallest = + * -5db) longblocks: sfb=12 en0/bw=-11db max_en0 = 1.3db shortblocks: sfb=5 + * -9db 0db + * + * Input: 1 1 1 1 1 1 1 -1 -1 -1 -1 -1 -1 -1 (repeated) longblocks: amp=1 + * sfb=12 en0/bw=-103 db max_en0 = -92db amp=32767 sfb=12 -12 db -1.4db + * + * Input: 1 1 1 1 1 1 1 -1 -1 -1 -1 -1 -1 -1 (repeated) shortblocks: amp=1 + * sfb=5 en0/bw= -99 -86 amp=32767 sfb=5 -9 db 4db + * + * + * MAX energy of largest wave at 3.3kHz = 1db AVE energy of largest wave at + * 3.3kHz = -11db Let's take AVE: -11db = maximum signal in sfb=12. Dynamic + * range of CD: 96db. Therefor energy of smallest audible wave in sfb=12 = + * -11 - 96 = -107db = ATH at 3.3kHz. + * + * ATH formula for this wave: -5db. To adjust to LAME scaling, we need ATH = + * ATH_formula - 103 (db) ATH = ATH * 2.5e-10 (ener) + *+ */ + function ATHmdct(gfp, f) { + var ath = psy.ATHformula(f, gfp); + + ath -= NSATHSCALE; + + /* modify the MDCT scaling for the ATH and convert to energy */ + ath = Math.pow(10.0, ath / 10.0 + gfp.ATHlower); + return ath; + } + + function compute_ath(gfp) { + var ATH_l = gfp.internal_flags.ATH.l; + var ATH_psfb21 = gfp.internal_flags.ATH.psfb21; + var ATH_s = gfp.internal_flags.ATH.s; + var ATH_psfb12 = gfp.internal_flags.ATH.psfb12; + var gfc = gfp.internal_flags; + var samp_freq = gfp.out_samplerate; + + for (var sfb = 0; sfb < Encoder_1.SBMAX_l; sfb++) { + var start = gfc.scalefac_band.l[sfb]; + var end = gfc.scalefac_band.l[sfb + 1]; + ATH_l[sfb] = Float$19.MAX_VALUE; + for (var i = start; i < end; i++) { + var freq = i * samp_freq / (2 * 576); + var ATH_f = ATHmdct(gfp, freq); + /* freq in kHz */ + ATH_l[sfb] = Math.min(ATH_l[sfb], ATH_f); + } + } + + for (var sfb = 0; sfb < Encoder_1.PSFB21; sfb++) { + var start = gfc.scalefac_band.psfb21[sfb]; + var end = gfc.scalefac_band.psfb21[sfb + 1]; + ATH_psfb21[sfb] = Float$19.MAX_VALUE; + for (var i = start; i < end; i++) { + var freq = i * samp_freq / (2 * 576); + var ATH_f = ATHmdct(gfp, freq); + /* freq in kHz */ + ATH_psfb21[sfb] = Math.min(ATH_psfb21[sfb], ATH_f); + } + } + + for (var sfb = 0; sfb < Encoder_1.SBMAX_s; sfb++) { + var start = gfc.scalefac_band.s[sfb]; + var end = gfc.scalefac_band.s[sfb + 1]; + ATH_s[sfb] = Float$19.MAX_VALUE; + for (var i = start; i < end; i++) { + var freq = i * samp_freq / (2 * 192); + var ATH_f = ATHmdct(gfp, freq); + /* freq in kHz */ + ATH_s[sfb] = Math.min(ATH_s[sfb], ATH_f); + } + ATH_s[sfb] *= (gfc.scalefac_band.s[sfb + 1] - gfc.scalefac_band.s[sfb]); + } + + for (var sfb = 0; sfb < Encoder_1.PSFB12; sfb++) { + var start = gfc.scalefac_band.psfb12[sfb]; + var end = gfc.scalefac_band.psfb12[sfb + 1]; + ATH_psfb12[sfb] = Float$19.MAX_VALUE; + for (var i = start; i < end; i++) { + var freq = i * samp_freq / (2 * 192); + var ATH_f = ATHmdct(gfp, freq); + /* freq in kHz */ + ATH_psfb12[sfb] = Math.min(ATH_psfb12[sfb], ATH_f); + } + /* not sure about the following */ + ATH_psfb12[sfb] *= (gfc.scalefac_band.s[13] - gfc.scalefac_band.s[12]); + } + + /* + * no-ATH mode: reduce ATH to -200 dB + */ + if (gfp.noATH) { + for (var sfb = 0; sfb < Encoder_1.SBMAX_l; sfb++) { + ATH_l[sfb] = 1E-20; + } + for (var sfb = 0; sfb < Encoder_1.PSFB21; sfb++) { + ATH_psfb21[sfb] = 1E-20; + } + for (var sfb = 0; sfb < Encoder_1.SBMAX_s; sfb++) { + ATH_s[sfb] = 1E-20; + } + for (var sfb = 0; sfb < Encoder_1.PSFB12; sfb++) { + ATH_psfb12[sfb] = 1E-20; + } + } + + /* + * work in progress, don't rely on it too much + */ + gfc.ATH.floor = 10. * Math.log10(ATHmdct(gfp, -1.)); + } + + /** + * initialization for iteration_loop + */ + this.iteration_init = function (gfp) { + var gfc = gfp.internal_flags; + var l3_side = gfc.l3_side; + var i; + + if (gfc.iteration_init_init == 0) { + gfc.iteration_init_init = 1; + + l3_side.main_data_begin = 0; + compute_ath(gfp); + + pow43[0] = 0.0; + for (i = 1; i < PRECALC_SIZE; i++) + pow43[i] = Math.pow(i, 4.0 / 3.0); + + for (i = 0; i < PRECALC_SIZE - 1; i++) + adj43[i] = ((i + 1) - Math.pow( + 0.5 * (pow43[i] + pow43[i + 1]), 0.75)); + adj43[i] = 0.5; + + for (i = 0; i < Q_MAX; i++) + ipow20[i] = Math.pow(2.0, (i - 210) * -0.1875); + for (i = 0; i <= Q_MAX + Q_MAX2; i++) + pow20[i] = Math.pow(2.0, (i - 210 - Q_MAX2) * 0.25); + + tak.huffman_init(gfc); + + { + var bass, alto, treble, sfb21; + + i = (gfp.exp_nspsytune >> 2) & 63; + if (i >= 32) + i -= 64; + bass = Math.pow(10, i / 4.0 / 10.0); + + i = (gfp.exp_nspsytune >> 8) & 63; + if (i >= 32) + i -= 64; + alto = Math.pow(10, i / 4.0 / 10.0); + + i = (gfp.exp_nspsytune >> 14) & 63; + if (i >= 32) + i -= 64; + treble = Math.pow(10, i / 4.0 / 10.0); + + /* + * to be compatible with Naoki's original code, the next 6 bits + * define only the amount of changing treble for sfb21 + */ + i = (gfp.exp_nspsytune >> 20) & 63; + if (i >= 32) + i -= 64; + sfb21 = treble * Math.pow(10, i / 4.0 / 10.0); + for (i = 0; i < Encoder_1.SBMAX_l; i++) { + var f; + if (i <= 6) + f = bass; + else if (i <= 13) + f = alto; + else if (i <= 20) + f = treble; + else + f = sfb21; + + gfc.nsPsy.longfact[i] = f; + } + for (i = 0; i < Encoder_1.SBMAX_s; i++) { + var f; + if (i <= 5) + f = bass; + else if (i <= 10) + f = alto; + else if (i <= 11) + f = treble; + else + f = sfb21; + + gfc.nsPsy.shortfact[i] = f; + } + } + } + }; + + /** + * allocate bits among 2 channels based on PE
+ * mt 6/99
+ * bugfixes rh 8/01: often allocated more than the allowed 4095 bits + */ + this.on_pe = function (gfp, pe, + targ_bits, mean_bits, gr, cbr) { + var gfc = gfp.internal_flags; + var tbits = 0, bits; + var add_bits = new_int$19(2); + var ch; + + /* allocate targ_bits for granule */ + var mb = new MeanBits_1(tbits); + var extra_bits = rv.ResvMaxBits(gfp, mean_bits, mb, cbr); + tbits = mb.bits; + /* maximum allowed bits for this granule */ + var max_bits = tbits + extra_bits; + if (max_bits > LameInternalFlags_1.MAX_BITS_PER_GRANULE) { + // hard limit per granule + max_bits = LameInternalFlags_1.MAX_BITS_PER_GRANULE; + } + for (bits = 0, ch = 0; ch < gfc.channels_out; ++ch) { + /****************************************************************** + * allocate bits for each channel + ******************************************************************/ + targ_bits[ch] = Math.min(LameInternalFlags_1.MAX_BITS_PER_CHANNEL, + tbits / gfc.channels_out); + + add_bits[ch] = 0 | (targ_bits[ch] * pe[gr][ch] / 700.0 - targ_bits[ch]); + + /* at most increase bits by 1.5*average */ + if (add_bits[ch] > mean_bits * 3 / 4) + add_bits[ch] = mean_bits * 3 / 4; + if (add_bits[ch] < 0) + add_bits[ch] = 0; + + if (add_bits[ch] + targ_bits[ch] > LameInternalFlags_1.MAX_BITS_PER_CHANNEL) + add_bits[ch] = Math.max(0, + LameInternalFlags_1.MAX_BITS_PER_CHANNEL - targ_bits[ch]); + + bits += add_bits[ch]; + } + if (bits > extra_bits) { + for (ch = 0; ch < gfc.channels_out; ++ch) { + add_bits[ch] = extra_bits * add_bits[ch] / bits; + } + } + + for (ch = 0; ch < gfc.channels_out; ++ch) { + targ_bits[ch] += add_bits[ch]; + extra_bits -= add_bits[ch]; + } + + for (bits = 0, ch = 0; ch < gfc.channels_out; ++ch) { + bits += targ_bits[ch]; + } + if (bits > LameInternalFlags_1.MAX_BITS_PER_GRANULE) { + var sum = 0; + for (ch = 0; ch < gfc.channels_out; ++ch) { + targ_bits[ch] *= LameInternalFlags_1.MAX_BITS_PER_GRANULE; + targ_bits[ch] /= bits; + sum += targ_bits[ch]; + } + assert$19(sum <= LameInternalFlags_1.MAX_BITS_PER_GRANULE); + } + + return max_bits; + }; + + this.reduce_side = function (targ_bits, ms_ener_ratio, mean_bits, max_bits) { + assert$19(max_bits <= LameInternalFlags_1.MAX_BITS_PER_GRANULE); + assert$19(targ_bits[0] + targ_bits[1] <= LameInternalFlags_1.MAX_BITS_PER_GRANULE); + + /* + * ms_ener_ratio = 0: allocate 66/33 mid/side fac=.33 ms_ener_ratio =.5: + * allocate 50/50 mid/side fac= 0 + */ + /* 75/25 split is fac=.5 */ + var fac = .33 * (.5 - ms_ener_ratio) / .5; + if (fac < 0) + fac = 0; + if (fac > .5) + fac = .5; + + /* number of bits to move from side channel to mid channel */ + /* move_bits = fac*targ_bits[1]; */ + var move_bits = 0 | (fac * .5 * (targ_bits[0] + targ_bits[1])); + + if (move_bits > LameInternalFlags_1.MAX_BITS_PER_CHANNEL - targ_bits[0]) { + move_bits = LameInternalFlags_1.MAX_BITS_PER_CHANNEL - targ_bits[0]; + } + if (move_bits < 0) + move_bits = 0; + + if (targ_bits[1] >= 125) { + /* dont reduce side channel below 125 bits */ + if (targ_bits[1] - move_bits > 125) { + + /* if mid channel already has 2x more than average, dont bother */ + /* mean_bits = bits per granule (for both channels) */ + if (targ_bits[0] < mean_bits) + targ_bits[0] += move_bits; + targ_bits[1] -= move_bits; + } else { + targ_bits[0] += targ_bits[1] - 125; + targ_bits[1] = 125; + } + } + + move_bits = targ_bits[0] + targ_bits[1]; + if (move_bits > max_bits) { + targ_bits[0] = (max_bits * targ_bits[0]) / move_bits; + targ_bits[1] = (max_bits * targ_bits[1]) / move_bits; + } + assert$19(targ_bits[0] <= LameInternalFlags_1.MAX_BITS_PER_CHANNEL); + assert$19(targ_bits[1] <= LameInternalFlags_1.MAX_BITS_PER_CHANNEL); + assert$19(targ_bits[0] + targ_bits[1] <= LameInternalFlags_1.MAX_BITS_PER_GRANULE); + }; + + /** + * Robert Hegemann 2001-04-27: + * this adjusts the ATH, keeping the original noise floor + * affects the higher frequencies more than the lower ones + */ + this.athAdjust = function (a, x, athFloor) { + /* + * work in progress + */ + var o = 90.30873362; + var p = 94.82444863; + var u = Util$19.FAST_LOG10_X(x, 10.0); + var v = a * a; + var w = 0.0; + u -= athFloor; + /* undo scaling */ + if (v > 1E-20) + w = 1. + Util$19.FAST_LOG10_X(v, 10.0 / o); + if (w < 0) + w = 0.; + u *= w; + u += athFloor + o - p; + /* redo scaling */ + + return Math.pow(10., 0.1 * u); + }; + + /** + * Calculate the allowed distortion for each scalefactor band, as determined + * by the psychoacoustic model. xmin(sb) = ratio(sb) * en(sb) / bw(sb) + * + * returns number of sfb's with energy > ATH + */ + this.calc_xmin = function (gfp, ratio, cod_info, pxmin) { + var pxminPos = 0; + var gfc = gfp.internal_flags; + var gsfb, j = 0, ath_over = 0; + var ATH = gfc.ATH; + var xr = cod_info.xr; + var enable_athaa_fix = (gfp.VBR == VbrMode$19.vbr_mtrh) ? 1 : 0; + var masking_lower = gfc.masking_lower; + + if (gfp.VBR == VbrMode$19.vbr_mtrh || gfp.VBR == VbrMode$19.vbr_mt) { + /* was already done in PSY-Model */ + masking_lower = 1.0; + } + + for (gsfb = 0; gsfb < cod_info.psy_lmax; gsfb++) { + var en0, xmin; + var rh1, rh2; + var width, l; + + if (gfp.VBR == VbrMode$19.vbr_rh || gfp.VBR == VbrMode$19.vbr_mtrh) + xmin = athAdjust(ATH.adjust, ATH.l[gsfb], ATH.floor); + else + xmin = ATH.adjust * ATH.l[gsfb]; + + width = cod_info.width[gsfb]; + rh1 = xmin / width; + rh2 = DBL_EPSILON; + l = width >> 1; + en0 = 0.0; + do { + var xa, xb; + xa = xr[j] * xr[j]; + en0 += xa; + rh2 += (xa < rh1) ? xa : rh1; + j++; + xb = xr[j] * xr[j]; + en0 += xb; + rh2 += (xb < rh1) ? xb : rh1; + j++; + } while (--l > 0); + if (en0 > xmin) + ath_over++; + + if (gsfb == Encoder_1.SBPSY_l) { + var x = xmin * gfc.nsPsy.longfact[gsfb]; + if (rh2 < x) { + rh2 = x; + } + } + if (enable_athaa_fix != 0) { + xmin = rh2; + } + if (!gfp.ATHonly) { + var e = ratio.en.l[gsfb]; + if (e > 0.0) { + var x; + x = en0 * ratio.thm.l[gsfb] * masking_lower / e; + if (enable_athaa_fix != 0) + x *= gfc.nsPsy.longfact[gsfb]; + if (xmin < x) + xmin = x; + } + } + if (enable_athaa_fix != 0) + pxmin[pxminPos++] = xmin; + else + pxmin[pxminPos++] = xmin * gfc.nsPsy.longfact[gsfb]; + } + /* end of long block loop */ + + /* use this function to determine the highest non-zero coeff */ + var max_nonzero = 575; + if (cod_info.block_type != Encoder_1.SHORT_TYPE) { + // NORM, START or STOP type, but not SHORT + var k = 576; + while (k-- != 0 && BitStream.EQ(xr[k], 0)) { + max_nonzero = k; + } + } + cod_info.max_nonzero_coeff = max_nonzero; + + for (var sfb = cod_info.sfb_smin; gsfb < cod_info.psymax; sfb++, gsfb += 3) { + var width, b; + var tmpATH; + if (gfp.VBR == VbrMode$19.vbr_rh || gfp.VBR == VbrMode$19.vbr_mtrh) + tmpATH = athAdjust(ATH.adjust, ATH.s[sfb], ATH.floor); + else + tmpATH = ATH.adjust * ATH.s[sfb]; + + width = cod_info.width[gsfb]; + for (b = 0; b < 3; b++) { + var en0 = 0.0, xmin; + var rh1, rh2; + var l = width >> 1; + + rh1 = tmpATH / width; + rh2 = DBL_EPSILON; + do { + var xa, xb; + xa = xr[j] * xr[j]; + en0 += xa; + rh2 += (xa < rh1) ? xa : rh1; + j++; + xb = xr[j] * xr[j]; + en0 += xb; + rh2 += (xb < rh1) ? xb : rh1; + j++; + } while (--l > 0); + if (en0 > tmpATH) + ath_over++; + if (sfb == Encoder_1.SBPSY_s) { + var x = tmpATH * gfc.nsPsy.shortfact[sfb]; + if (rh2 < x) { + rh2 = x; + } + } + if (enable_athaa_fix != 0) + xmin = rh2; + else + xmin = tmpATH; + + if (!gfp.ATHonly && !gfp.ATHshort) { + var e = ratio.en.s[sfb][b]; + if (e > 0.0) { + var x; + x = en0 * ratio.thm.s[sfb][b] * masking_lower / e; + if (enable_athaa_fix != 0) + x *= gfc.nsPsy.shortfact[sfb]; + if (xmin < x) + xmin = x; + } + } + if (enable_athaa_fix != 0) + pxmin[pxminPos++] = xmin; + else + pxmin[pxminPos++] = xmin * gfc.nsPsy.shortfact[sfb]; + } + /* b */ + if (gfp.useTemporal) { + if (pxmin[pxminPos - 3] > pxmin[pxminPos - 3 + 1]) + pxmin[pxminPos - 3 + 1] += (pxmin[pxminPos - 3] - pxmin[pxminPos - 3 + 1]) + * gfc.decay; + if (pxmin[pxminPos - 3 + 1] > pxmin[pxminPos - 3 + 2]) + pxmin[pxminPos - 3 + 2] += (pxmin[pxminPos - 3 + 1] - pxmin[pxminPos - 3 + 2]) + * gfc.decay; + } + } + /* end of short block sfb loop */ + + return ath_over; + }; + + function StartLine(j) { + this.s = j; + } + + this.calc_noise_core = function (cod_info, startline, l, step) { + var noise = 0; + var j = startline.s; + var ix = cod_info.l3_enc; + + if (j > cod_info.count1) { + while ((l--) != 0) { + var temp; + temp = cod_info.xr[j]; + j++; + noise += temp * temp; + temp = cod_info.xr[j]; + j++; + noise += temp * temp; + } + } else if (j > cod_info.big_values) { + var ix01 = new_float$19(2); + ix01[0] = 0; + ix01[1] = step; + while ((l--) != 0) { + var temp; + temp = Math.abs(cod_info.xr[j]) - ix01[ix[j]]; + j++; + noise += temp * temp; + temp = Math.abs(cod_info.xr[j]) - ix01[ix[j]]; + j++; + noise += temp * temp; + } + } else { + while ((l--) != 0) { + var temp; + temp = Math.abs(cod_info.xr[j]) - pow43[ix[j]] * step; + j++; + noise += temp * temp; + temp = Math.abs(cod_info.xr[j]) - pow43[ix[j]] * step; + j++; + noise += temp * temp; + } + } + + startline.s = j; + return noise; + }; + + /** + *
+ * -oo dB => -1.00 + * - 6 dB => -0.97 + * - 3 dB => -0.80 + * - 2 dB => -0.64 + * - 1 dB => -0.38 + * 0 dB => 0.00 + * + 1 dB => +0.49 + * + 2 dB => +1.06 + * + 3 dB => +1.68 + * + 6 dB => +3.69 + * +10 dB => +6.45 + *+ */ + this.calc_noise = function (cod_info, l3_xmin, distort, res, prev_noise) { + var distortPos = 0; + var l3_xminPos = 0; + var sfb, l, over = 0; + var over_noise_db = 0; + /* 0 dB relative to masking */ + var tot_noise_db = 0; + /* -200 dB relative to masking */ + var max_noise = -20.0; + var j = 0; + var scalefac = cod_info.scalefac; + var scalefacPos = 0; + + res.over_SSD = 0; + + for (sfb = 0; sfb < cod_info.psymax; sfb++) { + var s = cod_info.global_gain + - (((scalefac[scalefacPos++]) + (cod_info.preflag != 0 ? pretab[sfb] + : 0)) << (cod_info.scalefac_scale + 1)) + - cod_info.subblock_gain[cod_info.window[sfb]] * 8; + var noise = 0.0; + + if (prev_noise != null && (prev_noise.step[sfb] == s)) { + + /* use previously computed values */ + noise = prev_noise.noise[sfb]; + j += cod_info.width[sfb]; + distort[distortPos++] = noise / l3_xmin[l3_xminPos++]; + + noise = prev_noise.noise_log[sfb]; + + } else { + var step = POW20(s); + l = cod_info.width[sfb] >> 1; + + if ((j + cod_info.width[sfb]) > cod_info.max_nonzero_coeff) { + var usefullsize; + usefullsize = cod_info.max_nonzero_coeff - j + 1; + + if (usefullsize > 0) + l = usefullsize >> 1; + else + l = 0; + } + + var sl = new StartLine(j); + noise = this.calc_noise_core(cod_info, sl, l, step); + j = sl.s; + + if (prev_noise != null) { + /* save noise values */ + prev_noise.step[sfb] = s; + prev_noise.noise[sfb] = noise; + } + + noise = distort[distortPos++] = noise / l3_xmin[l3_xminPos++]; + + /* multiplying here is adding in dB, but can overflow */ + noise = Util$19.FAST_LOG10(Math.max(noise, 1E-20)); + + if (prev_noise != null) { + /* save noise values */ + prev_noise.noise_log[sfb] = noise; + } + } + + if (prev_noise != null) { + /* save noise values */ + prev_noise.global_gain = cod_info.global_gain; + } + + tot_noise_db += noise; + + if (noise > 0.0) { + var tmp; + + tmp = Math.max(0 | (noise * 10 + .5), 1); + res.over_SSD += tmp * tmp; + + over++; + /* multiplying here is adding in dB -but can overflow */ + /* over_noise *= noise; */ + over_noise_db += noise; + } + max_noise = Math.max(max_noise, noise); + + } + + res.over_count = over; + res.tot_noise = tot_noise_db; + res.over_noise = over_noise_db; + res.max_noise = max_noise; + + return over; + }; + + /** + * updates plotting data + * + * Mark Taylor 2000-??-?? + * + * Robert Hegemann: moved noise/distortion calc into it + */ + this.set_pinfo = function (gfp, cod_info, ratio, gr, ch) { + var gfc = gfp.internal_flags; + var sfb, sfb2; + var l; + var en0, en1; + var ifqstep = (cod_info.scalefac_scale == 0) ? .5 : 1.0; + var scalefac = cod_info.scalefac; + + var l3_xmin = new_float$19(L3Side.SFBMAX); + var xfsf = new_float$19(L3Side.SFBMAX); + var noise = new CalcNoiseResult(); + + calc_xmin(gfp, ratio, cod_info, l3_xmin); + calc_noise(cod_info, l3_xmin, xfsf, noise, null); + + var j = 0; + sfb2 = cod_info.sfb_lmax; + if (cod_info.block_type != Encoder_1.SHORT_TYPE + && 0 == cod_info.mixed_block_flag) + sfb2 = 22; + for (sfb = 0; sfb < sfb2; sfb++) { + var start = gfc.scalefac_band.l[sfb]; + var end = gfc.scalefac_band.l[sfb + 1]; + var bw = end - start; + for (en0 = 0.0; j < end; j++) + en0 += cod_info.xr[j] * cod_info.xr[j]; + en0 /= bw; + /* convert to MDCT units */ + /* scaling so it shows up on FFT plot */ + en1 = 1e15; + gfc.pinfo.en[gr][ch][sfb] = en1 * en0; + gfc.pinfo.xfsf[gr][ch][sfb] = en1 * l3_xmin[sfb] * xfsf[sfb] / bw; + + if (ratio.en.l[sfb] > 0 && !gfp.ATHonly) + en0 = en0 / ratio.en.l[sfb]; + else + en0 = 0.0; + + gfc.pinfo.thr[gr][ch][sfb] = en1 + * Math.max(en0 * ratio.thm.l[sfb], gfc.ATH.l[sfb]); + + /* there is no scalefactor bands >= SBPSY_l */ + gfc.pinfo.LAMEsfb[gr][ch][sfb] = 0; + if (cod_info.preflag != 0 && sfb >= 11) + gfc.pinfo.LAMEsfb[gr][ch][sfb] = -ifqstep * pretab[sfb]; + + if (sfb < Encoder_1.SBPSY_l) { + /* scfsi should be decoded by caller side */ + assert$19(scalefac[sfb] >= 0); + gfc.pinfo.LAMEsfb[gr][ch][sfb] -= ifqstep * scalefac[sfb]; + } + } + /* for sfb */ + + if (cod_info.block_type == Encoder_1.SHORT_TYPE) { + sfb2 = sfb; + for (sfb = cod_info.sfb_smin; sfb < Encoder_1.SBMAX_s; sfb++) { + var start = gfc.scalefac_band.s[sfb]; + var end = gfc.scalefac_band.s[sfb + 1]; + var bw = end - start; + for (var i = 0; i < 3; i++) { + for (en0 = 0.0, l = start; l < end; l++) { + en0 += cod_info.xr[j] * cod_info.xr[j]; + j++; + } + en0 = Math.max(en0 / bw, 1e-20); + /* convert to MDCT units */ + /* scaling so it shows up on FFT plot */ + en1 = 1e15; + + gfc.pinfo.en_s[gr][ch][3 * sfb + i] = en1 * en0; + gfc.pinfo.xfsf_s[gr][ch][3 * sfb + i] = en1 * l3_xmin[sfb2] + * xfsf[sfb2] / bw; + if (ratio.en.s[sfb][i] > 0) + en0 = en0 / ratio.en.s[sfb][i]; + else + en0 = 0.0; + if (gfp.ATHonly || gfp.ATHshort) + en0 = 0; + + gfc.pinfo.thr_s[gr][ch][3 * sfb + i] = en1 + * Math.max(en0 * ratio.thm.s[sfb][i], + gfc.ATH.s[sfb]); + + /* there is no scalefactor bands >= SBPSY_s */ + gfc.pinfo.LAMEsfb_s[gr][ch][3 * sfb + i] = -2.0 + * cod_info.subblock_gain[i]; + if (sfb < Encoder_1.SBPSY_s) { + gfc.pinfo.LAMEsfb_s[gr][ch][3 * sfb + i] -= ifqstep + * scalefac[sfb2]; + } + sfb2++; + } + } + } + /* block type short */ + gfc.pinfo.LAMEqss[gr][ch] = cod_info.global_gain; + gfc.pinfo.LAMEmainbits[gr][ch] = cod_info.part2_3_length + + cod_info.part2_length; + gfc.pinfo.LAMEsfbits[gr][ch] = cod_info.part2_length; + + gfc.pinfo.over[gr][ch] = noise.over_count; + gfc.pinfo.max_noise[gr][ch] = noise.max_noise * 10.0; + gfc.pinfo.over_noise[gr][ch] = noise.over_noise * 10.0; + gfc.pinfo.tot_noise[gr][ch] = noise.tot_noise * 10.0; + gfc.pinfo.over_SSD[gr][ch] = noise.over_SSD; + }; + + /** + * updates plotting data for a whole frame + * + * Robert Hegemann 2000-10-21 + */ + + +} + +var QuantizePVT_1 = QuantizePVT$1; + +/* + * MP3 huffman table selecting and bit counting + * + * Copyright (c) 1999-2005 Takehiro TOMINAGA + * Copyright (c) 2002-2005 Gabriel Bouvigne + * + * 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: Takehiro.java,v 1.26 2011/05/24 20:48:06 kenchis Exp $ */ + +//package mp3; + +//import java.util.Arrays; + +var System$18 = common.System; +var Arrays$18 = common.Arrays; +var new_int$18 = common.new_int; +var assert$18 = common.assert; + + + + + + + +function Takehiro$1() { + + var qupvt = null; + this.qupvt = null; + + this.setModules = function (_qupvt) { + this.qupvt = _qupvt; + qupvt = _qupvt; + }; + + function Bits(b) { + this.bits = 0 | b; + } + + var subdv_table = [[0, 0], /* 0 bands */ + [0, 0], /* 1 bands */ + [0, 0], /* 2 bands */ + [0, 0], /* 3 bands */ + [0, 0], /* 4 bands */ + [0, 1], /* 5 bands */ + [1, 1], /* 6 bands */ + [1, 1], /* 7 bands */ + [1, 2], /* 8 bands */ + [2, 2], /* 9 bands */ + [2, 3], /* 10 bands */ + [2, 3], /* 11 bands */ + [3, 4], /* 12 bands */ + [3, 4], /* 13 bands */ + [3, 4], /* 14 bands */ + [4, 5], /* 15 bands */ + [4, 5], /* 16 bands */ + [4, 6], /* 17 bands */ + [5, 6], /* 18 bands */ + [5, 6], /* 19 bands */ + [5, 7], /* 20 bands */ + [6, 7], /* 21 bands */ + [6, 7], /* 22 bands */ + ]; + + /** + * nonlinear quantization of xr More accurate formula than the ISO formula. + * Takes into account the fact that we are quantizing xr . ix, but we want + * ix^4/3 to be as close as possible to x^4/3. (taking the nearest int would + * mean ix is as close as possible to xr, which is different.) + * + * From Segher Boessenkool
+ * if XRPOW_FTOI(x) = nearest_int(x), then QUANTFAC(x)=adj43asm[x]
+ * ROUNDFAC= -0.0946
+ * + * if XRPOW_FTOI(x) = floor(x), then QUANTFAC(x)=asj43[x]
+ * ROUNDFAC=0.4054
+ * + * Note: using floor() or 0| is extremely slow. On machines where the + * TAKEHIRO_IEEE754_HACK code above does not work, it is worthwile to write + * some ASM for XRPOW_FTOI(). + */ + function quantize_lines_xrpow(l, istep, xr, xrPos, ix, ixPos) { + assert$18(l > 0); + + l = l >> 1; + var remaining = l % 2; + l = l >> 1; + while (l-- != 0) { + var x0, x1, x2, x3; + var rx0, rx1, rx2, rx3; + + x0 = xr[xrPos++] * istep; + x1 = xr[xrPos++] * istep; + rx0 = 0 | x0; + x2 = xr[xrPos++] * istep; + rx1 = 0 | x1; + x3 = xr[xrPos++] * istep; + rx2 = 0 | x2; + x0 += qupvt.adj43[rx0]; + rx3 = 0 | x3; + x1 += qupvt.adj43[rx1]; + ix[ixPos++] = 0 | x0; + x2 += qupvt.adj43[rx2]; + ix[ixPos++] = 0 | x1; + x3 += qupvt.adj43[rx3]; + ix[ixPos++] = 0 | x2; + ix[ixPos++] = 0 | x3; + } + if (remaining != 0) { + var x0, x1; + var rx0, rx1; + + x0 = xr[xrPos++] * istep; + x1 = xr[xrPos++] * istep; + rx0 = 0 | x0; + rx1 = 0 | x1; + x0 += qupvt.adj43[rx0]; + x1 += qupvt.adj43[rx1]; + ix[ixPos++] = 0 | x0; + ix[ixPos++] = 0 | x1; + } + } + + /** + * Quantization function This function will select which lines to quantize + * and call the proper quantization function + */ + function quantize_xrpow(xp, pi, istep, codInfo, prevNoise) { + /* quantize on xr^(3/4) instead of xr */ + var sfb; + var sfbmax; + var j = 0; + var prev_data_use; + var accumulate = 0; + var accumulate01 = 0; + var xpPos = 0; + var iData = pi; + var iDataPos = 0; + var acc_iData = iData; + var acc_iDataPos = 0; + var acc_xp = xp; + var acc_xpPos = 0; + + /* + * Reusing previously computed data does not seems to work if global + * gain is changed. Finding why it behaves this way would allow to use a + * cache of previously computed values (let's 10 cached values per sfb) + * that would probably provide a noticeable speedup + */ + prev_data_use = (prevNoise != null && (codInfo.global_gain == prevNoise.global_gain)); + + if (codInfo.block_type == Encoder_1.SHORT_TYPE) + sfbmax = 38; + else + sfbmax = 21; + + for (sfb = 0; sfb <= sfbmax; sfb++) { + var step = -1; + + if (prev_data_use || codInfo.block_type == Encoder_1.NORM_TYPE) { + step = codInfo.global_gain + - ((codInfo.scalefac[sfb] + (codInfo.preflag != 0 ? qupvt.pretab[sfb] + : 0)) << (codInfo.scalefac_scale + 1)) + - codInfo.subblock_gain[codInfo.window[sfb]] * 8; + } + assert$18(codInfo.width[sfb] >= 0); + if (prev_data_use && (prevNoise.step[sfb] == step)) { + /* + * do not recompute this part, but compute accumulated lines + */ + if (accumulate != 0) { + quantize_lines_xrpow(accumulate, istep, acc_xp, acc_xpPos, + acc_iData, acc_iDataPos); + accumulate = 0; + } + if (accumulate01 != 0) { + quantize_lines_xrpow_01(accumulate01, istep, acc_xp, + acc_xpPos, acc_iData, acc_iDataPos); + accumulate01 = 0; + } + } else { /* should compute this part */ + var l = codInfo.width[sfb]; + + if ((j + codInfo.width[sfb]) > codInfo.max_nonzero_coeff) { + /* do not compute upper zero part */ + var usefullsize; + usefullsize = codInfo.max_nonzero_coeff - j + 1; + Arrays$18.fill(pi, codInfo.max_nonzero_coeff, 576, 0); + l = usefullsize; + + if (l < 0) { + l = 0; + } + + /* no need to compute higher sfb values */ + sfb = sfbmax + 1; + } + + /* accumulate lines to quantize */ + if (0 == accumulate && 0 == accumulate01) { + acc_iData = iData; + acc_iDataPos = iDataPos; + acc_xp = xp; + acc_xpPos = xpPos; + } + if (prevNoise != null && prevNoise.sfb_count1 > 0 + && sfb >= prevNoise.sfb_count1 + && prevNoise.step[sfb] > 0 + && step >= prevNoise.step[sfb]) { + + if (accumulate != 0) { + quantize_lines_xrpow(accumulate, istep, acc_xp, + acc_xpPos, acc_iData, acc_iDataPos); + accumulate = 0; + acc_iData = iData; + acc_iDataPos = iDataPos; + acc_xp = xp; + acc_xpPos = xpPos; + } + accumulate01 += l; + } else { + if (accumulate01 != 0) { + quantize_lines_xrpow_01(accumulate01, istep, acc_xp, + acc_xpPos, acc_iData, acc_iDataPos); + accumulate01 = 0; + acc_iData = iData; + acc_iDataPos = iDataPos; + acc_xp = xp; + acc_xpPos = xpPos; + } + accumulate += l; + } + + if (l <= 0) { + /* + * rh: 20040215 may happen due to "prev_data_use" + * optimization + */ + if (accumulate01 != 0) { + quantize_lines_xrpow_01(accumulate01, istep, acc_xp, + acc_xpPos, acc_iData, acc_iDataPos); + accumulate01 = 0; + } + if (accumulate != 0) { + quantize_lines_xrpow(accumulate, istep, acc_xp, + acc_xpPos, acc_iData, acc_iDataPos); + accumulate = 0; + } + + break; + /* ends for-loop */ + } + } + if (sfb <= sfbmax) { + iDataPos += codInfo.width[sfb]; + xpPos += codInfo.width[sfb]; + j += codInfo.width[sfb]; + } + } + if (accumulate != 0) { /* last data part */ + quantize_lines_xrpow(accumulate, istep, acc_xp, acc_xpPos, + acc_iData, acc_iDataPos); + accumulate = 0; + } + if (accumulate01 != 0) { /* last data part */ + quantize_lines_xrpow_01(accumulate01, istep, acc_xp, acc_xpPos, + acc_iData, acc_iDataPos); + accumulate01 = 0; + } + + } + + /** + * ix_max + */ + function ix_max(ix, ixPos, endPos) { + var max1 = 0, max2 = 0; + + do { + var x1 = ix[ixPos++]; + var x2 = ix[ixPos++]; + if (max1 < x1) + max1 = x1; + + if (max2 < x2) + max2 = x2; + } while (ixPos < endPos); + if (max1 < max2) + max1 = max2; + return max1; + } + + function count_bit_ESC(ix, ixPos, end, t1, t2, s) { + /* ESC-table is used */ + var linbits = Tables_1.ht[t1].xlen * 65536 + Tables_1.ht[t2].xlen; + var sum = 0, sum2; + + do { + var x = ix[ixPos++]; + var y = ix[ixPos++]; + + if (x != 0) { + if (x > 14) { + x = 15; + sum += linbits; + } + x *= 16; + } + + if (y != 0) { + if (y > 14) { + y = 15; + sum += linbits; + } + x += y; + } + + sum += Tables_1.largetbl[x]; + } while (ixPos < end); + + sum2 = sum & 0xffff; + sum >>= 16; + + if (sum > sum2) { + sum = sum2; + t1 = t2; + } + + s.bits += sum; + return t1; + } + + function count_bit_noESC(ix, ixPos, end, s) { + /* No ESC-words */ + var sum1 = 0; + var hlen1 = Tables_1.ht[1].hlen; + + do { + var x = ix[ixPos + 0] * 2 + ix[ixPos + 1]; + ixPos += 2; + sum1 += hlen1[x]; + } while (ixPos < end); + + s.bits += sum1; + return 1; + } + + function count_bit_noESC_from2(ix, ixPos, end, t1, s) { + /* No ESC-words */ + var sum = 0, sum2; + var xlen = Tables_1.ht[t1].xlen; + var hlen; + if (t1 == 2) + hlen = Tables_1.table23; + else + hlen = Tables_1.table56; + + do { + var x = ix[ixPos + 0] * xlen + ix[ixPos + 1]; + ixPos += 2; + sum += hlen[x]; + } while (ixPos < end); + + sum2 = sum & 0xffff; + sum >>= 16; + + if (sum > sum2) { + sum = sum2; + t1++; + } + + s.bits += sum; + return t1; + } + + function count_bit_noESC_from3(ix, ixPos, end, t1, s) { + /* No ESC-words */ + var sum1 = 0; + var sum2 = 0; + var sum3 = 0; + var xlen = Tables_1.ht[t1].xlen; + var hlen1 = Tables_1.ht[t1].hlen; + var hlen2 = Tables_1.ht[t1 + 1].hlen; + var hlen3 = Tables_1.ht[t1 + 2].hlen; + + do { + var x = ix[ixPos + 0] * xlen + ix[ixPos + 1]; + ixPos += 2; + sum1 += hlen1[x]; + sum2 += hlen2[x]; + sum3 += hlen3[x]; + } while (ixPos < end); + var t = t1; + if (sum1 > sum2) { + sum1 = sum2; + t++; + } + if (sum1 > sum3) { + sum1 = sum3; + t = t1 + 2; + } + s.bits += sum1; + + return t; + } + + /*************************************************************************/ + /* choose table */ + /*************************************************************************/ + + var huf_tbl_noESC = [1, 2, 5, 7, 7, 10, 10, 13, 13, + 13, 13, 13, 13, 13, 13]; + + /** + * Choose the Huffman table that will encode ix[begin..end] with the fewest + * bits. + * + * Note: This code contains knowledge about the sizes and characteristics of + * the Huffman tables as defined in the IS (Table B.7), and will not work + * with any arbitrary tables. + */ + function choose_table(ix, ixPos, endPos, s) { + var max = ix_max(ix, ixPos, endPos); + + switch (max) { + case 0: + return max; + + case 1: + return count_bit_noESC(ix, ixPos, endPos, s); + + case 2: + case 3: + return count_bit_noESC_from2(ix, ixPos, endPos, + huf_tbl_noESC[max - 1], s); + + case 4: + case 5: + case 6: + case 7: + case 8: + case 9: + case 10: + case 11: + case 12: + case 13: + case 14: + case 15: + return count_bit_noESC_from3(ix, ixPos, endPos, + huf_tbl_noESC[max - 1], s); + + default: + /* try tables with linbits */ + if (max > QuantizePVT_1.IXMAX_VAL) { + s.bits = QuantizePVT_1.LARGE_BITS; + return -1; + } + max -= 15; + var choice2; + for (choice2 = 24; choice2 < 32; choice2++) { + if (Tables_1.ht[choice2].linmax >= max) { + break; + } + } + var choice; + for (choice = choice2 - 8; choice < 24; choice++) { + if (Tables_1.ht[choice].linmax >= max) { + break; + } + } + return count_bit_ESC(ix, ixPos, endPos, choice, choice2, s); + } + } + + /** + * count_bit + */ + this.noquant_count_bits = function (gfc, gi, prev_noise) { + var ix = gi.l3_enc; + var i = Math.min(576, ((gi.max_nonzero_coeff + 2) >> 1) << 1); + + if (prev_noise != null) + prev_noise.sfb_count1 = 0; + + /* Determine count1 region */ + for (; i > 1; i -= 2) + if ((ix[i - 1] | ix[i - 2]) != 0) + break; + gi.count1 = i; + + /* Determines the number of bits to encode the quadruples. */ + var a1 = 0; + var a2 = 0; + for (; i > 3; i -= 4) { + var p; + /* hack to check if all values <= 1 */ + //throw "TODO: HACK if ((((long) ix[i - 1] | (long) ix[i - 2] | (long) ix[i - 3] | (long) ix[i - 4]) & 0xffffffffL) > 1L " + //if (true) { + if (((ix[i - 1] | ix[i - 2] | ix[i - 3] | ix[i - 4]) & 0x7fffffff) > 1) { + break; + } + p = ((ix[i - 4] * 2 + ix[i - 3]) * 2 + ix[i - 2]) * 2 + ix[i - 1]; + a1 += Tables_1.t32l[p]; + a2 += Tables_1.t33l[p]; + } + var bits = a1; + gi.count1table_select = 0; + if (a1 > a2) { + bits = a2; + gi.count1table_select = 1; + } + + gi.count1bits = bits; + gi.big_values = i; + if (i == 0) + return bits; + + if (gi.block_type == Encoder_1.SHORT_TYPE) { + a1 = 3 * gfc.scalefac_band.s[3]; + if (a1 > gi.big_values) + a1 = gi.big_values; + a2 = gi.big_values; + + } else if (gi.block_type == Encoder_1.NORM_TYPE) { + assert$18(i <= 576); + /* bv_scf has 576 entries (0..575) */ + a1 = gi.region0_count = gfc.bv_scf[i - 2]; + a2 = gi.region1_count = gfc.bv_scf[i - 1]; + + assert$18(a1 + a2 + 2 < Encoder_1.SBPSY_l); + a2 = gfc.scalefac_band.l[a1 + a2 + 2]; + a1 = gfc.scalefac_band.l[a1 + 1]; + if (a2 < i) { + var bi = new Bits(bits); + gi.table_select[2] = choose_table(ix, a2, i, bi); + bits = bi.bits; + } + } else { + gi.region0_count = 7; + /* gi.region1_count = SBPSY_l - 7 - 1; */ + gi.region1_count = Encoder_1.SBMAX_l - 1 - 7 - 1; + a1 = gfc.scalefac_band.l[7 + 1]; + a2 = i; + if (a1 > a2) { + a1 = a2; + } + } + + /* have to allow for the case when bigvalues < region0 < region1 */ + /* (and region0, region1 are ignored) */ + a1 = Math.min(a1, i); + a2 = Math.min(a2, i); + + assert$18(a1 >= 0); + assert$18(a2 >= 0); + + /* Count the number of bits necessary to code the bigvalues region. */ + if (0 < a1) { + var bi = new Bits(bits); + gi.table_select[0] = choose_table(ix, 0, a1, bi); + bits = bi.bits; + } + if (a1 < a2) { + var bi = new Bits(bits); + gi.table_select[1] = choose_table(ix, a1, a2, bi); + bits = bi.bits; + } + if (gfc.use_best_huffman == 2) { + gi.part2_3_length = bits; + best_huffman_divide(gfc, gi); + bits = gi.part2_3_length; + } + + if (prev_noise != null) { + if (gi.block_type == Encoder_1.NORM_TYPE) { + var sfb = 0; + while (gfc.scalefac_band.l[sfb] < gi.big_values) { + sfb++; + } + prev_noise.sfb_count1 = sfb; + } + } + + return bits; + }; + + this.count_bits = function (gfc, xr, gi, prev_noise) { + var ix = gi.l3_enc; + + /* since quantize_xrpow uses table lookup, we need to check this first: */ + var w = (QuantizePVT_1.IXMAX_VAL) / qupvt.IPOW20(gi.global_gain); + + if (gi.xrpow_max > w) + return QuantizePVT_1.LARGE_BITS; + + quantize_xrpow(xr, ix, qupvt.IPOW20(gi.global_gain), gi, prev_noise); + + if ((gfc.substep_shaping & 2) != 0) { + var j = 0; + /* 0.634521682242439 = 0.5946*2**(.5*0.1875) */ + var gain = gi.global_gain + gi.scalefac_scale; + var roundfac = 0.634521682242439 / qupvt.IPOW20(gain); + for (var sfb = 0; sfb < gi.sfbmax; sfb++) { + var width = gi.width[sfb]; + assert$18(width >= 0); + if (0 == gfc.pseudohalf[sfb]) { + j += width; + } else { + var k; + for (k = j, j += width; k < j; ++k) { + ix[k] = (xr[k] >= roundfac) ? ix[k] : 0; + } + } + } + } + return this.noquant_count_bits(gfc, gi, prev_noise); + }; + + /** + * re-calculate the best scalefac_compress using scfsi the saved bits are + * kept in the bit reservoir. + */ + function recalc_divide_init(gfc, cod_info, ix, r01_bits, r01_div, r0_tbl, r1_tbl) { + var bigv = cod_info.big_values; + + for (var r0 = 0; r0 <= 7 + 15; r0++) { + r01_bits[r0] = QuantizePVT_1.LARGE_BITS; + } + + for (var r0 = 0; r0 < 16; r0++) { + var a1 = gfc.scalefac_band.l[r0 + 1]; + if (a1 >= bigv) + break; + var r0bits = 0; + var bi = new Bits(r0bits); + var r0t = choose_table(ix, 0, a1, bi); + r0bits = bi.bits; + + for (var r1 = 0; r1 < 8; r1++) { + var a2 = gfc.scalefac_band.l[r0 + r1 + 2]; + if (a2 >= bigv) + break; + var bits = r0bits; + bi = new Bits(bits); + var r1t = choose_table(ix, a1, a2, bi); + bits = bi.bits; + if (r01_bits[r0 + r1] > bits) { + r01_bits[r0 + r1] = bits; + r01_div[r0 + r1] = r0; + r0_tbl[r0 + r1] = r0t; + r1_tbl[r0 + r1] = r1t; + } + } + } + } + + function recalc_divide_sub(gfc, cod_info2, gi, ix, r01_bits, r01_div, r0_tbl, r1_tbl) { + var bigv = cod_info2.big_values; + + for (var r2 = 2; r2 < Encoder_1.SBMAX_l + 1; r2++) { + var a2 = gfc.scalefac_band.l[r2]; + if (a2 >= bigv) + break; + var bits = r01_bits[r2 - 2] + cod_info2.count1bits; + if (gi.part2_3_length <= bits) + break; + + var bi = new Bits(bits); + var r2t = choose_table(ix, a2, bigv, bi); + bits = bi.bits; + if (gi.part2_3_length <= bits) + continue; + + gi.assign(cod_info2); + gi.part2_3_length = bits; + gi.region0_count = r01_div[r2 - 2]; + gi.region1_count = r2 - 2 - r01_div[r2 - 2]; + gi.table_select[0] = r0_tbl[r2 - 2]; + gi.table_select[1] = r1_tbl[r2 - 2]; + gi.table_select[2] = r2t; + } + } + + this.best_huffman_divide = function (gfc, gi) { + var cod_info2 = new GrInfo_1(); + var ix = gi.l3_enc; + var r01_bits = new_int$18(7 + 15 + 1); + var r01_div = new_int$18(7 + 15 + 1); + var r0_tbl = new_int$18(7 + 15 + 1); + var r1_tbl = new_int$18(7 + 15 + 1); + + /* SHORT BLOCK stuff fails for MPEG2 */ + if (gi.block_type == Encoder_1.SHORT_TYPE && gfc.mode_gr == 1) + return; + + cod_info2.assign(gi); + if (gi.block_type == Encoder_1.NORM_TYPE) { + recalc_divide_init(gfc, gi, ix, r01_bits, r01_div, r0_tbl, r1_tbl); + recalc_divide_sub(gfc, cod_info2, gi, ix, r01_bits, r01_div, + r0_tbl, r1_tbl); + } + var i = cod_info2.big_values; + if (i == 0 || (ix[i - 2] | ix[i - 1]) > 1) + return; + + i = gi.count1 + 2; + if (i > 576) + return; + + /* Determines the number of bits to encode the quadruples. */ + cod_info2.assign(gi); + cod_info2.count1 = i; + var a1 = 0; + var a2 = 0; + + assert$18(i <= 576); + + for (; i > cod_info2.big_values; i -= 4) { + var p = ((ix[i - 4] * 2 + ix[i - 3]) * 2 + ix[i - 2]) * 2 + + ix[i - 1]; + a1 += Tables_1.t32l[p]; + a2 += Tables_1.t33l[p]; + } + cod_info2.big_values = i; + + cod_info2.count1table_select = 0; + if (a1 > a2) { + a1 = a2; + cod_info2.count1table_select = 1; + } + + cod_info2.count1bits = a1; + + if (cod_info2.block_type == Encoder_1.NORM_TYPE) + recalc_divide_sub(gfc, cod_info2, gi, ix, r01_bits, r01_div, + r0_tbl, r1_tbl); + else { + /* Count the number of bits necessary to code the bigvalues region. */ + cod_info2.part2_3_length = a1; + a1 = gfc.scalefac_band.l[7 + 1]; + if (a1 > i) { + a1 = i; + } + if (a1 > 0) { + var bi = new Bits(cod_info2.part2_3_length); + cod_info2.table_select[0] = choose_table(ix, 0, a1, bi); + cod_info2.part2_3_length = bi.bits; + } + if (i > a1) { + var bi = new Bits(cod_info2.part2_3_length); + cod_info2.table_select[1] = choose_table(ix, a1, i, bi); + cod_info2.part2_3_length = bi.bits; + } + if (gi.part2_3_length > cod_info2.part2_3_length) + gi.assign(cod_info2); + } + }; + + var slen1_n = [1, 1, 1, 1, 8, 2, 2, 2, 4, 4, 4, 8, 8, 8, 16, 16]; + var slen2_n = [1, 2, 4, 8, 1, 2, 4, 8, 2, 4, 8, 2, 4, 8, 4, 8]; + var slen1_tab = [0, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4]; + var slen2_tab = [0, 1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 2, 3]; + Takehiro$1.slen1_tab = slen1_tab; + Takehiro$1.slen2_tab = slen2_tab; + + function scfsi_calc(ch, l3_side) { + var sfb; + var gi = l3_side.tt[1][ch]; + var g0 = l3_side.tt[0][ch]; + + for (var i = 0; i < Tables_1.scfsi_band.length - 1; i++) { + for (sfb = Tables_1.scfsi_band[i]; sfb < Tables_1.scfsi_band[i + 1]; sfb++) { + if (g0.scalefac[sfb] != gi.scalefac[sfb] + && gi.scalefac[sfb] >= 0) + break; + } + if (sfb == Tables_1.scfsi_band[i + 1]) { + for (sfb = Tables_1.scfsi_band[i]; sfb < Tables_1.scfsi_band[i + 1]; sfb++) { + gi.scalefac[sfb] = -1; + } + l3_side.scfsi[ch][i] = 1; + } + } + var s1 = 0; + var c1 = 0; + for (sfb = 0; sfb < 11; sfb++) { + if (gi.scalefac[sfb] == -1) + continue; + c1++; + if (s1 < gi.scalefac[sfb]) + s1 = gi.scalefac[sfb]; + } + var s2 = 0; + var c2 = 0; + for (; sfb < Encoder_1.SBPSY_l; sfb++) { + if (gi.scalefac[sfb] == -1) + continue; + c2++; + if (s2 < gi.scalefac[sfb]) + s2 = gi.scalefac[sfb]; + } + + for (var i = 0; i < 16; i++) { + if (s1 < slen1_n[i] && s2 < slen2_n[i]) { + var c = slen1_tab[i] * c1 + slen2_tab[i] * c2; + if (gi.part2_length > c) { + gi.part2_length = c; + gi.scalefac_compress = i; + } + } + } + } + + /** + * Find the optimal way to store the scalefactors. Only call this routine + * after final scalefactors have been chosen and the channel/granule will + * not be re-encoded. + */ + this.best_scalefac_store = function (gfc, gr, ch, l3_side) { + /* use scalefac_scale if we can */ + var gi = l3_side.tt[gr][ch]; + var sfb, i, j, l; + var recalc = 0; + + /* + * remove scalefacs from bands with ix=0. This idea comes from the AAC + * ISO docs. added mt 3/00 + */ + /* check if l3_enc=0 */ + j = 0; + for (sfb = 0; sfb < gi.sfbmax; sfb++) { + var width = gi.width[sfb]; + assert$18(width >= 0); + j += width; + for (l = -width; l < 0; l++) { + if (gi.l3_enc[l + j] != 0) + break; + } + if (l == 0) + gi.scalefac[sfb] = recalc = -2; + /* anything goes. */ + /* + * only best_scalefac_store and calc_scfsi know--and only they + * should know--about the magic number -2. + */ + } + + if (0 == gi.scalefac_scale && 0 == gi.preflag) { + var s = 0; + for (sfb = 0; sfb < gi.sfbmax; sfb++) + if (gi.scalefac[sfb] > 0) + s |= gi.scalefac[sfb]; + + if (0 == (s & 1) && s != 0) { + for (sfb = 0; sfb < gi.sfbmax; sfb++) + if (gi.scalefac[sfb] > 0) + gi.scalefac[sfb] >>= 1; + + gi.scalefac_scale = recalc = 1; + } + } + + if (0 == gi.preflag && gi.block_type != Encoder_1.SHORT_TYPE + && gfc.mode_gr == 2) { + for (sfb = 11; sfb < Encoder_1.SBPSY_l; sfb++) + if (gi.scalefac[sfb] < qupvt.pretab[sfb] + && gi.scalefac[sfb] != -2) + break; + if (sfb == Encoder_1.SBPSY_l) { + for (sfb = 11; sfb < Encoder_1.SBPSY_l; sfb++) + if (gi.scalefac[sfb] > 0) + gi.scalefac[sfb] -= qupvt.pretab[sfb]; + + gi.preflag = recalc = 1; + } + } + + for (i = 0; i < 4; i++) + l3_side.scfsi[ch][i] = 0; + + if (gfc.mode_gr == 2 && gr == 1 + && l3_side.tt[0][ch].block_type != Encoder_1.SHORT_TYPE + && l3_side.tt[1][ch].block_type != Encoder_1.SHORT_TYPE) { + scfsi_calc(ch, l3_side); + recalc = 0; + } + for (sfb = 0; sfb < gi.sfbmax; sfb++) { + if (gi.scalefac[sfb] == -2) { + gi.scalefac[sfb] = 0; + /* if anything goes, then 0 is a good choice */ + } + } + if (recalc != 0) { + if (gfc.mode_gr == 2) { + this.scale_bitcount(gi); + } else { + this.scale_bitcount_lsf(gfc, gi); + } + } + }; + + function all_scalefactors_not_negative(scalefac, n) { + for (var i = 0; i < n; ++i) { + if (scalefac[i] < 0) + return false; + } + return true; + } + + /** + * number of bits used to encode scalefacs. + * + * 18*slen1_tab[i] + 18*slen2_tab[i] + */ + var scale_short = [0, 18, 36, 54, 54, 36, 54, 72, + 54, 72, 90, 72, 90, 108, 108, 126]; + + /** + * number of bits used to encode scalefacs. + * + * 17*slen1_tab[i] + 18*slen2_tab[i] + */ + var scale_mixed = [0, 18, 36, 54, 51, 35, 53, 71, + 52, 70, 88, 69, 87, 105, 104, 122]; + + /** + * number of bits used to encode scalefacs. + * + * 11*slen1_tab[i] + 10*slen2_tab[i] + */ + var scale_long = [0, 10, 20, 30, 33, 21, 31, 41, 32, 42, + 52, 43, 53, 63, 64, 74]; + + /** + * Also calculates the number of bits necessary to code the scalefactors. + */ + this.scale_bitcount = function (cod_info) { + var k, sfb, max_slen1 = 0, max_slen2 = 0; + + /* maximum values */ + var tab; + var scalefac = cod_info.scalefac; + + assert$18(all_scalefactors_not_negative(scalefac, cod_info.sfbmax)); + + if (cod_info.block_type == Encoder_1.SHORT_TYPE) { + tab = scale_short; + if (cod_info.mixed_block_flag != 0) + tab = scale_mixed; + } else { /* block_type == 1,2,or 3 */ + tab = scale_long; + if (0 == cod_info.preflag) { + for (sfb = 11; sfb < Encoder_1.SBPSY_l; sfb++) + if (scalefac[sfb] < qupvt.pretab[sfb]) + break; + + if (sfb == Encoder_1.SBPSY_l) { + cod_info.preflag = 1; + for (sfb = 11; sfb < Encoder_1.SBPSY_l; sfb++) + scalefac[sfb] -= qupvt.pretab[sfb]; + } + } + } + + for (sfb = 0; sfb < cod_info.sfbdivide; sfb++) + if (max_slen1 < scalefac[sfb]) + max_slen1 = scalefac[sfb]; + + for (; sfb < cod_info.sfbmax; sfb++) + if (max_slen2 < scalefac[sfb]) + max_slen2 = scalefac[sfb]; + + /* + * from Takehiro TOMINAGA
+ * 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. + *+ */ + this.copy_buffer = function (gfc, buffer, bufferPos, size, mp3data) { + var minimum = bufByteIdx + 1; + if (minimum <= 0) + return 0; + if (size != 0 && minimum > size) { + /* buffer is too small */ + return -1; + } + System$17.arraycopy(buf, 0, buffer, bufferPos, minimum); + bufByteIdx = -1; + bufBitIdx = 0; + + if (mp3data != 0) { + var crc = new_int$17(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 */ + var pcm_buf = new_float_n$17([2, 1152]); + var mp3_in = minimum; + var samples_out = -1; + var 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$17(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; + }; + + this.init_bit_stream_w = function (gfc) { + buf = new_byte$17(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 + + +} + +var BitStream_1 = BitStream$1; + +var System$2 = common.System; +var VbrMode$2 = common.VbrMode; +var ShortBlock$2 = common.ShortBlock; +var new_float$2 = common.new_float; +var new_int_n$2 = common.new_int_n; +var new_short_n$1 = common.new_short_n; +var assert$2 = common.assert; + + + + + + + + + + + +function Lame$1() { + var self = this; + var LAME_MAXALBUMART = (128 * 1024); + + Lame$1.V9 = 410; + Lame$1.V8 = 420; + Lame$1.V7 = 430; + Lame$1.V6 = 440; + Lame$1.V5 = 450; + Lame$1.V4 = 460; + Lame$1.V3 = 470; + Lame$1.V2 = 480; + Lame$1.V1 = 490; + Lame$1.V0 = 500; + + /* still there for compatibility */ + + Lame$1.R3MIX = 1000; + Lame$1.STANDARD = 1001; + Lame$1.EXTREME = 1002; + Lame$1.INSANE = 1003; + Lame$1.STANDARD_FAST = 1004; + Lame$1.EXTREME_FAST = 1005; + Lame$1.MEDIUM = 1006; + Lame$1.MEDIUM_FAST = 1007; + + /** + * maximum size of mp3buffer needed if you encode at most 1152 samples for + * each call to lame_encode_buffer. see lame_encode_buffer() below + * (LAME_MAXMP3BUFFER is now obsolete) + */ + var LAME_MAXMP3BUFFER = (16384 + LAME_MAXALBUMART); + Lame$1.LAME_MAXMP3BUFFER = LAME_MAXMP3BUFFER; + + var ga; + var bs; + var p; + var qupvt; + var qu; + var psy = new PsyModel_1(); + var vbr; + var ver; + var id3; + var mpglib; + this.enc = new Encoder_1(); + + this.setModules = function (_ga, _bs, _p, _qupvt, _qu, _vbr, _ver, _id3, _mpglib) { + ga = _ga; + bs = _bs; + p = _p; + qupvt = _qupvt; + qu = _qu; + vbr = _vbr; + ver = _ver; + id3 = _id3; + mpglib = _mpglib; + this.enc.setModules(bs, psy, qupvt, vbr); + }; + + /** + * PSY Model related stuff + */ + function PSY() { + /** + * The dbQ stuff. + */ + this.mask_adjust = 0.; + /** + * The dbQ stuff. + */ + this.mask_adjust_short = 0.; + /* at transition from one scalefactor band to next */ + /** + * Band weight long scalefactor bands. + */ + this.bo_l_weight = new_float$2(Encoder_1.SBMAX_l); + /** + * Band weight short scalefactor bands. + */ + this.bo_s_weight = new_float$2(Encoder_1.SBMAX_s); + } + + function LowPassHighPass() { + this.lowerlimit = 0.; + } + + function BandPass(bitrate, lPass) { + this.lowpass = lPass; + } + + var LAME_ID = 0xFFF88E3B; + + function lame_init_old(gfp) { + var gfc; + + gfp.class_id = LAME_ID; + + gfc = gfp.internal_flags = new LameInternalFlags_1(); + + /* Global flags. set defaults here for non-zero values */ + /* see lame.h for description */ + /* + * set integer values to -1 to mean that LAME will compute the best + * value, UNLESS the calling program as set it (and the value is no + * longer -1) + */ + + gfp.mode = MPEGMode.NOT_SET; + gfp.original = 1; + gfp.in_samplerate = 44100; + gfp.num_channels = 2; + gfp.num_samples = -1; + + gfp.bWriteVbrTag = true; + gfp.quality = -1; + gfp.short_blocks = null; + gfc.subblock_gain = -1; + + gfp.lowpassfreq = 0; + gfp.highpassfreq = 0; + gfp.lowpasswidth = -1; + gfp.highpasswidth = -1; + + gfp.VBR = VbrMode$2.vbr_off; + gfp.VBR_q = 4; + gfp.ATHcurve = -1; + gfp.VBR_mean_bitrate_kbps = 128; + gfp.VBR_min_bitrate_kbps = 0; + gfp.VBR_max_bitrate_kbps = 0; + gfp.VBR_hard_min = 0; + gfc.VBR_min_bitrate = 1; + /* not 0 ????? */ + gfc.VBR_max_bitrate = 13; + /* not 14 ????? */ + + gfp.quant_comp = -1; + gfp.quant_comp_short = -1; + + gfp.msfix = -1; + + gfc.resample_ratio = 1; + + gfc.OldValue[0] = 180; + gfc.OldValue[1] = 180; + gfc.CurrentStep[0] = 4; + gfc.CurrentStep[1] = 4; + gfc.masking_lower = 1; + gfc.nsPsy.attackthre = -1; + gfc.nsPsy.attackthre_s = -1; + + gfp.scale = -1; + + gfp.athaa_type = -1; + gfp.ATHtype = -1; + /* default = -1 = set in lame_init_params */ + gfp.athaa_loudapprox = -1; + /* 1 = flat loudness approx. (total energy) */ + /* 2 = equal loudness curve */ + gfp.athaa_sensitivity = 0.0; + /* no offset */ + gfp.useTemporal = null; + gfp.interChRatio = -1; + + /* + * The reason for int mf_samples_to_encode = ENCDELAY + POSTDELAY; + * ENCDELAY = internal encoder delay. And then we have to add + * POSTDELAY=288 because of the 50% MDCT overlap. A 576 MDCT granule + * decodes to 1152 samples. To synthesize the 576 samples centered under + * this granule we need the previous granule for the first 288 samples + * (no problem), and the next granule for the next 288 samples (not + * possible if this is last granule). So we need to pad with 288 samples + * to make sure we can encode the 576 samples we are interested in. + */ + gfc.mf_samples_to_encode = Encoder_1.ENCDELAY + Encoder_1.POSTDELAY; + gfp.encoder_padding = 0; + gfc.mf_size = Encoder_1.ENCDELAY - Encoder_1.MDCTDELAY; + /* + * we pad input with this many 0's + */ + + gfp.findReplayGain = false; + gfp.decode_on_the_fly = false; + + gfc.decode_on_the_fly = false; + gfc.findReplayGain = false; + gfc.findPeakSample = false; + + gfc.RadioGain = 0; + gfc.AudiophileGain = 0; + gfc.noclipGainChange = 0; + gfc.noclipScale = -1.0; + + gfp.preset = 0; + + gfp.write_id3tag_automatic = true; + return 0; + } + + this.lame_init = function () { + var gfp = new LameGlobalFlags_1(); + + var ret = lame_init_old(gfp); + if (ret != 0) { + return null; + } + + gfp.lame_allocated_gfp = 1; + return gfp; + }; + + function filter_coef(x) { + if (x > 1.0) + return 0.0; + if (x <= 0.0) + return 1.0; + + return Math.cos(Math.PI / 2 * x); + } + + this.nearestBitrateFullIndex = function (bitrate) { + /* borrowed from DM abr presets */ + + var full_bitrate_table = [8, 16, 24, 32, 40, 48, 56, 64, 80, + 96, 112, 128, 160, 192, 224, 256, 320]; + + var lower_range = 0, lower_range_kbps = 0, upper_range = 0, upper_range_kbps = 0; + + /* We assume specified bitrate will be 320kbps */ + upper_range_kbps = full_bitrate_table[16]; + upper_range = 16; + lower_range_kbps = full_bitrate_table[16]; + lower_range = 16; + + /* + * Determine which significant bitrates the value specified falls + * between, if loop ends without breaking then we were correct above + * that the value was 320 + */ + for (var b = 0; b < 16; b++) { + if ((Math.max(bitrate, full_bitrate_table[b + 1])) != bitrate) { + upper_range_kbps = full_bitrate_table[b + 1]; + upper_range = b + 1; + lower_range_kbps = full_bitrate_table[b]; + lower_range = (b); + break; + /* We found upper range */ + } + } + + /* Determine which range the value specified is closer to */ + if ((upper_range_kbps - bitrate) > (bitrate - lower_range_kbps)) { + return lower_range; + } + return upper_range; + }; + + function optimum_samplefreq(lowpassfreq, input_samplefreq) { + /* + * Rules: + * + * - if possible, sfb21 should NOT be used + */ + var suggested_samplefreq = 44100; + + if (input_samplefreq >= 48000) + suggested_samplefreq = 48000; + else if (input_samplefreq >= 44100) + suggested_samplefreq = 44100; + else if (input_samplefreq >= 32000) + suggested_samplefreq = 32000; + else if (input_samplefreq >= 24000) + suggested_samplefreq = 24000; + else if (input_samplefreq >= 22050) + suggested_samplefreq = 22050; + else if (input_samplefreq >= 16000) + suggested_samplefreq = 16000; + else if (input_samplefreq >= 12000) + suggested_samplefreq = 12000; + else if (input_samplefreq >= 11025) + suggested_samplefreq = 11025; + else if (input_samplefreq >= 8000) + suggested_samplefreq = 8000; + + if (lowpassfreq == -1) + return suggested_samplefreq; + + if (lowpassfreq <= 15960) + suggested_samplefreq = 44100; + if (lowpassfreq <= 15250) + suggested_samplefreq = 32000; + if (lowpassfreq <= 11220) + suggested_samplefreq = 24000; + if (lowpassfreq <= 9970) + suggested_samplefreq = 22050; + if (lowpassfreq <= 7230) + suggested_samplefreq = 16000; + if (lowpassfreq <= 5420) + suggested_samplefreq = 12000; + if (lowpassfreq <= 4510) + suggested_samplefreq = 11025; + if (lowpassfreq <= 3970) + suggested_samplefreq = 8000; + + if (input_samplefreq < suggested_samplefreq) { + /* + * choose a valid MPEG sample frequency above the input sample + * frequency to avoid SFB21/12 bitrate bloat rh 061115 + */ + if (input_samplefreq > 44100) { + return 48000; + } + if (input_samplefreq > 32000) { + return 44100; + } + if (input_samplefreq > 24000) { + return 32000; + } + if (input_samplefreq > 22050) { + return 24000; + } + if (input_samplefreq > 16000) { + return 22050; + } + if (input_samplefreq > 12000) { + return 16000; + } + if (input_samplefreq > 11025) { + return 12000; + } + if (input_samplefreq > 8000) { + return 11025; + } + return 8000; + } + return suggested_samplefreq; + } + + /** + * convert samp freq in Hz to index + */ + function SmpFrqIndex(sample_freq, gpf) { + switch (sample_freq) { + case 44100: + gpf.version = 1; + return 0; + case 48000: + gpf.version = 1; + return 1; + case 32000: + gpf.version = 1; + return 2; + case 22050: + gpf.version = 0; + return 0; + case 24000: + gpf.version = 0; + return 1; + case 16000: + gpf.version = 0; + return 2; + case 11025: + gpf.version = 0; + return 0; + case 12000: + gpf.version = 0; + return 1; + case 8000: + gpf.version = 0; + return 2; + default: + gpf.version = 0; + return -1; + } + } + + /** + * @param bRate + * legal rates from 8 to 320 + */ + function FindNearestBitrate(bRate, version, samplerate) { + /* MPEG-1 or MPEG-2 LSF */ + if (samplerate < 16000) + version = 2; + + var bitrate = Tables_1.bitrate_table[version][1]; + + for (var i = 2; i <= 14; i++) { + if (Tables_1.bitrate_table[version][i] > 0) { + if (Math.abs(Tables_1.bitrate_table[version][i] - bRate) < Math + .abs(bitrate - bRate)) + bitrate = Tables_1.bitrate_table[version][i]; + } + } + return bitrate; + } + + /** + * @param bRate + * legal rates from 32 to 448 kbps + * @param version + * MPEG-1 or MPEG-2/2.5 LSF + */ + function BitrateIndex(bRate, version, samplerate) { + /* convert bitrate in kbps to index */ + if (samplerate < 16000) + version = 2; + for (var i = 0; i <= 14; i++) { + if (Tables_1.bitrate_table[version][i] > 0) { + if (Tables_1.bitrate_table[version][i] == bRate) { + return i; + } + } + } + return -1; + } + + function optimum_bandwidth(lh, bitrate) { + /** + *
+ * Input: + * bitrate total bitrate in kbps + * + * Output: + * lowerlimit: best lowpass frequency limit for input filter in Hz + * upperlimit: best highpass frequency limit for input filter in Hz + *+ */ + var freq_map = [new BandPass(8, 2000), + new BandPass(16, 3700), new BandPass(24, 3900), + new BandPass(32, 5500), new BandPass(40, 7000), + new BandPass(48, 7500), new BandPass(56, 10000), + new BandPass(64, 11000), new BandPass(80, 13500), + new BandPass(96, 15100), new BandPass(112, 15600), + new BandPass(128, 17000), new BandPass(160, 17500), + new BandPass(192, 18600), new BandPass(224, 19400), + new BandPass(256, 19700), new BandPass(320, 20500)]; + + var table_index = self.nearestBitrateFullIndex(bitrate); + lh.lowerlimit = freq_map[table_index].lowpass; + } + + function lame_init_params_ppflt(gfp) { + var gfc = gfp.internal_flags; + /***************************************************************/ + /* compute info needed for polyphase filter (filter type==0, default) */ + /***************************************************************/ + + var lowpass_band = 32; + var highpass_band = -1; + + if (gfc.lowpass1 > 0) { + var minband = 999; + for (var band = 0; band <= 31; band++) { + var freq = (band / 31.0); + /* this band and above will be zeroed: */ + if (freq >= gfc.lowpass2) { + lowpass_band = Math.min(lowpass_band, band); + } + if (gfc.lowpass1 < freq && freq < gfc.lowpass2) { + minband = Math.min(minband, band); + } + } + + /* + * compute the *actual* transition band implemented by the polyphase + * filter + */ + if (minband == 999) { + gfc.lowpass1 = (lowpass_band - .75) / 31.0; + } else { + gfc.lowpass1 = (minband - .75) / 31.0; + } + gfc.lowpass2 = lowpass_band / 31.0; + } + + /* + * make sure highpass filter is within 90% of what the effective + * highpass frequency will be + */ + if (gfc.highpass2 > 0) { + if (gfc.highpass2 < .9 * (.75 / 31.0)) { + gfc.highpass1 = 0; + gfc.highpass2 = 0; + System$2.err.println("Warning: highpass filter disabled. " + + "highpass frequency too small\n"); + } + } + + if (gfc.highpass2 > 0) { + var maxband = -1; + for (var band = 0; band <= 31; band++) { + var freq = band / 31.0; + /* this band and below will be zereod */ + if (freq <= gfc.highpass1) { + highpass_band = Math.max(highpass_band, band); + } + if (gfc.highpass1 < freq && freq < gfc.highpass2) { + maxband = Math.max(maxband, band); + } + } + /* + * compute the *actual* transition band implemented by the polyphase + * filter + */ + gfc.highpass1 = highpass_band / 31.0; + if (maxband == -1) { + gfc.highpass2 = (highpass_band + .75) / 31.0; + } else { + gfc.highpass2 = (maxband + .75) / 31.0; + } + } + + for (var band = 0; band < 32; band++) { + var fc1, fc2; + var freq = band / 31.0; + if (gfc.highpass2 > gfc.highpass1) { + fc1 = filter_coef((gfc.highpass2 - freq) + / (gfc.highpass2 - gfc.highpass1 + 1e-20)); + } else { + fc1 = 1.0; + } + if (gfc.lowpass2 > gfc.lowpass1) { + fc2 = filter_coef((freq - gfc.lowpass1) + / (gfc.lowpass2 - gfc.lowpass1 + 1e-20)); + } else { + fc2 = 1.0; + } + gfc.amp_filter[band] = (fc1 * fc2); + } + } + + function lame_init_qval(gfp) { + var gfc = gfp.internal_flags; + + switch (gfp.quality) { + default: + case 9: /* no psymodel, no noise shaping */ + gfc.psymodel = 0; + gfc.noise_shaping = 0; + gfc.noise_shaping_amp = 0; + gfc.noise_shaping_stop = 0; + gfc.use_best_huffman = 0; + gfc.full_outer_loop = 0; + break; + + case 8: + gfp.quality = 7; + //$FALL-THROUGH$ + case 7: + /* + * use psymodel (for short block and m/s switching), but no noise + * shapping + */ + gfc.psymodel = 1; + gfc.noise_shaping = 0; + gfc.noise_shaping_amp = 0; + gfc.noise_shaping_stop = 0; + gfc.use_best_huffman = 0; + gfc.full_outer_loop = 0; + break; + + case 6: + gfc.psymodel = 1; + if (gfc.noise_shaping == 0) + gfc.noise_shaping = 1; + gfc.noise_shaping_amp = 0; + gfc.noise_shaping_stop = 0; + if (gfc.subblock_gain == -1) + gfc.subblock_gain = 1; + gfc.use_best_huffman = 0; + gfc.full_outer_loop = 0; + break; + + case 5: + gfc.psymodel = 1; + if (gfc.noise_shaping == 0) + gfc.noise_shaping = 1; + gfc.noise_shaping_amp = 0; + gfc.noise_shaping_stop = 0; + if (gfc.subblock_gain == -1) + gfc.subblock_gain = 1; + gfc.use_best_huffman = 0; + gfc.full_outer_loop = 0; + break; + + case 4: + gfc.psymodel = 1; + if (gfc.noise_shaping == 0) + gfc.noise_shaping = 1; + gfc.noise_shaping_amp = 0; + gfc.noise_shaping_stop = 0; + if (gfc.subblock_gain == -1) + gfc.subblock_gain = 1; + gfc.use_best_huffman = 1; + gfc.full_outer_loop = 0; + break; + + case 3: + gfc.psymodel = 1; + if (gfc.noise_shaping == 0) + gfc.noise_shaping = 1; + gfc.noise_shaping_amp = 1; + gfc.noise_shaping_stop = 1; + if (gfc.subblock_gain == -1) + gfc.subblock_gain = 1; + gfc.use_best_huffman = 1; + gfc.full_outer_loop = 0; + break; + + case 2: + gfc.psymodel = 1; + if (gfc.noise_shaping == 0) + gfc.noise_shaping = 1; + if (gfc.substep_shaping == 0) + gfc.substep_shaping = 2; + gfc.noise_shaping_amp = 1; + gfc.noise_shaping_stop = 1; + if (gfc.subblock_gain == -1) + gfc.subblock_gain = 1; + gfc.use_best_huffman = 1; + /* inner loop */ + gfc.full_outer_loop = 0; + break; + + case 1: + gfc.psymodel = 1; + if (gfc.noise_shaping == 0) + gfc.noise_shaping = 1; + if (gfc.substep_shaping == 0) + gfc.substep_shaping = 2; + gfc.noise_shaping_amp = 2; + gfc.noise_shaping_stop = 1; + if (gfc.subblock_gain == -1) + gfc.subblock_gain = 1; + gfc.use_best_huffman = 1; + gfc.full_outer_loop = 0; + break; + + case 0: + gfc.psymodel = 1; + if (gfc.noise_shaping == 0) + gfc.noise_shaping = 1; + if (gfc.substep_shaping == 0) + gfc.substep_shaping = 2; + gfc.noise_shaping_amp = 2; + gfc.noise_shaping_stop = 1; + if (gfc.subblock_gain == -1) + gfc.subblock_gain = 1; + gfc.use_best_huffman = 1; + /* + * type 2 disabled because of it slowness, in favor of full outer + * loop search + */ + gfc.full_outer_loop = 0; + /* + * full outer loop search disabled because of audible distortions it + * may generate rh 060629 + */ + break; + } + + } + + function lame_init_bitstream(gfp) { + var gfc = gfp.internal_flags; + gfp.frameNum = 0; + + if (gfp.write_id3tag_automatic) { + id3.id3tag_write_v2(gfp); + } + /* initialize histogram data optionally used by frontend */ + + gfc.bitrate_stereoMode_Hist = new_int_n$2([16, 4 + 1]); + gfc.bitrate_blockType_Hist = new_int_n$2([16, 4 + 1 + 1]); + + gfc.PeakSample = 0.0; + + /* Write initial VBR Header to bitstream and init VBR data */ + if (gfp.bWriteVbrTag) + vbr.InitVbrTag(gfp); + } + + /******************************************************************** + * initialize internal params based on data in gf (globalflags struct filled + * in by calling program) + * + * OUTLINE: + * + * We first have some complex code to determine bitrate, output samplerate + * and mode. It is complicated by the fact that we allow the user to set + * some or all of these parameters, and need to determine best possible + * values for the rest of them: + * + * 1. set some CPU related flags 2. check if we are mono.mono, stereo.mono + * or stereo.stereo 3. compute bitrate and output samplerate: user may have + * set compression ratio user may have set a bitrate user may have set a + * output samplerate 4. set some options which depend on output samplerate + * 5. compute the actual compression ratio 6. set mode based on compression + * ratio + * + * The remaining code is much simpler - it just sets options based on the + * mode & compression ratio: + * + * set allow_diff_short based on mode select lowpass filter based on + * compression ratio & mode set the bitrate index, and min/max bitrates for + * VBR modes disable VBR tag if it is not appropriate initialize the + * bitstream initialize scalefac_band data set sideinfo_len (based on + * channels, CRC, out_samplerate) write an id3v2 tag into the bitstream + * write VBR tag into the bitstream set mpeg1/2 flag estimate the number of + * frames (based on a lot of data) + * + * now we set more flags: nspsytune: see code VBR modes see code CBR/ABR see + * code + * + * Finally, we set the algorithm flags based on the gfp.quality value + * lame_init_qval(gfp); + * + ********************************************************************/ + this.lame_init_params = function (gfp) { + var gfc = gfp.internal_flags; + + gfc.Class_ID = 0; + if (gfc.ATH == null) + gfc.ATH = new ATH_1(); + if (gfc.PSY == null) + gfc.PSY = new PSY(); + if (gfc.rgdata == null) + gfc.rgdata = new ReplayGain_1(); + + gfc.channels_in = gfp.num_channels; + if (gfc.channels_in == 1) + gfp.mode = MPEGMode.MONO; + gfc.channels_out = (gfp.mode == MPEGMode.MONO) ? 1 : 2; + gfc.mode_ext = Encoder_1.MPG_MD_MS_LR; + if (gfp.mode == MPEGMode.MONO) + gfp.force_ms = false; + /* + * don't allow forced mid/side stereo for mono output + */ + + if (gfp.VBR == VbrMode$2.vbr_off && gfp.VBR_mean_bitrate_kbps != 128 + && gfp.brate == 0) + gfp.brate = gfp.VBR_mean_bitrate_kbps; + + if (gfp.VBR == VbrMode$2.vbr_off || gfp.VBR == VbrMode$2.vbr_mtrh + || gfp.VBR == VbrMode$2.vbr_mt) { + /* these modes can handle free format condition */ + } else { + gfp.free_format = false; + /* mode can't be mixed with free format */ + } + + if (gfp.VBR == VbrMode$2.vbr_off && gfp.brate == 0) { + /* no bitrate or compression ratio specified, use 11.025 */ + if (BitStream_1.EQ(gfp.compression_ratio, 0)) + gfp.compression_ratio = 11.025; + /* + * rate to compress a CD down to exactly 128000 bps + */ + } + + /* find bitrate if user specify a compression ratio */ + if (gfp.VBR == VbrMode$2.vbr_off && gfp.compression_ratio > 0) { + + if (gfp.out_samplerate == 0) + gfp.out_samplerate = map2MP3Frequency((int)(0.97 * gfp.in_samplerate)); + /* + * round up with a margin of 3 % + */ + + /* + * choose a bitrate for the output samplerate which achieves + * specified compression ratio + */ + gfp.brate = 0 | (gfp.out_samplerate * 16 * gfc.channels_out / (1.e3 * gfp.compression_ratio)); + + /* we need the version for the bitrate table look up */ + gfc.samplerate_index = SmpFrqIndex(gfp.out_samplerate, gfp); + + if (!gfp.free_format) /* + * for non Free Format find the nearest allowed + * bitrate + */ + gfp.brate = FindNearestBitrate(gfp.brate, gfp.version, + gfp.out_samplerate); + } + + if (gfp.out_samplerate != 0) { + if (gfp.out_samplerate < 16000) { + gfp.VBR_mean_bitrate_kbps = Math.max(gfp.VBR_mean_bitrate_kbps, + 8); + gfp.VBR_mean_bitrate_kbps = Math.min(gfp.VBR_mean_bitrate_kbps, + 64); + } else if (gfp.out_samplerate < 32000) { + gfp.VBR_mean_bitrate_kbps = Math.max(gfp.VBR_mean_bitrate_kbps, + 8); + gfp.VBR_mean_bitrate_kbps = Math.min(gfp.VBR_mean_bitrate_kbps, + 160); + } else { + gfp.VBR_mean_bitrate_kbps = Math.max(gfp.VBR_mean_bitrate_kbps, + 32); + gfp.VBR_mean_bitrate_kbps = Math.min(gfp.VBR_mean_bitrate_kbps, + 320); + } + } + + /****************************************************************/ + /* if a filter has not been enabled, see if we should add one: */ + /****************************************************************/ + if (gfp.lowpassfreq == 0) { + var lowpass = 16000.; + + switch (gfp.VBR) { + case VbrMode$2.vbr_off: + { + var lh = new LowPassHighPass(); + optimum_bandwidth(lh, gfp.brate); + lowpass = lh.lowerlimit; + break; + } + case VbrMode$2.vbr_abr: + { + var lh = new LowPassHighPass(); + optimum_bandwidth(lh, gfp.VBR_mean_bitrate_kbps); + lowpass = lh.lowerlimit; + break; + } + case VbrMode$2.vbr_rh: + { + var x = [19500, 19000, 18600, 18000, 17500, 16000, + 15600, 14900, 12500, 10000, 3950]; + if (0 <= gfp.VBR_q && gfp.VBR_q <= 9) { + var a = x[gfp.VBR_q], b = x[gfp.VBR_q + 1], m = gfp.VBR_q_frac; + lowpass = linear_int(a, b, m); + } else { + lowpass = 19500; + } + break; + } + default: + { + var x = [19500, 19000, 18500, 18000, 17500, 16500, + 15500, 14500, 12500, 9500, 3950]; + if (0 <= gfp.VBR_q && gfp.VBR_q <= 9) { + var a = x[gfp.VBR_q], b = x[gfp.VBR_q + 1], m = gfp.VBR_q_frac; + lowpass = linear_int(a, b, m); + } else { + lowpass = 19500; + } + } + } + if (gfp.mode == MPEGMode.MONO + && (gfp.VBR == VbrMode$2.vbr_off || gfp.VBR == VbrMode$2.vbr_abr)) + lowpass *= 1.5; + + gfp.lowpassfreq = lowpass | 0; + } + + if (gfp.out_samplerate == 0) { + if (2 * gfp.lowpassfreq > gfp.in_samplerate) { + gfp.lowpassfreq = gfp.in_samplerate / 2; + } + gfp.out_samplerate = optimum_samplefreq(gfp.lowpassfreq | 0, + gfp.in_samplerate); + } + + gfp.lowpassfreq = Math.min(20500, gfp.lowpassfreq); + gfp.lowpassfreq = Math.min(gfp.out_samplerate / 2, gfp.lowpassfreq); + + if (gfp.VBR == VbrMode$2.vbr_off) { + gfp.compression_ratio = gfp.out_samplerate * 16 * gfc.channels_out + / (1.e3 * gfp.brate); + } + if (gfp.VBR == VbrMode$2.vbr_abr) { + gfp.compression_ratio = gfp.out_samplerate * 16 * gfc.channels_out + / (1.e3 * gfp.VBR_mean_bitrate_kbps); + } + + /* + * do not compute ReplayGain values and do not find the peak sample if + * we can't store them + */ + if (!gfp.bWriteVbrTag) { + gfp.findReplayGain = false; + gfp.decode_on_the_fly = false; + gfc.findPeakSample = false; + } + gfc.findReplayGain = gfp.findReplayGain; + gfc.decode_on_the_fly = gfp.decode_on_the_fly; + + if (gfc.decode_on_the_fly) + gfc.findPeakSample = true; + + if (gfc.findReplayGain) { + if (ga.InitGainAnalysis(gfc.rgdata, gfp.out_samplerate) == GainAnalysis.INIT_GAIN_ANALYSIS_ERROR) { + gfp.internal_flags = null; + return -6; + } + } + + if (gfc.decode_on_the_fly && !gfp.decode_only) { + if (gfc.hip != null) { + mpglib.hip_decode_exit(gfc.hip); + } + gfc.hip = mpglib.hip_decode_init(); + } + + gfc.mode_gr = gfp.out_samplerate <= 24000 ? 1 : 2; + /* + * Number of granules per frame + */ + gfp.framesize = 576 * gfc.mode_gr; + gfp.encoder_delay = Encoder_1.ENCDELAY; + + gfc.resample_ratio = gfp.in_samplerate / gfp.out_samplerate; + + /** + *
+ * sample freq bitrate compression ratio + * [kHz] [kbps/channel] for 16 bit input + * 44.1 56 12.6 + * 44.1 64 11.025 + * 44.1 80 8.82 + * 22.05 24 14.7 + * 22.05 32 11.025 + * 22.05 40 8.82 + * 16 16 16.0 + * 16 24 10.667 + *+ */ + /** + *
+ * For VBR, take a guess at the compression_ratio. + * For example: + * + * VBR_q compression like + * - 4.4 320 kbps/44 kHz + * 0...1 5.5 256 kbps/44 kHz + * 2 7.3 192 kbps/44 kHz + * 4 8.8 160 kbps/44 kHz + * 6 11 128 kbps/44 kHz + * 9 14.7 96 kbps + * + * for lower bitrates, downsample with --resample + *+ */ + switch (gfp.VBR) { + case VbrMode$2.vbr_mt: + case VbrMode$2.vbr_rh: + case VbrMode$2.vbr_mtrh: + { + /* numbers are a bit strange, but they determine the lowpass value */ + var cmp = [5.7, 6.5, 7.3, 8.2, 10, 11.9, 13, 14, + 15, 16.5]; + gfp.compression_ratio = cmp[gfp.VBR_q]; + } + break; + case VbrMode$2.vbr_abr: + gfp.compression_ratio = gfp.out_samplerate * 16 * gfc.channels_out + / (1.e3 * gfp.VBR_mean_bitrate_kbps); + break; + default: + gfp.compression_ratio = gfp.out_samplerate * 16 * gfc.channels_out + / (1.e3 * gfp.brate); + break; + } + + /* + * mode = -1 (not set by user) or mode = MONO (because of only 1 input + * channel). If mode has not been set, then select J-STEREO + */ + if (gfp.mode == MPEGMode.NOT_SET) { + gfp.mode = MPEGMode.JOINT_STEREO; + } + + /* apply user driven high pass filter */ + if (gfp.highpassfreq > 0) { + gfc.highpass1 = 2. * gfp.highpassfreq; + + if (gfp.highpasswidth >= 0) + gfc.highpass2 = 2. * (gfp.highpassfreq + gfp.highpasswidth); + else + /* 0% above on default */ + gfc.highpass2 = (1 + 0.00) * 2. * gfp.highpassfreq; + + gfc.highpass1 /= gfp.out_samplerate; + gfc.highpass2 /= gfp.out_samplerate; + } else { + gfc.highpass1 = 0; + gfc.highpass2 = 0; + } + /* apply user driven low pass filter */ + if (gfp.lowpassfreq > 0) { + gfc.lowpass2 = 2. * gfp.lowpassfreq; + if (gfp.lowpasswidth >= 0) { + gfc.lowpass1 = 2. * (gfp.lowpassfreq - gfp.lowpasswidth); + if (gfc.lowpass1 < 0) /* has to be >= 0 */ + gfc.lowpass1 = 0; + } else { /* 0% below on default */ + gfc.lowpass1 = (1 - 0.00) * 2. * gfp.lowpassfreq; + } + gfc.lowpass1 /= gfp.out_samplerate; + gfc.lowpass2 /= gfp.out_samplerate; + } else { + gfc.lowpass1 = 0; + gfc.lowpass2 = 0; + } + + /**********************************************************************/ + /* compute info needed for polyphase filter (filter type==0, default) */ + /**********************************************************************/ + lame_init_params_ppflt(gfp); + /******************************************************* + * samplerate and bitrate index + *******************************************************/ + gfc.samplerate_index = SmpFrqIndex(gfp.out_samplerate, gfp); + if (gfc.samplerate_index < 0) { + gfp.internal_flags = null; + return -1; + } + + if (gfp.VBR == VbrMode$2.vbr_off) { + if (gfp.free_format) { + gfc.bitrate_index = 0; + } else { + gfp.brate = FindNearestBitrate(gfp.brate, gfp.version, + gfp.out_samplerate); + gfc.bitrate_index = BitrateIndex(gfp.brate, gfp.version, + gfp.out_samplerate); + if (gfc.bitrate_index <= 0) { + gfp.internal_flags = null; + return -1; + } + } + } else { + gfc.bitrate_index = 1; + } + + /* for CBR, we will write an "info" tag. */ + + if (gfp.analysis) + gfp.bWriteVbrTag = false; + + /* some file options not allowed if output is: not specified or stdout */ + if (gfc.pinfo != null) + gfp.bWriteVbrTag = false; + /* disable Xing VBR tag */ + + bs.init_bit_stream_w(gfc); + + var j = gfc.samplerate_index + (3 * gfp.version) + 6 + * (gfp.out_samplerate < 16000 ? 1 : 0); + for (var i = 0; i < Encoder_1.SBMAX_l + 1; i++) + gfc.scalefac_band.l[i] = qupvt.sfBandIndex[j].l[i]; + + for (var i = 0; i < Encoder_1.PSFB21 + 1; i++) { + var size = (gfc.scalefac_band.l[22] - gfc.scalefac_band.l[21]) + / Encoder_1.PSFB21; + var start = gfc.scalefac_band.l[21] + i * size; + gfc.scalefac_band.psfb21[i] = start; + } + gfc.scalefac_band.psfb21[Encoder_1.PSFB21] = 576; + + for (var i = 0; i < Encoder_1.SBMAX_s + 1; i++) + gfc.scalefac_band.s[i] = qupvt.sfBandIndex[j].s[i]; + + for (var i = 0; i < Encoder_1.PSFB12 + 1; i++) { + var size = (gfc.scalefac_band.s[13] - gfc.scalefac_band.s[12]) + / Encoder_1.PSFB12; + var start = gfc.scalefac_band.s[12] + i * size; + gfc.scalefac_band.psfb12[i] = start; + } + gfc.scalefac_band.psfb12[Encoder_1.PSFB12] = 192; + /* determine the mean bitrate for main data */ + if (gfp.version == 1) /* MPEG 1 */ + gfc.sideinfo_len = (gfc.channels_out == 1) ? 4 + 17 : 4 + 32; + else + /* MPEG 2 */ + gfc.sideinfo_len = (gfc.channels_out == 1) ? 4 + 9 : 4 + 17; + + if (gfp.error_protection) + gfc.sideinfo_len += 2; + + lame_init_bitstream(gfp); + + gfc.Class_ID = LAME_ID; + + { + var k; + + for (k = 0; k < 19; k++) + gfc.nsPsy.pefirbuf[k] = 700 * gfc.mode_gr * gfc.channels_out; + + if (gfp.ATHtype == -1) + gfp.ATHtype = 4; + } + assert$2(gfp.VBR_q <= 9); + assert$2(gfp.VBR_q >= 0); + + switch (gfp.VBR) { + + case VbrMode$2.vbr_mt: + gfp.VBR = VbrMode$2.vbr_mtrh; + //$FALL-THROUGH$ + case VbrMode$2.vbr_mtrh: + { + if (gfp.useTemporal == null) { + gfp.useTemporal = false; + /* off by default for this VBR mode */ + } + + p.apply_preset(gfp, 500 - (gfp.VBR_q * 10), 0); + /** + *
+ * The newer VBR code supports only a limited + * subset of quality levels: + * 9-5=5 are the same, uses x^3/4 quantization + * 4-0=0 are the same 5 plus best huffman divide code + *+ */ + if (gfp.quality < 0) + gfp.quality = LAME_DEFAULT_QUALITY; + if (gfp.quality < 5) + gfp.quality = 0; + if (gfp.quality > 5) + gfp.quality = 5; + + gfc.PSY.mask_adjust = gfp.maskingadjust; + gfc.PSY.mask_adjust_short = gfp.maskingadjust_short; + + /* + * sfb21 extra only with MPEG-1 at higher sampling rates + */ + if (gfp.experimentalY) + gfc.sfb21_extra = false; + else + gfc.sfb21_extra = (gfp.out_samplerate > 44000); + + gfc.iteration_loop = new VBRNewIterationLoop(qu); + break; + + } + case VbrMode$2.vbr_rh: + { + + p.apply_preset(gfp, 500 - (gfp.VBR_q * 10), 0); + + gfc.PSY.mask_adjust = gfp.maskingadjust; + gfc.PSY.mask_adjust_short = gfp.maskingadjust_short; + + /* + * sfb21 extra only with MPEG-1 at higher sampling rates + */ + if (gfp.experimentalY) + gfc.sfb21_extra = false; + else + gfc.sfb21_extra = (gfp.out_samplerate > 44000); + + /* + * VBR needs at least the output of GPSYCHO, so we have to garantee + * that by setting a minimum quality level, actually level 6 does + * it. down to level 6 + */ + if (gfp.quality > 6) + gfp.quality = 6; + + if (gfp.quality < 0) + gfp.quality = LAME_DEFAULT_QUALITY; + + gfc.iteration_loop = new VBROldIterationLoop(qu); + break; + } + + default: /* cbr/abr */ + { + var vbrmode; + + /* + * no sfb21 extra with CBR code + */ + gfc.sfb21_extra = false; + + if (gfp.quality < 0) + gfp.quality = LAME_DEFAULT_QUALITY; + + vbrmode = gfp.VBR; + if (vbrmode == VbrMode$2.vbr_off) + gfp.VBR_mean_bitrate_kbps = gfp.brate; + /* second, set parameters depending on bitrate */ + p.apply_preset(gfp, gfp.VBR_mean_bitrate_kbps, 0); + gfp.VBR = vbrmode; + + gfc.PSY.mask_adjust = gfp.maskingadjust; + gfc.PSY.mask_adjust_short = gfp.maskingadjust_short; + + if (vbrmode == VbrMode$2.vbr_off) { + gfc.iteration_loop = new CBRNewIterationLoop_1(qu); + } else { + gfc.iteration_loop = new ABRIterationLoop(qu); + } + break; + } + } + assert$2(gfp.scale >= 0); + /* initialize default values common for all modes */ + + if (gfp.VBR != VbrMode$2.vbr_off) { /* choose a min/max bitrate for VBR */ + /* if the user didn't specify VBR_max_bitrate: */ + gfc.VBR_min_bitrate = 1; + /* + * default: allow 8 kbps (MPEG-2) or 32 kbps (MPEG-1) + */ + gfc.VBR_max_bitrate = 14; + /* + * default: allow 160 kbps (MPEG-2) or 320 kbps (MPEG-1) + */ + if (gfp.out_samplerate < 16000) + gfc.VBR_max_bitrate = 8; + /* default: allow 64 kbps (MPEG-2.5) */ + if (gfp.VBR_min_bitrate_kbps != 0) { + gfp.VBR_min_bitrate_kbps = FindNearestBitrate( + gfp.VBR_min_bitrate_kbps, gfp.version, + gfp.out_samplerate); + gfc.VBR_min_bitrate = BitrateIndex(gfp.VBR_min_bitrate_kbps, + gfp.version, gfp.out_samplerate); + if (gfc.VBR_min_bitrate < 0) + return -1; + } + if (gfp.VBR_max_bitrate_kbps != 0) { + gfp.VBR_max_bitrate_kbps = FindNearestBitrate( + gfp.VBR_max_bitrate_kbps, gfp.version, + gfp.out_samplerate); + gfc.VBR_max_bitrate = BitrateIndex(gfp.VBR_max_bitrate_kbps, + gfp.version, gfp.out_samplerate); + if (gfc.VBR_max_bitrate < 0) + return -1; + } + gfp.VBR_min_bitrate_kbps = Tables_1.bitrate_table[gfp.version][gfc.VBR_min_bitrate]; + gfp.VBR_max_bitrate_kbps = Tables_1.bitrate_table[gfp.version][gfc.VBR_max_bitrate]; + gfp.VBR_mean_bitrate_kbps = Math.min( + Tables_1.bitrate_table[gfp.version][gfc.VBR_max_bitrate], + gfp.VBR_mean_bitrate_kbps); + gfp.VBR_mean_bitrate_kbps = Math.max( + Tables_1.bitrate_table[gfp.version][gfc.VBR_min_bitrate], + gfp.VBR_mean_bitrate_kbps); + } + + /* just another daily changing developer switch */ + if (gfp.tune) { + gfc.PSY.mask_adjust += gfp.tune_value_a; + gfc.PSY.mask_adjust_short += gfp.tune_value_a; + } + + /* initialize internal qval settings */ + lame_init_qval(gfp); + assert$2(gfp.scale >= 0); + /* + * automatic ATH adjustment on + */ + if (gfp.athaa_type < 0) + gfc.ATH.useAdjust = 3; + else + gfc.ATH.useAdjust = gfp.athaa_type; + + /* initialize internal adaptive ATH settings -jd */ + gfc.ATH.aaSensitivityP = Math.pow(10.0, gfp.athaa_sensitivity + / -10.0); + + if (gfp.short_blocks == null) { + gfp.short_blocks = ShortBlock$2.short_block_allowed; + } + + /* + * Note Jan/2003: Many hardware decoders cannot handle short blocks in + * regular stereo mode unless they are coupled (same type in both + * channels) it is a rare event (1 frame per min. or so) that LAME would + * use uncoupled short blocks, so lets turn them off until we decide how + * to handle this. No other encoders allow uncoupled short blocks, even + * though it is in the standard. + */ + /* + * rh 20040217: coupling makes no sense for mono and dual-mono streams + */ + if (gfp.short_blocks == ShortBlock$2.short_block_allowed + && (gfp.mode == MPEGMode.JOINT_STEREO || gfp.mode == MPEGMode.STEREO)) { + gfp.short_blocks = ShortBlock$2.short_block_coupled; + } + + if (gfp.quant_comp < 0) + gfp.quant_comp = 1; + if (gfp.quant_comp_short < 0) + gfp.quant_comp_short = 0; + + if (gfp.msfix < 0) + gfp.msfix = 0; + + /* select psychoacoustic model */ + gfp.exp_nspsytune = gfp.exp_nspsytune | 1; + + if (gfp.internal_flags.nsPsy.attackthre < 0) + gfp.internal_flags.nsPsy.attackthre = PsyModel_1.NSATTACKTHRE; + if (gfp.internal_flags.nsPsy.attackthre_s < 0) + gfp.internal_flags.nsPsy.attackthre_s = PsyModel_1.NSATTACKTHRE_S; + + assert$2(gfp.scale >= 0); + + if (gfp.scale < 0) + gfp.scale = 1; + + if (gfp.ATHtype < 0) + gfp.ATHtype = 4; + + if (gfp.ATHcurve < 0) + gfp.ATHcurve = 4; + + if (gfp.athaa_loudapprox < 0) + gfp.athaa_loudapprox = 2; + + if (gfp.interChRatio < 0) + gfp.interChRatio = 0; + + if (gfp.useTemporal == null) + gfp.useTemporal = true; + /* on by default */ + + /* + * padding method as described in + * "MPEG-Layer3 / Bitstream Syntax and Decoding" by Martin Sieler, Ralph + * Sperschneider + * + * note: there is no padding for the very first frame + * + * Robert Hegemann 2000-06-22 + */ + gfc.slot_lag = gfc.frac_SpF = 0; + if (gfp.VBR == VbrMode$2.vbr_off) + gfc.slot_lag = gfc.frac_SpF = (((gfp.version + 1) * 72000 * gfp.brate) % gfp.out_samplerate) | 0; + + qupvt.iteration_init(gfp); + psy.psymodel_init(gfp); + assert$2(gfp.scale >= 0); + return 0; + }; + + function update_inbuffer_size(gfc, nsamples) { + if (gfc.in_buffer_0 == null || gfc.in_buffer_nsamples < nsamples) { + gfc.in_buffer_0 = new_float$2(nsamples); + gfc.in_buffer_1 = new_float$2(nsamples); + gfc.in_buffer_nsamples = nsamples; + } + } + + this.lame_encode_flush = function (gfp, mp3buffer, mp3bufferPos, mp3buffer_size) { + var gfc = gfp.internal_flags; + var buffer = new_short_n$1([2, 1152]); + var imp3 = 0, mp3count, mp3buffer_size_remaining; + + /* + * we always add POSTDELAY=288 padding to make sure granule with real + * data can be complety decoded (because of 50% overlap with next + * granule + */ + var end_padding; + var frames_left; + var samples_to_encode = gfc.mf_samples_to_encode - Encoder_1.POSTDELAY; + var mf_needed = calcNeeded(gfp); + + /* Was flush already called? */ + if (gfc.mf_samples_to_encode < 1) { + return 0; + } + mp3count = 0; + + if (gfp.in_samplerate != gfp.out_samplerate) { + /* + * delay due to resampling; needs to be fixed, if resampling code + * gets changed + */ + samples_to_encode += 16. * gfp.out_samplerate / gfp.in_samplerate; + } + end_padding = gfp.framesize - (samples_to_encode % gfp.framesize); + if (end_padding < 576) + end_padding += gfp.framesize; + gfp.encoder_padding = end_padding; + + frames_left = (samples_to_encode + end_padding) / gfp.framesize; + + /* + * send in a frame of 0 padding until all internal sample buffers are + * flushed + */ + while (frames_left > 0 && imp3 >= 0) { + var bunch = mf_needed - gfc.mf_size; + var frame_num = gfp.frameNum; + + bunch *= gfp.in_samplerate; + bunch /= gfp.out_samplerate; + if (bunch > 1152) + bunch = 1152; + if (bunch < 1) + bunch = 1; + + mp3buffer_size_remaining = mp3buffer_size - mp3count; + + /* if user specifed buffer size = 0, dont check size */ + if (mp3buffer_size == 0) + mp3buffer_size_remaining = 0; + + imp3 = this.lame_encode_buffer(gfp, buffer[0], buffer[1], bunch, + mp3buffer, mp3bufferPos, mp3buffer_size_remaining); + + mp3bufferPos += imp3; + mp3count += imp3; + frames_left -= (frame_num != gfp.frameNum) ? 1 : 0; + } + /* + * Set gfc.mf_samples_to_encode to 0, so we may detect and break loops + * calling it more than once in a row. + */ + gfc.mf_samples_to_encode = 0; + + if (imp3 < 0) { + /* some type of fatal error */ + return imp3; + } + + mp3buffer_size_remaining = mp3buffer_size - mp3count; + /* if user specifed buffer size = 0, dont check size */ + if (mp3buffer_size == 0) + mp3buffer_size_remaining = 0; + + /* mp3 related stuff. bit buffer might still contain some mp3 data */ + bs.flush_bitstream(gfp); + imp3 = bs.copy_buffer(gfc, mp3buffer, mp3bufferPos, + mp3buffer_size_remaining, 1); + if (imp3 < 0) { + /* some type of fatal error */ + return imp3; + } + mp3bufferPos += imp3; + mp3count += imp3; + mp3buffer_size_remaining = mp3buffer_size - mp3count; + /* if user specifed buffer size = 0, dont check size */ + if (mp3buffer_size == 0) + mp3buffer_size_remaining = 0; + + if (gfp.write_id3tag_automatic) { + /* write a id3 tag to the bitstream */ + id3.id3tag_write_v1(gfp); + + imp3 = bs.copy_buffer(gfc, mp3buffer, mp3bufferPos, + mp3buffer_size_remaining, 0); + + if (imp3 < 0) { + return imp3; + } + mp3count += imp3; + } + return mp3count; + }; + + this.lame_encode_buffer = function (gfp, buffer_l, buffer_r, nsamples, mp3buf, mp3bufPos, mp3buf_size) { + var gfc = gfp.internal_flags; + var in_buffer = [null, null]; + + if (gfc.Class_ID != LAME_ID) + return -3; + + if (nsamples == 0) + return 0; + + update_inbuffer_size(gfc, nsamples); + + in_buffer[0] = gfc.in_buffer_0; + in_buffer[1] = gfc.in_buffer_1; + + /* make a copy of input buffer, changing type to sample_t */ + for (var i = 0; i < nsamples; i++) { + in_buffer[0][i] = buffer_l[i]; + if (gfc.channels_in > 1) + in_buffer[1][i] = buffer_r[i]; + } + + return lame_encode_buffer_sample(gfp, in_buffer[0], in_buffer[1], + nsamples, mp3buf, mp3bufPos, mp3buf_size); + }; + + function calcNeeded(gfp) { + var mf_needed = Encoder_1.BLKSIZE + gfp.framesize - Encoder_1.FFTOFFSET; + /* + * amount needed for FFT + */ + mf_needed = Math.max(mf_needed, 512 + gfp.framesize - 32); + assert$2(LameInternalFlags_1.MFSIZE >= mf_needed); + + return mf_needed; + } + + function lame_encode_buffer_sample(gfp, buffer_l, buffer_r, nsamples, mp3buf, mp3bufPos, mp3buf_size) { + var gfc = gfp.internal_flags; + var mp3size = 0, ret, i, ch, mf_needed; + var mp3out; + var mfbuf = [null, null]; + var in_buffer = [null, null]; + + if (gfc.Class_ID != LAME_ID) + return -3; + + if (nsamples == 0) + return 0; + + /* copy out any tags that may have been written into bitstream */ + mp3out = bs.copy_buffer(gfc, mp3buf, mp3bufPos, mp3buf_size, 0); + if (mp3out < 0) + return mp3out; + /* not enough buffer space */ + mp3bufPos += mp3out; + mp3size += mp3out; + + in_buffer[0] = buffer_l; + in_buffer[1] = buffer_r; + + /* Apply user defined re-scaling */ + + /* user selected scaling of the samples */ + if (BitStream_1.NEQ(gfp.scale, 0) && BitStream_1.NEQ(gfp.scale, 1.0)) { + for (i = 0; i < nsamples; ++i) { + in_buffer[0][i] *= gfp.scale; + if (gfc.channels_out == 2) + in_buffer[1][i] *= gfp.scale; + } + } + + /* user selected scaling of the channel 0 (left) samples */ + if (BitStream_1.NEQ(gfp.scale_left, 0) + && BitStream_1.NEQ(gfp.scale_left, 1.0)) { + for (i = 0; i < nsamples; ++i) { + in_buffer[0][i] *= gfp.scale_left; + } + } + + /* user selected scaling of the channel 1 (right) samples */ + if (BitStream_1.NEQ(gfp.scale_right, 0) + && BitStream_1.NEQ(gfp.scale_right, 1.0)) { + for (i = 0; i < nsamples; ++i) { + in_buffer[1][i] *= gfp.scale_right; + } + } + + /* Downsample to Mono if 2 channels in and 1 channel out */ + if (gfp.num_channels == 2 && gfc.channels_out == 1) { + for (i = 0; i < nsamples; ++i) { + in_buffer[0][i] = 0.5 * ( in_buffer[0][i] + in_buffer[1][i]); + in_buffer[1][i] = 0.0; + } + } + + mf_needed = calcNeeded(gfp); + + mfbuf[0] = gfc.mfbuf[0]; + mfbuf[1] = gfc.mfbuf[1]; + + var in_bufferPos = 0; + while (nsamples > 0) { + var in_buffer_ptr = [null, null]; + var n_in = 0; + /* number of input samples processed with fill_buffer */ + var n_out = 0; + /* number of samples output with fill_buffer */ + /* n_in <> n_out if we are resampling */ + + in_buffer_ptr[0] = in_buffer[0]; + in_buffer_ptr[1] = in_buffer[1]; + /* copy in new samples into mfbuf, with resampling */ + var inOut = new InOut(); + fill_buffer(gfp, mfbuf, in_buffer_ptr, in_bufferPos, nsamples, + inOut); + n_in = inOut.n_in; + n_out = inOut.n_out; + + /* compute ReplayGain of resampled input if requested */ + if (gfc.findReplayGain && !gfc.decode_on_the_fly) + if (ga.AnalyzeSamples(gfc.rgdata, mfbuf[0], gfc.mf_size, + mfbuf[1], gfc.mf_size, n_out, gfc.channels_out) == GainAnalysis.GAIN_ANALYSIS_ERROR) + return -6; + + /* update in_buffer counters */ + nsamples -= n_in; + in_bufferPos += n_in; + if (gfc.channels_out == 2) + ;// in_bufferPos += n_in; + + /* update mfbuf[] counters */ + gfc.mf_size += n_out; + assert$2(gfc.mf_size <= LameInternalFlags_1.MFSIZE); + + /* + * lame_encode_flush may have set gfc.mf_sample_to_encode to 0 so we + * have to reinitialize it here when that happened. + */ + if (gfc.mf_samples_to_encode < 1) { + gfc.mf_samples_to_encode = Encoder_1.ENCDELAY + Encoder_1.POSTDELAY; + } + gfc.mf_samples_to_encode += n_out; + + if (gfc.mf_size >= mf_needed) { + /* encode the frame. */ + /* mp3buf = pointer to current location in buffer */ + /* mp3buf_size = size of original mp3 output buffer */ + /* = 0 if we should not worry about the */ + /* buffer size because calling program is */ + /* to lazy to compute it */ + /* mp3size = size of data written to buffer so far */ + /* mp3buf_size-mp3size = amount of space avalable */ + + var buf_size = mp3buf_size - mp3size; + if (mp3buf_size == 0) + buf_size = 0; + + ret = lame_encode_frame(gfp, mfbuf[0], mfbuf[1], mp3buf, + mp3bufPos, buf_size); + + if (ret < 0) + return ret; + mp3bufPos += ret; + mp3size += ret; + + /* shift out old samples */ + gfc.mf_size -= gfp.framesize; + gfc.mf_samples_to_encode -= gfp.framesize; + for (ch = 0; ch < gfc.channels_out; ch++) + for (i = 0; i < gfc.mf_size; i++) + mfbuf[ch][i] = mfbuf[ch][i + gfp.framesize]; + } + } + assert$2(nsamples == 0); + + return mp3size; + } + + function lame_encode_frame(gfp, inbuf_l, inbuf_r, mp3buf, mp3bufPos, mp3buf_size) { + var ret = self.enc.lame_encode_mp3_frame(gfp, inbuf_l, inbuf_r, mp3buf, + mp3bufPos, mp3buf_size); + gfp.frameNum++; + return ret; + } + + function InOut() { + this.n_in = 0; + this.n_out = 0; + } + + + function NumUsed() { + this.num_used = 0; + } + + /** + * Greatest common divisor. + *
+ * Joint work of Euclid and M. Hendry + */ + function gcd(i, j) { + return j != 0 ? gcd(j, i % j) : i; + } + + /** + * Resampling via FIR filter, blackman window. + */ + function blackman(x, fcn, l) { + /* + * This algorithm from: SIGNAL PROCESSING ALGORITHMS IN FORTRAN AND C + * S.D. Stearns and R.A. David, Prentice-Hall, 1992 + */ + var wcn = (Math.PI * fcn); + + x /= l; + if (x < 0) + x = 0; + if (x > 1) + x = 1; + var x2 = x - .5; + + var bkwn = 0.42 - 0.5 * Math.cos(2 * x * Math.PI) + 0.08 * Math.cos(4 * x * Math.PI); + if (Math.abs(x2) < 1e-9) + return (wcn / Math.PI); + else + return (bkwn * Math.sin(l * wcn * x2) / (Math.PI * l * x2)); + } + + function fill_buffer_resample(gfp, outbuf, outbufPos, desired_len, inbuf, in_bufferPos, len, num_used, ch) { + var gfc = gfp.internal_flags; + var i, j = 0, k; + /* number of convolution functions to pre-compute */ + var bpc = gfp.out_samplerate + / gcd(gfp.out_samplerate, gfp.in_samplerate); + if (bpc > LameInternalFlags_1.BPC) + bpc = LameInternalFlags_1.BPC; + + var intratio = (Math.abs(gfc.resample_ratio + - Math.floor(.5 + gfc.resample_ratio)) < .0001) ? 1 : 0; + var fcn = 1.00 / gfc.resample_ratio; + if (fcn > 1.00) + fcn = 1.00; + var filter_l = 31; + if (0 == filter_l % 2) + --filter_l; + /* must be odd */ + filter_l += intratio; + /* unless resample_ratio=int, it must be even */ + + var BLACKSIZE = filter_l + 1; + /* size of data needed for FIR */ + + if (gfc.fill_buffer_resample_init == 0) { + gfc.inbuf_old[0] = new_float$2(BLACKSIZE); + gfc.inbuf_old[1] = new_float$2(BLACKSIZE); + for (i = 0; i <= 2 * bpc; ++i) + gfc.blackfilt[i] = new_float$2(BLACKSIZE); + + gfc.itime[0] = 0; + gfc.itime[1] = 0; + + /* precompute blackman filter coefficients */ + for (j = 0; j <= 2 * bpc; j++) { + var sum = 0.; + var offset = (j - bpc) / (2. * bpc); + for (i = 0; i <= filter_l; i++) + sum += gfc.blackfilt[j][i] = blackman(i - offset, fcn, + filter_l); + for (i = 0; i <= filter_l; i++) + gfc.blackfilt[j][i] /= sum; + } + gfc.fill_buffer_resample_init = 1; + } + + var inbuf_old = gfc.inbuf_old[ch]; + + /* time of j'th element in inbuf = itime + j/ifreq; */ + /* time of k'th element in outbuf = j/ofreq */ + for (k = 0; k < desired_len; k++) { + var time0; + var joff; + + time0 = k * gfc.resample_ratio; + /* time of k'th output sample */ + j = 0 | Math.floor(time0 - gfc.itime[ch]); + + /* check if we need more input data */ + if ((filter_l + j - filter_l / 2) >= len) + break; + + /* blackman filter. by default, window centered at j+.5(filter_l%2) */ + /* but we want a window centered at time0. */ + var offset = (time0 - gfc.itime[ch] - (j + .5 * (filter_l % 2))); + assert$2(Math.abs(offset) <= .501); + + /* find the closest precomputed window for this offset: */ + joff = 0 | Math.floor((offset * 2 * bpc) + bpc + .5); + var xvalue = 0.; + for (i = 0; i <= filter_l; ++i) { + var j2 = i + j - filter_l / 2; + var y; + assert$2(j2 < len); + assert$2(j2 + BLACKSIZE >= 0); + y = (j2 < 0) ? inbuf_old[BLACKSIZE + j2] : inbuf[in_bufferPos + + j2]; + xvalue += y * gfc.blackfilt[joff][i]; + } + outbuf[outbufPos + k] = xvalue; + } + + /* k = number of samples added to outbuf */ + /* last k sample used data from [j-filter_l/2,j+filter_l-filter_l/2] */ + + /* how many samples of input data were used: */ + num_used.num_used = Math.min(len, filter_l + j - filter_l / 2); + + /* + * adjust our input time counter. Incriment by the number of samples + * used, then normalize so that next output sample is at time 0, next + * input buffer is at time itime[ch] + */ + gfc.itime[ch] += num_used.num_used - k * gfc.resample_ratio; + + /* save the last BLACKSIZE samples into the inbuf_old buffer */ + if (num_used.num_used >= BLACKSIZE) { + for (i = 0; i < BLACKSIZE; i++) + inbuf_old[i] = inbuf[in_bufferPos + num_used.num_used + i + - BLACKSIZE]; + } else { + /* shift in num_used.num_used samples into inbuf_old */ + var n_shift = BLACKSIZE - num_used.num_used; + /* + * number of samples to + * shift + */ + + /* + * shift n_shift samples by num_used.num_used, to make room for the + * num_used new samples + */ + for (i = 0; i < n_shift; ++i) + inbuf_old[i] = inbuf_old[i + num_used.num_used]; + + /* shift in the num_used.num_used samples */ + for (j = 0; i < BLACKSIZE; ++i, ++j) + inbuf_old[i] = inbuf[in_bufferPos + j]; + + assert$2(j == num_used.num_used); + } + return k; + /* return the number samples created at the new samplerate */ + } + + function fill_buffer(gfp, mfbuf, in_buffer, in_bufferPos, nsamples, io) { + var gfc = gfp.internal_flags; + + /* copy in new samples into mfbuf, with resampling if necessary */ + if ((gfc.resample_ratio < .9999) || (gfc.resample_ratio > 1.0001)) { + for (var ch = 0; ch < gfc.channels_out; ch++) { + var numUsed = new NumUsed(); + io.n_out = fill_buffer_resample(gfp, mfbuf[ch], gfc.mf_size, + gfp.framesize, in_buffer[ch], in_bufferPos, nsamples, + numUsed, ch); + io.n_in = numUsed.num_used; + } + } else { + io.n_out = Math.min(gfp.framesize, nsamples); + io.n_in = io.n_out; + for (var i = 0; i < io.n_out; ++i) { + mfbuf[0][gfc.mf_size + i] = in_buffer[0][in_bufferPos + i]; + if (gfc.channels_out == 2) + mfbuf[1][gfc.mf_size + i] = in_buffer[1][in_bufferPos + i]; + } + } + } + +} + +var Lame_1 = Lame$1; + +var VbrMode$20 = common.VbrMode; +function Presets$1() { + function VBRPresets(qual, comp, compS, + y, shThreshold, shThresholdS, + adj, adjShort, lower, + curve, sens, inter, + joint, mod, fix) { + this.vbr_q = qual; + this.quant_comp = comp; + this.quant_comp_s = compS; + this.expY = y; + this.st_lrm = shThreshold; + this.st_s = shThresholdS; + this.masking_adj = adj; + this.masking_adj_short = adjShort; + this.ath_lower = lower; + this.ath_curve = curve; + this.ath_sensitivity = sens; + this.interch = inter; + this.safejoint = joint; + this.sfb21mod = mod; + this.msfix = fix; + } + + function ABRPresets(kbps, comp, compS, + joint, fix, shThreshold, + shThresholdS, bass, sc, + mask, lower, curve, + interCh, sfScale) { + this.quant_comp = comp; + this.quant_comp_s = compS; + this.safejoint = joint; + this.nsmsfix = fix; + this.st_lrm = shThreshold; + this.st_s = shThresholdS; + this.nsbass = bass; + this.scale = sc; + this.masking_adj = mask; + this.ath_lower = lower; + this.ath_curve = curve; + this.interch = interCh; + this.sfscale = sfScale; + } + + var lame; + + this.setModules = function (_lame) { + lame = _lame; + }; + + /** + *
+ * Switch mappings for VBR mode VBR_RH + * vbr_q qcomp_l qcomp_s expY st_lrm st_s mask adj_l adj_s ath_lower ath_curve ath_sens interChR safejoint sfb21mod msfix + *+ */ + var vbr_old_switch_map = [ + new VBRPresets(0, 9, 9, 0, 5.20, 125.0, -4.2, -6.3, 4.8, 1, 0, 0, 2, 21, 0.97), + new VBRPresets(1, 9, 9, 0, 5.30, 125.0, -3.6, -5.6, 4.5, 1.5, 0, 0, 2, 21, 1.35), + new VBRPresets(2, 9, 9, 0, 5.60, 125.0, -2.2, -3.5, 2.8, 2, 0, 0, 2, 21, 1.49), + new VBRPresets(3, 9, 9, 1, 5.80, 130.0, -1.8, -2.8, 2.6, 3, -4, 0, 2, 20, 1.64), + new VBRPresets(4, 9, 9, 1, 6.00, 135.0, -0.7, -1.1, 1.1, 3.5, -8, 0, 2, 0, 1.79), + new VBRPresets(5, 9, 9, 1, 6.40, 140.0, 0.5, 0.4, -7.5, 4, -12, 0.0002, 0, 0, 1.95), + new VBRPresets(6, 9, 9, 1, 6.60, 145.0, 0.67, 0.65, -14.7, 6.5, -19, 0.0004, 0, 0, 2.30), + new VBRPresets(7, 9, 9, 1, 6.60, 145.0, 0.8, 0.75, -19.7, 8, -22, 0.0006, 0, 0, 2.70), + new VBRPresets(8, 9, 9, 1, 6.60, 145.0, 1.2, 1.15, -27.5, 10, -23, 0.0007, 0, 0, 0), + new VBRPresets(9, 9, 9, 1, 6.60, 145.0, 1.6, 1.6, -36, 11, -25, 0.0008, 0, 0, 0), + new VBRPresets(10, 9, 9, 1, 6.60, 145.0, 2.0, 2.0, -36, 12, -25, 0.0008, 0, 0, 0) + ]; + + /** + *
+ * vbr_q qcomp_l qcomp_s expY st_lrm st_s mask adj_l adj_s ath_lower ath_curve ath_sens interChR safejoint sfb21mod msfix + *+ */ + var vbr_psy_switch_map = [ + new VBRPresets(0, 9, 9, 0, 4.20, 25.0, -7.0, -4.0, 7.5, 1, 0, 0, 2, 26, 0.97), + new VBRPresets(1, 9, 9, 0, 4.20, 25.0, -5.6, -3.6, 4.5, 1.5, 0, 0, 2, 21, 1.35), + new VBRPresets(2, 9, 9, 0, 4.20, 25.0, -4.4, -1.8, 2, 2, 0, 0, 2, 18, 1.49), + new VBRPresets(3, 9, 9, 1, 4.20, 25.0, -3.4, -1.25, 1.1, 3, -4, 0, 2, 15, 1.64), + new VBRPresets(4, 9, 9, 1, 4.20, 25.0, -2.2, 0.1, 0, 3.5, -8, 0, 2, 0, 1.79), + new VBRPresets(5, 9, 9, 1, 4.20, 25.0, -1.0, 1.65, -7.7, 4, -12, 0.0002, 0, 0, 1.95), + new VBRPresets(6, 9, 9, 1, 4.20, 25.0, -0.0, 2.47, -7.7, 6.5, -19, 0.0004, 0, 0, 2), + new VBRPresets(7, 9, 9, 1, 4.20, 25.0, 0.5, 2.0, -14.5, 8, -22, 0.0006, 0, 0, 2), + new VBRPresets(8, 9, 9, 1, 4.20, 25.0, 1.0, 2.4, -22.0, 10, -23, 0.0007, 0, 0, 2), + new VBRPresets(9, 9, 9, 1, 4.20, 25.0, 1.5, 2.95, -30.0, 11, -25, 0.0008, 0, 0, 2), + new VBRPresets(10, 9, 9, 1, 4.20, 25.0, 2.0, 2.95, -36.0, 12, -30, 0.0008, 0, 0, 2) + ]; + + function apply_vbr_preset(gfp, a, enforce) { + var vbr_preset = gfp.VBR == VbrMode$20.vbr_rh ? vbr_old_switch_map + : vbr_psy_switch_map; + + var x = gfp.VBR_q_frac; + var p = vbr_preset[a]; + var q = vbr_preset[a + 1]; + var set = p; + + // NOOP(vbr_q); + // NOOP(quant_comp); + // NOOP(quant_comp_s); + // NOOP(expY); + p.st_lrm = p.st_lrm + x * (q.st_lrm - p.st_lrm); + // LERP(st_lrm); + p.st_s = p.st_s + x * (q.st_s - p.st_s); + // LERP(st_s); + p.masking_adj = p.masking_adj + x * (q.masking_adj - p.masking_adj); + // LERP(masking_adj); + p.masking_adj_short = p.masking_adj_short + x + * (q.masking_adj_short - p.masking_adj_short); + // LERP(masking_adj_short); + p.ath_lower = p.ath_lower + x * (q.ath_lower - p.ath_lower); + // LERP(ath_lower); + p.ath_curve = p.ath_curve + x * (q.ath_curve - p.ath_curve); + // LERP(ath_curve); + p.ath_sensitivity = p.ath_sensitivity + x + * (q.ath_sensitivity - p.ath_sensitivity); + // LERP(ath_sensitivity); + p.interch = p.interch + x * (q.interch - p.interch); + // LERP(interch); + // NOOP(safejoint); + // NOOP(sfb21mod); + p.msfix = p.msfix + x * (q.msfix - p.msfix); + // LERP(msfix); + + lame_set_VBR_q(gfp, set.vbr_q); + + if (enforce != 0) + gfp.quant_comp = set.quant_comp; + else if (!(Math.abs(gfp.quant_comp - -1) > 0)) + gfp.quant_comp = set.quant_comp; + // SET_OPTION(quant_comp, set.quant_comp, -1); + if (enforce != 0) + gfp.quant_comp_short = set.quant_comp_s; + else if (!(Math.abs(gfp.quant_comp_short - -1) > 0)) + gfp.quant_comp_short = set.quant_comp_s; + // SET_OPTION(quant_comp_short, set.quant_comp_s, -1); + if (set.expY != 0) { + gfp.experimentalY = set.expY != 0; + } + if (enforce != 0) + gfp.internal_flags.nsPsy.attackthre = set.st_lrm; + else if (!(Math.abs(gfp.internal_flags.nsPsy.attackthre - -1) > 0)) + gfp.internal_flags.nsPsy.attackthre = set.st_lrm; + // SET_OPTION(short_threshold_lrm, set.st_lrm, -1); + if (enforce != 0) + gfp.internal_flags.nsPsy.attackthre_s = set.st_s; + else if (!(Math.abs(gfp.internal_flags.nsPsy.attackthre_s - -1) > 0)) + gfp.internal_flags.nsPsy.attackthre_s = set.st_s; + // SET_OPTION(short_threshold_s, set.st_s, -1); + if (enforce != 0) + gfp.maskingadjust = set.masking_adj; + else if (!(Math.abs(gfp.maskingadjust - 0) > 0)) + gfp.maskingadjust = set.masking_adj; + // SET_OPTION(maskingadjust, set.masking_adj, 0); + if (enforce != 0) + gfp.maskingadjust_short = set.masking_adj_short; + else if (!(Math.abs(gfp.maskingadjust_short - 0) > 0)) + gfp.maskingadjust_short = set.masking_adj_short; + // SET_OPTION(maskingadjust_short, set.masking_adj_short, 0); + if (enforce != 0) + gfp.ATHlower = -set.ath_lower / 10.0; + else if (!(Math.abs((-gfp.ATHlower * 10.0) - 0) > 0)) + gfp.ATHlower = -set.ath_lower / 10.0; + // SET_OPTION(ATHlower, set.ath_lower, 0); + if (enforce != 0) + gfp.ATHcurve = set.ath_curve; + else if (!(Math.abs(gfp.ATHcurve - -1) > 0)) + gfp.ATHcurve = set.ath_curve; + // SET_OPTION(ATHcurve, set.ath_curve, -1); + if (enforce != 0) + gfp.athaa_sensitivity = set.ath_sensitivity; + else if (!(Math.abs(gfp.athaa_sensitivity - -1) > 0)) + gfp.athaa_sensitivity = set.ath_sensitivity; + // SET_OPTION(athaa_sensitivity, set.ath_sensitivity, 0); + if (set.interch > 0) { + if (enforce != 0) + gfp.interChRatio = set.interch; + else if (!(Math.abs(gfp.interChRatio - -1) > 0)) + gfp.interChRatio = set.interch; + // SET_OPTION(interChRatio, set.interch, -1); + } + + /* parameters for which there is no proper set/get interface */ + if (set.safejoint > 0) { + gfp.exp_nspsytune = gfp.exp_nspsytune | set.safejoint; + } + if (set.sfb21mod > 0) { + gfp.exp_nspsytune = gfp.exp_nspsytune | (set.sfb21mod << 20); + } + if (enforce != 0) + gfp.msfix = set.msfix; + else if (!(Math.abs(gfp.msfix - -1) > 0)) + gfp.msfix = set.msfix; + // SET_OPTION(msfix, set.msfix, -1); + + if (enforce == 0) { + gfp.VBR_q = a; + gfp.VBR_q_frac = x; + } + } + + /** + *
+ * Switch mappings for ABR mode + * + * kbps quant q_s safejoint nsmsfix st_lrm st_s ns-bass scale msk ath_lwr ath_curve interch , sfscale + *+ */ + var abr_switch_map = [ + new ABRPresets(8, 9, 9, 0, 0, 6.60, 145, 0, 0.95, 0, -30.0, 11, 0.0012, 1), /* 8, impossible to use in stereo */ + new ABRPresets(16, 9, 9, 0, 0, 6.60, 145, 0, 0.95, 0, -25.0, 11, 0.0010, 1), /* 16 */ + new ABRPresets(24, 9, 9, 0, 0, 6.60, 145, 0, 0.95, 0, -20.0, 11, 0.0010, 1), /* 24 */ + new ABRPresets(32, 9, 9, 0, 0, 6.60, 145, 0, 0.95, 0, -15.0, 11, 0.0010, 1), /* 32 */ + new ABRPresets(40, 9, 9, 0, 0, 6.60, 145, 0, 0.95, 0, -10.0, 11, 0.0009, 1), /* 40 */ + new ABRPresets(48, 9, 9, 0, 0, 6.60, 145, 0, 0.95, 0, -10.0, 11, 0.0009, 1), /* 48 */ + new ABRPresets(56, 9, 9, 0, 0, 6.60, 145, 0, 0.95, 0, -6.0, 11, 0.0008, 1), /* 56 */ + new ABRPresets(64, 9, 9, 0, 0, 6.60, 145, 0, 0.95, 0, -2.0, 11, 0.0008, 1), /* 64 */ + new ABRPresets(80, 9, 9, 0, 0, 6.60, 145, 0, 0.95, 0, .0, 8, 0.0007, 1), /* 80 */ + new ABRPresets(96, 9, 9, 0, 2.50, 6.60, 145, 0, 0.95, 0, 1.0, 5.5, 0.0006, 1), /* 96 */ + new ABRPresets(112, 9, 9, 0, 2.25, 6.60, 145, 0, 0.95, 0, 2.0, 4.5, 0.0005, 1), /* 112 */ + new ABRPresets(128, 9, 9, 0, 1.95, 6.40, 140, 0, 0.95, 0, 3.0, 4, 0.0002, 1), /* 128 */ + new ABRPresets(160, 9, 9, 1, 1.79, 6.00, 135, 0, 0.95, -2, 5.0, 3.5, 0, 1), /* 160 */ + new ABRPresets(192, 9, 9, 1, 1.49, 5.60, 125, 0, 0.97, -4, 7.0, 3, 0, 0), /* 192 */ + new ABRPresets(224, 9, 9, 1, 1.25, 5.20, 125, 0, 0.98, -6, 9.0, 2, 0, 0), /* 224 */ + new ABRPresets(256, 9, 9, 1, 0.97, 5.20, 125, 0, 1.00, -8, 10.0, 1, 0, 0), /* 256 */ + new ABRPresets(320, 9, 9, 1, 0.90, 5.20, 125, 0, 1.00, -10, 12.0, 0, 0, 0) /* 320 */ + ]; + + function apply_abr_preset(gfp, preset, enforce) { + /* Variables for the ABR stuff */ + var actual_bitrate = preset; + + var r = lame.nearestBitrateFullIndex(preset); + + gfp.VBR = VbrMode$20.vbr_abr; + gfp.VBR_mean_bitrate_kbps = actual_bitrate; + gfp.VBR_mean_bitrate_kbps = Math.min(gfp.VBR_mean_bitrate_kbps, 320); + gfp.VBR_mean_bitrate_kbps = Math.max(gfp.VBR_mean_bitrate_kbps, 8); + gfp.brate = gfp.VBR_mean_bitrate_kbps; + if (gfp.VBR_mean_bitrate_kbps > 320) { + gfp.disable_reservoir = true; + } + + /* parameters for which there is no proper set/get interface */ + if (abr_switch_map[r].safejoint > 0) + gfp.exp_nspsytune = gfp.exp_nspsytune | 2; + /* safejoint */ + + if (abr_switch_map[r].sfscale > 0) { + gfp.internal_flags.noise_shaping = 2; + } + /* ns-bass tweaks */ + if (Math.abs(abr_switch_map[r].nsbass) > 0) { + var k = (int)(abr_switch_map[r].nsbass * 4); + if (k < 0) + k += 64; + gfp.exp_nspsytune = gfp.exp_nspsytune | (k << 2); + } + + if (enforce != 0) + gfp.quant_comp = abr_switch_map[r].quant_comp; + else if (!(Math.abs(gfp.quant_comp - -1) > 0)) + gfp.quant_comp = abr_switch_map[r].quant_comp; + // SET_OPTION(quant_comp, abr_switch_map[r].quant_comp, -1); + if (enforce != 0) + gfp.quant_comp_short = abr_switch_map[r].quant_comp_s; + else if (!(Math.abs(gfp.quant_comp_short - -1) > 0)) + gfp.quant_comp_short = abr_switch_map[r].quant_comp_s; + // SET_OPTION(quant_comp_short, abr_switch_map[r].quant_comp_s, -1); + + if (enforce != 0) + gfp.msfix = abr_switch_map[r].nsmsfix; + else if (!(Math.abs(gfp.msfix - -1) > 0)) + gfp.msfix = abr_switch_map[r].nsmsfix; + // SET_OPTION(msfix, abr_switch_map[r].nsmsfix, -1); + + if (enforce != 0) + gfp.internal_flags.nsPsy.attackthre = abr_switch_map[r].st_lrm; + else if (!(Math.abs(gfp.internal_flags.nsPsy.attackthre - -1) > 0)) + gfp.internal_flags.nsPsy.attackthre = abr_switch_map[r].st_lrm; + // SET_OPTION(short_threshold_lrm, abr_switch_map[r].st_lrm, -1); + if (enforce != 0) + gfp.internal_flags.nsPsy.attackthre_s = abr_switch_map[r].st_s; + else if (!(Math.abs(gfp.internal_flags.nsPsy.attackthre_s - -1) > 0)) + gfp.internal_flags.nsPsy.attackthre_s = abr_switch_map[r].st_s; + // SET_OPTION(short_threshold_s, abr_switch_map[r].st_s, -1); + + /* + * ABR seems to have big problems with clipping, especially at low + * bitrates + */ + /* + * so we compensate for that here by using a scale value depending on + * bitrate + */ + if (enforce != 0) + gfp.scale = abr_switch_map[r].scale; + else if (!(Math.abs(gfp.scale - -1) > 0)) + gfp.scale = abr_switch_map[r].scale; + // SET_OPTION(scale, abr_switch_map[r].scale, -1); + + if (enforce != 0) + gfp.maskingadjust = abr_switch_map[r].masking_adj; + else if (!(Math.abs(gfp.maskingadjust - 0) > 0)) + gfp.maskingadjust = abr_switch_map[r].masking_adj; + // SET_OPTION(maskingadjust, abr_switch_map[r].masking_adj, 0); + if (abr_switch_map[r].masking_adj > 0) { + if (enforce != 0) + gfp.maskingadjust_short = (abr_switch_map[r].masking_adj * .9); + else if (!(Math.abs(gfp.maskingadjust_short - 0) > 0)) + gfp.maskingadjust_short = (abr_switch_map[r].masking_adj * .9); + // SET_OPTION(maskingadjust_short, abr_switch_map[r].masking_adj * + // .9, 0); + } else { + if (enforce != 0) + gfp.maskingadjust_short = (abr_switch_map[r].masking_adj * 1.1); + else if (!(Math.abs(gfp.maskingadjust_short - 0) > 0)) + gfp.maskingadjust_short = (abr_switch_map[r].masking_adj * 1.1); + // SET_OPTION(maskingadjust_short, abr_switch_map[r].masking_adj * + // 1.1, 0); + } + + if (enforce != 0) + gfp.ATHlower = -abr_switch_map[r].ath_lower / 10.; + else if (!(Math.abs((-gfp.ATHlower * 10.) - 0) > 0)) + gfp.ATHlower = -abr_switch_map[r].ath_lower / 10.; + // SET_OPTION(ATHlower, abr_switch_map[r].ath_lower, 0); + if (enforce != 0) + gfp.ATHcurve = abr_switch_map[r].ath_curve; + else if (!(Math.abs(gfp.ATHcurve - -1) > 0)) + gfp.ATHcurve = abr_switch_map[r].ath_curve; + // SET_OPTION(ATHcurve, abr_switch_map[r].ath_curve, -1); + + if (enforce != 0) + gfp.interChRatio = abr_switch_map[r].interch; + else if (!(Math.abs(gfp.interChRatio - -1) > 0)) + gfp.interChRatio = abr_switch_map[r].interch; + // SET_OPTION(interChRatio, abr_switch_map[r].interch, -1); + + return preset; + } + + this.apply_preset = function(gfp, preset, enforce) { + /* translate legacy presets */ + switch (preset) { + case Lame.R3MIX: + { + preset = Lame.V3; + gfp.VBR = VbrMode$20.vbr_mtrh; + break; + } + case Lame.MEDIUM: + { + preset = Lame.V4; + gfp.VBR = VbrMode$20.vbr_rh; + break; + } + case Lame.MEDIUM_FAST: + { + preset = Lame.V4; + gfp.VBR = VbrMode$20.vbr_mtrh; + break; + } + case Lame.STANDARD: + { + preset = Lame.V2; + gfp.VBR = VbrMode$20.vbr_rh; + break; + } + case Lame.STANDARD_FAST: + { + preset = Lame.V2; + gfp.VBR = VbrMode$20.vbr_mtrh; + break; + } + case Lame.EXTREME: + { + preset = Lame.V0; + gfp.VBR = VbrMode$20.vbr_rh; + break; + } + case Lame.EXTREME_FAST: + { + preset = Lame.V0; + gfp.VBR = VbrMode$20.vbr_mtrh; + break; + } + case Lame.INSANE: + { + preset = 320; + gfp.preset = preset; + apply_abr_preset(gfp, preset, enforce); + gfp.VBR = VbrMode$20.vbr_off; + return preset; + } + } + + gfp.preset = preset; + { + switch (preset) { + case Lame.V9: + apply_vbr_preset(gfp, 9, enforce); + return preset; + case Lame.V8: + apply_vbr_preset(gfp, 8, enforce); + return preset; + case Lame.V7: + apply_vbr_preset(gfp, 7, enforce); + return preset; + case Lame.V6: + apply_vbr_preset(gfp, 6, enforce); + return preset; + case Lame.V5: + apply_vbr_preset(gfp, 5, enforce); + return preset; + case Lame.V4: + apply_vbr_preset(gfp, 4, enforce); + return preset; + case Lame.V3: + apply_vbr_preset(gfp, 3, enforce); + return preset; + case Lame.V2: + apply_vbr_preset(gfp, 2, enforce); + return preset; + case Lame.V1: + apply_vbr_preset(gfp, 1, enforce); + return preset; + case Lame.V0: + apply_vbr_preset(gfp, 0, enforce); + return preset; + default: + break; + } + } + if (8 <= preset && preset <= 320) { + return apply_abr_preset(gfp, preset, enforce); + } + + /* no corresponding preset found */ + gfp.preset = 0; + return preset; + }; + + // Rest from getset.c: + + /** + * VBR quality level.
+ * 0 = highest
+ * 9 = lowest + */ + function lame_set_VBR_q(gfp, VBR_q) { + var ret = 0; + + if (0 > VBR_q) { + /* Unknown VBR quality level! */ + ret = -1; + VBR_q = 0; + } + if (9 < VBR_q) { + ret = -1; + VBR_q = 9; + } + + gfp.VBR_q = VBR_q; + gfp.VBR_q_frac = 0; + return ret; + } + +} + +var Presets_1 = Presets$1; + +function VBRQuantize() { + var qupvt; + var tak; + + this.setModules = function (_qupvt, _tk) { + qupvt = _qupvt; + tak = _tk; + }; + //TODO + +} + +var VBRQuantize_1 = VBRQuantize; + +//package mp3; + +function CalcNoiseResult$1() { + /** + * sum of quantization noise > masking + */ + this.over_noise = 0.; + /** + * sum of all quantization noise + */ + this.tot_noise = 0.; + /** + * max quantization noise + */ + this.max_noise = 0.; + /** + * number of quantization noise > masking + */ + this.over_count = 0; + /** + * SSD-like cost of distorted bands + */ + this.over_SSD = 0; + this.bits = 0; +} + +var CalcNoiseResult_1 = CalcNoiseResult$1; + +var new_float$22 = common.new_float; +var new_int$22 = common.new_int; +function CalcNoiseData() { + this.global_gain = 0; + this.sfb_count1 = 0; + this.step = new_int$22(39); + this.noise = new_float$22(39); + this.noise_log = new_float$22(39); +} + +var CalcNoiseData_1 = CalcNoiseData; + +/* + * MP3 quantization + * + * Copyright (c) 1999-2000 Mark Taylor + * Copyright (c) 1999-2003 Takehiro Tominaga + * Copyright (c) 2000-2007 Robert Hegemann + * Copyright (c) 2001-2005 Gabriel Bouvigne + * + * 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: Quantize.java,v 1.24 2011/05/24 20:48:06 kenchis Exp $ */ + +//package mp3; + +//import java.util.Arrays; + +var System$21 = common.System; +var VbrMode$21 = common.VbrMode; +var Util$21 = common.Util; +var Arrays$21 = common.Arrays; +var new_float$21 = common.new_float; +var assert$21 = common.assert; + + + + + + + + +function Quantize$1() { + var bs; + this.rv = null; + var rv; + this.qupvt = null; + var qupvt; + + var vbr = new VBRQuantize_1(); + var tk; + + this.setModules = function (_bs, _rv, _qupvt, _tk) { + bs = _bs; + rv = _rv; + this.rv = _rv; + qupvt = _qupvt; + this.qupvt = _qupvt; + tk = _tk; + vbr.setModules(qupvt, tk); + }; + + /** + * convert from L/R <. Mid/Side + */ + this.ms_convert = function (l3_side, gr) { + for (var i = 0; i < 576; ++i) { + var l = l3_side.tt[gr][0].xr[i]; + var r = l3_side.tt[gr][1].xr[i]; + l3_side.tt[gr][0].xr[i] = (l + r) * (Util$21.SQRT2 * 0.5); + l3_side.tt[gr][1].xr[i] = (l - r) * (Util$21.SQRT2 * 0.5); + } + }; + + /** + * mt 6/99 + * + * initializes cod_info, scalefac and xrpow + * + * returns 0 if all energies in xr are zero, else 1 + */ + function init_xrpow_core(cod_info, xrpow, upper, sum) { + sum = 0; + for (var i = 0; i <= upper; ++i) { + var tmp = Math.abs(cod_info.xr[i]); + sum += tmp; + xrpow[i] = Math.sqrt(tmp * Math.sqrt(tmp)); + + if (xrpow[i] > cod_info.xrpow_max) + cod_info.xrpow_max = xrpow[i]; + } + return sum; + } + + this.init_xrpow = function (gfc, cod_info, xrpow) { + var sum = 0; + var upper = 0 | cod_info.max_nonzero_coeff; + + assert$21(xrpow != null); + cod_info.xrpow_max = 0; + + /* + * check if there is some energy we have to quantize and calculate xrpow + * matching our fresh scalefactors + */ + assert$21(0 <= upper && upper <= 575); + + Arrays$21.fill(xrpow, upper, 576, 0); + + sum = init_xrpow_core(cod_info, xrpow, upper, sum); + + /* + * return 1 if we have something to quantize, else 0 + */ + if (sum > 1E-20) { + var j = 0; + if ((gfc.substep_shaping & 2) != 0) + j = 1; + + for (var i = 0; i < cod_info.psymax; i++) + gfc.pseudohalf[i] = j; + + return true; + } + + Arrays$21.fill(cod_info.l3_enc, 0, 576, 0); + return false; + }; + + /** + * Gabriel Bouvigne feb/apr 2003
+ * Analog silence detection in partitionned sfb21 or sfb12 for short blocks + * + * From top to bottom of sfb, changes to 0 coeffs which are below ath. It + * stops on the first coeff higher than ath. + */ + function psfb21_analogsilence(gfc, cod_info) { + var ath = gfc.ATH; + var xr = cod_info.xr; + + if (cod_info.block_type != Encoder_1.SHORT_TYPE) { + /* NORM, START or STOP type, but not SHORT blocks */ + var stop = false; + for (var gsfb = Encoder_1.PSFB21 - 1; gsfb >= 0 && !stop; gsfb--) { + var start = gfc.scalefac_band.psfb21[gsfb]; + var end = gfc.scalefac_band.psfb21[gsfb + 1]; + var ath21 = qupvt.athAdjust(ath.adjust, ath.psfb21[gsfb], + ath.floor); + + if (gfc.nsPsy.longfact[21] > 1e-12) + ath21 *= gfc.nsPsy.longfact[21]; + + for (var j = end - 1; j >= start; j--) { + if (Math.abs(xr[j]) < ath21) + xr[j] = 0; + else { + stop = true; + break; + } + } + } + } else { + /* note: short blocks coeffs are reordered */ + for (var block = 0; block < 3; block++) { + var stop = false; + for (var gsfb = Encoder_1.PSFB12 - 1; gsfb >= 0 && !stop; gsfb--) { + var start = gfc.scalefac_band.s[12] + * 3 + + (gfc.scalefac_band.s[13] - gfc.scalefac_band.s[12]) + * block + + (gfc.scalefac_band.psfb12[gsfb] - gfc.scalefac_band.psfb12[0]); + var end = start + + (gfc.scalefac_band.psfb12[gsfb + 1] - gfc.scalefac_band.psfb12[gsfb]); + var ath12 = qupvt.athAdjust(ath.adjust, ath.psfb12[gsfb], + ath.floor); + + if (gfc.nsPsy.shortfact[12] > 1e-12) + ath12 *= gfc.nsPsy.shortfact[12]; + + for (var j = end - 1; j >= start; j--) { + if (Math.abs(xr[j]) < ath12) + xr[j] = 0; + else { + stop = true; + break; + } + } + } + } + } + + } + + this.init_outer_loop = function (gfc, cod_info) { + /* + * initialize fresh cod_info + */ + cod_info.part2_3_length = 0; + cod_info.big_values = 0; + cod_info.count1 = 0; + cod_info.global_gain = 210; + cod_info.scalefac_compress = 0; + /* mixed_block_flag, block_type was set in psymodel.c */ + cod_info.table_select[0] = 0; + cod_info.table_select[1] = 0; + cod_info.table_select[2] = 0; + cod_info.subblock_gain[0] = 0; + cod_info.subblock_gain[1] = 0; + cod_info.subblock_gain[2] = 0; + cod_info.subblock_gain[3] = 0; + /* this one is always 0 */ + cod_info.region0_count = 0; + cod_info.region1_count = 0; + cod_info.preflag = 0; + cod_info.scalefac_scale = 0; + cod_info.count1table_select = 0; + cod_info.part2_length = 0; + cod_info.sfb_lmax = Encoder_1.SBPSY_l; + cod_info.sfb_smin = Encoder_1.SBPSY_s; + cod_info.psy_lmax = gfc.sfb21_extra ? Encoder_1.SBMAX_l : Encoder_1.SBPSY_l; + cod_info.psymax = cod_info.psy_lmax; + cod_info.sfbmax = cod_info.sfb_lmax; + cod_info.sfbdivide = 11; + for (var sfb = 0; sfb < Encoder_1.SBMAX_l; sfb++) { + cod_info.width[sfb] = gfc.scalefac_band.l[sfb + 1] + - gfc.scalefac_band.l[sfb]; + /* which is always 0. */ + cod_info.window[sfb] = 3; + } + if (cod_info.block_type == Encoder_1.SHORT_TYPE) { + var ixwork = new_float$21(576); + + cod_info.sfb_smin = 0; + cod_info.sfb_lmax = 0; + if (cod_info.mixed_block_flag != 0) { + /* + * MPEG-1: sfbs 0-7 long block, 3-12 short blocks MPEG-2(.5): + * sfbs 0-5 long block, 3-12 short blocks + */ + cod_info.sfb_smin = 3; + cod_info.sfb_lmax = gfc.mode_gr * 2 + 4; + } + cod_info.psymax = cod_info.sfb_lmax + + 3 + * ((gfc.sfb21_extra ? Encoder_1.SBMAX_s : Encoder_1.SBPSY_s) - cod_info.sfb_smin); + cod_info.sfbmax = cod_info.sfb_lmax + 3 + * (Encoder_1.SBPSY_s - cod_info.sfb_smin); + cod_info.sfbdivide = cod_info.sfbmax - 18; + cod_info.psy_lmax = cod_info.sfb_lmax; + /* re-order the short blocks, for more efficient encoding below */ + /* By Takehiro TOMINAGA */ + /* + * Within each scalefactor band, data is given for successive time + * windows, beginning with window 0 and ending with window 2. Within + * each window, the quantized values are then arranged in order of + * increasing frequency... + */ + var ix = gfc.scalefac_band.l[cod_info.sfb_lmax]; + System$21.arraycopy(cod_info.xr, 0, ixwork, 0, 576); + for (var sfb = cod_info.sfb_smin; sfb < Encoder_1.SBMAX_s; sfb++) { + var start = gfc.scalefac_band.s[sfb]; + var end = gfc.scalefac_band.s[sfb + 1]; + for (var window = 0; window < 3; window++) { + for (var l = start; l < end; l++) { + cod_info.xr[ix++] = ixwork[3 * l + window]; + } + } + } + + var j = cod_info.sfb_lmax; + for (var sfb = cod_info.sfb_smin; sfb < Encoder_1.SBMAX_s; sfb++) { + cod_info.width[j] = cod_info.width[j + 1] = cod_info.width[j + 2] = gfc.scalefac_band.s[sfb + 1] + - gfc.scalefac_band.s[sfb]; + cod_info.window[j] = 0; + cod_info.window[j + 1] = 1; + cod_info.window[j + 2] = 2; + j += 3; + } + } + + cod_info.count1bits = 0; + cod_info.sfb_partition_table = qupvt.nr_of_sfb_block[0][0]; + cod_info.slen[0] = 0; + cod_info.slen[1] = 0; + cod_info.slen[2] = 0; + cod_info.slen[3] = 0; + + cod_info.max_nonzero_coeff = 575; + + /* + * fresh scalefactors are all zero + */ + Arrays$21.fill(cod_info.scalefac, 0); + + psfb21_analogsilence(gfc, cod_info); + }; + + function BinSearchDirection(ordinal) { + this.ordinal = ordinal; + } + + BinSearchDirection.BINSEARCH_NONE = new BinSearchDirection(0); + BinSearchDirection.BINSEARCH_UP = new BinSearchDirection(1); + BinSearchDirection.BINSEARCH_DOWN = new BinSearchDirection(2); + + /** + * author/date?? + * + * binary step size search used by outer_loop to get a quantizer step size + * to start with + */ + function bin_search_StepSize(gfc, cod_info, desired_rate, ch, xrpow) { + var nBits; + var CurrentStep = gfc.CurrentStep[ch]; + var flagGoneOver = false; + var start = gfc.OldValue[ch]; + var Direction = BinSearchDirection.BINSEARCH_NONE; + cod_info.global_gain = start; + desired_rate -= cod_info.part2_length; + + assert$21(CurrentStep != 0); + for (; ;) { + var step; + nBits = tk.count_bits(gfc, xrpow, cod_info, null); + + if (CurrentStep == 1 || nBits == desired_rate) + break; + /* nothing to adjust anymore */ + + if (nBits > desired_rate) { + /* increase Quantize_StepSize */ + if (Direction == BinSearchDirection.BINSEARCH_DOWN) + flagGoneOver = true; + + if (flagGoneOver) + CurrentStep /= 2; + Direction = BinSearchDirection.BINSEARCH_UP; + step = CurrentStep; + } else { + /* decrease Quantize_StepSize */ + if (Direction == BinSearchDirection.BINSEARCH_UP) + flagGoneOver = true; + + if (flagGoneOver) + CurrentStep /= 2; + Direction = BinSearchDirection.BINSEARCH_DOWN; + step = -CurrentStep; + } + cod_info.global_gain += step; + if (cod_info.global_gain < 0) { + cod_info.global_gain = 0; + flagGoneOver = true; + } + if (cod_info.global_gain > 255) { + cod_info.global_gain = 255; + flagGoneOver = true; + } + } + + assert$21(cod_info.global_gain >= 0); + assert$21(cod_info.global_gain < 256); + + while (nBits > desired_rate && cod_info.global_gain < 255) { + cod_info.global_gain++; + nBits = tk.count_bits(gfc, xrpow, cod_info, null); + } + gfc.CurrentStep[ch] = (start - cod_info.global_gain >= 4) ? 4 : 2; + gfc.OldValue[ch] = cod_info.global_gain; + cod_info.part2_3_length = nBits; + return nBits; + } + + this.trancate_smallspectrums = function (gfc, gi, l3_xmin, work) { + var distort = new_float$21(L3Side_1.SFBMAX); + + if ((0 == (gfc.substep_shaping & 4) && gi.block_type == Encoder_1.SHORT_TYPE) + || (gfc.substep_shaping & 0x80) != 0) + return; + qupvt.calc_noise(gi, l3_xmin, distort, new CalcNoiseResult_1(), null); + for (var j = 0; j < 576; j++) { + var xr = 0.0; + if (gi.l3_enc[j] != 0) + xr = Math.abs(gi.xr[j]); + work[j] = xr; + } + + var j = 0; + var sfb = 8; + if (gi.block_type == Encoder_1.SHORT_TYPE) + sfb = 6; + do { + var allowedNoise, trancateThreshold; + var nsame, start; + + var width = gi.width[sfb]; + j += width; + if (distort[sfb] >= 1.0) + continue; + + Arrays$21.sort(work, j - width, width); + if (BitStream.EQ(work[j - 1], 0.0)) + continue; + /* all zero sfb */ + + allowedNoise = (1.0 - distort[sfb]) * l3_xmin[sfb]; + trancateThreshold = 0.0; + start = 0; + do { + var noise; + for (nsame = 1; start + nsame < width; nsame++) + if (BitStream.NEQ(work[start + j - width], work[start + j + + nsame - width])) + break; + + noise = work[start + j - width] * work[start + j - width] + * nsame; + if (allowedNoise < noise) { + if (start != 0) + trancateThreshold = work[start + j - width - 1]; + break; + } + allowedNoise -= noise; + start += nsame; + } while (start < width); + if (BitStream.EQ(trancateThreshold, 0.0)) + continue; + + do { + if (Math.abs(gi.xr[j - width]) <= trancateThreshold) + gi.l3_enc[j - width] = 0; + } while (--width > 0); + } while (++sfb < gi.psymax); + + gi.part2_3_length = tk.noquant_count_bits(gfc, gi, null); + }; + + /** + * author/date?? + * + * Function: Returns zero if there is a scalefac which has not been + * amplified. Otherwise it returns one. + */ + function loop_break(cod_info) { + for (var sfb = 0; sfb < cod_info.sfbmax; sfb++) + if (cod_info.scalefac[sfb] + + cod_info.subblock_gain[cod_info.window[sfb]] == 0) + return false; + + return true; + } + + /* mt 5/99: Function: Improved calc_noise for a single channel */ + + function penalties(noise) { + return Util$21.FAST_LOG10((0.368 + 0.632 * noise * noise * noise)); + } + + /** + * author/date?? + * + * several different codes to decide which quantization is better + */ + function get_klemm_noise(distort, gi) { + var klemm_noise = 1E-37; + for (var sfb = 0; sfb < gi.psymax; sfb++) + klemm_noise += penalties(distort[sfb]); + + return Math.max(1e-20, klemm_noise); + } + + function quant_compare(quant_comp, best, calc, gi, distort) { + /** + * noise is given in decibels (dB) relative to masking thesholds.
+ * + * over_noise: ??? (the previous comment is fully wrong)
+ * tot_noise: ??? (the previous comment is fully wrong)
+ * max_noise: max quantization noise + */ + var better; + + switch (quant_comp) { + default: + case 9: + { + if (best.over_count > 0) { + /* there are distorted sfb */ + better = calc.over_SSD <= best.over_SSD; + if (calc.over_SSD == best.over_SSD) + better = calc.bits < best.bits; + } else { + /* no distorted sfb */ + better = ((calc.max_noise < 0) && ((calc.max_noise * 10 + calc.bits) <= (best.max_noise * 10 + best.bits))); + } + break; + } + + case 0: + better = calc.over_count < best.over_count + || (calc.over_count == best.over_count && calc.over_noise < best.over_noise) + || (calc.over_count == best.over_count + && BitStream.EQ(calc.over_noise, best.over_noise) && calc.tot_noise < best.tot_noise); + break; + + case 8: + calc.max_noise = get_klemm_noise(distort, gi); + //$FALL-THROUGH$ + case 1: + better = calc.max_noise < best.max_noise; + break; + case 2: + better = calc.tot_noise < best.tot_noise; + break; + case 3: + better = (calc.tot_noise < best.tot_noise) + && (calc.max_noise < best.max_noise); + break; + case 4: + better = (calc.max_noise <= 0.0 && best.max_noise > 0.2) + || (calc.max_noise <= 0.0 && best.max_noise < 0.0 + && best.max_noise > calc.max_noise - 0.2 && calc.tot_noise < best.tot_noise) + || (calc.max_noise <= 0.0 && best.max_noise > 0.0 + && best.max_noise > calc.max_noise - 0.2 && calc.tot_noise < best.tot_noise + + best.over_noise) + || (calc.max_noise > 0.0 && best.max_noise > -0.05 + && best.max_noise > calc.max_noise - 0.1 && calc.tot_noise + + calc.over_noise < best.tot_noise + + best.over_noise) + || (calc.max_noise > 0.0 && best.max_noise > -0.1 + && best.max_noise > calc.max_noise - 0.15 && calc.tot_noise + + calc.over_noise + calc.over_noise < best.tot_noise + + best.over_noise + best.over_noise); + break; + case 5: + better = calc.over_noise < best.over_noise + || (BitStream.EQ(calc.over_noise, best.over_noise) && calc.tot_noise < best.tot_noise); + break; + case 6: + better = calc.over_noise < best.over_noise + || (BitStream.EQ(calc.over_noise, best.over_noise) && (calc.max_noise < best.max_noise || (BitStream + .EQ(calc.max_noise, best.max_noise) && calc.tot_noise <= best.tot_noise))); + break; + case 7: + better = calc.over_count < best.over_count + || calc.over_noise < best.over_noise; + break; + } + + if (best.over_count == 0) { + /* + * If no distorted bands, only use this quantization if it is + * better, and if it uses less bits. Unfortunately, part2_3_length + * is sometimes a poor estimator of the final size at low bitrates. + */ + better = better && calc.bits < best.bits; + } + + return better; + } + + /** + * author/date?? + * + *
+ * Amplify the scalefactor bands that violate the masking threshold. + * See ISO 11172-3 Section C.1.5.4.3.5 + * + * distort[] = noise/masking + * distort[] > 1 ==> noise is not masked + * distort[] < 1 ==> noise is masked + * max_dist = maximum value of distort[] + * + * Three algorithms: + * noise_shaping_amp + * 0 Amplify all bands with distort[]>1. + * + * 1 Amplify all bands with distort[] >= max_dist^(.5); + * ( 50% in the db scale) + * + * 2 Amplify first band with distort[] >= max_dist; + * + * + * For algorithms 0 and 1, if max_dist < 1, then amplify all bands + * with distort[] >= .95*max_dist. This is to make sure we always + * amplify at least one band. + *+ */ + function amp_scalefac_bands(gfp, cod_info, distort, xrpow, bRefine) { + var gfc = gfp.internal_flags; + var ifqstep34; + + if (cod_info.scalefac_scale == 0) { + ifqstep34 = 1.29683955465100964055; + /* 2**(.75*.5) */ + } else { + ifqstep34 = 1.68179283050742922612; + /* 2**(.75*1) */ + } + + /* compute maximum value of distort[] */ + var trigger = 0; + for (var sfb = 0; sfb < cod_info.sfbmax; sfb++) { + if (trigger < distort[sfb]) + trigger = distort[sfb]; + } + + var noise_shaping_amp = gfc.noise_shaping_amp; + if (noise_shaping_amp == 3) { + if (bRefine) + noise_shaping_amp = 2; + else + noise_shaping_amp = 1; + } + switch (noise_shaping_amp) { + case 2: + /* amplify exactly 1 band */ + break; + + case 1: + /* amplify bands within 50% of max (on db scale) */ + if (trigger > 1.0) + trigger = Math.pow(trigger, .5); + else + trigger *= .95; + break; + + case 0: + default: + /* ISO algorithm. amplify all bands with distort>1 */ + if (trigger > 1.0) + trigger = 1.0; + else + trigger *= .95; + break; + } + + var j = 0; + for (var sfb = 0; sfb < cod_info.sfbmax; sfb++) { + var width = cod_info.width[sfb]; + var l; + j += width; + if (distort[sfb] < trigger) + continue; + + if ((gfc.substep_shaping & 2) != 0) { + gfc.pseudohalf[sfb] = (0 == gfc.pseudohalf[sfb]) ? 1 : 0; + if (0 == gfc.pseudohalf[sfb] && gfc.noise_shaping_amp == 2) + return; + } + cod_info.scalefac[sfb]++; + for (l = -width; l < 0; l++) { + xrpow[j + l] *= ifqstep34; + if (xrpow[j + l] > cod_info.xrpow_max) + cod_info.xrpow_max = xrpow[j + l]; + } + + if (gfc.noise_shaping_amp == 2) + return; + } + } + + /** + * Takehiro Tominaga 2000-xx-xx + * + * turns on scalefac scale and adjusts scalefactors + */ + function inc_scalefac_scale(cod_info, xrpow) { + var ifqstep34 = 1.29683955465100964055; + + var j = 0; + for (var sfb = 0; sfb < cod_info.sfbmax; sfb++) { + var width = cod_info.width[sfb]; + var s = cod_info.scalefac[sfb]; + if (cod_info.preflag != 0) + s += qupvt.pretab[sfb]; + j += width; + if ((s & 1) != 0) { + s++; + for (var l = -width; l < 0; l++) { + xrpow[j + l] *= ifqstep34; + if (xrpow[j + l] > cod_info.xrpow_max) + cod_info.xrpow_max = xrpow[j + l]; + } + } + cod_info.scalefac[sfb] = s >> 1; + } + cod_info.preflag = 0; + cod_info.scalefac_scale = 1; + } + + /** + * Takehiro Tominaga 2000-xx-xx + * + * increases the subblock gain and adjusts scalefactors + */ + function inc_subblock_gain(gfc, cod_info, xrpow) { + var sfb; + var scalefac = cod_info.scalefac; + + /* subbloc_gain can't do anything in the long block region */ + for (sfb = 0; sfb < cod_info.sfb_lmax; sfb++) { + if (scalefac[sfb] >= 16) + return true; + } + + for (var window = 0; window < 3; window++) { + var s1 = 0; + var s2 = 0; + + for (sfb = cod_info.sfb_lmax + window; sfb < cod_info.sfbdivide; sfb += 3) { + if (s1 < scalefac[sfb]) + s1 = scalefac[sfb]; + } + for (; sfb < cod_info.sfbmax; sfb += 3) { + if (s2 < scalefac[sfb]) + s2 = scalefac[sfb]; + } + + if (s1 < 16 && s2 < 8) + continue; + + if (cod_info.subblock_gain[window] >= 7) + return true; + + /* + * even though there is no scalefactor for sfb12 subblock gain + * affects upper frequencies too, that's why we have to go up to + * SBMAX_s + */ + cod_info.subblock_gain[window]++; + var j = gfc.scalefac_band.l[cod_info.sfb_lmax]; + for (sfb = cod_info.sfb_lmax + window; sfb < cod_info.sfbmax; sfb += 3) { + var amp; + var width = cod_info.width[sfb]; + var s = scalefac[sfb]; + assert$21(s >= 0); + s = s - (4 >> cod_info.scalefac_scale); + if (s >= 0) { + scalefac[sfb] = s; + j += width * 3; + continue; + } + + scalefac[sfb] = 0; + { + var gain = 210 + (s << (cod_info.scalefac_scale + 1)); + amp = qupvt.IPOW20(gain); + } + j += width * (window + 1); + for (var l = -width; l < 0; l++) { + xrpow[j + l] *= amp; + if (xrpow[j + l] > cod_info.xrpow_max) + cod_info.xrpow_max = xrpow[j + l]; + } + j += width * (3 - window - 1); + } + + { + var amp = qupvt.IPOW20(202); + j += cod_info.width[sfb] * (window + 1); + for (var l = -cod_info.width[sfb]; l < 0; l++) { + xrpow[j + l] *= amp; + if (xrpow[j + l] > cod_info.xrpow_max) + cod_info.xrpow_max = xrpow[j + l]; + } + } + } + return false; + } + + /** + *
+ * Takehiro Tominaga /date?? + * Robert Hegemann 2000-09-06: made a function of it + * + * amplifies scalefactor bands, + * - if all are already amplified returns 0 + * - if some bands are amplified too much: + * * try to increase scalefac_scale + * * if already scalefac_scale was set + * try on short blocks to increase subblock gain + *+ */ + function balance_noise(gfp, cod_info, distort, xrpow, bRefine) { + var gfc = gfp.internal_flags; + + amp_scalefac_bands(gfp, cod_info, distort, xrpow, bRefine); + + /* + * check to make sure we have not amplified too much loop_break returns + * 0 if there is an unamplified scalefac scale_bitcount returns 0 if no + * scalefactors are too large + */ + + var status = loop_break(cod_info); + + if (status) + return false; + /* all bands amplified */ + + /* + * not all scalefactors have been amplified. so these scalefacs are + * possibly valid. encode them: + */ + if (gfc.mode_gr == 2) + status = tk.scale_bitcount(cod_info); + else + status = tk.scale_bitcount_lsf(gfc, cod_info); + + if (!status) + return true; + /* amplified some bands not exceeding limits */ + + /* + * some scalefactors are too large. lets try setting scalefac_scale=1 + */ + if (gfc.noise_shaping > 1) { + Arrays$21.fill(gfc.pseudohalf, 0); + if (0 == cod_info.scalefac_scale) { + inc_scalefac_scale(cod_info, xrpow); + status = false; + } else { + if (cod_info.block_type == Encoder_1.SHORT_TYPE + && gfc.subblock_gain > 0) { + status = (inc_subblock_gain(gfc, cod_info, xrpow) || loop_break(cod_info)); + } + } + } + + if (!status) { + if (gfc.mode_gr == 2) + status = tk.scale_bitcount(cod_info); + else + status = tk.scale_bitcount_lsf(gfc, cod_info); + } + return !status; + } + + /** + *
+ * Function: The outer iteration loop controls the masking conditions + * of all scalefactorbands. It computes the best scalefac and + * global gain. This module calls the inner iteration loop + * + * mt 5/99 completely rewritten to allow for bit reservoir control, + * mid/side channels with L/R or mid/side masking thresholds, + * and chooses best quantization instead of last quantization when + * no distortion free quantization can be found. + * + * added VBR support mt 5/99 + * + * some code shuffle rh 9/00 + *+ * + * @param l3_xmin + * allowed distortion + * @param xrpow + * coloured magnitudes of spectral + * @param targ_bits + * maximum allowed bits + */ + this.outer_loop = function (gfp, cod_info, l3_xmin, xrpow, ch, targ_bits) { + var gfc = gfp.internal_flags; + var cod_info_w = new GrInfo_1(); + var save_xrpow = new_float$21(576); + var distort = new_float$21(L3Side_1.SFBMAX); + var best_noise_info = new CalcNoiseResult_1(); + var better; + var prev_noise = new CalcNoiseData_1(); + var best_part2_3_length = 9999999; + var bEndOfSearch = false; + var bRefine = false; + var best_ggain_pass1 = 0; + + bin_search_StepSize(gfc, cod_info, targ_bits, ch, xrpow); + + if (0 == gfc.noise_shaping) + /* fast mode, no noise shaping, we are ready */ + return 100; + /* default noise_info.over_count */ + + /* compute the distortion in this quantization */ + /* coefficients and thresholds both l/r (or both mid/side) */ + qupvt.calc_noise(cod_info, l3_xmin, distort, best_noise_info, + prev_noise); + best_noise_info.bits = cod_info.part2_3_length; + + cod_info_w.assign(cod_info); + var age = 0; + System$21.arraycopy(xrpow, 0, save_xrpow, 0, 576); + + while (!bEndOfSearch) { + /* BEGIN MAIN LOOP */ + do { + var noise_info = new CalcNoiseResult_1(); + var search_limit; + var maxggain = 255; + + /* + * When quantization with no distorted bands is found, allow up + * to X new unsuccesful tries in serial. This gives us more + * possibilities for different quant_compare modes. Much more + * than 3 makes not a big difference, it is only slower. + */ + + if ((gfc.substep_shaping & 2) != 0) { + search_limit = 20; + } else { + search_limit = 3; + } + + /* + * Check if the last scalefactor band is distorted. in VBR mode + * we can't get rid of the distortion, so quit now and VBR mode + * will try again with more bits. (makes a 10% speed increase, + * the files I tested were binary identical, 2000/05/20 Robert + * Hegemann) distort[] > 1 means noise > allowed noise + */ + if (gfc.sfb21_extra) { + if (distort[cod_info_w.sfbmax] > 1.0) + break; + if (cod_info_w.block_type == Encoder_1.SHORT_TYPE + && (distort[cod_info_w.sfbmax + 1] > 1.0 || distort[cod_info_w.sfbmax + 2] > 1.0)) + break; + } + + /* try a new scalefactor conbination on cod_info_w */ + if (!balance_noise(gfp, cod_info_w, distort, xrpow, bRefine)) + break; + if (cod_info_w.scalefac_scale != 0) + maxggain = 254; + + /* + * inner_loop starts with the initial quantization step computed + * above and slowly increases until the bits < huff_bits. Thus + * it is important not to start with too large of an inital + * quantization step. Too small is ok, but inner_loop will take + * longer + */ + var huff_bits = targ_bits - cod_info_w.part2_length; + if (huff_bits <= 0) + break; + + /* + * increase quantizer stepsize until needed bits are below + * maximum + */ + while ((cod_info_w.part2_3_length = tk.count_bits(gfc, xrpow, + cod_info_w, prev_noise)) > huff_bits + && cod_info_w.global_gain <= maxggain) + cod_info_w.global_gain++; + + if (cod_info_w.global_gain > maxggain) + break; + + if (best_noise_info.over_count == 0) { + + while ((cod_info_w.part2_3_length = tk.count_bits(gfc, + xrpow, cod_info_w, prev_noise)) > best_part2_3_length + && cod_info_w.global_gain <= maxggain) + cod_info_w.global_gain++; + + if (cod_info_w.global_gain > maxggain) + break; + } + + /* compute the distortion in this quantization */ + qupvt.calc_noise(cod_info_w, l3_xmin, distort, noise_info, + prev_noise); + noise_info.bits = cod_info_w.part2_3_length; + + /* + * check if this quantization is better than our saved + * quantization + */ + if (cod_info.block_type != Encoder_1.SHORT_TYPE) { + // NORM, START or STOP type + better = gfp.quant_comp; + } else + better = gfp.quant_comp_short; + + better = quant_compare(better, best_noise_info, noise_info, + cod_info_w, distort) ? 1 : 0; + + /* save data so we can restore this quantization later */ + if (better != 0) { + best_part2_3_length = cod_info.part2_3_length; + best_noise_info = noise_info; + cod_info.assign(cod_info_w); + age = 0; + /* save data so we can restore this quantization later */ + /* store for later reuse */ + System$21.arraycopy(xrpow, 0, save_xrpow, 0, 576); + } else { + /* early stop? */ + if (gfc.full_outer_loop == 0) { + if (++age > search_limit + && best_noise_info.over_count == 0) + break; + if ((gfc.noise_shaping_amp == 3) && bRefine && age > 30) + break; + if ((gfc.noise_shaping_amp == 3) + && bRefine + && (cod_info_w.global_gain - best_ggain_pass1) > 15) + break; + } + } + } while ((cod_info_w.global_gain + cod_info_w.scalefac_scale) < 255); + + if (gfc.noise_shaping_amp == 3) { + if (!bRefine) { + /* refine search */ + cod_info_w.assign(cod_info); + System$21.arraycopy(save_xrpow, 0, xrpow, 0, 576); + age = 0; + best_ggain_pass1 = cod_info_w.global_gain; + + bRefine = true; + } else { + /* search already refined, stop */ + bEndOfSearch = true; + } + + } else { + bEndOfSearch = true; + } + } + + assert$21((cod_info.global_gain + cod_info.scalefac_scale) <= 255); + /* + * finish up + */ + if (gfp.VBR == VbrMode$21.vbr_rh || gfp.VBR == VbrMode$21.vbr_mtrh) + /* restore for reuse on next try */ + System$21.arraycopy(save_xrpow, 0, xrpow, 0, 576); + /* + * do the 'substep shaping' + */ + else if ((gfc.substep_shaping & 1) != 0) + trancate_smallspectrums(gfc, cod_info, l3_xmin, xrpow); + + return best_noise_info.over_count; + }; + + /** + * Robert Hegemann 2000-09-06 + * + * update reservoir status after FINAL quantization/bitrate + */ + this.iteration_finish_one = function (gfc, gr, ch) { + var l3_side = gfc.l3_side; + var cod_info = l3_side.tt[gr][ch]; + + /* + * try some better scalefac storage + */ + tk.best_scalefac_store(gfc, gr, ch, l3_side); + + /* + * best huffman_divide may save some bits too + */ + if (gfc.use_best_huffman == 1) + tk.best_huffman_divide(gfc, cod_info); + + /* + * update reservoir status after FINAL quantization/bitrate + */ + rv.ResvAdjust(gfc, cod_info); + }; + + /** + * + * 2000-09-04 Robert Hegemann + * + * @param l3_xmin + * allowed distortion of the scalefactor + * @param xrpow + * coloured magnitudes of spectral values + */ + this.VBR_encode_granule = function (gfp, cod_info, l3_xmin, xrpow, ch, min_bits, max_bits) { + var gfc = gfp.internal_flags; + var bst_cod_info = new GrInfo_1(); + var bst_xrpow = new_float$21(576); + var Max_bits = max_bits; + var real_bits = max_bits + 1; + var this_bits = (max_bits + min_bits) / 2; + var dbits, over, found = 0; + var sfb21_extra = gfc.sfb21_extra; + + assert$21(Max_bits <= LameInternalFlags.MAX_BITS_PER_CHANNEL); + Arrays$21.fill(bst_cod_info.l3_enc, 0); + + /* + * search within round about 40 bits of optimal + */ + do { + assert$21(this_bits >= min_bits); + assert$21(this_bits <= max_bits); + assert$21(min_bits <= max_bits); + + if (this_bits > Max_bits - 42) + gfc.sfb21_extra = false; + else + gfc.sfb21_extra = sfb21_extra; + + over = outer_loop(gfp, cod_info, l3_xmin, xrpow, ch, this_bits); + + /* + * is quantization as good as we are looking for ? in this case: is + * no scalefactor band distorted? + */ + if (over <= 0) { + found = 1; + /* + * now we know it can be done with "real_bits" and maybe we can + * skip some iterations + */ + real_bits = cod_info.part2_3_length; + + /* + * store best quantization so far + */ + bst_cod_info.assign(cod_info); + System$21.arraycopy(xrpow, 0, bst_xrpow, 0, 576); + + /* + * try with fewer bits + */ + max_bits = real_bits - 32; + dbits = max_bits - min_bits; + this_bits = (max_bits + min_bits) / 2; + } else { + /* + * try with more bits + */ + min_bits = this_bits + 32; + dbits = max_bits - min_bits; + this_bits = (max_bits + min_bits) / 2; + + if (found != 0) { + found = 2; + /* + * start again with best quantization so far + */ + cod_info.assign(bst_cod_info); + System$21.arraycopy(bst_xrpow, 0, xrpow, 0, 576); + } + } + } while (dbits > 12); + + gfc.sfb21_extra = sfb21_extra; + + /* + * found=0 => nothing found, use last one found=1 => we just found the + * best and left the loop found=2 => we restored a good one and have now + * l3_enc to restore too + */ + if (found == 2) { + System$21.arraycopy(bst_cod_info.l3_enc, 0, cod_info.l3_enc, 0, 576); + } + assert$21(cod_info.part2_3_length <= Max_bits); + }; + + /** + * Robert Hegemann 2000-09-05 + * + * calculates * how many bits are available for analog silent granules * how + * many bits to use for the lowest allowed bitrate * how many bits each + * bitrate would provide + */ + this.get_framebits = function (gfp, frameBits) { + var gfc = gfp.internal_flags; + + /* + * always use at least this many bits per granule per channel unless we + * detect analog silence, see below + */ + gfc.bitrate_index = gfc.VBR_min_bitrate; + var bitsPerFrame = bs.getframebits(gfp); + + /* + * bits for analog silence + */ + gfc.bitrate_index = 1; + bitsPerFrame = bs.getframebits(gfp); + + for (var i = 1; i <= gfc.VBR_max_bitrate; i++) { + gfc.bitrate_index = i; + var mb = new MeanBits(bitsPerFrame); + frameBits[i] = rv.ResvFrameBegin(gfp, mb); + bitsPerFrame = mb.bits; + } + }; + + /* RH: this one needs to be overhauled sometime */ + + /** + *
+ * 2000-09-04 Robert Hegemann + * + * * converts LR to MS coding when necessary + * * calculates allowed/adjusted quantization noise amounts + * * detects analog silent frames + * + * some remarks: + * - lower masking depending on Quality setting + * - quality control together with adjusted ATH MDCT scaling + * on lower quality setting allocate more noise from + * ATH masking, and on higher quality setting allocate + * less noise from ATH masking. + * - experiments show that going more than 2dB over GPSYCHO's + * limits ends up in very annoying artefacts + *+ */ + this.VBR_old_prepare = function (gfp, pe, ms_ener_ratio, ratio, l3_xmin, frameBits, min_bits, + max_bits, bands) { + var gfc = gfp.internal_flags; + + var masking_lower_db, adjust = 0.0; + var analog_silence = 1; + var bits = 0; + + gfc.bitrate_index = gfc.VBR_max_bitrate; + var avg = rv.ResvFrameBegin(gfp, new MeanBits(0)) / gfc.mode_gr; + + get_framebits(gfp, frameBits); + + for (var gr = 0; gr < gfc.mode_gr; gr++) { + var mxb = qupvt.on_pe(gfp, pe, max_bits[gr], avg, gr, 0); + if (gfc.mode_ext == Encoder_1.MPG_MD_MS_LR) { + ms_convert(gfc.l3_side, gr); + qupvt.reduce_side(max_bits[gr], ms_ener_ratio[gr], avg, mxb); + } + for (var ch = 0; ch < gfc.channels_out; ++ch) { + var cod_info = gfc.l3_side.tt[gr][ch]; + + if (cod_info.block_type != Encoder_1.SHORT_TYPE) { + // NORM, START or STOP type + adjust = 1.28 / (1 + Math + .exp(3.5 - pe[gr][ch] / 300.)) - 0.05; + masking_lower_db = gfc.PSY.mask_adjust - adjust; + } else { + adjust = 2.56 / (1 + Math + .exp(3.5 - pe[gr][ch] / 300.)) - 0.14; + masking_lower_db = gfc.PSY.mask_adjust_short - adjust; + } + gfc.masking_lower = Math.pow(10.0, + masking_lower_db * 0.1); + + init_outer_loop(gfc, cod_info); + bands[gr][ch] = qupvt.calc_xmin(gfp, ratio[gr][ch], cod_info, + l3_xmin[gr][ch]); + if (bands[gr][ch] != 0) + analog_silence = 0; + + min_bits[gr][ch] = 126; + + bits += max_bits[gr][ch]; + } + } + for (var gr = 0; gr < gfc.mode_gr; gr++) { + for (var ch = 0; ch < gfc.channels_out; ch++) { + if (bits > frameBits[gfc.VBR_max_bitrate]) { + max_bits[gr][ch] *= frameBits[gfc.VBR_max_bitrate]; + max_bits[gr][ch] /= bits; + } + if (min_bits[gr][ch] > max_bits[gr][ch]) + min_bits[gr][ch] = max_bits[gr][ch]; + + } + /* for ch */ + } + /* for gr */ + + return analog_silence; + }; + + this.bitpressure_strategy = function (gfc, l3_xmin, min_bits, max_bits) { + for (var gr = 0; gr < gfc.mode_gr; gr++) { + for (var ch = 0; ch < gfc.channels_out; ch++) { + var gi = gfc.l3_side.tt[gr][ch]; + var pxmin = l3_xmin[gr][ch]; + var pxminPos = 0; + for (var sfb = 0; sfb < gi.psy_lmax; sfb++) + pxmin[pxminPos++] *= 1. + .029 * sfb * sfb + / Encoder_1.SBMAX_l / Encoder_1.SBMAX_l; + + if (gi.block_type == Encoder_1.SHORT_TYPE) { + for (var sfb = gi.sfb_smin; sfb < Encoder_1.SBMAX_s; sfb++) { + pxmin[pxminPos++] *= 1. + .029 * sfb * sfb + / Encoder_1.SBMAX_s / Encoder_1.SBMAX_s; + pxmin[pxminPos++] *= 1. + .029 * sfb * sfb + / Encoder_1.SBMAX_s / Encoder_1.SBMAX_s; + pxmin[pxminPos++] *= 1. + .029 * sfb * sfb + / Encoder_1.SBMAX_s / Encoder_1.SBMAX_s; + } + } + max_bits[gr][ch] = 0 | Math.max(min_bits[gr][ch], + 0.9 * max_bits[gr][ch]); + } + } + }; + + this.VBR_new_prepare = function (gfp, pe, ratio, l3_xmin, frameBits, max_bits) { + var gfc = gfp.internal_flags; + + var analog_silence = 1; + var avg = 0, bits = 0; + var maximum_framebits; + + if (!gfp.free_format) { + gfc.bitrate_index = gfc.VBR_max_bitrate; + + var mb = new MeanBits(avg); + rv.ResvFrameBegin(gfp, mb); + avg = mb.bits; + + get_framebits(gfp, frameBits); + maximum_framebits = frameBits[gfc.VBR_max_bitrate]; + } else { + gfc.bitrate_index = 0; + var mb = new MeanBits(avg); + maximum_framebits = rv.ResvFrameBegin(gfp, mb); + avg = mb.bits; + frameBits[0] = maximum_framebits; + } + + for (var gr = 0; gr < gfc.mode_gr; gr++) { + qupvt.on_pe(gfp, pe, max_bits[gr], avg, gr, 0); + if (gfc.mode_ext == Encoder_1.MPG_MD_MS_LR) { + ms_convert(gfc.l3_side, gr); + } + for (var ch = 0; ch < gfc.channels_out; ++ch) { + var cod_info = gfc.l3_side.tt[gr][ch]; + + gfc.masking_lower = Math.pow(10.0, + gfc.PSY.mask_adjust * 0.1); + + init_outer_loop(gfc, cod_info); + if (0 != qupvt.calc_xmin(gfp, ratio[gr][ch], cod_info, + l3_xmin[gr][ch])) + analog_silence = 0; + + bits += max_bits[gr][ch]; + } + } + for (var gr = 0; gr < gfc.mode_gr; gr++) { + for (var ch = 0; ch < gfc.channels_out; ch++) { + if (bits > maximum_framebits) { + max_bits[gr][ch] *= maximum_framebits; + max_bits[gr][ch] /= bits; + } + + } + /* for ch */ + } + /* for gr */ + + return analog_silence; + }; + + /** + * calculates target bits for ABR encoding + * + * mt 2000/05/31 + */ + this.calc_target_bits = function (gfp, pe, ms_ener_ratio, targ_bits, analog_silence_bits, max_frame_bits) { + var gfc = gfp.internal_flags; + var l3_side = gfc.l3_side; + var res_factor; + var gr, ch, totbits, mean_bits = 0; + + gfc.bitrate_index = gfc.VBR_max_bitrate; + var mb = new MeanBits(mean_bits); + max_frame_bits[0] = rv.ResvFrameBegin(gfp, mb); + mean_bits = mb.bits; + + gfc.bitrate_index = 1; + mean_bits = bs.getframebits(gfp) - gfc.sideinfo_len * 8; + analog_silence_bits[0] = mean_bits / (gfc.mode_gr * gfc.channels_out); + + mean_bits = gfp.VBR_mean_bitrate_kbps * gfp.framesize * 1000; + if ((gfc.substep_shaping & 1) != 0) + mean_bits *= 1.09; + mean_bits /= gfp.out_samplerate; + mean_bits -= gfc.sideinfo_len * 8; + mean_bits /= (gfc.mode_gr * gfc.channels_out); + + /** + *
+ * res_factor is the percentage of the target bitrate that should + * be used on average. the remaining bits are added to the + * bitreservoir and used for difficult to encode frames. + * + * Since we are tracking the average bitrate, we should adjust + * res_factor "on the fly", increasing it if the average bitrate + * is greater than the requested bitrate, and decreasing it + * otherwise. Reasonable ranges are from .9 to 1.0 + * + * Until we get the above suggestion working, we use the following + * tuning: + * compression ratio res_factor + * 5.5 (256kbps) 1.0 no need for bitreservoir + * 11 (128kbps) .93 7% held for reservoir + * + * with linear interpolation for other values. + *+ */ + res_factor = .93 + .07 * (11.0 - gfp.compression_ratio) + / (11.0 - 5.5); + if (res_factor < .90) + res_factor = .90; + if (res_factor > 1.00) + res_factor = 1.00; + + for (gr = 0; gr < gfc.mode_gr; gr++) { + var sum = 0; + for (ch = 0; ch < gfc.channels_out; ch++) { + targ_bits[gr][ch] = (int)(res_factor * mean_bits); + + if (pe[gr][ch] > 700) { + var add_bits = (int)((pe[gr][ch] - 700) / 1.4); + + var cod_info = l3_side.tt[gr][ch]; + targ_bits[gr][ch] = (int)(res_factor * mean_bits); + + /* short blocks use a little extra, no matter what the pe */ + if (cod_info.block_type == Encoder_1.SHORT_TYPE) { + if (add_bits < mean_bits / 2) + add_bits = mean_bits / 2; + } + /* at most increase bits by 1.5*average */ + if (add_bits > mean_bits * 3 / 2) + add_bits = mean_bits * 3 / 2; + else if (add_bits < 0) + add_bits = 0; + + targ_bits[gr][ch] += add_bits; + } + if (targ_bits[gr][ch] > LameInternalFlags.MAX_BITS_PER_CHANNEL) { + targ_bits[gr][ch] = LameInternalFlags.MAX_BITS_PER_CHANNEL; + } + sum += targ_bits[gr][ch]; + } + /* for ch */ + if (sum > LameInternalFlags.MAX_BITS_PER_GRANULE) { + for (ch = 0; ch < gfc.channels_out; ++ch) { + targ_bits[gr][ch] *= LameInternalFlags.MAX_BITS_PER_GRANULE; + targ_bits[gr][ch] /= sum; + } + } + } + /* for gr */ + + if (gfc.mode_ext == Encoder_1.MPG_MD_MS_LR) + for (gr = 0; gr < gfc.mode_gr; gr++) { + qupvt.reduce_side(targ_bits[gr], ms_ener_ratio[gr], mean_bits + * gfc.channels_out, + LameInternalFlags.MAX_BITS_PER_GRANULE); + } + + /* + * sum target bits + */ + totbits = 0; + for (gr = 0; gr < gfc.mode_gr; gr++) { + for (ch = 0; ch < gfc.channels_out; ch++) { + if (targ_bits[gr][ch] > LameInternalFlags.MAX_BITS_PER_CHANNEL) + targ_bits[gr][ch] = LameInternalFlags.MAX_BITS_PER_CHANNEL; + totbits += targ_bits[gr][ch]; + } + } + + /* + * repartion target bits if needed + */ + if (totbits > max_frame_bits[0]) { + for (gr = 0; gr < gfc.mode_gr; gr++) { + for (ch = 0; ch < gfc.channels_out; ch++) { + targ_bits[gr][ch] *= max_frame_bits[0]; + targ_bits[gr][ch] /= totbits; + } + } + } + }; + +} + +var Quantize_1 = Quantize$1; + +/* + * bit reservoir source file + * + * Copyright (c) 1999-2000 Mark Taylor + * + * 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: Reservoir.java,v 1.9 2011/05/24 20:48:06 kenchis Exp $ */ + +//package mp3; + +/** + * ResvFrameBegin:
+ * Called (repeatedly) at the beginning of a frame. Updates the maximum size of + * the reservoir, and checks to make sure main_data_begin was set properly by + * the formatter
+ * Background information: + * + * This is the original text from the ISO standard. Because of sooo many bugs + * and irritations correcting comments are added in brackets []. A '^W' means + * you should remove the last word. + * + *
+ * 1. The following rule can be used to calculate the maximum + * number of bits used for one granule [^W frame]:+ */ + + +var assert$23 = common.assert; + +function Reservoir$1() { + var bs; + + this.setModules = function(_bs) { + bs = _bs; + }; + + this.ResvFrameBegin = function(gfp, mean_bits) { + var gfc = gfp.internal_flags; + var maxmp3buf; + var l3_side = gfc.l3_side; + + var frameLength = bs.getframebits(gfp); + mean_bits.bits = (frameLength - gfc.sideinfo_len * 8) / gfc.mode_gr; + + /** + *
+ * At the highest possible bitrate of Layer III (320 kbps + * per stereo signal [^W^W^W], 48 kHz) the frames must be of + * [^W^W^W are designed to have] constant length, i.e. + * one buffer [^W^W the frame] length is:
+ * + * 320 kbps * 1152/48 kHz = 7680 bit = 960 byte + * + * This value is used as the maximum buffer per channel [^W^W] at + * lower bitrates [than 320 kbps]. At 64 kbps mono or 128 kbps + * stereo the main granule length is 64 kbps * 576/48 kHz = 768 bit + * [per granule and channel] at 48 kHz sampling frequency. + * This means that there is a maximum deviation (short time buffer + * [= reservoir]) of 7680 - 2*2*768 = 4608 bits is allowed at 64 kbps. + * The actual deviation is equal to the number of bytes [with the + * meaning of octets] denoted by the main_data_end offset pointer. + * The actual maximum deviation is (2^9-1)*8 bit = 4088 bits + * [for MPEG-1 and (2^8-1)*8 bit for MPEG-2, both are hard limits]. + * ... The xchange of buffer bits between the left and right channel + * is allowed without restrictions [exception: dual channel]. + * Because of the [constructed] constraint on the buffer size + * main_data_end is always set to 0 in the case of bit_rate_index==14, + * i.e. data rate 320 kbps per stereo signal [^W^W^W]. In this case + * all data are allocated between adjacent header [^W sync] words + * [, i.e. there is no buffering at all]. + *
+ * Meaning of the variables: + * resvLimit: (0, 8, ..., 8*255 (MPEG-2), 8*511 (MPEG-1)) + * Number of bits can be stored in previous frame(s) due to + * counter size constaints + * maxmp3buf: ( ??? ... 8*1951 (MPEG-1 and 2), 8*2047 (MPEG-2.5)) + * Number of bits allowed to encode one frame (you can take 8*511 bit + * from the bit reservoir and at most 8*1440 bit from the current + * frame (320 kbps, 32 kHz), so 8*1951 bit is the largest possible + * value for MPEG-1 and -2) + * + * maximum allowed granule/channel size times 4 = 8*2047 bits., + * so this is the absolute maximum supported by the format. + * + * + * fullFrameBits: maximum number of bits available for encoding + * the current frame. + * + * mean_bits: target number of bits per granule. + * + * frameLength: + * + * gfc.ResvMax: maximum allowed reservoir + * + * gfc.ResvSize: current reservoir size + * + * l3_side.resvDrain_pre: + * ancillary data to be added to previous frame: + * (only usefull in VBR modes if it is possible to have + * maxmp3buf < fullFrameBits)). Currently disabled, + * see #define NEW_DRAIN + * 2010-02-13: RH now enabled, it seems to be needed for CBR too, + * as there exists one example, where the FhG decoder + * can't decode a -b320 CBR file anymore. + * + * l3_side.resvDrain_post: + * ancillary data to be added to this frame: + * + *+ */ + + /* main_data_begin has 9 bits in MPEG-1, 8 bits MPEG-2 */ + var resvLimit = (8 * 256) * gfc.mode_gr - 8; + + /* + * maximum allowed frame size. dont use more than this number of bits, + * even if the frame has the space for them: + */ + if (gfp.brate > 320) { + /* in freeformat the buffer is constant */ + maxmp3buf = 8 * ((int) ((gfp.brate * 1000) + / (gfp.out_samplerate / 1152) / 8 + .5)); + } else { + /* + * all mp3 decoders should have enough buffer to handle this value: + * size of a 320kbps 32kHz frame + */ + maxmp3buf = 8 * 1440; + + /* + * Bouvigne suggests this more lax interpretation of the ISO doc + * instead of using 8*960. + */ + + if (gfp.strict_ISO) { + maxmp3buf = 8 * ((int) (320000 / (gfp.out_samplerate / 1152) / 8 + .5)); + } + } + + gfc.ResvMax = maxmp3buf - frameLength; + if (gfc.ResvMax > resvLimit) + gfc.ResvMax = resvLimit; + if (gfc.ResvMax < 0 || gfp.disable_reservoir) + gfc.ResvMax = 0; + + var fullFrameBits = mean_bits.bits * gfc.mode_gr + + Math.min(gfc.ResvSize, gfc.ResvMax); + + if (fullFrameBits > maxmp3buf) + fullFrameBits = maxmp3buf; + + assert$23 (0 == gfc.ResvMax % 8); + assert$23 (gfc.ResvMax >= 0); + + l3_side.resvDrain_pre = 0; + + // frame analyzer code + if (gfc.pinfo != null) { + /* + * expected bits per channel per granule [is this also right for + * mono/stereo, MPEG-1/2 ?] + */ + gfc.pinfo.mean_bits = mean_bits.bits / 2; + gfc.pinfo.resvsize = gfc.ResvSize; + } + + return fullFrameBits; + }; + + /** + * returns targ_bits: target number of bits to use for 1 granule
+ * extra_bits: amount extra available from reservoir
+ * Mark Taylor 4/99 + */ + this.ResvMaxBits = function(gfp, mean_bits, targ_bits, cbr) { + var gfc = gfp.internal_flags; + var add_bits; + var ResvSize = gfc.ResvSize, ResvMax = gfc.ResvMax; + + /* compensate the saved bits used in the 1st granule */ + if (cbr != 0) + ResvSize += mean_bits; + + if ((gfc.substep_shaping & 1) != 0) + ResvMax *= 0.9; + + targ_bits.bits = mean_bits; + + /* extra bits if the reservoir is almost full */ + if (ResvSize * 10 > ResvMax * 9) { + add_bits = ResvSize - (ResvMax * 9) / 10; + targ_bits.bits += add_bits; + gfc.substep_shaping |= 0x80; + } else { + add_bits = 0; + gfc.substep_shaping &= 0x7f; + /* + * build up reservoir. this builds the reservoir a little slower + * than FhG. It could simple be mean_bits/15, but this was rigged to + * always produce 100 (the old value) at 128kbs + */ + if (!gfp.disable_reservoir && 0 == (gfc.substep_shaping & 1)) + targ_bits.bits -= .1 * mean_bits; + } + + /* amount from the reservoir we are allowed to use. ISO says 6/10 */ + var extra_bits = (ResvSize < (gfc.ResvMax * 6) / 10 ? ResvSize + : (gfc.ResvMax * 6) / 10); + extra_bits -= add_bits; + + if (extra_bits < 0) + extra_bits = 0; + return extra_bits; + }; + + /** + * Called after a granule's bit allocation. Readjusts the size of the + * reservoir to reflect the granule's usage. + */ + this.ResvAdjust = function(gfc, gi) { + gfc.ResvSize -= gi.part2_3_length + gi.part2_length; + }; + + /** + * Called after all granules in a frame have been allocated. Makes sure that + * the reservoir size is within limits, possibly by adding stuffing bits. + */ + this.ResvFrameEnd = function(gfc, mean_bits) { + var over_bits; + var l3_side = gfc.l3_side; + + gfc.ResvSize += mean_bits * gfc.mode_gr; + var stuffingBits = 0; + l3_side.resvDrain_post = 0; + l3_side.resvDrain_pre = 0; + + /* we must be byte aligned */ + if ((over_bits = gfc.ResvSize % 8) != 0) + stuffingBits += over_bits; + + over_bits = (gfc.ResvSize - stuffingBits) - gfc.ResvMax; + if (over_bits > 0) { + assert$23 (0 == over_bits % 8); + assert$23 (over_bits >= 0); + stuffingBits += over_bits; + } + + /* + * NOTE: enabling the NEW_DRAIN code fixes some problems with FhG + * decoder shipped with MS Windows operating systems. Using this, it is + * even possible to use Gabriel's lax buffer consideration again, which + * assumes, any decoder should have a buffer large enough for a 320 kbps + * frame at 32 kHz sample rate. + * + * old drain code: lame -b320 BlackBird.wav --. does not play with + * GraphEdit.exe using FhG decoder V1.5 Build 50 + * + * new drain code: lame -b320 BlackBird.wav --. plays fine with + * GraphEdit.exe using FhG decoder V1.5 Build 50 + * + * Robert Hegemann, 2010-02-13. + */ + /* + * drain as many bits as possible into previous frame ancillary data In + * particular, in VBR mode ResvMax may have changed, and we have to make + * sure main_data_begin does not create a reservoir bigger than ResvMax + * mt 4/00 + */ + { + var mdb_bytes = Math.min(l3_side.main_data_begin * 8, stuffingBits) / 8; + l3_side.resvDrain_pre += 8 * mdb_bytes; + stuffingBits -= 8 * mdb_bytes; + gfc.ResvSize -= 8 * mdb_bytes; + l3_side.main_data_begin -= mdb_bytes; + } + /* drain the rest into this frames ancillary data */ + l3_side.resvDrain_post += stuffingBits; + gfc.ResvSize -= stuffingBits; + }; +} + +var Reservoir_1 = Reservoir$1; + +function Version() { + + /** + * URL for the LAME website. + */ + var LAME_URL = "http://www.mp3dev.org/"; + + /** + * Major version number. + */ + var LAME_MAJOR_VERSION = 3; + /** + * Minor version number. + */ + var LAME_MINOR_VERSION = 98; + /** + * Patch level. + */ + var LAME_PATCH_VERSION = 4; + + /** + * Major version number. + */ + var PSY_MAJOR_VERSION = 0; + /** + * Minor version number. + */ + var PSY_MINOR_VERSION = 93; + + /** + * A string which describes the version of LAME. + * + * @return string which describes the version of LAME + */ + this.getLameVersion = function () { + // primary to write screen reports + return (LAME_MAJOR_VERSION + "." + LAME_MINOR_VERSION + "." + LAME_PATCH_VERSION); + }; + + /** + * The short version of the LAME version string. + * + * @return short version of the LAME version string + */ + this.getLameShortVersion = function () { + // Adding date and time to version string makes it harder for output + // validation + return (LAME_MAJOR_VERSION + "." + LAME_MINOR_VERSION + "." + LAME_PATCH_VERSION); + }; + + /** + * The shortest version of the LAME version string. + * + * @return shortest version of the LAME version string + */ + this.getLameVeryShortVersion = function () { + // Adding date and time to version string makes it harder for output + return ("LAME" + LAME_MAJOR_VERSION + "." + LAME_MINOR_VERSION + "r"); + }; + + /** + * String which describes the version of GPSYCHO + * + * @return string which describes the version of GPSYCHO + */ + this.getPsyVersion = function () { + return (PSY_MAJOR_VERSION + "." + PSY_MINOR_VERSION); + }; + + /** + * String which is a URL for the LAME website. + * + * @return string which is a URL for the LAME website + */ + this.getLameUrl = function () { + return LAME_URL; + }; + + /** + * Quite useless for a java version, however we are compatible ;-) + * + * @return "32bits" + */ + this.getLameOsBitness = function () { + return "32bits"; + }; + +} + +var Version_1 = Version; + +var System$22 = common.System; +var VbrMode$22 = common.VbrMode; +var ShortBlock$22 = common.ShortBlock; +var Arrays$22 = common.Arrays; +var new_byte$22 = common.new_byte; +var assert$24 = common.assert; + +/** + * A Vbr header may be present in the ancillary data field of the first frame of + * an mp3 bitstream
+ * The Vbr header (optionally) contains + *
-
+ *
- frames total number of audio frames in the bitstream + *
- bytes total number of bytes in the bitstream + *
- toc table of contents + *
+ * The ith entry determines the seek point for i-percent duration.
+ * seek point in bytes = (toc[i]/256.0) * total_bitstream_bytes
+ * e.g. half duration seek point = (toc[50]/256.0) * total_bitstream_bytes + */ +VBRTag.NUMTOCENTRIES = 100; +VBRTag.MAXFRAMESIZE = 2880; + +function VBRTag() { + + var lame; + var bs; + var v; + + this.setModules = function (_lame, _bs, _v) { + lame = _lame; + bs = _bs; + v = _v; + }; + + var FRAMES_FLAG = 0x0001; + var BYTES_FLAG = 0x0002; + var TOC_FLAG = 0x0004; + var VBR_SCALE_FLAG = 0x0008; + + var NUMTOCENTRIES = VBRTag.NUMTOCENTRIES; + + /** + * (0xB40) the max freeformat 640 32kHz framesize. + */ + var MAXFRAMESIZE = VBRTag.MAXFRAMESIZE; + + /** + *
+ * 4 bytes for Header Tag + * 4 bytes for Header Flags + * 100 bytes for entry (toc) + * 4 bytes for frame size + * 4 bytes for stream size + * 4 bytes for VBR scale. a VBR quality indicator: 0=best 100=worst + * 20 bytes for LAME tag. for example, "LAME3.12 (beta 6)" + * ___________ + * 140 bytes + *+ */ + var VBRHEADERSIZE = (NUMTOCENTRIES + 4 + 4 + 4 + 4 + 4); + + var LAMEHEADERSIZE = (VBRHEADERSIZE + 9 + 1 + 1 + 8 + + 1 + 1 + 3 + 1 + 1 + 2 + 4 + 2 + 2); + + /** + * The size of the Xing header MPEG-1, bit rate in kbps. + */ + var XING_BITRATE1 = 128; + /** + * The size of the Xing header MPEG-2, bit rate in kbps. + */ + var XING_BITRATE2 = 64; + /** + * The size of the Xing header MPEG-2.5, bit rate in kbps. + */ + var XING_BITRATE25 = 32; + + /** + * ISO-8859-1 charset for byte to string operations. + */ + var ISO_8859_1 = null; //Charset.forName("ISO-8859-1"); + + /** + * VBR header magic string. + */ + var VBRTag0 = "Xing"; + /** + * VBR header magic string (VBR == VBRMode.vbr_off). + */ + var VBRTag1 = "Info"; + + /** + * Lookup table for fast CRC-16 computation. Uses the polynomial + * x^16+x^15+x^2+1 + */ + var crc16Lookup = [0x0000, 0xC0C1, 0xC181, 0x0140, + 0xC301, 0x03C0, 0x0280, 0xC241, 0xC601, 0x06C0, 0x0780, 0xC741, + 0x0500, 0xC5C1, 0xC481, 0x0440, 0xCC01, 0x0CC0, 0x0D80, 0xCD41, + 0x0F00, 0xCFC1, 0xCE81, 0x0E40, 0x0A00, 0xCAC1, 0xCB81, 0x0B40, + 0xC901, 0x09C0, 0x0880, 0xC841, 0xD801, 0x18C0, 0x1980, 0xD941, + 0x1B00, 0xDBC1, 0xDA81, 0x1A40, 0x1E00, 0xDEC1, 0xDF81, 0x1F40, + 0xDD01, 0x1DC0, 0x1C80, 0xDC41, 0x1400, 0xD4C1, 0xD581, 0x1540, + 0xD701, 0x17C0, 0x1680, 0xD641, 0xD201, 0x12C0, 0x1380, 0xD341, + 0x1100, 0xD1C1, 0xD081, 0x1040, 0xF001, 0x30C0, 0x3180, 0xF141, + 0x3300, 0xF3C1, 0xF281, 0x3240, 0x3600, 0xF6C1, 0xF781, 0x3740, + 0xF501, 0x35C0, 0x3480, 0xF441, 0x3C00, 0xFCC1, 0xFD81, 0x3D40, + 0xFF01, 0x3FC0, 0x3E80, 0xFE41, 0xFA01, 0x3AC0, 0x3B80, 0xFB41, + 0x3900, 0xF9C1, 0xF881, 0x3840, 0x2800, 0xE8C1, 0xE981, 0x2940, + 0xEB01, 0x2BC0, 0x2A80, 0xEA41, 0xEE01, 0x2EC0, 0x2F80, 0xEF41, + 0x2D00, 0xEDC1, 0xEC81, 0x2C40, 0xE401, 0x24C0, 0x2580, 0xE541, + 0x2700, 0xE7C1, 0xE681, 0x2640, 0x2200, 0xE2C1, 0xE381, 0x2340, + 0xE101, 0x21C0, 0x2080, 0xE041, 0xA001, 0x60C0, 0x6180, 0xA141, + 0x6300, 0xA3C1, 0xA281, 0x6240, 0x6600, 0xA6C1, 0xA781, 0x6740, + 0xA501, 0x65C0, 0x6480, 0xA441, 0x6C00, 0xACC1, 0xAD81, 0x6D40, + 0xAF01, 0x6FC0, 0x6E80, 0xAE41, 0xAA01, 0x6AC0, 0x6B80, 0xAB41, + 0x6900, 0xA9C1, 0xA881, 0x6840, 0x7800, 0xB8C1, 0xB981, 0x7940, + 0xBB01, 0x7BC0, 0x7A80, 0xBA41, 0xBE01, 0x7EC0, 0x7F80, 0xBF41, + 0x7D00, 0xBDC1, 0xBC81, 0x7C40, 0xB401, 0x74C0, 0x7580, 0xB541, + 0x7700, 0xB7C1, 0xB681, 0x7640, 0x7200, 0xB2C1, 0xB381, 0x7340, + 0xB101, 0x71C0, 0x7080, 0xB041, 0x5000, 0x90C1, 0x9181, 0x5140, + 0x9301, 0x53C0, 0x5280, 0x9241, 0x9601, 0x56C0, 0x5780, 0x9741, + 0x5500, 0x95C1, 0x9481, 0x5440, 0x9C01, 0x5CC0, 0x5D80, 0x9D41, + 0x5F00, 0x9FC1, 0x9E81, 0x5E40, 0x5A00, 0x9AC1, 0x9B81, 0x5B40, + 0x9901, 0x59C0, 0x5880, 0x9841, 0x8801, 0x48C0, 0x4980, 0x8941, + 0x4B00, 0x8BC1, 0x8A81, 0x4A40, 0x4E00, 0x8EC1, 0x8F81, 0x4F40, + 0x8D01, 0x4DC0, 0x4C80, 0x8C41, 0x4400, 0x84C1, 0x8581, 0x4540, + 0x8701, 0x47C0, 0x4680, 0x8641, 0x8201, 0x42C0, 0x4380, 0x8341, + 0x4100, 0x81C1, 0x8081, 0x4040]; + + /*********************************************************************** + * Robert Hegemann 2001-01-17 + ***********************************************************************/ + + function addVbr(v, bitrate) { + v.nVbrNumFrames++; + v.sum += bitrate; + v.seen++; + + if (v.seen < v.want) { + return; + } + + if (v.pos < v.size) { + v.bag[v.pos] = v.sum; + v.pos++; + v.seen = 0; + } + if (v.pos == v.size) { + for (var i = 1; i < v.size; i += 2) { + v.bag[i / 2] = v.bag[i]; + } + v.want *= 2; + v.pos /= 2; + } + } + + function xingSeekTable(v, t) { + if (v.pos <= 0) + return; + + for (var i = 1; i < NUMTOCENTRIES; ++i) { + var j = i / NUMTOCENTRIES, act, sum; + var indx = 0 | (Math.floor(j * v.pos)); + if (indx > v.pos - 1) + indx = v.pos - 1; + act = v.bag[indx]; + sum = v.sum; + var seek_point = 0 | (256. * act / sum); + if (seek_point > 255) + seek_point = 255; + t[i] = 0xff & seek_point; + } + } + + /** + * Add VBR entry, used to fill the VBR TOC entries. + * + * @param gfp + * global flags + */ + this.addVbrFrame = function (gfp) { + var gfc = gfp.internal_flags; + var kbps = Tables.bitrate_table[gfp.version][gfc.bitrate_index]; + assert$24(gfc.VBR_seek_table.bag != null); + addVbr(gfc.VBR_seek_table, kbps); + }; + + /** + * Read big endian integer (4-bytes) from header. + * + * @param buf + * header containing the integer + * @param bufPos + * offset into the header + * @return extracted integer + */ + function extractInteger(buf, bufPos) { + var x = buf[bufPos + 0] & 0xff; + x <<= 8; + x |= buf[bufPos + 1] & 0xff; + x <<= 8; + x |= buf[bufPos + 2] & 0xff; + x <<= 8; + x |= buf[bufPos + 3] & 0xff; + return x; + } + + /** + * Write big endian integer (4-bytes) in the header. + * + * @param buf + * header to write the integer into + * @param bufPos + * offset into the header + * @param value + * integer value to write + */ + function createInteger(buf, bufPos, value) { + buf[bufPos + 0] = 0xff & ((value >> 24) & 0xff); + buf[bufPos + 1] = 0xff & ((value >> 16) & 0xff); + buf[bufPos + 2] = 0xff & ((value >> 8) & 0xff); + buf[bufPos + 3] = 0xff & (value & 0xff); + } + + /** + * Write big endian short (2-bytes) in the header. + * + * @param buf + * header to write the integer into + * @param bufPos + * offset into the header + * @param value + * integer value to write + */ + function createShort(buf, bufPos, value) { + buf[bufPos + 0] = 0xff & ((value >> 8) & 0xff); + buf[bufPos + 1] = 0xff & (value & 0xff); + } + + /** + * Check for magic strings (Xing/Info). + * + * @param buf + * header to check + * @param bufPos + * header offset to check + * @return magic string found + */ + function isVbrTag(buf, bufPos) { + return new String(buf, bufPos, VBRTag0.length(), ISO_8859_1) + .equals(VBRTag0) + || new String(buf, bufPos, VBRTag1.length(), ISO_8859_1) + .equals(VBRTag1); + } + + function shiftInBitsValue(x, n, v) { + return 0xff & ((x << n) | (v & ~(-1 << n))); + } + + /** + * Construct the MP3 header using the settings of the global flags. + * + *
+ *
+ * @param gfp
+ * global flags
+ * @param buffer
+ * header
+ */
+ function setLameTagFrameHeader(gfp, buffer) {
+ var gfc = gfp.internal_flags;
+
+ // MP3 Sync Word
+ buffer[0] = shiftInBitsValue(buffer[0], 8, 0xff);
+
+ buffer[1] = shiftInBitsValue(buffer[1], 3, 7);
+ buffer[1] = shiftInBitsValue(buffer[1], 1,
+ (gfp.out_samplerate < 16000) ? 0 : 1);
+ // Version
+ buffer[1] = shiftInBitsValue(buffer[1], 1, gfp.version);
+ // 01 == Layer 3
+ buffer[1] = shiftInBitsValue(buffer[1], 2, 4 - 3);
+ // Error protection
+ buffer[1] = shiftInBitsValue(buffer[1], 1, (!gfp.error_protection) ? 1
+ : 0);
+
+ // Bit rate
+ buffer[2] = shiftInBitsValue(buffer[2], 4, gfc.bitrate_index);
+ // Frequency
+ buffer[2] = shiftInBitsValue(buffer[2], 2, gfc.samplerate_index);
+ // Pad. Bit
+ buffer[2] = shiftInBitsValue(buffer[2], 1, 0);
+ // Priv. Bit
+ buffer[2] = shiftInBitsValue(buffer[2], 1, gfp.extension);
+
+ // Mode
+ buffer[3] = shiftInBitsValue(buffer[3], 2, gfp.mode.ordinal());
+ // Mode extension (Used with Joint Stereo)
+ buffer[3] = shiftInBitsValue(buffer[3], 2, gfc.mode_ext);
+ // Copy
+ buffer[3] = shiftInBitsValue(buffer[3], 1, gfp.copyright);
+ // Original
+ buffer[3] = shiftInBitsValue(buffer[3], 1, gfp.original);
+ // Emphasis
+ buffer[3] = shiftInBitsValue(buffer[3], 2, gfp.emphasis);
+
+ /* the default VBR header. 48 kbps layer III, no padding, no crc */
+ /* but sampling freq, mode and copyright/copy protection taken */
+ /* from first valid frame */
+ buffer[0] = 0xff;
+ var abyte = 0xff & (buffer[1] & 0xf1);
+ var bitrate;
+ if (1 == gfp.version) {
+ bitrate = XING_BITRATE1;
+ } else {
+ if (gfp.out_samplerate < 16000)
+ bitrate = XING_BITRATE25;
+ else
+ bitrate = XING_BITRATE2;
+ }
+
+ if (gfp.VBR == VbrMode$22.vbr_off)
+ bitrate = gfp.brate;
+
+ var bbyte;
+ if (gfp.free_format)
+ bbyte = 0x00;
+ else
+ bbyte = 0xff & (16 * lame.BitrateIndex(bitrate, gfp.version,
+ gfp.out_samplerate));
+
+ /*
+ * Use as much of the info from the real frames in the Xing header:
+ * samplerate, channels, crc, etc...
+ */
+ if (gfp.version == 1) {
+ /* MPEG1 */
+ buffer[1] = 0xff & (abyte | 0x0a);
+ /* was 0x0b; */
+ abyte = 0xff & (buffer[2] & 0x0d);
+ /* AF keep also private bit */
+ buffer[2] = 0xff & (bbyte | abyte);
+ /* 64kbs MPEG1 frame */
+ } else {
+ /* MPEG2 */
+ buffer[1] = 0xff & (abyte | 0x02);
+ /* was 0x03; */
+ abyte = 0xff & (buffer[2] & 0x0d);
+ /* AF keep also private bit */
+ buffer[2] = 0xff & (bbyte | abyte);
+ /* 64kbs MPEG2 frame */
+ }
+ }
+
+ /**
+ * Get VBR tag information
+ *
+ * @param buf
+ * header to analyze
+ * @param bufPos
+ * offset into the header
+ * @return VBR tag data
+ */
+ this.getVbrTag = function (buf) {
+ var pTagData = new VBRTagData();
+ var bufPos = 0;
+
+ /* get Vbr header data */
+ pTagData.flags = 0;
+
+ /* get selected MPEG header data */
+ var hId = (buf[bufPos + 1] >> 3) & 1;
+ var hSrIndex = (buf[bufPos + 2] >> 2) & 3;
+ var hMode = (buf[bufPos + 3] >> 6) & 3;
+ var hBitrate = ((buf[bufPos + 2] >> 4) & 0xf);
+ hBitrate = Tables.bitrate_table[hId][hBitrate];
+
+ /* check for FFE syncword */
+ if ((buf[bufPos + 1] >> 4) == 0xE)
+ pTagData.samprate = Tables.samplerate_table[2][hSrIndex];
+ else
+ pTagData.samprate = Tables.samplerate_table[hId][hSrIndex];
+
+ /* determine offset of header */
+ if (hId != 0) {
+ /* mpeg1 */
+ if (hMode != 3)
+ bufPos += (32 + 4);
+ else
+ bufPos += (17 + 4);
+ } else {
+ /* mpeg2 */
+ if (hMode != 3)
+ bufPos += (17 + 4);
+ else
+ bufPos += (9 + 4);
+ }
+
+ if (!isVbrTag(buf, bufPos))
+ return null;
+
+ bufPos += 4;
+
+ pTagData.hId = hId;
+
+ /* get flags */
+ var head_flags = pTagData.flags = extractInteger(buf, bufPos);
+ bufPos += 4;
+
+ if ((head_flags & FRAMES_FLAG) != 0) {
+ pTagData.frames = extractInteger(buf, bufPos);
+ bufPos += 4;
+ }
+
+ if ((head_flags & BYTES_FLAG) != 0) {
+ pTagData.bytes = extractInteger(buf, bufPos);
+ bufPos += 4;
+ }
+
+ if ((head_flags & TOC_FLAG) != 0) {
+ if (pTagData.toc != null) {
+ for (var i = 0; i < NUMTOCENTRIES; i++)
+ pTagData.toc[i] = buf[bufPos + i];
+ }
+ bufPos += NUMTOCENTRIES;
+ }
+
+ pTagData.vbrScale = -1;
+
+ if ((head_flags & VBR_SCALE_FLAG) != 0) {
+ pTagData.vbrScale = extractInteger(buf, bufPos);
+ bufPos += 4;
+ }
+
+ pTagData.headersize = ((hId + 1) * 72000 * hBitrate)
+ / pTagData.samprate;
+
+ bufPos += 21;
+ var encDelay = buf[bufPos + 0] << 4;
+ encDelay += buf[bufPos + 1] >> 4;
+ var encPadding = (buf[bufPos + 1] & 0x0F) << 8;
+ encPadding += buf[bufPos + 2] & 0xff;
+ /* check for reasonable values (this may be an old Xing header, */
+ /* not a INFO tag) */
+ if (encDelay < 0 || encDelay > 3000)
+ encDelay = -1;
+ if (encPadding < 0 || encPadding > 3000)
+ encPadding = -1;
+
+ pTagData.encDelay = encDelay;
+ pTagData.encPadding = encPadding;
+
+ /* success */
+ return pTagData;
+ };
+
+ /**
+ * Initializes the header
+ *
+ * @param gfp
+ * global flags
+ */
+ this.InitVbrTag = function (gfp) {
+ var gfc = gfp.internal_flags;
+
+ /**
+ * + * Xing VBR pretends to be a 48kbs layer III frame. (at 44.1kHz). + * (at 48kHz they use 56kbs since 48kbs frame not big enough for + * table of contents) + * let's always embed Xing header inside a 64kbs layer III frame. + * this gives us enough room for a LAME version string too. + * size determined by sampling frequency (MPEG1) + * 32kHz: 216 bytes@48kbs 288bytes@ 64kbs + * 44.1kHz: 156 bytes 208bytes@64kbs (+1 if padding = 1) + * 48kHz: 144 bytes 192 + * + * MPEG 2 values are the same since the framesize and samplerate + * are each reduced by a factor of 2. + *+ */ + var kbps_header; + if (1 == gfp.version) { + kbps_header = XING_BITRATE1; + } else { + if (gfp.out_samplerate < 16000) + kbps_header = XING_BITRATE25; + else + kbps_header = XING_BITRATE2; + } + + if (gfp.VBR == VbrMode$22.vbr_off) + kbps_header = gfp.brate; + + // make sure LAME Header fits into Frame + var totalFrameSize = ((gfp.version + 1) * 72000 * kbps_header) + / gfp.out_samplerate; + var headerSize = (gfc.sideinfo_len + LAMEHEADERSIZE); + gfc.VBR_seek_table.TotalFrameSize = totalFrameSize; + if (totalFrameSize < headerSize || totalFrameSize > MAXFRAMESIZE) { + /* disable tag, it wont fit */ + gfp.bWriteVbrTag = false; + return; + } + + gfc.VBR_seek_table.nVbrNumFrames = 0; + gfc.VBR_seek_table.nBytesWritten = 0; + gfc.VBR_seek_table.sum = 0; + + gfc.VBR_seek_table.seen = 0; + gfc.VBR_seek_table.want = 1; + gfc.VBR_seek_table.pos = 0; + + if (gfc.VBR_seek_table.bag == null) { + gfc.VBR_seek_table.bag = new int[400]; + gfc.VBR_seek_table.size = 400; + } + + // write dummy VBR tag of all 0's into bitstream + var buffer = new_byte$22(MAXFRAMESIZE); + + setLameTagFrameHeader(gfp, buffer); + var n = gfc.VBR_seek_table.TotalFrameSize; + for (var i = 0; i < n; ++i) { + bs.add_dummy_byte(gfp, buffer[i] & 0xff, 1); + } + }; + + /** + * Fast CRC-16 computation (uses table crc16Lookup). + * + * @param value + * @param crc + * @return + */ + function crcUpdateLookup(value, crc) { + var tmp = crc ^ value; + crc = (crc >> 8) ^ crc16Lookup[tmp & 0xff]; + return crc; + } + + this.updateMusicCRC = function (crc, buffer, bufferPos, size) { + for (var i = 0; i < size; ++i) + crc[0] = crcUpdateLookup(buffer[bufferPos + i], crc[0]); + }; + + /** + * Write LAME info: mini version + info on various switches used (Jonathan + * Dee 2001/08/31). + * + * @param gfp + * global flags + * @param musicLength + * music length + * @param streamBuffer + * pointer to output buffer + * @param streamBufferPos + * offset into the output buffer + * @param crc + * computation of CRC-16 of Lame Tag so far (starting at frame + * sync) + * @return number of bytes written to the stream + */ + function putLameVBR(gfp, musicLength, streamBuffer, streamBufferPos, crc) { + var gfc = gfp.internal_flags; + var bytesWritten = 0; + + /* encoder delay */ + var encDelay = gfp.encoder_delay; + /* encoder padding */ + var encPadding = gfp.encoder_padding; + + /* recall: gfp.VBR_q is for example set by the switch -V */ + /* gfp.quality by -q, -h, -f, etc */ + var quality = (100 - 10 * gfp.VBR_q - gfp.quality); + + var version = v.getLameVeryShortVersion(); + var vbr; + var revision = 0x00; + var revMethod; + // numbering different in vbr_mode vs. Lame tag + var vbrTypeTranslator = [1, 5, 3, 2, 4, 0, 3]; + var lowpass = 0 | (((gfp.lowpassfreq / 100.0) + .5) > 255 ? 255 + : (gfp.lowpassfreq / 100.0) + .5); + var peakSignalAmplitude = 0; + var radioReplayGain = 0; + var audiophileReplayGain = 0; + var noiseShaping = gfp.internal_flags.noise_shaping; + var stereoMode = 0; + var nonOptimal = 0; + var sourceFreq = 0; + var misc = 0; + var musicCRC = 0; + + // psy model type: Gpsycho or NsPsytune + var expNPsyTune = (gfp.exp_nspsytune & 1) != 0; + var safeJoint = (gfp.exp_nspsytune & 2) != 0; + var noGapMore = false; + var noGapPrevious = false; + var noGapCount = gfp.internal_flags.nogap_total; + var noGapCurr = gfp.internal_flags.nogap_current; + + // 4 bits + var athType = gfp.ATHtype; + var flags = 0; + + // vbr modes + var abrBitrate; + switch (gfp.VBR) { + case vbr_abr: + abrBitrate = gfp.VBR_mean_bitrate_kbps; + break; + case vbr_off: + abrBitrate = gfp.brate; + break; + default: + abrBitrate = gfp.VBR_min_bitrate_kbps; + } + + // revision and vbr method + if (gfp.VBR.ordinal() < vbrTypeTranslator.length) + vbr = vbrTypeTranslator[gfp.VBR.ordinal()]; + else + vbr = 0x00; // unknown + + revMethod = 0x10 * revision + vbr; + + // ReplayGain + if (gfc.findReplayGain) { + if (gfc.RadioGain > 0x1FE) + gfc.RadioGain = 0x1FE; + if (gfc.RadioGain < -0x1FE) + gfc.RadioGain = -0x1FE; + + // set name code + radioReplayGain = 0x2000; + // set originator code to `determined automatically' + radioReplayGain |= 0xC00; + + if (gfc.RadioGain >= 0) { + // set gain adjustment + radioReplayGain |= gfc.RadioGain; + } else { + // set the sign bit + radioReplayGain |= 0x200; + // set gain adjustment + radioReplayGain |= -gfc.RadioGain; + } + } + + // peak sample + if (gfc.findPeakSample) + peakSignalAmplitude = Math + .abs(0 | ((( gfc.PeakSample) / 32767.0) * Math.pow(2, 23) + .5)); + + // nogap + if (noGapCount != -1) { + if (noGapCurr > 0) + noGapPrevious = true; + + if (noGapCurr < noGapCount - 1) + noGapMore = true; + } + + // flags + flags = athType + ((expNPsyTune ? 1 : 0) << 4) + + ((safeJoint ? 1 : 0) << 5) + ((noGapMore ? 1 : 0) << 6) + + ((noGapPrevious ? 1 : 0) << 7); + + if (quality < 0) + quality = 0; + + // stereo mode field (Intensity stereo is not implemented) + switch (gfp.mode) { + case MONO: + stereoMode = 0; + break; + case STEREO: + stereoMode = 1; + break; + case DUAL_CHANNEL: + stereoMode = 2; + break; + case JOINT_STEREO: + if (gfp.force_ms) + stereoMode = 4; + else + stereoMode = 3; + break; + case NOT_SET: + //$FALL-THROUGH$ + default: + stereoMode = 7; + break; + } + + if (gfp.in_samplerate <= 32000) + sourceFreq = 0x00; + else if (gfp.in_samplerate == 48000) + sourceFreq = 0x02; + else if (gfp.in_samplerate > 48000) + sourceFreq = 0x03; + else { + // default is 44100Hz + sourceFreq = 0x01; + } + + // Check if the user overrided the default LAME behavior with some + // nasty options + if (gfp.short_blocks == ShortBlock$22.short_block_forced + || gfp.short_blocks == ShortBlock$22.short_block_dispensed + || ((gfp.lowpassfreq == -1) && (gfp.highpassfreq == -1)) || /* "-k" */ + (gfp.scale_left < gfp.scale_right) + || (gfp.scale_left > gfp.scale_right) + || (gfp.disable_reservoir && gfp.brate < 320) || gfp.noATH + || gfp.ATHonly || (athType == 0) || gfp.in_samplerate <= 32000) + nonOptimal = 1; + + misc = noiseShaping + (stereoMode << 2) + (nonOptimal << 5) + + (sourceFreq << 6); + + musicCRC = gfc.nMusicCRC; + + // Write all this information into the stream + + createInteger(streamBuffer, streamBufferPos + bytesWritten, quality); + bytesWritten += 4; + + for (var j = 0; j < 9; j++) { + streamBuffer[streamBufferPos + bytesWritten + j] = 0xff & version .charAt(j); + } + bytesWritten += 9; + + streamBuffer[streamBufferPos + bytesWritten] = 0xff & revMethod; + bytesWritten++; + + streamBuffer[streamBufferPos + bytesWritten] = 0xff & lowpass; + bytesWritten++; + + createInteger(streamBuffer, streamBufferPos + bytesWritten, + peakSignalAmplitude); + bytesWritten += 4; + + createShort(streamBuffer, streamBufferPos + bytesWritten, + radioReplayGain); + bytesWritten += 2; + + createShort(streamBuffer, streamBufferPos + bytesWritten, + audiophileReplayGain); + bytesWritten += 2; + + streamBuffer[streamBufferPos + bytesWritten] = 0xff & flags; + bytesWritten++; + + if (abrBitrate >= 255) + streamBuffer[streamBufferPos + bytesWritten] = 0xFF; + else + streamBuffer[streamBufferPos + bytesWritten] = 0xff & abrBitrate; + bytesWritten++; + + streamBuffer[streamBufferPos + bytesWritten] = 0xff & (encDelay >> 4); + streamBuffer[streamBufferPos + bytesWritten + 1] = 0xff & ((encDelay << 4) + (encPadding >> 8)); + streamBuffer[streamBufferPos + bytesWritten + 2] = 0xff & encPadding; + + bytesWritten += 3; + + streamBuffer[streamBufferPos + bytesWritten] = 0xff & misc; + bytesWritten++; + + // unused in rev0 + streamBuffer[streamBufferPos + bytesWritten++] = 0; + + createShort(streamBuffer, streamBufferPos + bytesWritten, gfp.preset); + bytesWritten += 2; + + createInteger(streamBuffer, streamBufferPos + bytesWritten, musicLength); + bytesWritten += 4; + + createShort(streamBuffer, streamBufferPos + bytesWritten, musicCRC); + bytesWritten += 2; + + // Calculate tag CRC.... must be done here, since it includes previous + // information + + for (var i = 0; i < bytesWritten; i++) + crc = crcUpdateLookup(streamBuffer[streamBufferPos + i], crc); + + createShort(streamBuffer, streamBufferPos + bytesWritten, crc); + bytesWritten += 2; + + return bytesWritten; + } + + function skipId3v2(fpStream) { + // seek to the beginning of the stream + fpStream.seek(0); + // read 10 bytes in case there's an ID3 version 2 header here + var id3v2Header = new_byte$22(10); + fpStream.readFully(id3v2Header); + /* does the stream begin with the ID3 version 2 file identifier? */ + var id3v2TagSize; + if (!new String(id3v2Header, "ISO-8859-1").startsWith("ID3")) { + /* + * the tag size (minus the 10-byte header) is encoded into four + * bytes where the most significant bit is clear in each byte + */ + id3v2TagSize = (((id3v2Header[6] & 0x7f) << 21) + | ((id3v2Header[7] & 0x7f) << 14) + | ((id3v2Header[8] & 0x7f) << 7) | (id3v2Header[9] & 0x7f)) + + id3v2Header.length; + } else { + /* no ID3 version 2 tag in this stream */ + id3v2TagSize = 0; + } + return id3v2TagSize; + } + + this.getLameTagFrame = function (gfp, buffer) { + var gfc = gfp.internal_flags; + + if (!gfp.bWriteVbrTag) { + return 0; + } + if (gfc.Class_ID != Lame.LAME_ID) { + return 0; + } + if (gfc.VBR_seek_table.pos <= 0) { + return 0; + } + if (buffer.length < gfc.VBR_seek_table.TotalFrameSize) { + return gfc.VBR_seek_table.TotalFrameSize; + } + + Arrays$22.fill(buffer, 0, gfc.VBR_seek_table.TotalFrameSize, 0); + + // 4 bytes frame header + setLameTagFrameHeader(gfp, buffer); + + // Create TOC entries + var toc = new_byte$22(NUMTOCENTRIES); + + if (gfp.free_format) { + for (var i = 1; i < NUMTOCENTRIES; ++i) + toc[i] = 0xff & (255 * i / 100); + } else { + xingSeekTable(gfc.VBR_seek_table, toc); + } + + // Start writing the tag after the zero frame + var streamIndex = gfc.sideinfo_len; + /** + * Note: Xing header specifies that Xing data goes in the ancillary data + * with NO ERROR PROTECTION. If error protecton in enabled, the Xing + * data still starts at the same offset, and now it is in sideinfo data + * block, and thus will not decode correctly by non-Xing tag aware + * players + */ + if (gfp.error_protection) + streamIndex -= 2; + + // Put Vbr tag + if (gfp.VBR == VbrMode$22.vbr_off) { + buffer[streamIndex++] = 0xff & VBRTag1.charAt(0); + buffer[streamIndex++] = 0xff & VBRTag1.charAt(1); + buffer[streamIndex++] = 0xff & VBRTag1.charAt(2); + buffer[streamIndex++] = 0xff & VBRTag1.charAt(3); + + } else { + buffer[streamIndex++] = 0xff & VBRTag0.charAt(0); + buffer[streamIndex++] = 0xff & VBRTag0.charAt(1); + buffer[streamIndex++] = 0xff & VBRTag0.charAt(2); + buffer[streamIndex++] = 0xff & VBRTag0.charAt(3); + } + + // Put header flags + createInteger(buffer, streamIndex, FRAMES_FLAG + BYTES_FLAG + TOC_FLAG + + VBR_SCALE_FLAG); + streamIndex += 4; + + // Put Total Number of frames + createInteger(buffer, streamIndex, gfc.VBR_seek_table.nVbrNumFrames); + streamIndex += 4; + + // Put total audio stream size, including Xing/LAME Header + var streamSize = (gfc.VBR_seek_table.nBytesWritten + gfc.VBR_seek_table.TotalFrameSize); + createInteger(buffer, streamIndex, 0 | streamSize); + streamIndex += 4; + + /* Put TOC */ + System$22.arraycopy(toc, 0, buffer, streamIndex, toc.length); + streamIndex += toc.length; + + if (gfp.error_protection) { + // (jo) error_protection: add crc16 information to header + bs.CRC_writeheader(gfc, buffer); + } + + // work out CRC so far: initially crc = 0 + var crc = 0x00; + for (var i = 0; i < streamIndex; i++) + crc = crcUpdateLookup(buffer[i], crc); + // Put LAME VBR info + streamIndex += putLameVBR(gfp, streamSize, buffer, streamIndex, crc); + + return gfc.VBR_seek_table.TotalFrameSize; + }; + + /** + * Write final VBR tag to the file. + * + * @param gfp + * global flags + * @param stream + * stream to add the VBR tag to + * @return 0 (OK), -1 else + * @throws IOException + * I/O error + */ + this.putVbrTag = function (gfp, stream) { + var gfc = gfp.internal_flags; + + if (gfc.VBR_seek_table.pos <= 0) + return -1; + + // Seek to end of file + stream.seek(stream.length()); + + // Get file size, abort if file has zero length. + if (stream.length() == 0) + return -1; + + // The VBR tag may NOT be located at the beginning of the stream. If an + // ID3 version 2 tag was added, then it must be skipped to write the VBR + // tag data. + var id3v2TagSize = skipId3v2(stream); + + // Seek to the beginning of the stream + stream.seek(id3v2TagSize); + + var buffer = new_byte$22(MAXFRAMESIZE); + var bytes = getLameTagFrame(gfp, buffer); + if (bytes > buffer.length) { + return -1; + } + + if (bytes < 1) { + return 0; + } + + // Put it all to disk again + stream.write(buffer, 0, bytes); + // success + return 0; + }; + +} + +var VBRTag_1 = VBRTag; + +var new_byte = common.new_byte; +var assert = common.assert; + +Lame = Lame_1; +Presets = Presets_1; +GainAnalysis = GainAnalysis_1; +QuantizePVT = QuantizePVT_1; +Quantize = Quantize_1; +Takehiro = Takehiro_1; +Reservoir = Reservoir_1; +MPEGMode = MPEGMode_1; +BitStream = BitStream_1; + + + + +function GetAudio() { + var parse; + var mpg; + + this.setModules = function (parse2, mpg2) { + parse = parse2; + mpg = mpg2; + }; +} + + +function Parse() { + var ver; + var id3; + var pre; + + this.setModules = function (ver2, id32, pre2) { + ver = ver2; + id3 = id32; + pre = pre2; + }; +} + +function MPGLib() { +} + +function ID3Tag() { + var bits; + var ver; + + this.setModules = function (_bits, _ver) { + bits = _bits; + ver = _ver; + }; +} + +function Mp3Encoder(channels, samplerate, kbps) { + if (arguments.length != 3) { + console.error('WARN: Mp3Encoder(channels, samplerate, kbps) not specified'); + channels = 1; + samplerate = 44100; + kbps = 128; + } + var lame = new Lame(); + var gaud = new GetAudio(); + var ga = new GainAnalysis(); + var bs = new BitStream(); + var p = new Presets(); + var qupvt = new QuantizePVT(); + var qu = new Quantize(); + var vbr = new VBRTag_1(); + var ver = new Version_1(); + var id3 = new ID3Tag(); + var rv = new Reservoir(); + var tak = new Takehiro(); + var parse = new Parse(); + var mpg = new MPGLib(); + + lame.setModules(ga, bs, p, qupvt, qu, vbr, ver, id3, mpg); + bs.setModules(ga, mpg, ver, vbr); + id3.setModules(bs, ver); + p.setModules(lame); + qu.setModules(bs, rv, qupvt, tak); + qupvt.setModules(tak, rv, lame.enc.psy); + rv.setModules(bs); + tak.setModules(qupvt); + vbr.setModules(lame, bs, ver); + gaud.setModules(parse, mpg); + parse.setModules(ver, id3, p); + + var gfp = lame.lame_init(); + + gfp.num_channels = channels; + gfp.in_samplerate = samplerate; + gfp.brate = kbps; + gfp.mode = MPEGMode.STEREO; + gfp.quality = 3; + gfp.bWriteVbrTag = false; + gfp.disable_reservoir = true; + gfp.write_id3tag_automatic = false; + + var retcode = lame.lame_init_params(gfp); + assert(0 == retcode); + var maxSamples = 1152; + var mp3buf_size = 0 | (1.25 * maxSamples + 7200); + var mp3buf = new_byte(mp3buf_size); + + this.encodeBuffer = function (left, right) { + if (channels == 1) { + right = left; + } + assert(left.length == right.length); + if (left.length > maxSamples) { + maxSamples = left.length; + mp3buf_size = 0 | (1.25 * maxSamples + 7200); + mp3buf = new_byte(mp3buf_size); + } + + var _sz = lame.lame_encode_buffer(gfp, left, right, left.length, mp3buf, 0, mp3buf_size); + return new Int8Array(mp3buf.subarray(0, _sz)); + }; + + this.flush = function () { + var _sz = lame.lame_encode_flush(gfp, mp3buf, 0, mp3buf_size); + return new Int8Array(mp3buf.subarray(0, _sz)); + }; +} + +function WavHeader() { + this.dataOffset = 0; + this.dataLen = 0; + this.channels = 0; + this.sampleRate = 0; +} + +function fourccToInt(fourcc) { + return fourcc.charCodeAt(0) << 24 | fourcc.charCodeAt(1) << 16 | fourcc.charCodeAt(2) << 8 | fourcc.charCodeAt(3); +} + +WavHeader.RIFF = fourccToInt("RIFF"); +WavHeader.WAVE = fourccToInt("WAVE"); +WavHeader.fmt_ = fourccToInt("fmt "); +WavHeader.data = fourccToInt("data"); + +WavHeader.readHeader = function (dataView) { + var w = new WavHeader(); + + var header = dataView.getUint32(0, false); + if (WavHeader.RIFF != header) { + return; + } + var fileLen = dataView.getUint32(4, true); + if (WavHeader.WAVE != dataView.getUint32(8, false)) { + return; + } + if (WavHeader.fmt_ != dataView.getUint32(12, false)) { + return; + } + var fmtLen = dataView.getUint32(16, true); + var pos = 16 + 4; + switch (fmtLen) { + case 16: + case 18: + w.channels = dataView.getUint16(pos + 2, true); + w.sampleRate = dataView.getUint32(pos + 4, true); + break; + default: + throw 'extended fmt chunk not implemented'; + } + pos += fmtLen; + var data = WavHeader.data; + var len = 0; + while (data != header) { + header = dataView.getUint32(pos, false); + len = dataView.getUint32(pos + 4, true); + if (data == header) { + break; + } + pos += (len + 8); + } + w.dataLen = len; + w.dataOffset = pos + 8; + return w; +}; + +var Mp3Encoder_1 = Mp3Encoder; + +var classCallCheck = function (instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } +}; + +var createClass = function () { + function defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, descriptor.key, descriptor); + } + } + + return function (Constructor, protoProps, staticProps) { + if (protoProps) defineProperties(Constructor.prototype, protoProps); + if (staticProps) defineProperties(Constructor, staticProps); + return Constructor; + }; +}(); + +var Encoder = function () { + function Encoder(config) { + classCallCheck(this, Encoder); + + this.config = { + sampleRate: 44100, + bitRate: 128 + }; + + Object.assign(this.config, config); + + this.mp3Encoder = new Mp3Encoder_1(1, this.config.sampleRate, this.config.bitRate); + + // Audio is processed by frames of 1152 samples per audio channel + // http://lame.sourceforge.net/tech-FAQ.txt + this.maxSamples = 1152; + + this.samplesMono = null; + this.clearBuffer(); + } + + /** + * Clear active buffer + */ + + + createClass(Encoder, [{ + key: 'clearBuffer', + value: function clearBuffer() { + this.dataBuffer = []; + } + + /** + * Append new audio buffer to current active buffer + * @param {Buffer} buffer + */ + + }, { + key: 'appendToBuffer', + value: function appendToBuffer(buffer) { + this.dataBuffer.push(new Int8Array(buffer)); + } + + /** + * Float current data to 16 bits PCM + * @param {Float32Array} input + * @param {Int16Array} output + */ + + }, { + key: 'floatTo16BitPCM', + value: function floatTo16BitPCM(input, output) { + for (var i = 0; i < input.length; i++) { + var s = Math.max(-1, Math.min(1, input[i])); + output[i] = s < 0 ? s * 0x8000 : s * 0x7FFF; + } + } + + /** + * Convert buffer to proper format + * @param {Array} arrayBuffer + */ + + }, { + key: 'convertBuffer', + value: function convertBuffer(arrayBuffer) { + var data = new Float32Array(arrayBuffer); + var out = new Int16Array(arrayBuffer.length); + this.floatTo16BitPCM(data, out); + + return out; + } + + /** + * Encode and append current buffer to dataBuffer + * @param {Array} arrayBuffer + */ + + }, { + key: 'encode', + value: function encode(arrayBuffer) { + this.samplesMono = this.convertBuffer(arrayBuffer); + var remaining = this.samplesMono.length; + + for (var i = 0; remaining >= 0; i += this.maxSamples) { + var left = this.samplesMono.subarray(i, i + this.maxSamples); + var mp3buffer = this.mp3Encoder.encodeBuffer(left); + this.appendToBuffer(mp3buffer); + remaining -= this.maxSamples; + } + } + + /** + * Return full dataBuffer + */ + + }, { + key: 'finish', + value: function finish() { + this.appendToBuffer(this.mp3Encoder.flush()); + + return this.dataBuffer; + } + }]); + return Encoder; +}(); + +var MicRecorder = function () { + function MicRecorder(config) { + classCallCheck(this, MicRecorder); + + this.config = { + // 128 or 160 kbit/s – mid-range bitrate quality + bitRate: 128, + + // There is a known issue with some macOS machines, where the recording + // will sometimes have a loud 'pop' or 'pop-click' sound. This flag + // prevents getting audio from the microphone a few milliseconds after + // the begining of the recording. It also helps to remove the mouse + // "click" sound from the output mp3 file. + startRecordingAt: 300, + deviceId: null + }; + + this.activeStream = null; + this.context = null; + this.microphone = null; + this.processor = null; + this.startTime = 0; + + Object.assign(this.config, config); + } + + /** + * Starts to listen for the microphone sound + * @param {MediaStream} stream + */ + + + createClass(MicRecorder, [{ + key: 'addMicrophoneListener', + value: function addMicrophoneListener(stream) { + var _this = this; + + this.activeStream = stream; + + // This prevents the weird noise once you start listening to the microphone + this.timerToStart = setTimeout(function () { + delete _this.timerToStart; + }, this.config.startRecordingAt); + + // Set up Web Audio API to process data from the media stream (microphone). + this.microphone = this.context.createMediaStreamSource(stream); + + // Settings a bufferSize of 0 instructs the browser to choose the best bufferSize + this.processor = this.context.createScriptProcessor(0, 1, 1); + + // Add all buffers from LAME into an array. + this.processor.onaudioprocess = function (event) { + if (_this.timerToStart) { + return; + } + + // Send microphone data to LAME for MP3 encoding while recording. + _this.lameEncoder.encode(event.inputBuffer.getChannelData(0)); + }; + + // Begin retrieving microphone data. + this.microphone.connect(this.processor); + this.processor.connect(this.context.destination); + } + }, { + key: 'stop', + + + /** + * Disconnect microphone, processor and remove activeStream + */ + value: function stop() { + if (this.processor && this.microphone) { + // Clean up the Web Audio API resources. + this.microphone.disconnect(); + this.processor.disconnect(); + + // If all references using this.context are destroyed, context is closed + // automatically. DOMException is fired when trying to close again + if (this.context && this.context.state !== 'closed') { + this.context.close(); + } + + this.processor.onaudioprocess = null; + + // Stop all audio tracks. Also, removes recording icon from chrome tab + this.activeStream.getAudioTracks().forEach(function (track) { + return track.stop(); + }); + } + + return this; + } + }, { + key: 'start', + + + /** + * Requests access to the microphone and start recording + * @return Promise + */ + value: function start() { + var _this2 = this; + + var AudioContext = window.AudioContext || window.webkitAudioContext; + this.context = new AudioContext(); + this.config.sampleRate = this.context.sampleRate; + this.lameEncoder = new Encoder(this.config); + + var audio = this.config.deviceId ? { deviceId: { exact: this.config.deviceId } } : true; + + return new Promise(function (resolve, reject) { + navigator.mediaDevices.getUserMedia({ audio: audio }).then(function (stream) { + _this2.addMicrophoneListener(stream); + resolve(stream); + }).catch(function (err) { + reject(err); + }); + }); + } + }, { + key: 'getMp3', + + + /** + * Return Mp3 Buffer and Blob with type mp3 + * @return {Promise} + */ + value: function getMp3() { + var _this3 = this; + + var finalBuffer = this.lameEncoder.finish(); + + return new Promise(function (resolve, reject) { + if (finalBuffer.length === 0) { + reject(new Error('No buffer to send')); + } else { + resolve([finalBuffer, new Blob(finalBuffer, { type: 'audio/mp3' })]); + _this3.lameEncoder.clearBuffer(); + } + }); + } + }]); + return MicRecorder; +}(); + +return MicRecorder; + +}))); +//# sourceMappingURL=index.js.map diff --git a/app/templates/base.html b/app/templates/base.html index 81222b9..9715abc 100755 --- a/app/templates/base.html +++ b/app/templates/base.html @@ -15,7 +15,7 @@ - +
Longitude: " + crd.longitude + "
Distance to TENT: " + distance(target.longitude, target.latitude, crd.longitude, crd.latitude); + locationHandler(pos); + // if we want to clear the watch // if (target.latitude === crd.latitude && target.longitude === crd.longitude) { // console.log('Congratulations, you reached the target'); @@ -344,7 +346,7 @@ function init() { startBtn.addEventListener("click", startCompass); - navigator.geolocation.getCurrentPosition(locationHandler); + // navigator.geolocation.getCurrentPosition(locationHandler); if (!isIOS) { window.addEventListener("deviceorientationabsolute", handler, true);