vendor: 530,087 bytes, lines 1-15518
1function lamejs() { 2function new_byte(count) { 3 return new Int8Array(count); 4} 5 6function new_short(count) { 7 return new Int16Array(count); 8} 9 10function new_int(count) { 11 return new Int32Array(count); 12} 13 14function new_float(count) { 15 return new Float32Array(count); 16} 17 18function new_double(count) { 19 return new Float64Array(count); 20} 21 22function new_float_n(args) { 23 if (args.length == 1) { 24 return new_float(args[0]); 25 } 26 var sz = args[0]; 27 args = args.slice(1); 28 var A = []; 29 for (var i = 0; i < sz; i++) { 30 A.push(new_float_n(args)); 31 } 32 return A; 33} 34function new_int_n(args) { 35 if (args.length == 1) { 36 return new_int(args[0]); 37 } 38 var sz = args[0]; 39 args = args.slice(1); 40 var A = []; 41 for (var i = 0; i < sz; i++) { 42 A.push(new_int_n(args)); 43 } 44 return A; 45} 46 47function new_short_n(args) { 48 if (args.length == 1) { 49 return new_short(args[0]); 50 } 51 var sz = args[0]; 52 args = args.slice(1); 53 var A = []; 54 for (var i = 0; i < sz; i++) { 55 A.push(new_short_n(args)); 56 } 57 return A; 58} 59 60function new_array_n(args) { 61 if (args.length == 1) { 62 return new Array(args[0]); 63 } 64 var sz = args[0]; 65 args = args.slice(1); 66 var A = []; 67 for (var i = 0; i < sz; i++) { 68 A.push(new_array_n(args)); 69 } 70 return A; 71} 72 73 74var Arrays = {}; 75 76Arrays.fill = function (a, fromIndex, toIndex, val) { 77 if (arguments.length == 2) { 78 for (var i = 0; i < a.length; i++) { 79 a[i] = arguments[1]; 80 } 81 } else { 82 for (var i = fromIndex; i < toIndex; i++) { 83 a[i] = val; 84 } 85 } 86}; 87 88var System = {}; 89 90System.arraycopy = function (src, srcPos, dest, destPos, length) { 91 var srcEnd = srcPos + length; 92 while (srcPos < srcEnd) 93 dest[destPos++] = src[srcPos++]; 94}; 95 96 97var Util = {}; 98Util.SQRT2 = 1.41421356237309504880; 99Util.FAST_LOG10 = function (x) { 100 return Math.log10(x); 101}; 102 103Util.FAST_LOG10_X = function (x, y) { 104 return Math.log10(x) * y; 105}; 106 107function ShortBlock(ordinal) { 108 this.ordinal = ordinal; 109} 110/** 111 * LAME may use them, even different block types for L/R. 112 */ 113ShortBlock.short_block_allowed = new ShortBlock(0); 114/** 115 * LAME may use them, but always same block types in L/R. 116 */ 117ShortBlock.short_block_coupled = new ShortBlock(1); 118/** 119 * LAME will not use short blocks, long blocks only. 120 */ 121ShortBlock.short_block_dispensed = new ShortBlock(2); 122/** 123 * LAME will not use long blocks, short blocks only. 124 */ 125ShortBlock.short_block_forced = new ShortBlock(3); 126 127var Float = {}; 128Float.MAX_VALUE = 3.4028235e+38; 129 130function VbrMode(ordinal) { 131 this.ordinal = ordinal; 132} 133VbrMode.vbr_off = new VbrMode(0); 134VbrMode.vbr_mt = new VbrMode(1); 135VbrMode.vbr_rh = new VbrMode(2); 136VbrMode.vbr_abr = new VbrMode(3); 137VbrMode.vbr_mtrh = new VbrMode(4); 138VbrMode.vbr_default = VbrMode.vbr_mtrh; 139 140var assert = function (x) { 141 //console.assert(x); 142}; 143 144var module_exports = { 145 "System": System, 146 "VbrMode": VbrMode, 147 "Float": Float, 148 "ShortBlock": ShortBlock, 149 "Util": Util, 150 "Arrays": Arrays, 151 "new_array_n": new_array_n, 152 "new_byte": new_byte, 153 "new_double": new_double, 154 "new_float": new_float, 155 "new_float_n": new_float_n, 156 "new_int": new_int, 157 "new_int_n": new_int_n, 158 "new_short": new_short, 159 "new_short_n": new_short_n, 160 "assert": assert 161}; 162//package mp3; 163 164/* MPEG modes */ 165function MPEGMode(ordinal) { 166 var _ordinal = ordinal; 167 this.ordinal = function () { 168 return _ordinal; 169 } 170} 171 172MPEGMode.STEREO = new MPEGMode(0); 173MPEGMode.JOINT_STEREO = new MPEGMode(1); 174MPEGMode.DUAL_CHANNEL = new MPEGMode(2); 175MPEGMode.MONO = new MPEGMode(3); 176MPEGMode.NOT_SET = new MPEGMode(4); 177 178function Version() { 179 180 /** 181 * URL for the LAME website. 182 */ 183 var LAME_URL = "http://www.mp3dev.org/"; 184 185 /** 186 * Major version number. 187 */ 188 var LAME_MAJOR_VERSION = 3; 189 /** 190 * Minor version number. 191 */ 192 var LAME_MINOR_VERSION = 98; 193 /** 194 * Patch level. 195 */ 196 var LAME_PATCH_VERSION = 4; 197 198 /** 199 * Major version number. 200 */ 201 var PSY_MAJOR_VERSION = 0; 202 /** 203 * Minor version number. 204 */ 205 var PSY_MINOR_VERSION = 93; 206 207 /** 208 * A string which describes the version of LAME. 209 * 210 * @return string which describes the version of LAME 211 */ 212 this.getLameVersion = function () { 213 // primary to write screen reports 214 return (LAME_MAJOR_VERSION + "." + LAME_MINOR_VERSION + "." + LAME_PATCH_VERSION); 215 } 216 217 /** 218 * The short version of the LAME version string. 219 * 220 * @return short version of the LAME version string 221 */ 222 this.getLameShortVersion = function () { 223 // Adding date and time to version string makes it harder for output 224 // validation 225 return (LAME_MAJOR_VERSION + "." + LAME_MINOR_VERSION + "." + LAME_PATCH_VERSION); 226 } 227 228 /** 229 * The shortest version of the LAME version string. 230 * 231 * @return shortest version of the LAME version string 232 */ 233 this.getLameVeryShortVersion = function () { 234 // Adding date and time to version string makes it harder for output 235 return ("LAME" + LAME_MAJOR_VERSION + "." + LAME_MINOR_VERSION + "r"); 236 } 237 238 /** 239 * String which describes the version of GPSYCHO 240 * 241 * @return string which describes the version of GPSYCHO 242 */ 243 this.getPsyVersion = function () { 244 return (PSY_MAJOR_VERSION + "." + PSY_MINOR_VERSION); 245 } 246 247 /** 248 * String which is a URL for the LAME website. 249 * 250 * @return string which is a URL for the LAME website 251 */ 252 this.getLameUrl = function () { 253 return LAME_URL; 254 } 255 256 /** 257 * Quite useless for a java version, however we are compatible ;-) 258 * 259 * @return "32bits" 260 */ 261 this.getLameOsBitness = function () { 262 return "32bits"; 263 } 264 265} 266 267/* 268 * ReplayGainAnalysis - analyzes input samples and give the recommended dB change 269 * Copyright (C) 2001 David Robinson and Glen Sawyer 270 * Improvements and optimizations added by Frank Klemm, and by Marcel Muller 271 * 272 * This library is free software; you can redistribute it and/or 273 * modify it under the terms of the GNU Lesser General Public 274 * License as published by the Free Software Foundation; either 275 * version 2.1 of the License, or (at your option) any later version. 276 * 277 * This library is distributed in the hope that it will be useful, 278 * but WITHOUT ANY WARRANTY; without even the implied warranty of 279 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 280 * Lesser General Public License for more details. 281 * 282 * You should have received a copy of the GNU Lesser General Public 283 * License along with this library; if not, write to the Free Software 284 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 285 * 286 * concept and filter values by David Robinson ([email protected]) 287 * -- blame him if you think the idea is flawed 288 * original coding by Glen Sawyer ([email protected]) 289 * -- blame him if you think this runs too slowly, or the coding is otherwise flawed 290 * 291 * lots of code improvements by Frank Klemm ( http://www.uni-jena.de/~pfk/mpp/ ) 292 * -- credit him for all the _good_ programming ;) 293 * 294 * 295 * For an explanation of the concepts and the basic algorithms involved, go to: 296 * http://www.replaygain.org/ 297 */ 298 299/* 300 * Here's the deal. Call 301 * 302 * InitGainAnalysis ( long samplefreq ); 303 * 304 * to initialize everything. Call 305 * 306 * AnalyzeSamples ( var Float_t* left_samples, 307 * var Float_t* right_samples, 308 * size_t num_samples, 309 * int num_channels ); 310 * 311 * as many times as you want, with as many or as few samples as you want. 312 * If mono, pass the sample buffer in through left_samples, leave 313 * right_samples NULL, and make sure num_channels = 1. 314 * 315 * GetTitleGain() 316 * 317 * will return the recommended dB level change for all samples analyzed 318 * SINCE THE LAST TIME you called GetTitleGain() OR InitGainAnalysis(). 319 * 320 * GetAlbumGain() 321 * 322 * will return the recommended dB level change for all samples analyzed 323 * since InitGainAnalysis() was called and finalized with GetTitleGain(). 324 * 325 * Pseudo-code to process an album: 326 * 327 * Float_t l_samples [4096]; 328 * Float_t r_samples [4096]; 329 * size_t num_samples; 330 * unsigned int num_songs; 331 * unsigned int i; 332 * 333 * InitGainAnalysis ( 44100 ); 334 * for ( i = 1; i <= num_songs; i++ ) { 335 * while ( ( num_samples = getSongSamples ( song[i], left_samples, right_samples ) ) > 0 ) 336 * AnalyzeSamples ( left_samples, right_samples, num_samples, 2 ); 337 * fprintf ("Recommended dB change for song %2d: %+6.2 dB\n", i, GetTitleGain() ); 338 * } 339 * fprintf ("Recommended dB change for whole album: %+6.2 dB\n", GetAlbumGain() ); 340 */ 341 342/* 343 * So here's the main source of potential code confusion: 344 * 345 * The filters applied to the incoming samples are IIR filters, 346 * meaning they rely on up to <filter order> number of previous samples 347 * AND up to <filter order> number of previous filtered samples. 348 * 349 * I set up the AnalyzeSamples routine to minimize memory usage and interface 350 * complexity. The speed isn't compromised too much (I don't think), but the 351 * internal complexity is higher than it should be for such a relatively 352 * simple routine. 353 * 354 * Optimization/clarity suggestions are welcome. 355 */ 356 357/** 358 * Table entries per dB 359 */ 360GainAnalysis.STEPS_per_dB = 100.; 361/** 362 * Table entries for 0...MAX_dB (normal max. values are 70...80 dB) 363 */ 364GainAnalysis.MAX_dB = 120.; 365GainAnalysis.GAIN_NOT_ENOUGH_SAMPLES = -24601; 366GainAnalysis.GAIN_ANALYSIS_ERROR = 0; 367GainAnalysis.GAIN_ANALYSIS_OK = 1; 368GainAnalysis.INIT_GAIN_ANALYSIS_ERROR = 0; 369GainAnalysis.INIT_GAIN_ANALYSIS_OK = 1; 370 371GainAnalysis.YULE_ORDER = 10; 372GainAnalysis.MAX_ORDER = GainAnalysis.YULE_ORDER; 373 374GainAnalysis.MAX_SAMP_FREQ = 48000; 375GainAnalysis.RMS_WINDOW_TIME_NUMERATOR = 1; 376GainAnalysis.RMS_WINDOW_TIME_DENOMINATOR = 20; 377GainAnalysis.MAX_SAMPLES_PER_WINDOW = ((GainAnalysis.MAX_SAMP_FREQ * GainAnalysis.RMS_WINDOW_TIME_NUMERATOR) / GainAnalysis.RMS_WINDOW_TIME_DENOMINATOR + 1); 378 379function GainAnalysis() { 380 /** 381 * calibration value for 89dB 382 */ 383 var PINK_REF = 64.82; 384 385 var YULE_ORDER = GainAnalysis.YULE_ORDER; 386 /** 387 * percentile which is louder than the proposed level 388 */ 389 var RMS_PERCENTILE = 0.95; 390 /** 391 * maximum allowed sample frequency [Hz] 392 */ 393 var MAX_SAMP_FREQ = GainAnalysis.MAX_SAMP_FREQ; 394 var RMS_WINDOW_TIME_NUMERATOR = GainAnalysis.RMS_WINDOW_TIME_NUMERATOR; 395 /** 396 * numerator / denominator = time slice size [s] 397 */ 398 var RMS_WINDOW_TIME_DENOMINATOR = GainAnalysis.RMS_WINDOW_TIME_DENOMINATOR; 399 /** 400 * max. Samples per Time slice 401 */ 402 var MAX_SAMPLES_PER_WINDOW = GainAnalysis.MAX_SAMPLES_PER_WINDOW; 403 404 405 var ABYule = [ 406 [0.03857599435200, -3.84664617118067, -0.02160367184185, 407 7.81501653005538, -0.00123395316851, -11.34170355132042, 408 -0.00009291677959, 13.05504219327545, -0.01655260341619, 409 -12.28759895145294, 0.02161526843274, 9.48293806319790, 410 -0.02074045215285, -5.87257861775999, 0.00594298065125, 411 2.75465861874613, 0.00306428023191, -0.86984376593551, 412 0.00012025322027, 0.13919314567432, 0.00288463683916], 413 [0.05418656406430, -3.47845948550071, -0.02911007808948, 414 6.36317777566148, -0.00848709379851, -8.54751527471874, 415 -0.00851165645469, 9.47693607801280, -0.00834990904936, 416 -8.81498681370155, 0.02245293253339, 6.85401540936998, 417 -0.02596338512915, -4.39470996079559, 0.01624864962975, 418 2.19611684890774, -0.00240879051584, -0.75104302451432, 419 0.00674613682247, 0.13149317958808, -0.00187763777362], 420 [0.15457299681924, -2.37898834973084, -0.09331049056315, 421 2.84868151156327, -0.06247880153653, -2.64577170229825, 422 0.02163541888798, 2.23697657451713, -0.05588393329856, 423 -1.67148153367602, 0.04781476674921, 1.00595954808547, 424 0.00222312597743, -0.45953458054983, 0.03174092540049, 425 0.16378164858596, -0.01390589421898, -0.05032077717131, 426 0.00651420667831, 0.02347897407020, -0.00881362733839], 427 [0.30296907319327, -1.61273165137247, -0.22613988682123, 428 1.07977492259970, -0.08587323730772, -0.25656257754070, 429 0.03282930172664, -0.16276719120440, -0.00915702933434, 430 -0.22638893773906, -0.02364141202522, 0.39120800788284, 431 -0.00584456039913, -0.22138138954925, 0.06276101321749, 432 0.04500235387352, -0.00000828086748, 0.02005851806501, 433 0.00205861885564, 0.00302439095741, -0.02950134983287], 434 [0.33642304856132, -1.49858979367799, -0.25572241425570, 435 0.87350271418188, -0.11828570177555, 0.12205022308084, 436 0.11921148675203, -0.80774944671438, -0.07834489609479, 437 0.47854794562326, -0.00469977914380, -0.12453458140019, 438 -0.00589500224440, -0.04067510197014, 0.05724228140351, 439 0.08333755284107, 0.00832043980773, -0.04237348025746, 440 -0.01635381384540, 0.02977207319925, -0.01760176568150], 441 [0.44915256608450, -0.62820619233671, -0.14351757464547, 442 0.29661783706366, -0.22784394429749, -0.37256372942400, 443 -0.01419140100551, 0.00213767857124, 0.04078262797139, 444 -0.42029820170918, -0.12398163381748, 0.22199650564824, 445 0.04097565135648, 0.00613424350682, 0.10478503600251, 446 0.06747620744683, -0.01863887810927, 0.05784820375801, 447 -0.03193428438915, 0.03222754072173, 0.00541907748707], 448 [0.56619470757641, -1.04800335126349, -0.75464456939302, 449 0.29156311971249, 0.16242137742230, -0.26806001042947, 450 0.16744243493672, 0.00819999645858, -0.18901604199609, 451 0.45054734505008, 0.30931782841830, -0.33032403314006, 452 -0.27562961986224, 0.06739368333110, 0.00647310677246, 453 -0.04784254229033, 0.08647503780351, 0.01639907836189, 454 -0.03788984554840, 0.01807364323573, -0.00588215443421], 455 [0.58100494960553, -0.51035327095184, -0.53174909058578, 456 -0.31863563325245, -0.14289799034253, -0.20256413484477, 457 0.17520704835522, 0.14728154134330, 0.02377945217615, 458 0.38952639978999, 0.15558449135573, -0.23313271880868, 459 -0.25344790059353, -0.05246019024463, 0.01628462406333, 460 -0.02505961724053, 0.06920467763959, 0.02442357316099, 461 -0.03721611395801, 0.01818801111503, -0.00749618797172], 462 [0.53648789255105, -0.25049871956020, -0.42163034350696, 463 -0.43193942311114, -0.00275953611929, -0.03424681017675, 464 0.04267842219415, -0.04678328784242, -0.10214864179676, 465 0.26408300200955, 0.14590772289388, 0.15113130533216, 466 -0.02459864859345, -0.17556493366449, -0.11202315195388, 467 -0.18823009262115, -0.04060034127000, 0.05477720428674, 468 0.04788665548180, 0.04704409688120, -0.02217936801134]]; 469 470 var ABButter = [ 471 [0.98621192462708, -1.97223372919527, -1.97242384925416, 472 0.97261396931306, 0.98621192462708], 473 [0.98500175787242, -1.96977855582618, -1.97000351574484, 474 0.97022847566350, 0.98500175787242], 475 [0.97938932735214, -1.95835380975398, -1.95877865470428, 476 0.95920349965459, 0.97938932735214], 477 [0.97531843204928, -1.95002759149878, -1.95063686409857, 478 0.95124613669835, 0.97531843204928], 479 [0.97316523498161, -1.94561023566527, -1.94633046996323, 480 0.94705070426118, 0.97316523498161], 481 [0.96454515552826, -1.92783286977036, -1.92909031105652, 482 0.93034775234268, 0.96454515552826], 483 [0.96009142950541, -1.91858953033784, -1.92018285901082, 484 0.92177618768381, 0.96009142950541], 485 [0.95856916599601, -1.91542108074780, -1.91713833199203, 486 0.91885558323625, 0.95856916599601], 487 [0.94597685600279, -1.88903307939452, -1.89195371200558, 488 0.89487434461664, 0.94597685600279]]; 489 490 491 /** 492 * When calling this procedure, make sure that ip[-order] and op[-order] 493 * point to real data 494 */ 495 //private void filterYule(final float[] input, int inputPos, float[] output, 496 //int outputPos, int nSamples, final float[] kernel) { 497 function filterYule(input, inputPos, output, outputPos, nSamples, kernel) { 498 499 while ((nSamples--) != 0) { 500 /* 1e-10 is a hack to avoid slowdown because of denormals */ 501 output[outputPos] = 1e-10 + input[inputPos + 0] * kernel[0] 502 - output[outputPos - 1] * kernel[1] + input[inputPos - 1] 503 * kernel[2] - output[outputPos - 2] * kernel[3] 504 + input[inputPos - 2] * kernel[4] - output[outputPos - 3] 505 * kernel[5] + input[inputPos - 3] * kernel[6] 506 - output[outputPos - 4] * kernel[7] + input[inputPos - 4] 507 * kernel[8] - output[outputPos - 5] * kernel[9] 508 + input[inputPos - 5] * kernel[10] - output[outputPos - 6] 509 * kernel[11] + input[inputPos - 6] * kernel[12] 510 - output[outputPos - 7] * kernel[13] + input[inputPos - 7] 511 * kernel[14] - output[outputPos - 8] * kernel[15] 512 + input[inputPos - 8] * kernel[16] - output[outputPos - 9] 513 * kernel[17] + input[inputPos - 9] * kernel[18] 514 - output[outputPos - 10] * kernel[19] 515 + input[inputPos - 10] * kernel[20]; 516 ++outputPos; 517 ++inputPos; 518 } 519 } 520 521//private void filterButter(final float[] input, int inputPos, 522// float[] output, int outputPos, int nSamples, final float[] kernel) { 523 function filterButter(input, inputPos, output, outputPos, nSamples, kernel) { 524 525 while ((nSamples--) != 0) { 526 output[outputPos] = input[inputPos + 0] * kernel[0] 527 - output[outputPos - 1] * kernel[1] + input[inputPos - 1] 528 * kernel[2] - output[outputPos - 2] * kernel[3] 529 + input[inputPos - 2] * kernel[4]; 530 ++outputPos; 531 ++inputPos; 532 } 533 } 534 535 /** 536 * @return INIT_GAIN_ANALYSIS_OK if successful, INIT_GAIN_ANALYSIS_ERROR if 537 * not 538 */ 539 function ResetSampleFrequency(rgData, samplefreq) { 540 /* zero out initial values */ 541 for (var i = 0; i < MAX_ORDER; i++) 542 rgData.linprebuf[i] = rgData.lstepbuf[i] = rgData.loutbuf[i] = rgData.rinprebuf[i] = rgData.rstepbuf[i] = rgData.routbuf[i] = 0.; 543 544 switch (0 | (samplefreq)) { 545 case 48000: 546 rgData.reqindex = 0; 547 break; 548 case 44100: 549 rgData.reqindex = 1; 550 break; 551 case 32000: 552 rgData.reqindex = 2; 553 break; 554 case 24000: 555 rgData.reqindex = 3; 556 break; 557 case 22050: 558 rgData.reqindex = 4; 559 break; 560 case 16000: 561 rgData.reqindex = 5; 562 break; 563 case 12000: 564 rgData.reqindex = 6; 565 break; 566 case 11025: 567 rgData.reqindex = 7; 568 break; 569 case 8000: 570 rgData.reqindex = 8; 571 break; 572 default: 573 return INIT_GAIN_ANALYSIS_ERROR; 574 } 575 576 rgData.sampleWindow = 0 | ((samplefreq * RMS_WINDOW_TIME_NUMERATOR 577 + RMS_WINDOW_TIME_DENOMINATOR - 1) / RMS_WINDOW_TIME_DENOMINATOR); 578 579 rgData.lsum = 0.; 580 rgData.rsum = 0.; 581 rgData.totsamp = 0; 582 583 Arrays.ill(rgData.A, 0); 584 585 return INIT_GAIN_ANALYSIS_OK; 586 } 587 588 this.InitGainAnalysis = function (rgData, samplefreq) { 589 if (ResetSampleFrequency(rgData, samplefreq) != INIT_GAIN_ANALYSIS_OK) { 590 return INIT_GAIN_ANALYSIS_ERROR; 591 } 592 593 rgData.linpre = MAX_ORDER; 594 rgData.rinpre = MAX_ORDER; 595 rgData.lstep = MAX_ORDER; 596 rgData.rstep = MAX_ORDER; 597 rgData.lout = MAX_ORDER; 598 rgData.rout = MAX_ORDER; 599 600 Arrays.fill(rgData.B, 0); 601 602 return INIT_GAIN_ANALYSIS_OK; 603 }; 604 605 /** 606 * square 607 */ 608 function fsqr(d) { 609 return d * d; 610 } 611 612 this.AnalyzeSamples = function (rgData, left_samples, left_samplesPos, right_samples, right_samplesPos, num_samples, 613 num_channels) { 614 var curleft; 615 var curleftBase; 616 var curright; 617 var currightBase; 618 var batchsamples; 619 var cursamples; 620 var cursamplepos; 621 622 if (num_samples == 0) 623 return GAIN_ANALYSIS_OK; 624 625 cursamplepos = 0; 626 batchsamples = num_samples; 627 628 switch (num_channels) { 629 case 1: 630 right_samples = left_samples; 631 right_samplesPos = left_samplesPos; 632 break; 633 case 2: 634 break; 635 default: 636 return GAIN_ANALYSIS_ERROR; 637 } 638 639 if (num_samples < MAX_ORDER) { 640 System.arraycopy(left_samples, left_samplesPos, rgData.linprebuf, 641 MAX_ORDER, num_samples); 642 System.arraycopy(right_samples, right_samplesPos, rgData.rinprebuf, 643 MAX_ORDER, num_samples); 644 } else { 645 System.arraycopy(left_samples, left_samplesPos, rgData.linprebuf, 646 MAX_ORDER, MAX_ORDER); 647 System.arraycopy(right_samples, right_samplesPos, rgData.rinprebuf, 648 MAX_ORDER, MAX_ORDER); 649 } 650 651 while (batchsamples > 0) { 652 cursamples = batchsamples > rgData.sampleWindow - rgData.totsamp ? rgData.sampleWindow 653 - rgData.totsamp 654 : batchsamples; 655 if (cursamplepos < MAX_ORDER) { 656 curleft = rgData.linpre + cursamplepos; 657 curleftBase = rgData.linprebuf; 658 curright = rgData.rinpre + cursamplepos; 659 currightBase = rgData.rinprebuf; 660 if (cursamples > MAX_ORDER - cursamplepos) 661 cursamples = MAX_ORDER - cursamplepos; 662 } else { 663 curleft = left_samplesPos + cursamplepos; 664 curleftBase = left_samples; 665 curright = right_samplesPos + cursamplepos; 666 currightBase = right_samples; 667 } 668 669 filterYule(curleftBase, curleft, rgData.lstepbuf, rgData.lstep 670 + rgData.totsamp, cursamples, ABYule[rgData.reqindex]); 671 filterYule(currightBase, curright, rgData.rstepbuf, rgData.rstep 672 + rgData.totsamp, cursamples, ABYule[rgData.reqindex]); 673 674 filterButter(rgData.lstepbuf, rgData.lstep + rgData.totsamp, 675 rgData.loutbuf, rgData.lout + rgData.totsamp, cursamples, 676 ABButter[rgData.reqindex]); 677 filterButter(rgData.rstepbuf, rgData.rstep + rgData.totsamp, 678 rgData.routbuf, rgData.rout + rgData.totsamp, cursamples, 679 ABButter[rgData.reqindex]); 680 681 curleft = rgData.lout + rgData.totsamp; 682 /* Get the squared values */ 683 curleftBase = rgData.loutbuf; 684 curright = rgData.rout + rgData.totsamp; 685 currightBase = rgData.routbuf; 686 687 var i = cursamples % 8; 688 while ((i--) != 0) { 689 rgData.lsum += fsqr(curleftBase[curleft++]); 690 rgData.rsum += fsqr(currightBase[curright++]); 691 } 692 i = cursamples / 8; 693 while ((i--) != 0) { 694 rgData.lsum += fsqr(curleftBase[curleft + 0]) 695 + fsqr(curleftBase[curleft + 1]) 696 + fsqr(curleftBase[curleft + 2]) 697 + fsqr(curleftBase[curleft + 3]) 698 + fsqr(curleftBase[curleft + 4]) 699 + fsqr(curleftBase[curleft + 5]) 700 + fsqr(curleftBase[curleft + 6]) 701 + fsqr(curleftBase[curleft + 7]); 702 curleft += 8; 703 rgData.rsum += fsqr(currightBase[curright + 0]) 704 + fsqr(currightBase[curright + 1]) 705 + fsqr(currightBase[curright + 2]) 706 + fsqr(currightBase[curright + 3]) 707 + fsqr(currightBase[curright + 4]) 708 + fsqr(currightBase[curright + 5]) 709 + fsqr(currightBase[curright + 6]) 710 + fsqr(currightBase[curright + 7]); 711 curright += 8; 712 } 713 714 batchsamples -= cursamples; 715 cursamplepos += cursamples; 716 rgData.totsamp += cursamples; 717 if (rgData.totsamp == rgData.sampleWindow) { 718 /* Get the Root Mean Square (RMS) for this set of samples */ 719 var val = GainAnalysis.STEPS_per_dB 720 * 10. 721 * Math.log10((rgData.lsum + rgData.rsum) 722 / rgData.totsamp * 0.5 + 1.e-37); 723 var ival = (val <= 0) ? 0 : 0 | val; 724 if (ival >= rgData.A.length) 725 ival = rgData.A.length - 1; 726 rgData.A[ival]++; 727 rgData.lsum = rgData.rsum = 0.; 728 729 System.arraycopy(rgData.loutbuf, rgData.totsamp, 730 rgData.loutbuf, 0, MAX_ORDER); 731 System.arraycopy(rgData.routbuf, rgData.totsamp, 732 rgData.routbuf, 0, MAX_ORDER); 733 System.arraycopy(rgData.lstepbuf, rgData.totsamp, 734 rgData.lstepbuf, 0, MAX_ORDER); 735 System.arraycopy(rgData.rstepbuf, rgData.totsamp, 736 rgData.rstepbuf, 0, MAX_ORDER); 737 rgData.totsamp = 0; 738 } 739 if (rgData.totsamp > rgData.sampleWindow) { 740 /* 741 * somehow I really screwed up: Error in programming! Contact 742 * author about totsamp > sampleWindow 743 */ 744 return GAIN_ANALYSIS_ERROR; 745 } 746 } 747 if (num_samples < MAX_ORDER) { 748 System.arraycopy(rgData.linprebuf, num_samples, rgData.linprebuf, 749 0, MAX_ORDER - num_samples); 750 System.arraycopy(rgData.rinprebuf, num_samples, rgData.rinprebuf, 751 0, MAX_ORDER - num_samples); 752 System.arraycopy(left_samples, left_samplesPos, rgData.linprebuf, 753 MAX_ORDER - num_samples, num_samples); 754 System.arraycopy(right_samples, right_samplesPos, rgData.rinprebuf, 755 MAX_ORDER - num_samples, num_samples); 756 } else { 757 System.arraycopy(left_samples, left_samplesPos + num_samples 758 - MAX_ORDER, rgData.linprebuf, 0, MAX_ORDER); 759 System.arraycopy(right_samples, right_samplesPos + num_samples 760 - MAX_ORDER, rgData.rinprebuf, 0, MAX_ORDER); 761 } 762 763 return GAIN_ANALYSIS_OK; 764 }; 765 766 function analyzeResult(Array, len) { 767 var i; 768 769 var elems = 0; 770 for (i = 0; i < len; i++) 771 elems += Array[i]; 772 if (elems == 0) 773 return GAIN_NOT_ENOUGH_SAMPLES; 774 775 var upper = 0 | Math.ceil(elems * (1. - RMS_PERCENTILE)); 776 for (i = len; i-- > 0;) { 777 if ((upper -= Array[i]) <= 0) 778 break; 779 } 780 781 //return (float) ((float) PINK_REF - (float) i / (float) STEPS_per_dB); 782 return (PINK_REF - i / GainAnalysis.STEPS_per_dB); 783 } 784 785 this.GetTitleGain = function (rgData) { 786 var retval = analyzeResult(rgData.A, rgData.A.length); 787 788 for (var i = 0; i < rgData.A.length; i++) { 789 rgData.B[i] += rgData.A[i]; 790 rgData.A[i] = 0; 791 } 792 793 for (var i = 0; i < MAX_ORDER; i++) 794 rgData.linprebuf[i] = rgData.lstepbuf[i] = rgData.loutbuf[i] = rgData.rinprebuf[i] = rgData.rstepbuf[i] = rgData.routbuf[i] = 0.; 795 796 rgData.totsamp = 0; 797 rgData.lsum = rgData.rsum = 0.; 798 return retval; 799 } 800 801} 802 803 804function Presets() { 805 function VBRPresets(qual, comp, compS, 806 y, shThreshold, shThresholdS, 807 adj, adjShort, lower, 808 curve, sens, inter, 809 joint, mod, fix) { 810 this.vbr_q = qual; 811 this.quant_comp = comp; 812 this.quant_comp_s = compS; 813 this.expY = y; 814 this.st_lrm = shThreshold; 815 this.st_s = shThresholdS; 816 this.masking_adj = adj; 817 this.masking_adj_short = adjShort; 818 this.ath_lower = lower; 819 this.ath_curve = curve; 820 this.ath_sensitivity = sens; 821 this.interch = inter; 822 this.safejoint = joint; 823 this.sfb21mod = mod; 824 this.msfix = fix; 825 } 826 827 function ABRPresets(kbps, comp, compS, 828 joint, fix, shThreshold, 829 shThresholdS, bass, sc, 830 mask, lower, curve, 831 interCh, sfScale) { 832 this.quant_comp = comp; 833 this.quant_comp_s = compS; 834 this.safejoint = joint; 835 this.nsmsfix = fix; 836 this.st_lrm = shThreshold; 837 this.st_s = shThresholdS; 838 this.nsbass = bass; 839 this.scale = sc; 840 this.masking_adj = mask; 841 this.ath_lower = lower; 842 this.ath_curve = curve; 843 this.interch = interCh; 844 this.sfscale = sfScale; 845 } 846 847 var lame; 848 849 this.setModules = function (_lame) { 850 lame = _lame; 851 }; 852 853 /** 854 * <PRE> 855 * Switch mappings for VBR mode VBR_RH 856 * 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 857 * </PRE> 858 */ 859 var vbr_old_switch_map = [ 860 new VBRPresets(0, 9, 9, 0, 5.20, 125.0, -4.2, -6.3, 4.8, 1, 0, 0, 2, 21, 0.97), 861 new VBRPresets(1, 9, 9, 0, 5.30, 125.0, -3.6, -5.6, 4.5, 1.5, 0, 0, 2, 21, 1.35), 862 new VBRPresets(2, 9, 9, 0, 5.60, 125.0, -2.2, -3.5, 2.8, 2, 0, 0, 2, 21, 1.49), 863 new VBRPresets(3, 9, 9, 1, 5.80, 130.0, -1.8, -2.8, 2.6, 3, -4, 0, 2, 20, 1.64), 864 new VBRPresets(4, 9, 9, 1, 6.00, 135.0, -0.7, -1.1, 1.1, 3.5, -8, 0, 2, 0, 1.79), 865 new VBRPresets(5, 9, 9, 1, 6.40, 140.0, 0.5, 0.4, -7.5, 4, -12, 0.0002, 0, 0, 1.95), 866 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), 867 new VBRPresets(7, 9, 9, 1, 6.60, 145.0, 0.8, 0.75, -19.7, 8, -22, 0.0006, 0, 0, 2.70), 868 new VBRPresets(8, 9, 9, 1, 6.60, 145.0, 1.2, 1.15, -27.5, 10, -23, 0.0007, 0, 0, 0), 869 new VBRPresets(9, 9, 9, 1, 6.60, 145.0, 1.6, 1.6, -36, 11, -25, 0.0008, 0, 0, 0), 870 new VBRPresets(10, 9, 9, 1, 6.60, 145.0, 2.0, 2.0, -36, 12, -25, 0.0008, 0, 0, 0) 871 ]; 872 873 /** 874 * <PRE> 875 * 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 876 * </PRE> 877 */ 878 var vbr_psy_switch_map = [ 879 new VBRPresets(0, 9, 9, 0, 4.20, 25.0, -7.0, -4.0, 7.5, 1, 0, 0, 2, 26, 0.97), 880 new VBRPresets(1, 9, 9, 0, 4.20, 25.0, -5.6, -3.6, 4.5, 1.5, 0, 0, 2, 21, 1.35), 881 new VBRPresets(2, 9, 9, 0, 4.20, 25.0, -4.4, -1.8, 2, 2, 0, 0, 2, 18, 1.49), 882 new VBRPresets(3, 9, 9, 1, 4.20, 25.0, -3.4, -1.25, 1.1, 3, -4, 0, 2, 15, 1.64), 883 new VBRPresets(4, 9, 9, 1, 4.20, 25.0, -2.2, 0.1, 0, 3.5, -8, 0, 2, 0, 1.79), 884 new VBRPresets(5, 9, 9, 1, 4.20, 25.0, -1.0, 1.65, -7.7, 4, -12, 0.0002, 0, 0, 1.95), 885 new VBRPresets(6, 9, 9, 1, 4.20, 25.0, -0.0, 2.47, -7.7, 6.5, -19, 0.0004, 0, 0, 2), 886 new VBRPresets(7, 9, 9, 1, 4.20, 25.0, 0.5, 2.0, -14.5, 8, -22, 0.0006, 0, 0, 2), 887 new VBRPresets(8, 9, 9, 1, 4.20, 25.0, 1.0, 2.4, -22.0, 10, -23, 0.0007, 0, 0, 2), 888 new VBRPresets(9, 9, 9, 1, 4.20, 25.0, 1.5, 2.95, -30.0, 11, -25, 0.0008, 0, 0, 2), 889 new VBRPresets(10, 9, 9, 1, 4.20, 25.0, 2.0, 2.95, -36.0, 12, -30, 0.0008, 0, 0, 2) 890 ]; 891 892 function apply_vbr_preset(gfp, a, enforce) { 893 var vbr_preset = gfp.VBR == VbrMode.vbr_rh ? vbr_old_switch_map 894 : vbr_psy_switch_map; 895 896 var x = gfp.VBR_q_frac; 897 var p = vbr_preset[a]; 898 var q = vbr_preset[a + 1]; 899 var set = p; 900 901 // NOOP(vbr_q); 902 // NOOP(quant_comp); 903 // NOOP(quant_comp_s); 904 // NOOP(expY); 905 p.st_lrm = p.st_lrm + x * (q.st_lrm - p.st_lrm); 906 // LERP(st_lrm); 907 p.st_s = p.st_s + x * (q.st_s - p.st_s); 908 // LERP(st_s); 909 p.masking_adj = p.masking_adj + x * (q.masking_adj - p.masking_adj); 910 // LERP(masking_adj); 911 p.masking_adj_short = p.masking_adj_short + x 912 * (q.masking_adj_short - p.masking_adj_short); 913 // LERP(masking_adj_short); 914 p.ath_lower = p.ath_lower + x * (q.ath_lower - p.ath_lower); 915 // LERP(ath_lower); 916 p.ath_curve = p.ath_curve + x * (q.ath_curve - p.ath_curve); 917 // LERP(ath_curve); 918 p.ath_sensitivity = p.ath_sensitivity + x 919 * (q.ath_sensitivity - p.ath_sensitivity); 920 // LERP(ath_sensitivity); 921 p.interch = p.interch + x * (q.interch - p.interch); 922 // LERP(interch); 923 // NOOP(safejoint); 924 // NOOP(sfb21mod); 925 p.msfix = p.msfix + x * (q.msfix - p.msfix); 926 // LERP(msfix); 927 928 lame_set_VBR_q(gfp, set.vbr_q); 929 930 if (enforce != 0) 931 gfp.quant_comp = set.quant_comp; 932 else if (!(Math.abs(gfp.quant_comp - -1) > 0)) 933 gfp.quant_comp = set.quant_comp; 934 // SET_OPTION(quant_comp, set.quant_comp, -1); 935 if (enforce != 0) 936 gfp.quant_comp_short = set.quant_comp_s; 937 else if (!(Math.abs(gfp.quant_comp_short - -1) > 0)) 938 gfp.quant_comp_short = set.quant_comp_s; 939 // SET_OPTION(quant_comp_short, set.quant_comp_s, -1); 940 if (set.expY != 0) { 941 gfp.experimentalY = set.expY != 0; 942 } 943 if (enforce != 0) 944 gfp.internal_flags.nsPsy.attackthre = set.st_lrm; 945 else if (!(Math.abs(gfp.internal_flags.nsPsy.attackthre - -1) > 0)) 946 gfp.internal_flags.nsPsy.attackthre = set.st_lrm; 947 // SET_OPTION(short_threshold_lrm, set.st_lrm, -1); 948 if (enforce != 0) 949 gfp.internal_flags.nsPsy.attackthre_s = set.st_s; 950 else if (!(Math.abs(gfp.internal_flags.nsPsy.attackthre_s - -1) > 0)) 951 gfp.internal_flags.nsPsy.attackthre_s = set.st_s; 952 // SET_OPTION(short_threshold_s, set.st_s, -1); 953 if (enforce != 0) 954 gfp.maskingadjust = set.masking_adj; 955 else if (!(Math.abs(gfp.maskingadjust - 0) > 0)) 956 gfp.maskingadjust = set.masking_adj; 957 // SET_OPTION(maskingadjust, set.masking_adj, 0); 958 if (enforce != 0) 959 gfp.maskingadjust_short = set.masking_adj_short; 960 else if (!(Math.abs(gfp.maskingadjust_short - 0) > 0)) 961 gfp.maskingadjust_short = set.masking_adj_short; 962 // SET_OPTION(maskingadjust_short, set.masking_adj_short, 0); 963 if (enforce != 0) 964 gfp.ATHlower = -set.ath_lower / 10.0; 965 else if (!(Math.abs((-gfp.ATHlower * 10.0) - 0) > 0)) 966 gfp.ATHlower = -set.ath_lower / 10.0; 967 // SET_OPTION(ATHlower, set.ath_lower, 0); 968 if (enforce != 0) 969 gfp.ATHcurve = set.ath_curve; 970 else if (!(Math.abs(gfp.ATHcurve - -1) > 0)) 971 gfp.ATHcurve = set.ath_curve; 972 // SET_OPTION(ATHcurve, set.ath_curve, -1); 973 if (enforce != 0) 974 gfp.athaa_sensitivity = set.ath_sensitivity; 975 else if (!(Math.abs(gfp.athaa_sensitivity - -1) > 0)) 976 gfp.athaa_sensitivity = set.ath_sensitivity; 977 // SET_OPTION(athaa_sensitivity, set.ath_sensitivity, 0); 978 if (set.interch > 0) { 979 if (enforce != 0) 980 gfp.interChRatio = set.interch; 981 else if (!(Math.abs(gfp.interChRatio - -1) > 0)) 982 gfp.interChRatio = set.interch; 983 // SET_OPTION(interChRatio, set.interch, -1); 984 } 985 986 /* parameters for which there is no proper set/get interface */ 987 if (set.safejoint > 0) { 988 gfp.exp_nspsytune = gfp.exp_nspsytune | set.safejoint; 989 } 990 if (set.sfb21mod > 0) { 991 gfp.exp_nspsytune = gfp.exp_nspsytune | (set.sfb21mod << 20); 992 } 993 if (enforce != 0) 994 gfp.msfix = set.msfix; 995 else if (!(Math.abs(gfp.msfix - -1) > 0)) 996 gfp.msfix = set.msfix; 997 // SET_OPTION(msfix, set.msfix, -1); 998 999 if (enforce == 0) { 1000 gfp.VBR_q = a; 1001 gfp.VBR_q_frac = x; 1002 } 1003 } 1004 1005 /** 1006 * <PRE> 1007 * Switch mappings for ABR mode 1008 * 1009 * kbps quant q_s safejoint nsmsfix st_lrm st_s ns-bass scale msk ath_lwr ath_curve interch , sfscale 1010 * </PRE> 1011 */ 1012 var abr_switch_map = [ 1013 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 */ 1014 new ABRPresets(16, 9, 9, 0, 0, 6.60, 145, 0, 0.95, 0, -25.0, 11, 0.0010, 1), /* 16 */ 1015 new ABRPresets(24, 9, 9, 0, 0, 6.60, 145, 0, 0.95, 0, -20.0, 11, 0.0010, 1), /* 24 */ 1016 new ABRPresets(32, 9, 9, 0, 0, 6.60, 145, 0, 0.95, 0, -15.0, 11, 0.0010, 1), /* 32 */ 1017 new ABRPresets(40, 9, 9, 0, 0, 6.60, 145, 0, 0.95, 0, -10.0, 11, 0.0009, 1), /* 40 */ 1018 new ABRPresets(48, 9, 9, 0, 0, 6.60, 145, 0, 0.95, 0, -10.0, 11, 0.0009, 1), /* 48 */ 1019 new ABRPresets(56, 9, 9, 0, 0, 6.60, 145, 0, 0.95, 0, -6.0, 11, 0.0008, 1), /* 56 */ 1020 new ABRPresets(64, 9, 9, 0, 0, 6.60, 145, 0, 0.95, 0, -2.0, 11, 0.0008, 1), /* 64 */ 1021 new ABRPresets(80, 9, 9, 0, 0, 6.60, 145, 0, 0.95, 0, .0, 8, 0.0007, 1), /* 80 */ 1022 new ABRPresets(96, 9, 9, 0, 2.50, 6.60, 145, 0, 0.95, 0, 1.0, 5.5, 0.0006, 1), /* 96 */ 1023 new ABRPresets(112, 9, 9, 0, 2.25, 6.60, 145, 0, 0.95, 0, 2.0, 4.5, 0.0005, 1), /* 112 */ 1024 new ABRPresets(128, 9, 9, 0, 1.95, 6.40, 140, 0, 0.95, 0, 3.0, 4, 0.0002, 1), /* 128 */ 1025 new ABRPresets(160, 9, 9, 1, 1.79, 6.00, 135, 0, 0.95, -2, 5.0, 3.5, 0, 1), /* 160 */ 1026 new ABRPresets(192, 9, 9, 1, 1.49, 5.60, 125, 0, 0.97, -4, 7.0, 3, 0, 0), /* 192 */ 1027 new ABRPresets(224, 9, 9, 1, 1.25, 5.20, 125, 0, 0.98, -6, 9.0, 2, 0, 0), /* 224 */ 1028 new ABRPresets(256, 9, 9, 1, 0.97, 5.20, 125, 0, 1.00, -8, 10.0, 1, 0, 0), /* 256 */ 1029 new ABRPresets(320, 9, 9, 1, 0.90, 5.20, 125, 0, 1.00, -10, 12.0, 0, 0, 0) /* 320 */ 1030 ]; 1031 1032 function apply_abr_preset(gfp, preset, enforce) { 1033 /* Variables for the ABR stuff */ 1034 var actual_bitrate = preset; 1035 1036 var r = lame.nearestBitrateFullIndex(preset); 1037 1038 gfp.VBR = VbrMode.vbr_abr; 1039 gfp.VBR_mean_bitrate_kbps = actual_bitrate; 1040 gfp.VBR_mean_bitrate_kbps = Math.min(gfp.VBR_mean_bitrate_kbps, 320); 1041 gfp.VBR_mean_bitrate_kbps = Math.max(gfp.VBR_mean_bitrate_kbps, 8); 1042 gfp.brate = gfp.VBR_mean_bitrate_kbps; 1043 if (gfp.VBR_mean_bitrate_kbps > 320) { 1044 gfp.disable_reservoir = true; 1045 } 1046 1047 /* parameters for which there is no proper set/get interface */ 1048 if (abr_switch_map[r].safejoint > 0) 1049 gfp.exp_nspsytune = gfp.exp_nspsytune | 2; 1050 /* safejoint */ 1051 1052 if (abr_switch_map[r].sfscale > 0) { 1053 gfp.internal_flags.noise_shaping = 2; 1054 } 1055 /* ns-bass tweaks */ 1056 if (Math.abs(abr_switch_map[r].nsbass) > 0) { 1057 var k = (int)(abr_switch_map[r].nsbass * 4); 1058 if (k < 0) 1059 k += 64; 1060 gfp.exp_nspsytune = gfp.exp_nspsytune | (k << 2); 1061 } 1062 1063 if (enforce != 0) 1064 gfp.quant_comp = abr_switch_map[r].quant_comp; 1065 else if (!(Math.abs(gfp.quant_comp - -1) > 0)) 1066 gfp.quant_comp = abr_switch_map[r].quant_comp; 1067 // SET_OPTION(quant_comp, abr_switch_map[r].quant_comp, -1); 1068 if (enforce != 0) 1069 gfp.quant_comp_short = abr_switch_map[r].quant_comp_s; 1070 else if (!(Math.abs(gfp.quant_comp_short - -1) > 0)) 1071 gfp.quant_comp_short = abr_switch_map[r].quant_comp_s; 1072 // SET_OPTION(quant_comp_short, abr_switch_map[r].quant_comp_s, -1); 1073 1074 if (enforce != 0) 1075 gfp.msfix = abr_switch_map[r].nsmsfix; 1076 else if (!(Math.abs(gfp.msfix - -1) > 0)) 1077 gfp.msfix = abr_switch_map[r].nsmsfix; 1078 // SET_OPTION(msfix, abr_switch_map[r].nsmsfix, -1); 1079 1080 if (enforce != 0) 1081 gfp.internal_flags.nsPsy.attackthre = abr_switch_map[r].st_lrm; 1082 else if (!(Math.abs(gfp.internal_flags.nsPsy.attackthre - -1) > 0)) 1083 gfp.internal_flags.nsPsy.attackthre = abr_switch_map[r].st_lrm; 1084 // SET_OPTION(short_threshold_lrm, abr_switch_map[r].st_lrm, -1); 1085 if (enforce != 0) 1086 gfp.internal_flags.nsPsy.attackthre_s = abr_switch_map[r].st_s; 1087 else if (!(Math.abs(gfp.internal_flags.nsPsy.attackthre_s - -1) > 0)) 1088 gfp.internal_flags.nsPsy.attackthre_s = abr_switch_map[r].st_s; 1089 // SET_OPTION(short_threshold_s, abr_switch_map[r].st_s, -1); 1090 1091 /* 1092 * ABR seems to have big problems with clipping, especially at low 1093 * bitrates 1094 */ 1095 /* 1096 * so we compensate for that here by using a scale value depending on 1097 * bitrate 1098 */ 1099 if (enforce != 0) 1100 gfp.scale = abr_switch_map[r].scale; 1101 else if (!(Math.abs(gfp.scale - -1) > 0)) 1102 gfp.scale = abr_switch_map[r].scale; 1103 // SET_OPTION(scale, abr_switch_map[r].scale, -1); 1104 1105 if (enforce != 0) 1106 gfp.maskingadjust = abr_switch_map[r].masking_adj; 1107 else if (!(Math.abs(gfp.maskingadjust - 0) > 0)) 1108 gfp.maskingadjust = abr_switch_map[r].masking_adj; 1109 // SET_OPTION(maskingadjust, abr_switch_map[r].masking_adj, 0); 1110 if (abr_switch_map[r].masking_adj > 0) { 1111 if (enforce != 0) 1112 gfp.maskingadjust_short = (abr_switch_map[r].masking_adj * .9); 1113 else if (!(Math.abs(gfp.maskingadjust_short - 0) > 0)) 1114 gfp.maskingadjust_short = (abr_switch_map[r].masking_adj * .9); 1115 // SET_OPTION(maskingadjust_short, abr_switch_map[r].masking_adj * 1116 // .9, 0); 1117 } else { 1118 if (enforce != 0) 1119 gfp.maskingadjust_short = (abr_switch_map[r].masking_adj * 1.1); 1120 else if (!(Math.abs(gfp.maskingadjust_short - 0) > 0)) 1121 gfp.maskingadjust_short = (abr_switch_map[r].masking_adj * 1.1); 1122 // SET_OPTION(maskingadjust_short, abr_switch_map[r].masking_adj * 1123 // 1.1, 0); 1124 } 1125 1126 if (enforce != 0) 1127 gfp.ATHlower = -abr_switch_map[r].ath_lower / 10.; 1128 else if (!(Math.abs((-gfp.ATHlower * 10.) - 0) > 0)) 1129 gfp.ATHlower = -abr_switch_map[r].ath_lower / 10.; 1130 // SET_OPTION(ATHlower, abr_switch_map[r].ath_lower, 0); 1131 if (enforce != 0) 1132 gfp.ATHcurve = abr_switch_map[r].ath_curve; 1133 else if (!(Math.abs(gfp.ATHcurve - -1) > 0)) 1134 gfp.ATHcurve = abr_switch_map[r].ath_curve; 1135 // SET_OPTION(ATHcurve, abr_switch_map[r].ath_curve, -1); 1136 1137 if (enforce != 0) 1138 gfp.interChRatio = abr_switch_map[r].interch; 1139 else if (!(Math.abs(gfp.interChRatio - -1) > 0)) 1140 gfp.interChRatio = abr_switch_map[r].interch; 1141 // SET_OPTION(interChRatio, abr_switch_map[r].interch, -1); 1142 1143 return preset; 1144 } 1145 1146 this.apply_preset = function(gfp, preset, enforce) { 1147 /* translate legacy presets */ 1148 switch (preset) { 1149 case Lame.R3MIX: 1150 { 1151 preset = Lame.V3; 1152 gfp.VBR = VbrMode.vbr_mtrh; 1153 break; 1154 } 1155 case Lame.MEDIUM: 1156 { 1157 preset = Lame.V4; 1158 gfp.VBR = VbrMode.vbr_rh; 1159 break; 1160 } 1161 case Lame.MEDIUM_FAST: 1162 { 1163 preset = Lame.V4; 1164 gfp.VBR = VbrMode.vbr_mtrh; 1165 break; 1166 } 1167 case Lame.STANDARD: 1168 { 1169 preset = Lame.V2; 1170 gfp.VBR = VbrMode.vbr_rh; 1171 break; 1172 } 1173 case Lame.STANDARD_FAST: 1174 { 1175 preset = Lame.V2; 1176 gfp.VBR = VbrMode.vbr_mtrh; 1177 break; 1178 } 1179 case Lame.EXTREME: 1180 { 1181 preset = Lame.V0; 1182 gfp.VBR = VbrMode.vbr_rh; 1183 break; 1184 } 1185 case Lame.EXTREME_FAST: 1186 { 1187 preset = Lame.V0; 1188 gfp.VBR = VbrMode.vbr_mtrh; 1189 break; 1190 } 1191 case Lame.INSANE: 1192 { 1193 preset = 320; 1194 gfp.preset = preset; 1195 apply_abr_preset(gfp, preset, enforce); 1196 gfp.VBR = VbrMode.vbr_off; 1197 return preset; 1198 } 1199 } 1200 1201 gfp.preset = preset; 1202 { 1203 switch (preset) { 1204 case Lame.V9: 1205 apply_vbr_preset(gfp, 9, enforce); 1206 return preset; 1207 case Lame.V8: 1208 apply_vbr_preset(gfp, 8, enforce); 1209 return preset; 1210 case Lame.V7: 1211 apply_vbr_preset(gfp, 7, enforce); 1212 return preset; 1213 case Lame.V6: 1214 apply_vbr_preset(gfp, 6, enforce); 1215 return preset; 1216 case Lame.V5: 1217 apply_vbr_preset(gfp, 5, enforce); 1218 return preset; 1219 case Lame.V4: 1220 apply_vbr_preset(gfp, 4, enforce); 1221 return preset; 1222 case Lame.V3: 1223 apply_vbr_preset(gfp, 3, enforce); 1224 return preset; 1225 case Lame.V2: 1226 apply_vbr_preset(gfp, 2, enforce); 1227 return preset; 1228 case Lame.V1: 1229 apply_vbr_preset(gfp, 1, enforce); 1230 return preset; 1231 case Lame.V0: 1232 apply_vbr_preset(gfp, 0, enforce); 1233 return preset; 1234 default: 1235 break; 1236 } 1237 } 1238 if (8 <= preset && preset <= 320) { 1239 return apply_abr_preset(gfp, preset, enforce); 1240 } 1241 1242 /* no corresponding preset found */ 1243 gfp.preset = 0; 1244 return preset; 1245 } 1246 1247 // Rest from getset.c: 1248 1249 /** 1250 * VBR quality level.<BR> 1251 * 0 = highest<BR> 1252 * 9 = lowest 1253 */ 1254 function lame_set_VBR_q(gfp, VBR_q) { 1255 var ret = 0; 1256 1257 if (0 > VBR_q) { 1258 /* Unknown VBR quality level! */ 1259 ret = -1; 1260 VBR_q = 0; 1261 } 1262 if (9 < VBR_q) { 1263 ret = -1; 1264 VBR_q = 9; 1265 } 1266 1267 gfp.VBR_q = VBR_q; 1268 gfp.VBR_q_frac = 0; 1269 return ret; 1270 } 1271 1272} 1273 1274/* 1275 * MP3 huffman table selecting and bit counting 1276 * 1277 * Copyright (c) 1999-2005 Takehiro TOMINAGA 1278 * Copyright (c) 2002-2005 Gabriel Bouvigne 1279 * 1280 * This library is free software; you can redistribute it and/or 1281 * modify it under the terms of the GNU Lesser General Public 1282 * License as published by the Free Software Foundation; either 1283 * version 2 of the License, or (at your option) any later version. 1284 * 1285 * This library is distributed in the hope that it will be useful, 1286 * but WITHOUT ANY WARRANTY; without even the implied warranty of 1287 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 1288 * Library General Public License for more details. 1289 * 1290 * You should have received a copy of the GNU Lesser General Public 1291 * License along with this library; if not, write to the 1292 * Free Software Foundation, Inc., 59 Temple Place - Suite 330, 1293 * Boston, MA 02111-1307, USA. 1294 */ 1295 1296/* $Id: Takehiro.java,v 1.26 2011/05/24 20:48:06 kenchis Exp $ */ 1297 1298//package mp3; 1299 1300//import java.util.Arrays; 1301 1302 1303 1304function Takehiro() { 1305 1306 var qupvt = null; 1307 this.qupvt = null; 1308 1309 this.setModules = function (_qupvt) { 1310 this.qupvt = _qupvt; 1311 qupvt = _qupvt; 1312 } 1313 1314 function Bits(b) { 1315 this.bits = 0 | b; 1316 } 1317 1318 var subdv_table = [[0, 0], /* 0 bands */ 1319 [0, 0], /* 1 bands */ 1320 [0, 0], /* 2 bands */ 1321 [0, 0], /* 3 bands */ 1322 [0, 0], /* 4 bands */ 1323 [0, 1], /* 5 bands */ 1324 [1, 1], /* 6 bands */ 1325 [1, 1], /* 7 bands */ 1326 [1, 2], /* 8 bands */ 1327 [2, 2], /* 9 bands */ 1328 [2, 3], /* 10 bands */ 1329 [2, 3], /* 11 bands */ 1330 [3, 4], /* 12 bands */ 1331 [3, 4], /* 13 bands */ 1332 [3, 4], /* 14 bands */ 1333 [4, 5], /* 15 bands */ 1334 [4, 5], /* 16 bands */ 1335 [4, 6], /* 17 bands */ 1336 [5, 6], /* 18 bands */ 1337 [5, 6], /* 19 bands */ 1338 [5, 7], /* 20 bands */ 1339 [6, 7], /* 21 bands */ 1340 [6, 7], /* 22 bands */ 1341 ]; 1342 1343 /** 1344 * nonlinear quantization of xr More accurate formula than the ISO formula. 1345 * Takes into account the fact that we are quantizing xr . ix, but we want 1346 * ix^4/3 to be as close as possible to x^4/3. (taking the nearest int would 1347 * mean ix is as close as possible to xr, which is different.) 1348 * 1349 * From Segher Boessenkool <[email protected]> 11/1999 1350 * 1351 * 09/2000: ASM code removed in favor of IEEE754 hack by Takehiro Tominaga. 1352 * If you need the ASM code, check CVS circa Aug 2000. 1353 * 1354 * 01/2004: Optimizations by Gabriel Bouvigne 1355 */ 1356 function quantize_lines_xrpow_01(l, istep, xr, xrPos, ix, ixPos) { 1357 var compareval0 = (1.0 - 0.4054) / istep; 1358 1359 l = l >> 1; 1360 while ((l--) != 0) { 1361 ix[ixPos++] = (compareval0 > xr[xrPos++]) ? 0 : 1; 1362 ix[ixPos++] = (compareval0 > xr[xrPos++]) ? 0 : 1; 1363 } 1364 } 1365 1366 /** 1367 * XRPOW_FTOI is a macro to convert floats to ints.<BR> 1368 * if XRPOW_FTOI(x) = nearest_int(x), then QUANTFAC(x)=adj43asm[x]<BR> 1369 * ROUNDFAC= -0.0946<BR> 1370 * 1371 * if XRPOW_FTOI(x) = floor(x), then QUANTFAC(x)=asj43[x]<BR> 1372 * ROUNDFAC=0.4054<BR> 1373 * 1374 * Note: using floor() or 0| is extremely slow. On machines where the 1375 * TAKEHIRO_IEEE754_HACK code above does not work, it is worthwile to write 1376 * some ASM for XRPOW_FTOI(). 1377 */ 1378 function quantize_lines_xrpow(l, istep, xr, xrPos, ix, ixPos) { 1379 1380 l = l >> 1; 1381 var remaining = l % 2; 1382 l = l >> 1; 1383 while (l-- != 0) { 1384 var x0, x1, x2, x3; 1385 var rx0, rx1, rx2, rx3; 1386 1387 x0 = xr[xrPos++] * istep; 1388 x1 = xr[xrPos++] * istep; 1389 rx0 = 0 | x0; 1390 x2 = xr[xrPos++] * istep; 1391 rx1 = 0 | x1; 1392 x3 = xr[xrPos++] * istep; 1393 rx2 = 0 | x2; 1394 x0 += qupvt.adj43[rx0]; 1395 rx3 = 0 | x3; 1396 x1 += qupvt.adj43[rx1]; 1397 ix[ixPos++] = 0 | x0; 1398 x2 += qupvt.adj43[rx2]; 1399 ix[ixPos++] = 0 | x1; 1400 x3 += qupvt.adj43[rx3]; 1401 ix[ixPos++] = 0 | x2; 1402 ix[ixPos++] = 0 | x3; 1403 } 1404 if (remaining != 0) { 1405 var x0, x1; 1406 var rx0, rx1; 1407 1408 x0 = xr[xrPos++] * istep; 1409 x1 = xr[xrPos++] * istep; 1410 rx0 = 0 | x0; 1411 rx1 = 0 | x1; 1412 x0 += qupvt.adj43[rx0]; 1413 x1 += qupvt.adj43[rx1]; 1414 ix[ixPos++] = 0 | x0; 1415 ix[ixPos++] = 0 | x1; 1416 } 1417 } 1418 1419 /** 1420 * Quantization function This function will select which lines to quantize 1421 * and call the proper quantization function 1422 */ 1423 function quantize_xrpow(xp, pi, istep, codInfo, prevNoise) { 1424 /* quantize on xr^(3/4) instead of xr */ 1425 var sfb; 1426 var sfbmax; 1427 var j = 0; 1428 var prev_data_use; 1429 var accumulate = 0; 1430 var accumulate01 = 0; 1431 var xpPos = 0; 1432 var iData = pi; 1433 var iDataPos = 0; 1434 var acc_iData = iData; 1435 var acc_iDataPos = 0; 1436 var acc_xp = xp; 1437 var acc_xpPos = 0; 1438 1439 /* 1440 * Reusing previously computed data does not seems to work if global 1441 * gain is changed. Finding why it behaves this way would allow to use a 1442 * cache of previously computed values (let's 10 cached values per sfb) 1443 * that would probably provide a noticeable speedup 1444 */ 1445 prev_data_use = (prevNoise != null && (codInfo.global_gain == prevNoise.global_gain)); 1446 1447 if (codInfo.block_type == Encoder.SHORT_TYPE) 1448 sfbmax = 38; 1449 else 1450 sfbmax = 21; 1451 1452 for (sfb = 0; sfb <= sfbmax; sfb++) { 1453 var step = -1; 1454 1455 if (prev_data_use || codInfo.block_type == Encoder.NORM_TYPE) { 1456 step = codInfo.global_gain 1457 - ((codInfo.scalefac[sfb] + (codInfo.preflag != 0 ? qupvt.pretab[sfb] 1458 : 0)) << (codInfo.scalefac_scale + 1)) 1459 - codInfo.subblock_gain[codInfo.window[sfb]] * 8; 1460 } 1461 if (prev_data_use && (prevNoise.step[sfb] == step)) { 1462 /* 1463 * do not recompute this part, but compute accumulated lines 1464 */ 1465 if (accumulate != 0) { 1466 quantize_lines_xrpow(accumulate, istep, acc_xp, acc_xpPos, 1467 acc_iData, acc_iDataPos); 1468 accumulate = 0; 1469 } 1470 if (accumulate01 != 0) { 1471 quantize_lines_xrpow_01(accumulate01, istep, acc_xp, 1472 acc_xpPos, acc_iData, acc_iDataPos); 1473 accumulate01 = 0; 1474 } 1475 } else { /* should compute this part */ 1476 var l = codInfo.width[sfb]; 1477 1478 if ((j + codInfo.width[sfb]) > codInfo.max_nonzero_coeff) { 1479 /* do not compute upper zero part */ 1480 var usefullsize; 1481 usefullsize = codInfo.max_nonzero_coeff - j + 1; 1482 Arrays.fill(pi, codInfo.max_nonzero_coeff, 576, 0); 1483 l = usefullsize; 1484 1485 if (l < 0) { 1486 l = 0; 1487 } 1488 1489 /* no need to compute higher sfb values */ 1490 sfb = sfbmax + 1; 1491 } 1492 1493 /* accumulate lines to quantize */ 1494 if (0 == accumulate && 0 == accumulate01) { 1495 acc_iData = iData; 1496 acc_iDataPos = iDataPos; 1497 acc_xp = xp; 1498 acc_xpPos = xpPos; 1499 } 1500 if (prevNoise != null && prevNoise.sfb_count1 > 0 1501 && sfb >= prevNoise.sfb_count1 1502 && prevNoise.step[sfb] > 0 1503 && step >= prevNoise.step[sfb]) { 1504 1505 if (accumulate != 0) { 1506 quantize_lines_xrpow(accumulate, istep, acc_xp, 1507 acc_xpPos, acc_iData, acc_iDataPos); 1508 accumulate = 0; 1509 acc_iData = iData; 1510 acc_iDataPos = iDataPos; 1511 acc_xp = xp; 1512 acc_xpPos = xpPos; 1513 } 1514 accumulate01 += l; 1515 } else { 1516 if (accumulate01 != 0) { 1517 quantize_lines_xrpow_01(accumulate01, istep, acc_xp, 1518 acc_xpPos, acc_iData, acc_iDataPos); 1519 accumulate01 = 0; 1520 acc_iData = iData; 1521 acc_iDataPos = iDataPos; 1522 acc_xp = xp; 1523 acc_xpPos = xpPos; 1524 } 1525 accumulate += l; 1526 } 1527 1528 if (l <= 0) { 1529 /* 1530 * rh: 20040215 may happen due to "prev_data_use" 1531 * optimization 1532 */ 1533 if (accumulate01 != 0) { 1534 quantize_lines_xrpow_01(accumulate01, istep, acc_xp, 1535 acc_xpPos, acc_iData, acc_iDataPos); 1536 accumulate01 = 0; 1537 } 1538 if (accumulate != 0) { 1539 quantize_lines_xrpow(accumulate, istep, acc_xp, 1540 acc_xpPos, acc_iData, acc_iDataPos); 1541 accumulate = 0; 1542 } 1543 1544 break; 1545 /* ends for-loop */ 1546 } 1547 } 1548 if (sfb <= sfbmax) { 1549 iDataPos += codInfo.width[sfb]; 1550 xpPos += codInfo.width[sfb]; 1551 j += codInfo.width[sfb]; 1552 } 1553 } 1554 if (accumulate != 0) { /* last data part */ 1555 quantize_lines_xrpow(accumulate, istep, acc_xp, acc_xpPos, 1556 acc_iData, acc_iDataPos); 1557 accumulate = 0; 1558 } 1559 if (accumulate01 != 0) { /* last data part */ 1560 quantize_lines_xrpow_01(accumulate01, istep, acc_xp, acc_xpPos, 1561 acc_iData, acc_iDataPos); 1562 accumulate01 = 0; 1563 } 1564 1565 } 1566 1567 /** 1568 * ix_max 1569 */ 1570 function ix_max(ix, ixPos, endPos) { 1571 var max1 = 0, max2 = 0; 1572 1573 do { 1574 var x1 = ix[ixPos++]; 1575 var x2 = ix[ixPos++]; 1576 if (max1 < x1) 1577 max1 = x1; 1578 1579 if (max2 < x2) 1580 max2 = x2; 1581 } while (ixPos < endPos); 1582 if (max1 < max2) 1583 max1 = max2; 1584 return max1; 1585 } 1586 1587 function count_bit_ESC(ix, ixPos, end, t1, t2, s) { 1588 /* ESC-table is used */ 1589 var linbits = Tables.ht[t1].xlen * 65536 + Tables.ht[t2].xlen; 1590 var sum = 0, sum2; 1591 1592 do { 1593 var x = ix[ixPos++]; 1594 var y = ix[ixPos++]; 1595 1596 if (x != 0) { 1597 if (x > 14) { 1598 x = 15; 1599 sum += linbits; 1600 } 1601 x *= 16; 1602 } 1603 1604 if (y != 0) { 1605 if (y > 14) { 1606 y = 15; 1607 sum += linbits; 1608 } 1609 x += y; 1610 } 1611 1612 sum += Tables.largetbl[x]; 1613 } while (ixPos < end); 1614 1615 sum2 = sum & 0xffff; 1616 sum >>= 16; 1617 1618 if (sum > sum2) { 1619 sum = sum2; 1620 t1 = t2; 1621 } 1622 1623 s.bits += sum; 1624 return t1; 1625 } 1626 1627 function count_bit_noESC(ix, ixPos, end, s) { 1628 /* No ESC-words */ 1629 var sum1 = 0; 1630 var hlen1 = Tables.ht[1].hlen; 1631 1632 do { 1633 var x = ix[ixPos + 0] * 2 + ix[ixPos + 1]; 1634 ixPos += 2; 1635 sum1 += hlen1[x]; 1636 } while (ixPos < end); 1637 1638 s.bits += sum1; 1639 return 1; 1640 } 1641 1642 function count_bit_noESC_from2(ix, ixPos, end, t1, s) { 1643 /* No ESC-words */ 1644 var sum = 0, sum2; 1645 var xlen = Tables.ht[t1].xlen; 1646 var hlen; 1647 if (t1 == 2) 1648 hlen = Tables.table23; 1649 else 1650 hlen = Tables.table56; 1651 1652 do { 1653 var x = ix[ixPos + 0] * xlen + ix[ixPos + 1]; 1654 ixPos += 2; 1655 sum += hlen[x]; 1656 } while (ixPos < end); 1657 1658 sum2 = sum & 0xffff; 1659 sum >>= 16; 1660 1661 if (sum > sum2) { 1662 sum = sum2; 1663 t1++; 1664 } 1665 1666 s.bits += sum; 1667 return t1; 1668 } 1669 1670 function count_bit_noESC_from3(ix, ixPos, end, t1, s) { 1671 /* No ESC-words */ 1672 var sum1 = 0; 1673 var sum2 = 0; 1674 var sum3 = 0; 1675 var xlen = Tables.ht[t1].xlen; 1676 var hlen1 = Tables.ht[t1].hlen; 1677 var hlen2 = Tables.ht[t1 + 1].hlen; 1678 var hlen3 = Tables.ht[t1 + 2].hlen; 1679 1680 do { 1681 var x = ix[ixPos + 0] * xlen + ix[ixPos + 1]; 1682 ixPos += 2; 1683 sum1 += hlen1[x]; 1684 sum2 += hlen2[x]; 1685 sum3 += hlen3[x]; 1686 } while (ixPos < end); 1687 var t = t1; 1688 if (sum1 > sum2) { 1689 sum1 = sum2; 1690 t++; 1691 } 1692 if (sum1 > sum3) { 1693 sum1 = sum3; 1694 t = t1 + 2; 1695 } 1696 s.bits += sum1; 1697 1698 return t; 1699 } 1700 1701 /*************************************************************************/ 1702 /* choose table */ 1703 /*************************************************************************/ 1704 1705 var huf_tbl_noESC = [1, 2, 5, 7, 7, 10, 10, 13, 13, 1706 13, 13, 13, 13, 13, 13]; 1707 1708 /** 1709 * Choose the Huffman table that will encode ix[begin..end] with the fewest 1710 * bits. 1711 * 1712 * Note: This code contains knowledge about the sizes and characteristics of 1713 * the Huffman tables as defined in the IS (Table B.7), and will not work 1714 * with any arbitrary tables. 1715 */ 1716 function choose_table(ix, ixPos, endPos, s) { 1717 var max = ix_max(ix, ixPos, endPos); 1718 1719 switch (max) { 1720 case 0: 1721 return max; 1722 1723 case 1: 1724 return count_bit_noESC(ix, ixPos, endPos, s); 1725 1726 case 2: 1727 case 3: 1728 return count_bit_noESC_from2(ix, ixPos, endPos, 1729 huf_tbl_noESC[max - 1], s); 1730 1731 case 4: 1732 case 5: 1733 case 6: 1734 case 7: 1735 case 8: 1736 case 9: 1737 case 10: 1738 case 11: 1739 case 12: 1740 case 13: 1741 case 14: 1742 case 15: 1743 return count_bit_noESC_from3(ix, ixPos, endPos, 1744 huf_tbl_noESC[max - 1], s); 1745 1746 default: 1747 /* try tables with linbits */ 1748 if (max > QuantizePVT.IXMAX_VAL) { 1749 s.bits = QuantizePVT.LARGE_BITS; 1750 return -1; 1751 } 1752 max -= 15; 1753 var choice2; 1754 for (choice2 = 24; choice2 < 32; choice2++) { 1755 if (Tables.ht[choice2].linmax >= max) { 1756 break; 1757 } 1758 } 1759 var choice; 1760 for (choice = choice2 - 8; choice < 24; choice++) { 1761 if (Tables.ht[choice].linmax >= max) { 1762 break; 1763 } 1764 } 1765 return count_bit_ESC(ix, ixPos, endPos, choice, choice2, s); 1766 } 1767 } 1768 1769 /** 1770 * count_bit 1771 */ 1772 this.noquant_count_bits = function (gfc, gi, prev_noise) { 1773 var ix = gi.l3_enc; 1774 var i = Math.min(576, ((gi.max_nonzero_coeff + 2) >> 1) << 1); 1775 1776 if (prev_noise != null) 1777 prev_noise.sfb_count1 = 0; 1778 1779 /* Determine count1 region */ 1780 for (; i > 1; i -= 2) 1781 if ((ix[i - 1] | ix[i - 2]) != 0) 1782 break; 1783 gi.count1 = i; 1784 1785 /* Determines the number of bits to encode the quadruples. */ 1786 var a1 = 0; 1787 var a2 = 0; 1788 for (; i > 3; i -= 4) { 1789 var p; 1790 /* hack to check if all values <= 1 */ 1791 //throw "TODO: HACK if ((((long) ix[i - 1] | (long) ix[i - 2] | (long) ix[i - 3] | (long) ix[i - 4]) & 0xffffffffL) > 1L " 1792 //if (true) { 1793 if (((ix[i - 1] | ix[i - 2] | ix[i - 3] | ix[i - 4]) & 0x7fffffff) > 1) { 1794 break; 1795 } 1796 p = ((ix[i - 4] * 2 + ix[i - 3]) * 2 + ix[i - 2]) * 2 + ix[i - 1]; 1797 a1 += Tables.t32l[p]; 1798 a2 += Tables.t33l[p]; 1799 } 1800 var bits = a1; 1801 gi.count1table_select = 0; 1802 if (a1 > a2) { 1803 bits = a2; 1804 gi.count1table_select = 1; 1805 } 1806 1807 gi.count1bits = bits; 1808 gi.big_values = i; 1809 if (i == 0) 1810 return bits; 1811 1812 if (gi.block_type == Encoder.SHORT_TYPE) { 1813 a1 = 3 * gfc.scalefac_band.s[3]; 1814 if (a1 > gi.big_values) 1815 a1 = gi.big_values; 1816 a2 = gi.big_values; 1817 1818 } else if (gi.block_type == Encoder.NORM_TYPE) { 1819 /* bv_scf has 576 entries (0..575) */ 1820 a1 = gi.region0_count = gfc.bv_scf[i - 2]; 1821 a2 = gi.region1_count = gfc.bv_scf[i - 1]; 1822 1823 a2 = gfc.scalefac_band.l[a1 + a2 + 2]; 1824 a1 = gfc.scalefac_band.l[a1 + 1]; 1825 if (a2 < i) { 1826 var bi = new Bits(bits); 1827 gi.table_select[2] = choose_table(ix, a2, i, bi); 1828 bits = bi.bits; 1829 } 1830 } else { 1831 gi.region0_count = 7; 1832 /* gi.region1_count = SBPSY_l - 7 - 1; */ 1833 gi.region1_count = Encoder.SBMAX_l - 1 - 7 - 1; 1834 a1 = gfc.scalefac_band.l[7 + 1]; 1835 a2 = i; 1836 if (a1 > a2) { 1837 a1 = a2; 1838 } 1839 } 1840 1841 /* have to allow for the case when bigvalues < region0 < region1 */ 1842 /* (and region0, region1 are ignored) */ 1843 a1 = Math.min(a1, i); 1844 a2 = Math.min(a2, i); 1845 1846 1847 /* Count the number of bits necessary to code the bigvalues region. */ 1848 if (0 < a1) { 1849 var bi = new Bits(bits); 1850 gi.table_select[0] = choose_table(ix, 0, a1, bi); 1851 bits = bi.bits; 1852 } 1853 if (a1 < a2) { 1854 var bi = new Bits(bits); 1855 gi.table_select[1] = choose_table(ix, a1, a2, bi); 1856 bits = bi.bits; 1857 } 1858 if (gfc.use_best_huffman == 2) { 1859 gi.part2_3_length = bits; 1860 best_huffman_divide(gfc, gi); 1861 bits = gi.part2_3_length; 1862 } 1863 1864 if (prev_noise != null) { 1865 if (gi.block_type == Encoder.NORM_TYPE) { 1866 var sfb = 0; 1867 while (gfc.scalefac_band.l[sfb] < gi.big_values) { 1868 sfb++; 1869 } 1870 prev_noise.sfb_count1 = sfb; 1871 } 1872 } 1873 1874 return bits; 1875 } 1876 1877 this.count_bits = function (gfc, xr, gi, prev_noise) { 1878 var ix = gi.l3_enc; 1879 1880 /* since quantize_xrpow uses table lookup, we need to check this first: */ 1881 var w = (QuantizePVT.IXMAX_VAL) / qupvt.IPOW20(gi.global_gain); 1882 1883 if (gi.xrpow_max > w) 1884 return QuantizePVT.LARGE_BITS; 1885 1886 quantize_xrpow(xr, ix, qupvt.IPOW20(gi.global_gain), gi, prev_noise); 1887 1888 if ((gfc.substep_shaping & 2) != 0) { 1889 var j = 0; 1890 /* 0.634521682242439 = 0.5946*2**(.5*0.1875) */ 1891 var gain = gi.global_gain + gi.scalefac_scale; 1892 var roundfac = 0.634521682242439 / qupvt.IPOW20(gain); 1893 for (var sfb = 0; sfb < gi.sfbmax; sfb++) { 1894 var width = gi.width[sfb]; 1895 if (0 == gfc.pseudohalf[sfb]) { 1896 j += width; 1897 } else { 1898 var k; 1899 for (k = j, j += width; k < j; ++k) { 1900 ix[k] = (xr[k] >= roundfac) ? ix[k] : 0; 1901 } 1902 } 1903 } 1904 } 1905 return this.noquant_count_bits(gfc, gi, prev_noise); 1906 } 1907 1908 /** 1909 * re-calculate the best scalefac_compress using scfsi the saved bits are 1910 * kept in the bit reservoir. 1911 */ 1912 function recalc_divide_init(gfc, cod_info, ix, r01_bits, r01_div, r0_tbl, r1_tbl) { 1913 var bigv = cod_info.big_values; 1914 1915 for (var r0 = 0; r0 <= 7 + 15; r0++) { 1916 r01_bits[r0] = QuantizePVT.LARGE_BITS; 1917 } 1918 1919 for (var r0 = 0; r0 < 16; r0++) { 1920 var a1 = gfc.scalefac_band.l[r0 + 1]; 1921 if (a1 >= bigv) 1922 break; 1923 var r0bits = 0; 1924 var bi = new Bits(r0bits); 1925 var r0t = choose_table(ix, 0, a1, bi); 1926 r0bits = bi.bits; 1927 1928 for (var r1 = 0; r1 < 8; r1++) { 1929 var a2 = gfc.scalefac_band.l[r0 + r1 + 2]; 1930 if (a2 >= bigv) 1931 break; 1932 var bits = r0bits; 1933 bi = new Bits(bits); 1934 var r1t = choose_table(ix, a1, a2, bi); 1935 bits = bi.bits; 1936 if (r01_bits[r0 + r1] > bits) { 1937 r01_bits[r0 + r1] = bits; 1938 r01_div[r0 + r1] = r0; 1939 r0_tbl[r0 + r1] = r0t; 1940 r1_tbl[r0 + r1] = r1t; 1941 } 1942 } 1943 } 1944 } 1945 1946 function recalc_divide_sub(gfc, cod_info2, gi, ix, r01_bits, r01_div, r0_tbl, r1_tbl) { 1947 var bigv = cod_info2.big_values; 1948 1949 for (var r2 = 2; r2 < Encoder.SBMAX_l + 1; r2++) { 1950 var a2 = gfc.scalefac_band.l[r2]; 1951 if (a2 >= bigv) 1952 break; 1953 var bits = r01_bits[r2 - 2] + cod_info2.count1bits; 1954 if (gi.part2_3_length <= bits) 1955 break; 1956 1957 var bi = new Bits(bits); 1958 var r2t = choose_table(ix, a2, bigv, bi); 1959 bits = bi.bits; 1960 if (gi.part2_3_length <= bits) 1961 continue; 1962 1963 gi.assign(cod_info2); 1964 gi.part2_3_length = bits; 1965 gi.region0_count = r01_div[r2 - 2]; 1966 gi.region1_count = r2 - 2 - r01_div[r2 - 2]; 1967 gi.table_select[0] = r0_tbl[r2 - 2]; 1968 gi.table_select[1] = r1_tbl[r2 - 2]; 1969 gi.table_select[2] = r2t; 1970 } 1971 } 1972 1973 this.best_huffman_divide = function (gfc, gi) { 1974 var cod_info2 = new GrInfo(); 1975 var ix = gi.l3_enc; 1976 var r01_bits = new_int(7 + 15 + 1); 1977 var r01_div = new_int(7 + 15 + 1); 1978 var r0_tbl = new_int(7 + 15 + 1); 1979 var r1_tbl = new_int(7 + 15 + 1); 1980 1981 /* SHORT BLOCK stuff fails for MPEG2 */ 1982 if (gi.block_type == Encoder.SHORT_TYPE && gfc.mode_gr == 1) 1983 return; 1984 1985 cod_info2.assign(gi); 1986 if (gi.block_type == Encoder.NORM_TYPE) { 1987 recalc_divide_init(gfc, gi, ix, r01_bits, r01_div, r0_tbl, r1_tbl); 1988 recalc_divide_sub(gfc, cod_info2, gi, ix, r01_bits, r01_div, 1989 r0_tbl, r1_tbl); 1990 } 1991 var i = cod_info2.big_values; 1992 if (i == 0 || (ix[i - 2] | ix[i - 1]) > 1) 1993 return; 1994 1995 i = gi.count1 + 2; 1996 if (i > 576) 1997 return; 1998 1999 /* Determines the number of bits to encode the quadruples. */ 2000 cod_info2.assign(gi); 2001 cod_info2.count1 = i; 2002 var a1 = 0; 2003 var a2 = 0; 2004 2005 2006 for (; i > cod_info2.big_values; i -= 4) { 2007 var p = ((ix[i - 4] * 2 + ix[i - 3]) * 2 + ix[i - 2]) * 2 2008 + ix[i - 1]; 2009 a1 += Tables.t32l[p]; 2010 a2 += Tables.t33l[p]; 2011 } 2012 cod_info2.big_values = i; 2013 2014 cod_info2.count1table_select = 0; 2015 if (a1 > a2) { 2016 a1 = a2; 2017 cod_info2.count1table_select = 1; 2018 } 2019 2020 cod_info2.count1bits = a1; 2021 2022 if (cod_info2.block_type == Encoder.NORM_TYPE) 2023 recalc_divide_sub(gfc, cod_info2, gi, ix, r01_bits, r01_div, 2024 r0_tbl, r1_tbl); 2025 else { 2026 /* Count the number of bits necessary to code the bigvalues region. */ 2027 cod_info2.part2_3_length = a1; 2028 a1 = gfc.scalefac_band.l[7 + 1]; 2029 if (a1 > i) { 2030 a1 = i; 2031 } 2032 if (a1 > 0) { 2033 var bi = new Bits(cod_info2.part2_3_length); 2034 cod_info2.table_select[0] = choose_table(ix, 0, a1, bi); 2035 cod_info2.part2_3_length = bi.bits; 2036 } 2037 if (i > a1) { 2038 var bi = new Bits(cod_info2.part2_3_length); 2039 cod_info2.table_select[1] = choose_table(ix, a1, i, bi); 2040 cod_info2.part2_3_length = bi.bits; 2041 } 2042 if (gi.part2_3_length > cod_info2.part2_3_length) 2043 gi.assign(cod_info2); 2044 } 2045 } 2046 2047 var slen1_n = [1, 1, 1, 1, 8, 2, 2, 2, 4, 4, 4, 8, 8, 8, 16, 16]; 2048 var slen2_n = [1, 2, 4, 8, 1, 2, 4, 8, 2, 4, 8, 2, 4, 8, 4, 8]; 2049 var slen1_tab = [0, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4]; 2050 var slen2_tab = [0, 1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 2, 3]; 2051 Takehiro.slen1_tab = slen1_tab; 2052 Takehiro.slen2_tab = slen2_tab; 2053 2054 function scfsi_calc(ch, l3_side) { 2055 var sfb; 2056 var gi = l3_side.tt[1][ch]; 2057 var g0 = l3_side.tt[0][ch]; 2058 2059 for (var i = 0; i < Tables.scfsi_band.length - 1; i++) { 2060 for (sfb = Tables.scfsi_band[i]; sfb < Tables.scfsi_band[i + 1]; sfb++) { 2061 if (g0.scalefac[sfb] != gi.scalefac[sfb] 2062 && gi.scalefac[sfb] >= 0) 2063 break; 2064 } 2065 if (sfb == Tables.scfsi_band[i + 1]) { 2066 for (sfb = Tables.scfsi_band[i]; sfb < Tables.scfsi_band[i + 1]; sfb++) { 2067 gi.scalefac[sfb] = -1; 2068 } 2069 l3_side.scfsi[ch][i] = 1; 2070 } 2071 } 2072 var s1 = 0; 2073 var c1 = 0; 2074 for (sfb = 0; sfb < 11; sfb++) { 2075 if (gi.scalefac[sfb] == -1) 2076 continue; 2077 c1++; 2078 if (s1 < gi.scalefac[sfb]) 2079 s1 = gi.scalefac[sfb]; 2080 } 2081 var s2 = 0; 2082 var c2 = 0; 2083 for (; sfb < Encoder.SBPSY_l; sfb++) { 2084 if (gi.scalefac[sfb] == -1) 2085 continue; 2086 c2++; 2087 if (s2 < gi.scalefac[sfb]) 2088 s2 = gi.scalefac[sfb]; 2089 } 2090 2091 for (var i = 0; i < 16; i++) { 2092 if (s1 < slen1_n[i] && s2 < slen2_n[i]) { 2093 var c = slen1_tab[i] * c1 + slen2_tab[i] * c2; 2094 if (gi.part2_length > c) { 2095 gi.part2_length = c; 2096 gi.scalefac_compress = i; 2097 } 2098 } 2099 } 2100 } 2101 2102 /** 2103 * Find the optimal way to store the scalefactors. Only call this routine 2104 * after final scalefactors have been chosen and the channel/granule will 2105 * not be re-encoded. 2106 */ 2107 this.best_scalefac_store = function (gfc, gr, ch, l3_side) { 2108 /* use scalefac_scale if we can */ 2109 var gi = l3_side.tt[gr][ch]; 2110 var sfb, i, j, l; 2111 var recalc = 0; 2112 2113 /* 2114 * remove scalefacs from bands with ix=0. This idea comes from the AAC 2115 * ISO docs. added mt 3/00 2116 */ 2117 /* check if l3_enc=0 */ 2118 j = 0; 2119 for (sfb = 0; sfb < gi.sfbmax; sfb++) { 2120 var width = gi.width[sfb]; 2121 j += width; 2122 for (l = -width; l < 0; l++) { 2123 if (gi.l3_enc[l + j] != 0) 2124 break; 2125 } 2126 if (l == 0) 2127 gi.scalefac[sfb] = recalc = -2; 2128 /* anything goes. */ 2129 /* 2130 * only best_scalefac_store and calc_scfsi know--and only they 2131 * should know--about the magic number -2. 2132 */ 2133 } 2134 2135 if (0 == gi.scalefac_scale && 0 == gi.preflag) { 2136 var s = 0; 2137 for (sfb = 0; sfb < gi.sfbmax; sfb++) 2138 if (gi.scalefac[sfb] > 0) 2139 s |= gi.scalefac[sfb]; 2140 2141 if (0 == (s & 1) && s != 0) { 2142 for (sfb = 0; sfb < gi.sfbmax; sfb++) 2143 if (gi.scalefac[sfb] > 0) 2144 gi.scalefac[sfb] >>= 1; 2145 2146 gi.scalefac_scale = recalc = 1; 2147 } 2148 } 2149 2150 if (0 == gi.preflag && gi.block_type != Encoder.SHORT_TYPE 2151 && gfc.mode_gr == 2) { 2152 for (sfb = 11; sfb < Encoder.SBPSY_l; sfb++) 2153 if (gi.scalefac[sfb] < qupvt.pretab[sfb] 2154 && gi.scalefac[sfb] != -2) 2155 break; 2156 if (sfb == Encoder.SBPSY_l) { 2157 for (sfb = 11; sfb < Encoder.SBPSY_l; sfb++) 2158 if (gi.scalefac[sfb] > 0) 2159 gi.scalefac[sfb] -= qupvt.pretab[sfb]; 2160 2161 gi.preflag = recalc = 1; 2162 } 2163 } 2164 2165 for (i = 0; i < 4; i++) 2166 l3_side.scfsi[ch][i] = 0; 2167 2168 if (gfc.mode_gr == 2 && gr == 1 2169 && l3_side.tt[0][ch].block_type != Encoder.SHORT_TYPE 2170 && l3_side.tt[1][ch].block_type != Encoder.SHORT_TYPE) { 2171 scfsi_calc(ch, l3_side); 2172 recalc = 0; 2173 } 2174 for (sfb = 0; sfb < gi.sfbmax; sfb++) { 2175 if (gi.scalefac[sfb] == -2) { 2176 gi.scalefac[sfb] = 0; 2177 /* if anything goes, then 0 is a good choice */ 2178 } 2179 } 2180 if (recalc != 0) { 2181 if (gfc.mode_gr == 2) { 2182 this.scale_bitcount(gi); 2183 } else { 2184 this.scale_bitcount_lsf(gfc, gi); 2185 } 2186 } 2187 } 2188 2189 function all_scalefactors_not_negative(scalefac, n) { 2190 for (var i = 0; i < n; ++i) { 2191 if (scalefac[i] < 0) 2192 return false; 2193 } 2194 return true; 2195 } 2196 2197 /** 2198 * number of bits used to encode scalefacs. 2199 * 2200 * 18*slen1_tab[i] + 18*slen2_tab[i] 2201 */ 2202 var scale_short = [0, 18, 36, 54, 54, 36, 54, 72, 2203 54, 72, 90, 72, 90, 108, 108, 126]; 2204 2205 /** 2206 * number of bits used to encode scalefacs. 2207 * 2208 * 17*slen1_tab[i] + 18*slen2_tab[i] 2209 */ 2210 var scale_mixed = [0, 18, 36, 54, 51, 35, 53, 71, 2211 52, 70, 88, 69, 87, 105, 104, 122]; 2212 2213 /** 2214 * number of bits used to encode scalefacs. 2215 * 2216 * 11*slen1_tab[i] + 10*slen2_tab[i] 2217 */ 2218 var scale_long = [0, 10, 20, 30, 33, 21, 31, 41, 32, 42, 2219 52, 43, 53, 63, 64, 74]; 2220 2221 /** 2222 * Also calculates the number of bits necessary to code the scalefactors. 2223 */ 2224 this.scale_bitcount = function (cod_info) { 2225 var k, sfb, max_slen1 = 0, max_slen2 = 0; 2226 2227 /* maximum values */ 2228 var tab; 2229 var scalefac = cod_info.scalefac; 2230 2231 2232 if (cod_info.block_type == Encoder.SHORT_TYPE) { 2233 tab = scale_short; 2234 if (cod_info.mixed_block_flag != 0) 2235 tab = scale_mixed; 2236 } else { /* block_type == 1,2,or 3 */ 2237 tab = scale_long; 2238 if (0 == cod_info.preflag) { 2239 for (sfb = 11; sfb < Encoder.SBPSY_l; sfb++) 2240 if (scalefac[sfb] < qupvt.pretab[sfb]) 2241 break; 2242 2243 if (sfb == Encoder.SBPSY_l) { 2244 cod_info.preflag = 1; 2245 for (sfb = 11; sfb < Encoder.SBPSY_l; sfb++) 2246 scalefac[sfb] -= qupvt.pretab[sfb]; 2247 } 2248 } 2249 } 2250 2251 for (sfb = 0; sfb < cod_info.sfbdivide; sfb++) 2252 if (max_slen1 < scalefac[sfb]) 2253 max_slen1 = scalefac[sfb]; 2254 2255 for (; sfb < cod_info.sfbmax; sfb++) 2256 if (max_slen2 < scalefac[sfb]) 2257 max_slen2 = scalefac[sfb]; 2258 2259 /* 2260 * from Takehiro TOMINAGA <[email protected]> 10/99 loop over *all* 2261 * posible values of scalefac_compress to find the one which uses the 2262 * smallest number of bits. ISO would stop at first valid index 2263 */ 2264 cod_info.part2_length = QuantizePVT.LARGE_BITS; 2265 for (k = 0; k < 16; k++) { 2266 if (max_slen1 < slen1_n[k] && max_slen2 < slen2_n[k] 2267 && cod_info.part2_length > tab[k]) { 2268 cod_info.part2_length = tab[k]; 2269 cod_info.scalefac_compress = k; 2270 } 2271 } 2272 return cod_info.part2_length == QuantizePVT.LARGE_BITS; 2273 } 2274 2275 /** 2276 * table of largest scalefactor values for MPEG2 2277 */ 2278 var max_range_sfac_tab = [[15, 15, 7, 7], 2279 [15, 15, 7, 0], [7, 3, 0, 0], [15, 31, 31, 0], 2280 [7, 7, 7, 0], [3, 3, 0, 0]]; 2281 2282 /** 2283 * Also counts the number of bits to encode the scalefacs but for MPEG 2 2284 * Lower sampling frequencies (24, 22.05 and 16 kHz.) 2285 * 2286 * This is reverse-engineered from section 2.4.3.2 of the MPEG2 IS, 2287 * "Audio Decoding Layer III" 2288 */ 2289 this.scale_bitcount_lsf = function (gfc, cod_info) { 2290 var table_number, row_in_table, partition, nr_sfb, window; 2291 var over; 2292 var i, sfb; 2293 var max_sfac = new_int(4); 2294//var partition_table; 2295 var scalefac = cod_info.scalefac; 2296 2297 /* 2298 * Set partition table. Note that should try to use table one, but do 2299 * not yet... 2300 */ 2301 if (cod_info.preflag != 0) 2302 table_number = 2; 2303 else 2304 table_number = 0; 2305 2306 for (i = 0; i < 4; i++) 2307 max_sfac[i] = 0; 2308 2309 if (cod_info.block_type == Encoder.SHORT_TYPE) { 2310 row_in_table = 1; 2311 var partition_table = qupvt.nr_of_sfb_block[table_number][row_in_table]; 2312 for (sfb = 0, partition = 0; partition < 4; partition++) { 2313 nr_sfb = partition_table[partition] / 3; 2314 for (i = 0; i < nr_sfb; i++, sfb++) 2315 for (window = 0; window < 3; window++) 2316 if (scalefac[sfb * 3 + window] > max_sfac[partition]) 2317 max_sfac[partition] = scalefac[sfb * 3 + window]; 2318 } 2319 } else { 2320 row_in_table = 0; 2321 var partition_table = qupvt.nr_of_sfb_block[table_number][row_in_table]; 2322 for (sfb = 0, partition = 0; partition < 4; partition++) { 2323 nr_sfb = partition_table[partition]; 2324 for (i = 0; i < nr_sfb; i++, sfb++) 2325 if (scalefac[sfb] > max_sfac[partition]) 2326 max_sfac[partition] = scalefac[sfb]; 2327 } 2328 } 2329 2330 for (over = false, partition = 0; partition < 4; partition++) { 2331 if (max_sfac[partition] > max_range_sfac_tab[table_number][partition]) 2332 over = true; 2333 } 2334 if (!over) { 2335 var slen1, slen2, slen3, slen4; 2336 2337 cod_info.sfb_partition_table = qupvt.nr_of_sfb_block[table_number][row_in_table]; 2338 for (partition = 0; partition < 4; partition++) 2339 cod_info.slen[partition] = log2tab[max_sfac[partition]]; 2340 2341 /* set scalefac_compress */ 2342 slen1 = cod_info.slen[0]; 2343 slen2 = cod_info.slen[1]; 2344 slen3 = cod_info.slen[2]; 2345 slen4 = cod_info.slen[3]; 2346 2347 switch (table_number) { 2348 case 0: 2349 cod_info.scalefac_compress = (((slen1 * 5) + slen2) << 4) 2350 + (slen3 << 2) + slen4; 2351 break; 2352 2353 case 1: 2354 cod_info.scalefac_compress = 400 + (((slen1 * 5) + slen2) << 2) 2355 + slen3; 2356 break; 2357 2358 case 2: 2359 cod_info.scalefac_compress = 500 + (slen1 * 3) + slen2; 2360 break; 2361 2362 default: 2363 System.err.printf("intensity stereo not implemented yet\n"); 2364 break; 2365 } 2366 } 2367 if (!over) { 2368 cod_info.part2_length = 0; 2369 for (partition = 0; partition < 4; partition++) 2370 cod_info.part2_length += cod_info.slen[partition] 2371 * cod_info.sfb_partition_table[partition]; 2372 } 2373 return over; 2374 } 2375 2376 /* 2377 * Since no bands have been over-amplified, we can set scalefac_compress and 2378 * slen[] for the formatter 2379 */ 2380 var log2tab = [0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 2381 4, 4, 4, 4]; 2382 2383 this.huffman_init = function (gfc) { 2384 for (var i = 2; i <= 576; i += 2) { 2385 var scfb_anz = 0, bv_index; 2386 while (gfc.scalefac_band.l[++scfb_anz] < i) 2387 ; 2388 2389 bv_index = subdv_table[scfb_anz][0]; // .region0_count 2390 while (gfc.scalefac_band.l[bv_index + 1] > i) 2391 bv_index--; 2392 2393 if (bv_index < 0) { 2394 /* 2395 * this is an indication that everything is going to be encoded 2396 * as region0: bigvalues < region0 < region1 so lets set 2397 * region0, region1 to some value larger than bigvalues 2398 */ 2399 bv_index = subdv_table[scfb_anz][0]; // .region0_count 2400 } 2401 2402 gfc.bv_scf[i - 2] = bv_index; 2403 2404 bv_index = subdv_table[scfb_anz][1]; // .region1_count 2405 while (gfc.scalefac_band.l[bv_index + gfc.bv_scf[i - 2] + 2] > i) 2406 bv_index--; 2407 2408 if (bv_index < 0) { 2409 bv_index = subdv_table[scfb_anz][1]; // .region1_count 2410 } 2411 2412 gfc.bv_scf[i - 1] = bv_index; 2413 } 2414 } 2415} 2416 2417/* 2418 * bit reservoir source file 2419 * 2420 * Copyright (c) 1999-2000 Mark Taylor 2421 * 2422 * This library is free software; you can redistribute it and/or 2423 * modify it under the terms of the GNU Lesser General Public 2424 * License as published by the Free Software Foundation; either 2425 * version 2 of the License, or (at your option) any later version. 2426 * 2427 * This library is distributed in the hope that it will be useful, 2428 * but WITHOUT ANY WARRANTY; without even the implied warranty of 2429 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 2430 * Library General Public License for more details. 2431 * 2432 * You should have received a copy of the GNU Lesser General Public 2433 * License along with this library; if not, write to the 2434 * Free Software Foundation, Inc., 59 Temple Place - Suite 330, 2435 * Boston, MA 02111-1307, USA. 2436 */ 2437 2438/* $Id: Reservoir.java,v 1.9 2011/05/24 20:48:06 kenchis Exp $ */ 2439 2440//package mp3; 2441 2442/** 2443 * ResvFrameBegin:<BR> 2444 * Called (repeatedly) at the beginning of a frame. Updates the maximum size of 2445 * the reservoir, and checks to make sure main_data_begin was set properly by 2446 * the formatter<BR> 2447 * Background information: 2448 * 2449 * This is the original text from the ISO standard. Because of sooo many bugs 2450 * and irritations correcting comments are added in brackets []. A '^W' means 2451 * you should remove the last word. 2452 * 2453 * <PRE> 2454 * 1. The following rule can be used to calculate the maximum 2455 * number of bits used for one granule [^W frame]:<BR> 2456 * At the highest possible bitrate of Layer III (320 kbps 2457 * per stereo signal [^W^W^W], 48 kHz) the frames must be of 2458 * [^W^W^W are designed to have] constant length, i.e. 2459 * one buffer [^W^W the frame] length is:<BR> 2460 * 2461 * 320 kbps * 1152/48 kHz = 7680 bit = 960 byte 2462 * 2463 * This value is used as the maximum buffer per channel [^W^W] at 2464 * lower bitrates [than 320 kbps]. At 64 kbps mono or 128 kbps 2465 * stereo the main granule length is 64 kbps * 576/48 kHz = 768 bit 2466 * [per granule and channel] at 48 kHz sampling frequency. 2467 * This means that there is a maximum deviation (short time buffer 2468 * [= reservoir]) of 7680 - 2*2*768 = 4608 bits is allowed at 64 kbps. 2469 * The actual deviation is equal to the number of bytes [with the 2470 * meaning of octets] denoted by the main_data_end offset pointer. 2471 * The actual maximum deviation is (2^9-1)*8 bit = 4088 bits 2472 * [for MPEG-1 and (2^8-1)*8 bit for MPEG-2, both are hard limits]. 2473 * ... The xchange of buffer bits between the left and right channel 2474 * is allowed without restrictions [exception: dual channel]. 2475 * Because of the [constructed] constraint on the buffer size 2476 * main_data_end is always set to 0 in the case of bit_rate_index==14, 2477 * i.e. data rate 320 kbps per stereo signal [^W^W^W]. In this case 2478 * all data are allocated between adjacent header [^W sync] words 2479 * [, i.e. there is no buffering at all]. 2480 * </PRE> 2481 */ 2482 2483 2484function Reservoir() { 2485 var bs; 2486 2487 this.setModules = function(_bs) { 2488 bs = _bs; 2489 } 2490 2491 this.ResvFrameBegin = function(gfp, mean_bits) { 2492 var gfc = gfp.internal_flags; 2493 var maxmp3buf; 2494 var l3_side = gfc.l3_side; 2495 2496 var frameLength = bs.getframebits(gfp); 2497 mean_bits.bits = (frameLength - gfc.sideinfo_len * 8) / gfc.mode_gr; 2498 2499 /** 2500 * <PRE> 2501 * Meaning of the variables: 2502 * resvLimit: (0, 8, ..., 8*255 (MPEG-2), 8*511 (MPEG-1)) 2503 * Number of bits can be stored in previous frame(s) due to 2504 * counter size constaints 2505 * maxmp3buf: ( ??? ... 8*1951 (MPEG-1 and 2), 8*2047 (MPEG-2.5)) 2506 * Number of bits allowed to encode one frame (you can take 8*511 bit 2507 * from the bit reservoir and at most 8*1440 bit from the current 2508 * frame (320 kbps, 32 kHz), so 8*1951 bit is the largest possible 2509 * value for MPEG-1 and -2) 2510 * 2511 * maximum allowed granule/channel size times 4 = 8*2047 bits., 2512 * so this is the absolute maximum supported by the format. 2513 * 2514 * 2515 * fullFrameBits: maximum number of bits available for encoding 2516 * the current frame. 2517 * 2518 * mean_bits: target number of bits per granule. 2519 * 2520 * frameLength: 2521 * 2522 * gfc.ResvMax: maximum allowed reservoir 2523 * 2524 * gfc.ResvSize: current reservoir size 2525 * 2526 * l3_side.resvDrain_pre: 2527 * ancillary data to be added to previous frame: 2528 * (only usefull in VBR modes if it is possible to have 2529 * maxmp3buf < fullFrameBits)). Currently disabled, 2530 * see #define NEW_DRAIN 2531 * 2010-02-13: RH now enabled, it seems to be needed for CBR too, 2532 * as there exists one example, where the FhG decoder 2533 * can't decode a -b320 CBR file anymore. 2534 * 2535 * l3_side.resvDrain_post: 2536 * ancillary data to be added to this frame: 2537 * 2538 * </PRE> 2539 */ 2540 2541 /* main_data_begin has 9 bits in MPEG-1, 8 bits MPEG-2 */ 2542 var resvLimit = (8 * 256) * gfc.mode_gr - 8; 2543 2544 /* 2545 * maximum allowed frame size. dont use more than this number of bits, 2546 * even if the frame has the space for them: 2547 */ 2548 if (gfp.brate > 320) { 2549 /* in freeformat the buffer is constant */ 2550 maxmp3buf = 8 * ((int) ((gfp.brate * 1000) 2551 / (gfp.out_samplerate / 1152) / 8 + .5)); 2552 } else { 2553 /* 2554 * all mp3 decoders should have enough buffer to handle this value: 2555 * size of a 320kbps 32kHz frame 2556 */ 2557 maxmp3buf = 8 * 1440; 2558 2559 /* 2560 * Bouvigne suggests this more lax interpretation of the ISO doc 2561 * instead of using 8*960. 2562 */ 2563 2564 if (gfp.strict_ISO) { 2565 maxmp3buf = 8 * ((int) (320000 / (gfp.out_samplerate / 1152) / 8 + .5)); 2566 } 2567 } 2568 2569 gfc.ResvMax = maxmp3buf - frameLength; 2570 if (gfc.ResvMax > resvLimit) 2571 gfc.ResvMax = resvLimit; 2572 if (gfc.ResvMax < 0 || gfp.disable_reservoir) 2573 gfc.ResvMax = 0; 2574 2575 var fullFrameBits = mean_bits.bits * gfc.mode_gr 2576 + Math.min(gfc.ResvSize, gfc.ResvMax); 2577 2578 if (fullFrameBits > maxmp3buf) 2579 fullFrameBits = maxmp3buf; 2580 2581 2582 l3_side.resvDrain_pre = 0; 2583 2584 // frame analyzer code 2585 if (gfc.pinfo != null) { 2586 /* 2587 * expected bits per channel per granule [is this also right for 2588 * mono/stereo, MPEG-1/2 ?] 2589 */ 2590 gfc.pinfo.mean_bits = mean_bits.bits / 2; 2591 gfc.pinfo.resvsize = gfc.ResvSize; 2592 } 2593 2594 return fullFrameBits; 2595 } 2596 2597 /** 2598 * returns targ_bits: target number of bits to use for 1 granule<BR> 2599 * extra_bits: amount extra available from reservoir<BR> 2600 * Mark Taylor 4/99 2601 */ 2602 this.ResvMaxBits = function(gfp, mean_bits, targ_bits, cbr) { 2603 var gfc = gfp.internal_flags; 2604 var add_bits; 2605 var ResvSize = gfc.ResvSize, ResvMax = gfc.ResvMax; 2606 2607 /* compensate the saved bits used in the 1st granule */ 2608 if (cbr != 0) 2609 ResvSize += mean_bits; 2610 2611 if ((gfc.substep_shaping & 1) != 0) 2612 ResvMax *= 0.9; 2613 2614 targ_bits.bits = mean_bits; 2615 2616 /* extra bits if the reservoir is almost full */ 2617 if (ResvSize * 10 > ResvMax * 9) { 2618 add_bits = ResvSize - (ResvMax * 9) / 10; 2619 targ_bits.bits += add_bits; 2620 gfc.substep_shaping |= 0x80; 2621 } else { 2622 add_bits = 0; 2623 gfc.substep_shaping &= 0x7f; 2624 /* 2625 * build up reservoir. this builds the reservoir a little slower 2626 * than FhG. It could simple be mean_bits/15, but this was rigged to 2627 * always produce 100 (the old value) at 128kbs 2628 */ 2629 if (!gfp.disable_reservoir && 0 == (gfc.substep_shaping & 1)) 2630 targ_bits.bits -= .1 * mean_bits; 2631 } 2632 2633 /* amount from the reservoir we are allowed to use. ISO says 6/10 */ 2634 var extra_bits = (ResvSize < (gfc.ResvMax * 6) / 10 ? ResvSize 2635 : (gfc.ResvMax * 6) / 10); 2636 extra_bits -= add_bits; 2637 2638 if (extra_bits < 0) 2639 extra_bits = 0; 2640 return extra_bits; 2641 } 2642 2643 /** 2644 * Called after a granule's bit allocation. Readjusts the size of the 2645 * reservoir to reflect the granule's usage. 2646 */ 2647 this.ResvAdjust = function(gfc, gi) { 2648 gfc.ResvSize -= gi.part2_3_length + gi.part2_length; 2649 } 2650 2651 /** 2652 * Called after all granules in a frame have been allocated. Makes sure that 2653 * the reservoir size is within limits, possibly by adding stuffing bits. 2654 */ 2655 this.ResvFrameEnd = function(gfc, mean_bits) { 2656 var over_bits; 2657 var l3_side = gfc.l3_side; 2658 2659 gfc.ResvSize += mean_bits * gfc.mode_gr; 2660 var stuffingBits = 0; 2661 l3_side.resvDrain_post = 0; 2662 l3_side.resvDrain_pre = 0; 2663 2664 /* we must be byte aligned */ 2665 if ((over_bits = gfc.ResvSize % 8) != 0) 2666 stuffingBits += over_bits; 2667 2668 over_bits = (gfc.ResvSize - stuffingBits) - gfc.ResvMax; 2669 if (over_bits > 0) { 2670 stuffingBits += over_bits; 2671 } 2672 2673 /* 2674 * NOTE: enabling the NEW_DRAIN code fixes some problems with FhG 2675 * decoder shipped with MS Windows operating systems. Using this, it is 2676 * even possible to use Gabriel's lax buffer consideration again, which 2677 * assumes, any decoder should have a buffer large enough for a 320 kbps 2678 * frame at 32 kHz sample rate. 2679 * 2680 * old drain code: lame -b320 BlackBird.wav --. does not play with 2681 * GraphEdit.exe using FhG decoder V1.5 Build 50 2682 * 2683 * new drain code: lame -b320 BlackBird.wav --. plays fine with 2684 * GraphEdit.exe using FhG decoder V1.5 Build 50 2685 * 2686 * Robert Hegemann, 2010-02-13. 2687 */ 2688 /* 2689 * drain as many bits as possible into previous frame ancillary data In 2690 * particular, in VBR mode ResvMax may have changed, and we have to make 2691 * sure main_data_begin does not create a reservoir bigger than ResvMax 2692 * mt 4/00 2693 */ 2694 { 2695 var mdb_bytes = Math.min(l3_side.main_data_begin * 8, stuffingBits) / 8; 2696 l3_side.resvDrain_pre += 8 * mdb_bytes; 2697 stuffingBits -= 8 * mdb_bytes; 2698 gfc.ResvSize -= 8 * mdb_bytes; 2699 l3_side.main_data_begin -= mdb_bytes; 2700 } 2701 /* drain the rest into this frames ancillary data */ 2702 l3_side.resvDrain_post += stuffingBits; 2703 gfc.ResvSize -= stuffingBits; 2704 } 2705} 2706 2707 2708 2709BitStream.EQ = function (a, b) { 2710 return (Math.abs(a) > Math.abs(b)) ? (Math.abs((a) - (b)) <= (Math 2711 .abs(a) * 1e-6)) 2712 : (Math.abs((a) - (b)) <= (Math.abs(b) * 1e-6)); 2713}; 2714 2715BitStream.NEQ = function (a, b) { 2716 return !BitStream.EQ(a, b); 2717}; 2718 2719function BitStream() { 2720 var self = this; 2721 var CRC16_POLYNOMIAL = 0x8005; 2722 2723 /* 2724 * we work with ints, so when doing bit manipulation, we limit ourselves to 2725 * MAX_LENGTH-2 just to be on the safe side 2726 */ 2727 var MAX_LENGTH = 32; 2728 2729 //GainAnalysis ga; 2730 //MPGLib mpg; 2731 //Version ver; 2732 //VBRTag vbr; 2733 var ga = null; 2734 var mpg = null; 2735 var ver = null; 2736 var vbr = null; 2737 2738 //public final void setModules(GainAnalysis ga, MPGLib mpg, Version ver, 2739 // VBRTag vbr) { 2740 2741 this.setModules = function (_ga, _mpg, _ver, _vbr) { 2742 ga = _ga; 2743 mpg = _mpg; 2744 ver = _ver; 2745 vbr = _vbr; 2746 }; 2747 2748 /** 2749 * Bit stream buffer. 2750 */ 2751 //private byte[] buf; 2752 var buf = null; 2753 /** 2754 * Bit counter of bit stream. 2755 */ 2756 var totbit = 0; 2757 /** 2758 * Pointer to top byte in buffer. 2759 */ 2760 var bufByteIdx = 0; 2761 /** 2762 * Pointer to top bit of top byte in buffer. 2763 */ 2764 var bufBitIdx = 0; 2765 2766 /** 2767 * compute bitsperframe and mean_bits for a layer III frame 2768 */ 2769 this.getframebits = function (gfp) { 2770 var gfc = gfp.internal_flags; 2771 var bit_rate; 2772 2773 /* get bitrate in kbps [?] */ 2774 if (gfc.bitrate_index != 0) 2775 bit_rate = Tables.bitrate_table[gfp.version][gfc.bitrate_index]; 2776 else 2777 bit_rate = gfp.brate; 2778 2779 /* main encoding routine toggles padding on and off */ 2780 /* one Layer3 Slot consists of 8 bits */ 2781 var bytes = 0 | (gfp.version + 1) * 72000 * bit_rate / gfp.out_samplerate + gfc.padding; 2782 return 8 * bytes; 2783 }; 2784 2785 function putheader_bits(gfc) { 2786 System.arraycopy(gfc.header[gfc.w_ptr].buf, 0, buf, bufByteIdx, gfc.sideinfo_len); 2787 bufByteIdx += gfc.sideinfo_len; 2788 totbit += gfc.sideinfo_len * 8; 2789 gfc.w_ptr = (gfc.w_ptr + 1) & (LameInternalFlags.MAX_HEADER_BUF - 1); 2790 } 2791 2792 /** 2793 * write j bits into the bit stream 2794 */ 2795 function putbits2(gfc, val, j) { 2796 2797 while (j > 0) { 2798 var k; 2799 if (bufBitIdx == 0) { 2800 bufBitIdx = 8; 2801 bufByteIdx++; 2802 if (gfc.header[gfc.w_ptr].write_timing == totbit) { 2803 putheader_bits(gfc); 2804 } 2805 buf[bufByteIdx] = 0; 2806 } 2807 2808 k = Math.min(j, bufBitIdx); 2809 j -= k; 2810 2811 bufBitIdx -= k; 2812 2813 /* 32 too large on 32 bit machines */ 2814 2815 buf[bufByteIdx] |= ((val >> j) << bufBitIdx); 2816 totbit += k; 2817 } 2818 } 2819 2820 /** 2821 * write j bits into the bit stream, ignoring frame headers 2822 */ 2823 function putbits_noheaders(gfc, val, j) { 2824 2825 while (j > 0) { 2826 var k; 2827 if (bufBitIdx == 0) { 2828 bufBitIdx = 8; 2829 bufByteIdx++; 2830 buf[bufByteIdx] = 0; 2831 } 2832 2833 k = Math.min(j, bufBitIdx); 2834 j -= k; 2835 2836 bufBitIdx -= k; 2837 2838 /* 32 too large on 32 bit machines */ 2839 2840 buf[bufByteIdx] |= ((val >> j) << bufBitIdx); 2841 totbit += k; 2842 } 2843 } 2844 2845 /** 2846 * Some combinations of bitrate, Fs, and stereo make it impossible to stuff 2847 * out a frame using just main_data, due to the limited number of bits to 2848 * indicate main_data_length. In these situations, we put stuffing bits into 2849 * the ancillary data... 2850 */ 2851 function drain_into_ancillary(gfp, remainingBits) { 2852 var gfc = gfp.internal_flags; 2853 var i; 2854 2855 if (remainingBits >= 8) { 2856 putbits2(gfc, 0x4c, 8); 2857 remainingBits -= 8; 2858 } 2859 if (remainingBits >= 8) { 2860 putbits2(gfc, 0x41, 8); 2861 remainingBits -= 8; 2862 } 2863 if (remainingBits >= 8) { 2864 putbits2(gfc, 0x4d, 8); 2865 remainingBits -= 8; 2866 } 2867 if (remainingBits >= 8) { 2868 putbits2(gfc, 0x45, 8); 2869 remainingBits -= 8; 2870 } 2871 2872 if (remainingBits >= 32) { 2873 var version = ver.getLameShortVersion(); 2874 if (remainingBits >= 32) 2875 for (i = 0; i < version.length && remainingBits >= 8; ++i) { 2876 remainingBits -= 8; 2877 putbits2(gfc, version.charAt(i), 8); 2878 } 2879 } 2880 2881 for (; remainingBits >= 1; remainingBits -= 1) { 2882 putbits2(gfc, gfc.ancillary_flag, 1); 2883 gfc.ancillary_flag ^= (!gfp.disable_reservoir ? 1 : 0); 2884 } 2885 2886 2887 } 2888 2889 /** 2890 * write N bits into the header 2891 */ 2892 function writeheader(gfc, val, j) { 2893 var ptr = gfc.header[gfc.h_ptr].ptr; 2894 2895 while (j > 0) { 2896 var k = Math.min(j, 8 - (ptr & 7)); 2897 j -= k; 2898 /* >> 32 too large for 32 bit machines */ 2899 2900 gfc.header[gfc.h_ptr].buf[ptr >> 3] |= ((val >> j)) << (8 - (ptr & 7) - k); 2901 ptr += k; 2902 } 2903 gfc.header[gfc.h_ptr].ptr = ptr; 2904 } 2905 2906 function CRC_update(value, crc) { 2907 value <<= 8; 2908 for (var i = 0; i < 8; i++) { 2909 value <<= 1; 2910 crc <<= 1; 2911 2912 if ((((crc ^ value) & 0x10000) != 0)) 2913 crc ^= CRC16_POLYNOMIAL; 2914 } 2915 return crc; 2916 } 2917 2918 this.CRC_writeheader = function (gfc, header) { 2919 var crc = 0xffff; 2920 /* (jo) init crc16 for error_protection */ 2921 2922 crc = CRC_update(header[2] & 0xff, crc); 2923 crc = CRC_update(header[3] & 0xff, crc); 2924 for (var i = 6; i < gfc.sideinfo_len; i++) { 2925 crc = CRC_update(header[i] & 0xff, crc); 2926 } 2927 2928 header[4] = (byte)(crc >> 8); 2929 header[5] = (byte)(crc & 255); 2930 }; 2931 2932 function encodeSideInfo2(gfp, bitsPerFrame) { 2933 var gfc = gfp.internal_flags; 2934 var l3_side; 2935 var gr, ch; 2936 2937 l3_side = gfc.l3_side; 2938 gfc.header[gfc.h_ptr].ptr = 0; 2939 Arrays.fill(gfc.header[gfc.h_ptr].buf, 0, gfc.sideinfo_len, 0); 2940 if (gfp.out_samplerate < 16000) 2941 writeheader(gfc, 0xffe, 12); 2942 else 2943 writeheader(gfc, 0xfff, 12); 2944 writeheader(gfc, (gfp.version), 1); 2945 writeheader(gfc, 4 - 3, 2); 2946 writeheader(gfc, (!gfp.error_protection ? 1 : 0), 1); 2947 writeheader(gfc, (gfc.bitrate_index), 4); 2948 writeheader(gfc, (gfc.samplerate_index), 2); 2949 writeheader(gfc, (gfc.padding), 1); 2950 writeheader(gfc, (gfp.extension), 1); 2951 writeheader(gfc, (gfp.mode.ordinal()), 2); 2952 writeheader(gfc, (gfc.mode_ext), 2); 2953 writeheader(gfc, (gfp.copyright), 1); 2954 writeheader(gfc, (gfp.original), 1); 2955 writeheader(gfc, (gfp.emphasis), 2); 2956 if (gfp.error_protection) { 2957 writeheader(gfc, 0, 16); 2958 /* dummy */ 2959 } 2960 2961 if (gfp.version == 1) { 2962 /* MPEG1 */ 2963 writeheader(gfc, (l3_side.main_data_begin), 9); 2964 2965 if (gfc.channels_out == 2) 2966 writeheader(gfc, l3_side.private_bits, 3); 2967 else 2968 writeheader(gfc, l3_side.private_bits, 5); 2969 2970 for (ch = 0; ch < gfc.channels_out; ch++) { 2971 var band; 2972 for (band = 0; band < 4; band++) { 2973 writeheader(gfc, l3_side.scfsi[ch][band], 1); 2974 } 2975 } 2976 2977 for (gr = 0; gr < 2; gr++) { 2978 for (ch = 0; ch < gfc.channels_out; ch++) { 2979 var gi = l3_side.tt[gr][ch]; 2980 writeheader(gfc, gi.part2_3_length + gi.part2_length, 12); 2981 writeheader(gfc, gi.big_values / 2, 9); 2982 writeheader(gfc, gi.global_gain, 8); 2983 writeheader(gfc, gi.scalefac_compress, 4); 2984 2985 if (gi.block_type != Encoder.NORM_TYPE) { 2986 writeheader(gfc, 1, 1); 2987 /* window_switching_flag */ 2988 writeheader(gfc, gi.block_type, 2); 2989 writeheader(gfc, gi.mixed_block_flag, 1); 2990 2991 if (gi.table_select[0] == 14) 2992 gi.table_select[0] = 16; 2993 writeheader(gfc, gi.table_select[0], 5); 2994 if (gi.table_select[1] == 14) 2995 gi.table_select[1] = 16; 2996 writeheader(gfc, gi.table_select[1], 5); 2997 2998 writeheader(gfc, gi.subblock_gain[0], 3); 2999 writeheader(gfc, gi.subblock_gain[1], 3); 3000 writeheader(gfc, gi.subblock_gain[2], 3); 3001 } else { 3002 writeheader(gfc, 0, 1); 3003 /* window_switching_flag */ 3004 if (gi.table_select[0] == 14) 3005 gi.table_select[0] = 16; 3006 writeheader(gfc, gi.table_select[0], 5); 3007 if (gi.table_select[1] == 14) 3008 gi.table_select[1] = 16; 3009 writeheader(gfc, gi.table_select[1], 5); 3010 if (gi.table_select[2] == 14) 3011 gi.table_select[2] = 16; 3012 writeheader(gfc, gi.table_select[2], 5); 3013 3014 writeheader(gfc, gi.region0_count, 4); 3015 writeheader(gfc, gi.region1_count, 3); 3016 } 3017 writeheader(gfc, gi.preflag, 1); 3018 writeheader(gfc, gi.scalefac_scale, 1); 3019 writeheader(gfc, gi.count1table_select, 1); 3020 } 3021 } 3022 } else { 3023 /* MPEG2 */ 3024 writeheader(gfc, (l3_side.main_data_begin), 8); 3025 writeheader(gfc, l3_side.private_bits, gfc.channels_out); 3026 3027 gr = 0; 3028 for (ch = 0; ch < gfc.channels_out; ch++) { 3029 var gi = l3_side.tt[gr][ch]; 3030 writeheader(gfc, gi.part2_3_length + gi.part2_length, 12); 3031 writeheader(gfc, gi.big_values / 2, 9); 3032 writeheader(gfc, gi.global_gain, 8); 3033 writeheader(gfc, gi.scalefac_compress, 9); 3034 3035 if (gi.block_type != Encoder.NORM_TYPE) { 3036 writeheader(gfc, 1, 1); 3037 /* window_switching_flag */ 3038 writeheader(gfc, gi.block_type, 2); 3039 writeheader(gfc, gi.mixed_block_flag, 1); 3040 3041 if (gi.table_select[0] == 14) 3042 gi.table_select[0] = 16; 3043 writeheader(gfc, gi.table_select[0], 5); 3044 if (gi.table_select[1] == 14) 3045 gi.table_select[1] = 16; 3046 writeheader(gfc, gi.table_select[1], 5); 3047 3048 writeheader(gfc, gi.subblock_gain[0], 3); 3049 writeheader(gfc, gi.subblock_gain[1], 3); 3050 writeheader(gfc, gi.subblock_gain[2], 3); 3051 } else { 3052 writeheader(gfc, 0, 1); 3053 /* window_switching_flag */ 3054 if (gi.table_select[0] == 14) 3055 gi.table_select[0] = 16; 3056 writeheader(gfc, gi.table_select[0], 5); 3057 if (gi.table_select[1] == 14) 3058 gi.table_select[1] = 16; 3059 writeheader(gfc, gi.table_select[1], 5); 3060 if (gi.table_select[2] == 14) 3061 gi.table_select[2] = 16; 3062 writeheader(gfc, gi.table_select[2], 5); 3063 3064 writeheader(gfc, gi.region0_count, 4); 3065 writeheader(gfc, gi.region1_count, 3); 3066 } 3067 3068 writeheader(gfc, gi.scalefac_scale, 1); 3069 writeheader(gfc, gi.count1table_select, 1); 3070 } 3071 } 3072 3073 if (gfp.error_protection) { 3074 /* (jo) error_protection: add crc16 information to header */ 3075 CRC_writeheader(gfc, gfc.header[gfc.h_ptr].buf); 3076 } 3077 3078 { 3079 var old = gfc.h_ptr; 3080 3081 gfc.h_ptr = (old + 1) & (LameInternalFlags.MAX_HEADER_BUF - 1); 3082 gfc.header[gfc.h_ptr].write_timing = gfc.header[old].write_timing 3083 + bitsPerFrame; 3084 3085 if (gfc.h_ptr == gfc.w_ptr) { 3086 /* yikes! we are out of header buffer space */ 3087 System.err 3088 .println("Error: MAX_HEADER_BUF too small in bitstream.c \n"); 3089 } 3090 3091 } 3092 } 3093 3094 function huffman_coder_count1(gfc, gi) { 3095 /* Write count1 area */ 3096 var h = Tables.ht[gi.count1table_select + 32]; 3097 var i, bits = 0; 3098 3099 var ix = gi.big_values; 3100 var xr = gi.big_values; 3101 3102 for (i = (gi.count1 - gi.big_values) / 4; i > 0; --i) { 3103 var huffbits = 0; 3104 var p = 0, v; 3105 3106 v = gi.l3_enc[ix + 0]; 3107 if (v != 0) { 3108 p += 8; 3109 if (gi.xr[xr + 0] < 0) 3110 huffbits++; 3111 } 3112 3113 v = gi.l3_enc[ix + 1]; 3114 if (v != 0) { 3115 p += 4; 3116 huffbits *= 2; 3117 if (gi.xr[xr + 1] < 0) 3118 huffbits++; 3119 } 3120 3121 v = gi.l3_enc[ix + 2]; 3122 if (v != 0) { 3123 p += 2; 3124 huffbits *= 2; 3125 if (gi.xr[xr + 2] < 0) 3126 huffbits++; 3127 } 3128 3129 v = gi.l3_enc[ix + 3]; 3130 if (v != 0) { 3131 p++; 3132 huffbits *= 2; 3133 if (gi.xr[xr + 3] < 0) 3134 huffbits++; 3135 } 3136 3137 ix += 4; 3138 xr += 4; 3139 putbits2(gfc, huffbits + h.table[p], h.hlen[p]); 3140 bits += h.hlen[p]; 3141 } 3142 return bits; 3143 } 3144 3145 /** 3146 * Implements the pseudocode of page 98 of the IS 3147 */ 3148 function Huffmancode(gfc, tableindex, start, end, gi) { 3149 var h = Tables.ht[tableindex]; 3150 var bits = 0; 3151 3152 if (0 == tableindex) 3153 return bits; 3154 3155 for (var i = start; i < end; i += 2) { 3156 var cbits = 0; 3157 var xbits = 0; 3158 var linbits = h.xlen; 3159 var xlen = h.xlen; 3160 var ext = 0; 3161 var x1 = gi.l3_enc[i]; 3162 var x2 = gi.l3_enc[i + 1]; 3163 3164 if (x1 != 0) { 3165 if (gi.xr[i] < 0) 3166 ext++; 3167 cbits--; 3168 } 3169 3170 if (tableindex > 15) { 3171 /* use ESC-words */ 3172 if (x1 > 14) { 3173 var linbits_x1 = x1 - 15; 3174 ext |= linbits_x1 << 1; 3175 xbits = linbits; 3176 x1 = 15; 3177 } 3178 3179 if (x2 > 14) { 3180 var linbits_x2 = x2 - 15; 3181 ext <<= linbits; 3182 ext |= linbits_x2; 3183 xbits += linbits; 3184 x2 = 15; 3185 } 3186 xlen = 16; 3187 } 3188 3189 if (x2 != 0) { 3190 ext <<= 1; 3191 if (gi.xr[i + 1] < 0) 3192 ext++; 3193 cbits--; 3194 } 3195 3196 3197 x1 = x1 * xlen + x2; 3198 xbits -= cbits; 3199 cbits += h.hlen[x1]; 3200 3201 3202 putbits2(gfc, h.table[x1], cbits); 3203 putbits2(gfc, ext, xbits); 3204 bits += cbits + xbits; 3205 } 3206 return bits; 3207 } 3208 3209 /** 3210 * Note the discussion of huffmancodebits() on pages 28 and 29 of the IS, as 3211 * well as the definitions of the side information on pages 26 and 27. 3212 */ 3213 function ShortHuffmancodebits(gfc, gi) { 3214 var region1Start = 3 * gfc.scalefac_band.s[3]; 3215 if (region1Start > gi.big_values) 3216 region1Start = gi.big_values; 3217 3218 /* short blocks do not have a region2 */ 3219 var bits = Huffmancode(gfc, gi.table_select[0], 0, region1Start, gi); 3220 bits += Huffmancode(gfc, gi.table_select[1], region1Start, 3221 gi.big_values, gi); 3222 return bits; 3223 } 3224 3225 function LongHuffmancodebits(gfc, gi) { 3226 var bigvalues, bits; 3227 var region1Start, region2Start; 3228 3229 bigvalues = gi.big_values; 3230 3231 var i = gi.region0_count + 1; 3232 region1Start = gfc.scalefac_band.l[i]; 3233 i += gi.region1_count + 1; 3234 region2Start = gfc.scalefac_band.l[i]; 3235 3236 if (region1Start > bigvalues) 3237 region1Start = bigvalues; 3238 3239 if (region2Start > bigvalues) 3240 region2Start = bigvalues; 3241 3242 bits = Huffmancode(gfc, gi.table_select[0], 0, region1Start, gi); 3243 bits += Huffmancode(gfc, gi.table_select[1], region1Start, 3244 region2Start, gi); 3245 bits += Huffmancode(gfc, gi.table_select[2], region2Start, bigvalues, 3246 gi); 3247 return bits; 3248 } 3249 3250 function writeMainData(gfp) { 3251 var gr, ch, sfb, data_bits, tot_bits = 0; 3252 var gfc = gfp.internal_flags; 3253 var l3_side = gfc.l3_side; 3254 3255 if (gfp.version == 1) { 3256 /* MPEG 1 */ 3257 for (gr = 0; gr < 2; gr++) { 3258 for (ch = 0; ch < gfc.channels_out; ch++) { 3259 var gi = l3_side.tt[gr][ch]; 3260 var slen1 = Takehiro.slen1_tab[gi.scalefac_compress]; 3261 var slen2 = Takehiro.slen2_tab[gi.scalefac_compress]; 3262 data_bits = 0; 3263 for (sfb = 0; sfb < gi.sfbdivide; sfb++) { 3264 if (gi.scalefac[sfb] == -1) 3265 continue; 3266 /* scfsi is used */ 3267 putbits2(gfc, gi.scalefac[sfb], slen1); 3268 data_bits += slen1; 3269 } 3270 for (; sfb < gi.sfbmax; sfb++) { 3271 if (gi.scalefac[sfb] == -1) 3272 continue; 3273 /* scfsi is used */ 3274 putbits2(gfc, gi.scalefac[sfb], slen2); 3275 data_bits += slen2; 3276 } 3277 3278 if (gi.block_type == Encoder.SHORT_TYPE) { 3279 data_bits += ShortHuffmancodebits(gfc, gi); 3280 } else { 3281 data_bits += LongHuffmancodebits(gfc, gi); 3282 } 3283 data_bits += huffman_coder_count1(gfc, gi); 3284 /* does bitcount in quantize.c agree with actual bit count? */ 3285 tot_bits += data_bits; 3286 } 3287 /* for ch */ 3288 } 3289 /* for gr */ 3290 } else { 3291 /* MPEG 2 */ 3292 gr = 0; 3293 for (ch = 0; ch < gfc.channels_out; ch++) { 3294 var gi = l3_side.tt[gr][ch]; 3295 var i, sfb_partition, scale_bits = 0; 3296 data_bits = 0; 3297 sfb = 0; 3298 sfb_partition = 0; 3299 3300 if (gi.block_type == Encoder.SHORT_TYPE) { 3301 for (; sfb_partition < 4; sfb_partition++) { 3302 var sfbs = gi.sfb_partition_table[sfb_partition] / 3; 3303 var slen = gi.slen[sfb_partition]; 3304 for (i = 0; i < sfbs; i++, sfb++) { 3305 putbits2(gfc, 3306 Math.max(gi.scalefac[sfb * 3 + 0], 0), slen); 3307 putbits2(gfc, 3308 Math.max(gi.scalefac[sfb * 3 + 1], 0), slen); 3309 putbits2(gfc, 3310 Math.max(gi.scalefac[sfb * 3 + 2], 0), slen); 3311 scale_bits += 3 * slen; 3312 } 3313 } 3314 data_bits += ShortHuffmancodebits(gfc, gi); 3315 } else { 3316 for (; sfb_partition < 4; sfb_partition++) { 3317 var sfbs = gi.sfb_partition_table[sfb_partition]; 3318 var slen = gi.slen[sfb_partition]; 3319 for (i = 0; i < sfbs; i++, sfb++) { 3320 putbits2(gfc, Math.max(gi.scalefac[sfb], 0), slen); 3321 scale_bits += slen; 3322 } 3323 } 3324 data_bits += LongHuffmancodebits(gfc, gi); 3325 } 3326 data_bits += huffman_coder_count1(gfc, gi); 3327 /* does bitcount in quantize.c agree with actual bit count? */ 3328 tot_bits += scale_bits + data_bits; 3329 } 3330 /* for ch */ 3331 } 3332 /* for gf */ 3333 return tot_bits; 3334 } 3335 3336 /* main_data */ 3337 3338 function TotalBytes() { 3339 this.total = 0; 3340 } 3341 3342 /* 3343 * compute the number of bits required to flush all mp3 frames currently in 3344 * the buffer. This should be the same as the reservoir size. Only call this 3345 * routine between frames - i.e. only after all headers and data have been 3346 * added to the buffer by format_bitstream(). 3347 * 3348 * Also compute total_bits_output = size of mp3 buffer (including frame 3349 * headers which may not have yet been send to the mp3 buffer) + number of 3350 * bits needed to flush all mp3 frames. 3351 * 3352 * total_bytes_output is the size of the mp3 output buffer if 3353 * lame_encode_flush_nogap() was called right now. 3354 */ 3355 function compute_flushbits(gfp, total_bytes_output) { 3356 var gfc = gfp.internal_flags; 3357 var flushbits, remaining_headers; 3358 var bitsPerFrame; 3359 var last_ptr, first_ptr; 3360 first_ptr = gfc.w_ptr; 3361 /* first header to add to bitstream */ 3362 last_ptr = gfc.h_ptr - 1; 3363 /* last header to add to bitstream */ 3364 if (last_ptr == -1) 3365 last_ptr = LameInternalFlags.MAX_HEADER_BUF - 1; 3366 3367 /* add this many bits to bitstream so we can flush all headers */ 3368 flushbits = gfc.header[last_ptr].write_timing - totbit; 3369 total_bytes_output.total = flushbits; 3370 3371 if (flushbits >= 0) { 3372 /* if flushbits >= 0, some headers have not yet been written */ 3373 /* reduce flushbits by the size of the headers */ 3374 remaining_headers = 1 + last_ptr - first_ptr; 3375 if (last_ptr < first_ptr) 3376 remaining_headers = 1 + last_ptr - first_ptr 3377 + LameInternalFlags.MAX_HEADER_BUF; 3378 flushbits -= remaining_headers * 8 * gfc.sideinfo_len; 3379 } 3380 3381 /* 3382 * finally, add some bits so that the last frame is complete these bits 3383 * are not necessary to decode the last frame, but some decoders will 3384 * ignore last frame if these bits are missing 3385 */ 3386 bitsPerFrame = self.getframebits(gfp); 3387 flushbits += bitsPerFrame; 3388 total_bytes_output.total += bitsPerFrame; 3389 /* round up: */ 3390 if ((total_bytes_output.total % 8) != 0) 3391 total_bytes_output.total = 1 + (total_bytes_output.total / 8); 3392 else 3393 total_bytes_output.total = (total_bytes_output.total / 8); 3394 total_bytes_output.total += bufByteIdx + 1; 3395 3396 if (flushbits < 0) { 3397 System.err.println("strange error flushing buffer ... \n"); 3398 } 3399 return flushbits; 3400 } 3401 3402 this.flush_bitstream = function (gfp) { 3403 var gfc = gfp.internal_flags; 3404 var l3_side; 3405 var flushbits; 3406 var last_ptr = gfc.h_ptr - 1; 3407 /* last header to add to bitstream */ 3408 if (last_ptr == -1) 3409 last_ptr = LameInternalFlags.MAX_HEADER_BUF - 1; 3410 l3_side = gfc.l3_side; 3411 3412 if ((flushbits = compute_flushbits(gfp, new TotalBytes())) < 0) 3413 return; 3414 drain_into_ancillary(gfp, flushbits); 3415 3416 /* check that the 100% of the last frame has been written to bitstream */ 3417 3418 /* 3419 * we have padded out all frames with ancillary data, which is the same 3420 * as filling the bitreservoir with ancillary data, so : 3421 */ 3422 gfc.ResvSize = 0; 3423 l3_side.main_data_begin = 0; 3424 3425 /* save the ReplayGain value */ 3426 if (gfc.findReplayGain) { 3427 var RadioGain = ga.GetTitleGain(gfc.rgdata); 3428 gfc.RadioGain = Math.floor(RadioGain * 10.0 + 0.5) | 0; 3429 /* round to nearest */ 3430 } 3431 3432 /* find the gain and scale change required for no clipping */ 3433 if (gfc.findPeakSample) { 3434 gfc.noclipGainChange = Math.ceil(Math 3435 .log10(gfc.PeakSample / 32767.0) * 20.0 * 10.0) | 0; 3436 /* round up */ 3437 3438 if (gfc.noclipGainChange > 0) { 3439 /* clipping occurs */ 3440 if (EQ(gfp.scale, 1.0) || EQ(gfp.scale, 0.0)) 3441 gfc.noclipScale = (Math 3442 .floor((32767.0 / gfc.PeakSample) * 100.0) / 100.0); 3443 /* round down */ 3444 else { 3445 /* 3446 * the user specified his own scaling factor. We could 3447 * suggest the scaling factor of 3448 * (32767.0/gfp.PeakSample)*(gfp.scale) but it's usually 3449 * very inaccurate. So we'd rather not advice him on the 3450 * scaling factor. 3451 */ 3452 gfc.noclipScale = -1; 3453 } 3454 } else 3455 /* no clipping */ 3456 gfc.noclipScale = -1; 3457 } 3458 }; 3459 3460 this.add_dummy_byte = function (gfp, val, n) { 3461 var gfc = gfp.internal_flags; 3462 var i; 3463 3464 while (n-- > 0) { 3465 putbits_noheaders(gfc, val, 8); 3466 3467 for (i = 0; i < LameInternalFlags.MAX_HEADER_BUF; ++i) 3468 gfc.header[i].write_timing += 8; 3469 } 3470 }; 3471 3472 /** 3473 * This is called after a frame of audio has been quantized and coded. It 3474 * will write the encoded audio to the bitstream. Note that from a layer3 3475 * encoder's perspective the bit stream is primarily a series of main_data() 3476 * blocks, with header and side information inserted at the proper locations 3477 * to maintain framing. (See Figure A.7 in the IS). 3478 */ 3479 this.format_bitstream = function (gfp) { 3480 var gfc = gfp.internal_flags; 3481 var l3_side; 3482 l3_side = gfc.l3_side; 3483 3484 var bitsPerFrame = this.getframebits(gfp); 3485 drain_into_ancillary(gfp, l3_side.resvDrain_pre); 3486 3487 encodeSideInfo2(gfp, bitsPerFrame); 3488 var bits = 8 * gfc.sideinfo_len; 3489 bits += writeMainData(gfp); 3490 drain_into_ancillary(gfp, l3_side.resvDrain_post); 3491 bits += l3_side.resvDrain_post; 3492 3493 l3_side.main_data_begin += (bitsPerFrame - bits) / 8; 3494 3495 /* 3496 * compare number of bits needed to clear all buffered mp3 frames with 3497 * what we think the resvsize is: 3498 */ 3499 if (compute_flushbits(gfp, new TotalBytes()) != gfc.ResvSize) { 3500 System.err.println("Internal buffer inconsistency. flushbits <> ResvSize"); 3501 } 3502 3503 /* 3504 * compare main_data_begin for the next frame with what we think the 3505 * resvsize is: 3506 */ 3507 if ((l3_side.main_data_begin * 8) != gfc.ResvSize) { 3508 System.err.printf("bit reservoir error: \n" 3509 + "l3_side.main_data_begin: %d \n" 3510 + "Resvoir size: %d \n" 3511 + "resv drain (post) %d \n" 3512 + "resv drain (pre) %d \n" 3513 + "header and sideinfo: %d \n" 3514 + "data bits: %d \n" 3515 + "total bits: %d (remainder: %d) \n" 3516 + "bitsperframe: %d \n", 3517 8 * l3_side.main_data_begin, gfc.ResvSize, 3518 l3_side.resvDrain_post, l3_side.resvDrain_pre, 3519 8 * gfc.sideinfo_len, bits - l3_side.resvDrain_post - 8 3520 * gfc.sideinfo_len, bits, bits % 8, bitsPerFrame); 3521 3522 System.err.println("This is a fatal error. It has several possible causes:"); 3523 System.err.println("90%% LAME compiled with buggy version of gcc using advanced optimizations"); 3524 System.err.println(" 9%% Your system is overclocked"); 3525 System.err.println(" 1%% bug in LAME encoding library"); 3526 3527 gfc.ResvSize = l3_side.main_data_begin * 8; 3528 } 3529 //; 3530 3531 if (totbit > 1000000000) { 3532 /* 3533 * to avoid totbit overflow, (at 8h encoding at 128kbs) lets reset 3534 * bit counter 3535 */ 3536 var i; 3537 for (i = 0; i < LameInternalFlags.MAX_HEADER_BUF; ++i) 3538 gfc.header[i].write_timing -= totbit; 3539 totbit = 0; 3540 } 3541 3542 return 0; 3543 }; 3544 3545 /** 3546 * <PRE> 3547 * copy data out of the internal MP3 bit buffer into a user supplied 3548 * unsigned char buffer. 3549 * 3550 * mp3data=0 indicates data in buffer is an id3tags and VBR tags 3551 * mp3data=1 data is real mp3 frame data. 3552 * </PRE> 3553 */ 3554 this.copy_buffer = function (gfc, buffer, bufferPos, size, mp3data) { 3555 var minimum = bufByteIdx + 1; 3556 if (minimum <= 0) 3557 return 0; 3558 if (size != 0 && minimum > size) { 3559 /* buffer is too small */ 3560 return -1; 3561 } 3562 System.arraycopy(buf, 0, buffer, bufferPos, minimum); 3563 bufByteIdx = -1; 3564 bufBitIdx = 0; 3565 3566 if (mp3data != 0) { 3567 var crc = new_int(1); 3568 crc[0] = gfc.nMusicCRC; 3569 vbr.updateMusicCRC(crc, buffer, bufferPos, minimum); 3570 gfc.nMusicCRC = crc[0]; 3571 3572 /** 3573 * sum number of bytes belonging to the mp3 stream this info will be 3574 * written into the Xing/LAME header for seeking 3575 */ 3576 if (minimum > 0) { 3577 gfc.VBR_seek_table.nBytesWritten += minimum; 3578 } 3579 3580 if (gfc.decode_on_the_fly) { /* decode the frame */ 3581 var pcm_buf = new_float_n([2, 1152]); 3582 var mp3_in = minimum; 3583 var samples_out = -1; 3584 var i; 3585 3586 /* re-synthesis to pcm. Repeat until we get a samples_out=0 */ 3587 while (samples_out != 0) { 3588 3589 samples_out = mpg.hip_decode1_unclipped(gfc.hip, buffer, 3590 bufferPos, mp3_in, pcm_buf[0], pcm_buf[1]); 3591 /* 3592 * samples_out = 0: need more data to decode samples_out = 3593 * -1: error. Lets assume 0 pcm output samples_out = number 3594 * of samples output 3595 */ 3596 3597 /* 3598 * set the lenght of the mp3 input buffer to zero, so that 3599 * in the next iteration of the loop we will be querying 3600 * mpglib about buffered data 3601 */ 3602 mp3_in = 0; 3603 3604 if (samples_out == -1) { 3605 /* 3606 * error decoding. Not fatal, but might screw up the 3607 * ReplayGain tag. What should we do? Ignore for now 3608 */ 3609 samples_out = 0; 3610 } 3611 if (samples_out > 0) { 3612 /* process the PCM data */ 3613 3614 /* 3615 * this should not be possible, and indicates we have 3616 * overflown the pcm_buf buffer 3617 */ 3618 3619 if (gfc.findPeakSample) { 3620 for (i = 0; i < samples_out; i++) { 3621 if (pcm_buf[0][i] > gfc.PeakSample) 3622 gfc.PeakSample = pcm_buf[0][i]; 3623 else if (-pcm_buf[0][i] > gfc.PeakSample) 3624 gfc.PeakSample = -pcm_buf[0][i]; 3625 } 3626 if (gfc.channels_out > 1) 3627 for (i = 0; i < samples_out; i++) { 3628 if (pcm_buf[1][i] > gfc.PeakSample) 3629 gfc.PeakSample = pcm_buf[1][i]; 3630 else if (-pcm_buf[1][i] > gfc.PeakSample) 3631 gfc.PeakSample = -pcm_buf[1][i]; 3632 } 3633 } 3634 3635 if (gfc.findReplayGain) 3636 if (ga.AnalyzeSamples(gfc.rgdata, pcm_buf[0], 0, 3637 pcm_buf[1], 0, samples_out, 3638 gfc.channels_out) == GainAnalysis.GAIN_ANALYSIS_ERROR) 3639 return -6; 3640 3641 } 3642 /* if (samples_out>0) */ 3643 } 3644 /* while (samples_out!=0) */ 3645 } 3646 /* if (gfc.decode_on_the_fly) */ 3647 3648 } 3649 /* if (mp3data) */ 3650 return minimum; 3651 }; 3652 3653 this.init_bit_stream_w = function (gfc) { 3654 buf = new_byte(Lame.LAME_MAXMP3BUFFER); 3655 3656 gfc.h_ptr = gfc.w_ptr = 0; 3657 gfc.header[gfc.h_ptr].write_timing = 0; 3658 bufByteIdx = -1; 3659 bufBitIdx = 0; 3660 totbit = 0; 3661 }; 3662 3663 // From machine.h 3664 3665 3666} 3667 3668 3669/** 3670 * A Vbr header may be present in the ancillary data field of the first frame of 3671 * an mp3 bitstream<BR> 3672 * The Vbr header (optionally) contains 3673 * <UL> 3674 * <LI>frames total number of audio frames in the bitstream 3675 * <LI>bytes total number of bytes in the bitstream 3676 * <LI>toc table of contents 3677 * </UL> 3678 * 3679 * toc (table of contents) gives seek points for random access.<BR> 3680 * The ith entry determines the seek point for i-percent duration.<BR> 3681 * seek point in bytes = (toc[i]/256.0) * total_bitstream_bytes<BR> 3682 * e.g. half duration seek point = (toc[50]/256.0) * total_bitstream_bytes 3683 */ 3684VBRTag.NUMTOCENTRIES = 100; 3685VBRTag.MAXFRAMESIZE = 2880; 3686 3687function VBRTag() { 3688 3689 var lame; 3690 var bs; 3691 var v; 3692 3693 this.setModules = function (_lame, _bs, _v) { 3694 lame = _lame; 3695 bs = _bs; 3696 v = _v; 3697 }; 3698 3699 var FRAMES_FLAG = 0x0001; 3700 var BYTES_FLAG = 0x0002; 3701 var TOC_FLAG = 0x0004; 3702 var VBR_SCALE_FLAG = 0x0008; 3703 3704 var NUMTOCENTRIES = VBRTag.NUMTOCENTRIES; 3705 3706 /** 3707 * (0xB40) the max freeformat 640 32kHz framesize. 3708 */ 3709 var MAXFRAMESIZE = VBRTag.MAXFRAMESIZE; 3710 3711 /** 3712 * <PRE> 3713 * 4 bytes for Header Tag 3714 * 4 bytes for Header Flags 3715 * 100 bytes for entry (toc) 3716 * 4 bytes for frame size 3717 * 4 bytes for stream size 3718 * 4 bytes for VBR scale. a VBR quality indicator: 0=best 100=worst 3719 * 20 bytes for LAME tag. for example, "LAME3.12 (beta 6)" 3720 * ___________ 3721 * 140 bytes 3722 * </PRE> 3723 */ 3724 var VBRHEADERSIZE = (NUMTOCENTRIES + 4 + 4 + 4 + 4 + 4); 3725 3726 var LAMEHEADERSIZE = (VBRHEADERSIZE + 9 + 1 + 1 + 8 3727 + 1 + 1 + 3 + 1 + 1 + 2 + 4 + 2 + 2); 3728 3729 /** 3730 * The size of the Xing header MPEG-1, bit rate in kbps. 3731 */ 3732 var XING_BITRATE1 = 128; 3733 /** 3734 * The size of the Xing header MPEG-2, bit rate in kbps. 3735 */ 3736 var XING_BITRATE2 = 64; 3737 /** 3738 * The size of the Xing header MPEG-2.5, bit rate in kbps. 3739 */ 3740 var XING_BITRATE25 = 32; 3741 3742 /** 3743 * ISO-8859-1 charset for byte to string operations. 3744 */ 3745 var ISO_8859_1 = null; //Charset.forName("ISO-8859-1"); 3746 3747 /** 3748 * VBR header magic string. 3749 */ 3750 var VBRTag0 = "Xing"; 3751 /** 3752 * VBR header magic string (VBR == VBRMode.vbr_off). 3753 */ 3754 var VBRTag1 = "Info"; 3755 3756 /** 3757 * Lookup table for fast CRC-16 computation. Uses the polynomial 3758 * x^16+x^15+x^2+1 3759 */ 3760 var crc16Lookup = [0x0000, 0xC0C1, 0xC181, 0x0140, 3761 0xC301, 0x03C0, 0x0280, 0xC241, 0xC601, 0x06C0, 0x0780, 0xC741, 3762 0x0500, 0xC5C1, 0xC481, 0x0440, 0xCC01, 0x0CC0, 0x0D80, 0xCD41, 3763 0x0F00, 0xCFC1, 0xCE81, 0x0E40, 0x0A00, 0xCAC1, 0xCB81, 0x0B40, 3764 0xC901, 0x09C0, 0x0880, 0xC841, 0xD801, 0x18C0, 0x1980, 0xD941, 3765 0x1B00, 0xDBC1, 0xDA81, 0x1A40, 0x1E00, 0xDEC1, 0xDF81, 0x1F40, 3766 0xDD01, 0x1DC0, 0x1C80, 0xDC41, 0x1400, 0xD4C1, 0xD581, 0x1540, 3767 0xD701, 0x17C0, 0x1680, 0xD641, 0xD201, 0x12C0, 0x1380, 0xD341, 3768 0x1100, 0xD1C1, 0xD081, 0x1040, 0xF001, 0x30C0, 0x3180, 0xF141, 3769 0x3300, 0xF3C1, 0xF281, 0x3240, 0x3600, 0xF6C1, 0xF781, 0x3740, 3770 0xF501, 0x35C0, 0x3480, 0xF441, 0x3C00, 0xFCC1, 0xFD81, 0x3D40, 3771 0xFF01, 0x3FC0, 0x3E80, 0xFE41, 0xFA01, 0x3AC0, 0x3B80, 0xFB41, 3772 0x3900, 0xF9C1, 0xF881, 0x3840, 0x2800, 0xE8C1, 0xE981, 0x2940, 3773 0xEB01, 0x2BC0, 0x2A80, 0xEA41, 0xEE01, 0x2EC0, 0x2F80, 0xEF41, 3774 0x2D00, 0xEDC1, 0xEC81, 0x2C40, 0xE401, 0x24C0, 0x2580, 0xE541, 3775 0x2700, 0xE7C1, 0xE681, 0x2640, 0x2200, 0xE2C1, 0xE381, 0x2340, 3776 0xE101, 0x21C0, 0x2080, 0xE041, 0xA001, 0x60C0, 0x6180, 0xA141, 3777 0x6300, 0xA3C1, 0xA281, 0x6240, 0x6600, 0xA6C1, 0xA781, 0x6740, 3778 0xA501, 0x65C0, 0x6480, 0xA441, 0x6C00, 0xACC1, 0xAD81, 0x6D40, 3779 0xAF01, 0x6FC0, 0x6E80, 0xAE41, 0xAA01, 0x6AC0, 0x6B80, 0xAB41, 3780 0x6900, 0xA9C1, 0xA881, 0x6840, 0x7800, 0xB8C1, 0xB981, 0x7940, 3781 0xBB01, 0x7BC0, 0x7A80, 0xBA41, 0xBE01, 0x7EC0, 0x7F80, 0xBF41, 3782 0x7D00, 0xBDC1, 0xBC81, 0x7C40, 0xB401, 0x74C0, 0x7580, 0xB541, 3783 0x7700, 0xB7C1, 0xB681, 0x7640, 0x7200, 0xB2C1, 0xB381, 0x7340, 3784 0xB101, 0x71C0, 0x7080, 0xB041, 0x5000, 0x90C1, 0x9181, 0x5140, 3785 0x9301, 0x53C0, 0x5280, 0x9241, 0x9601, 0x56C0, 0x5780, 0x9741, 3786 0x5500, 0x95C1, 0x9481, 0x5440, 0x9C01, 0x5CC0, 0x5D80, 0x9D41, 3787 0x5F00, 0x9FC1, 0x9E81, 0x5E40, 0x5A00, 0x9AC1, 0x9B81, 0x5B40, 3788 0x9901, 0x59C0, 0x5880, 0x9841, 0x8801, 0x48C0, 0x4980, 0x8941, 3789 0x4B00, 0x8BC1, 0x8A81, 0x4A40, 0x4E00, 0x8EC1, 0x8F81, 0x4F40, 3790 0x8D01, 0x4DC0, 0x4C80, 0x8C41, 0x4400, 0x84C1, 0x8581, 0x4540, 3791 0x8701, 0x47C0, 0x4680, 0x8641, 0x8201, 0x42C0, 0x4380, 0x8341, 3792 0x4100, 0x81C1, 0x8081, 0x4040]; 3793 3794 /*********************************************************************** 3795 * Robert Hegemann 2001-01-17 3796 ***********************************************************************/ 3797 3798 function addVbr(v, bitrate) { 3799 v.nVbrNumFrames++; 3800 v.sum += bitrate; 3801 v.seen++; 3802 3803 if (v.seen < v.want) { 3804 return; 3805 } 3806 3807 if (v.pos < v.size) { 3808 v.bag[v.pos] = v.sum; 3809 v.pos++; 3810 v.seen = 0; 3811 } 3812 if (v.pos == v.size) { 3813 for (var i = 1; i < v.size; i += 2) { 3814 v.bag[i / 2] = v.bag[i]; 3815 } 3816 v.want *= 2; 3817 v.pos /= 2; 3818 } 3819 } 3820 3821 function xingSeekTable(v, t) { 3822 if (v.pos <= 0) 3823 return; 3824 3825 for (var i = 1; i < NUMTOCENTRIES; ++i) { 3826 var j = i / NUMTOCENTRIES, act, sum; 3827 var indx = 0 | (Math.floor(j * v.pos)); 3828 if (indx > v.pos - 1) 3829 indx = v.pos - 1; 3830 act = v.bag[indx]; 3831 sum = v.sum; 3832 var seek_point = 0 | (256. * act / sum); 3833 if (seek_point > 255) 3834 seek_point = 255; 3835 t[i] = 0xff & seek_point; 3836 } 3837 } 3838 3839 /** 3840 * Add VBR entry, used to fill the VBR TOC entries. 3841 * 3842 * @param gfp 3843 * global flags 3844 */ 3845 this.addVbrFrame = function (gfp) { 3846 var gfc = gfp.internal_flags; 3847 var kbps = Tables.bitrate_table[gfp.version][gfc.bitrate_index]; 3848 addVbr(gfc.VBR_seek_table, kbps); 3849 } 3850 3851 /** 3852 * Read big endian integer (4-bytes) from header. 3853 * 3854 * @param buf 3855 * header containing the integer 3856 * @param bufPos 3857 * offset into the header 3858 * @return extracted integer 3859 */ 3860 function extractInteger(buf, bufPos) { 3861 var x = buf[bufPos + 0] & 0xff; 3862 x <<= 8; 3863 x |= buf[bufPos + 1] & 0xff; 3864 x <<= 8; 3865 x |= buf[bufPos + 2] & 0xff; 3866 x <<= 8; 3867 x |= buf[bufPos + 3] & 0xff; 3868 return x; 3869 } 3870 3871 /** 3872 * Write big endian integer (4-bytes) in the header. 3873 * 3874 * @param buf 3875 * header to write the integer into 3876 * @param bufPos 3877 * offset into the header 3878 * @param value 3879 * integer value to write 3880 */ 3881 function createInteger(buf, bufPos, value) { 3882 buf[bufPos + 0] = 0xff & ((value >> 24) & 0xff); 3883 buf[bufPos + 1] = 0xff & ((value >> 16) & 0xff); 3884 buf[bufPos + 2] = 0xff & ((value >> 8) & 0xff); 3885 buf[bufPos + 3] = 0xff & (value & 0xff); 3886 } 3887 3888 /** 3889 * Write big endian short (2-bytes) in the header. 3890 * 3891 * @param buf 3892 * header to write the integer into 3893 * @param bufPos 3894 * offset into the header 3895 * @param value 3896 * integer value to write 3897 */ 3898 function createShort(buf, bufPos, value) { 3899 buf[bufPos + 0] = 0xff & ((value >> 8) & 0xff); 3900 buf[bufPos + 1] = 0xff & (value & 0xff); 3901 } 3902 3903 /** 3904 * Check for magic strings (Xing/Info). 3905 * 3906 * @param buf 3907 * header to check 3908 * @param bufPos 3909 * header offset to check 3910 * @return magic string found 3911 */ 3912 function isVbrTag(buf, bufPos) { 3913 return new String(buf, bufPos, VBRTag0.length(), ISO_8859_1) 3914 .equals(VBRTag0) 3915 || new String(buf, bufPos, VBRTag1.length(), ISO_8859_1) 3916 .equals(VBRTag1); 3917 } 3918 3919 function shiftInBitsValue(x, n, v) { 3920 return 0xff & ((x << n) | (v & ~(-1 << n))); 3921 } 3922 3923 /** 3924 * Construct the MP3 header using the settings of the global flags. 3925 * 3926 * <img src="1000px-Mp3filestructure.svg.png"> 3927 * 3928 * @param gfp 3929 * global flags 3930 * @param buffer 3931 * header 3932 */ 3933 function setLameTagFrameHeader(gfp, buffer) { 3934 var gfc = gfp.internal_flags; 3935 3936 // MP3 Sync Word 3937 buffer[0] = shiftInBitsValue(buffer[0], 8, 0xff); 3938 3939 buffer[1] = shiftInBitsValue(buffer[1], 3, 7); 3940 buffer[1] = shiftInBitsValue(buffer[1], 1, 3941 (gfp.out_samplerate < 16000) ? 0 : 1); 3942 // Version 3943 buffer[1] = shiftInBitsValue(buffer[1], 1, gfp.version); 3944 // 01 == Layer 3 3945 buffer[1] = shiftInBitsValue(buffer[1], 2, 4 - 3); 3946 // Error protection 3947 buffer[1] = shiftInBitsValue(buffer[1], 1, (!gfp.error_protection) ? 1 3948 : 0); 3949 3950 // Bit rate 3951 buffer[2] = shiftInBitsValue(buffer[2], 4, gfc.bitrate_index); 3952 // Frequency 3953 buffer[2] = shiftInBitsValue(buffer[2], 2, gfc.samplerate_index); 3954 // Pad. Bit 3955 buffer[2] = shiftInBitsValue(buffer[2], 1, 0); 3956 // Priv. Bit 3957 buffer[2] = shiftInBitsValue(buffer[2], 1, gfp.extension); 3958 3959 // Mode 3960 buffer[3] = shiftInBitsValue(buffer[3], 2, gfp.mode.ordinal()); 3961 // Mode extension (Used with Joint Stereo) 3962 buffer[3] = shiftInBitsValue(buffer[3], 2, gfc.mode_ext); 3963 // Copy 3964 buffer[3] = shiftInBitsValue(buffer[3], 1, gfp.copyright); 3965 // Original 3966 buffer[3] = shiftInBitsValue(buffer[3], 1, gfp.original); 3967 // Emphasis 3968 buffer[3] = shiftInBitsValue(buffer[3], 2, gfp.emphasis); 3969 3970 /* the default VBR header. 48 kbps layer III, no padding, no crc */ 3971 /* but sampling freq, mode and copyright/copy protection taken */ 3972 /* from first valid frame */ 3973 buffer[0] = 0xff; 3974 var abyte = 0xff & (buffer[1] & 0xf1); 3975 var bitrate; 3976 if (1 == gfp.version) { 3977 bitrate = XING_BITRATE1; 3978 } else { 3979 if (gfp.out_samplerate < 16000) 3980 bitrate = XING_BITRATE25; 3981 else 3982 bitrate = XING_BITRATE2; 3983 } 3984 3985 if (gfp.VBR == VbrMode.vbr_off) 3986 bitrate = gfp.brate; 3987 3988 var bbyte; 3989 if (gfp.free_format) 3990 bbyte = 0x00; 3991 else 3992 bbyte = 0xff & (16 * lame.BitrateIndex(bitrate, gfp.version, 3993 gfp.out_samplerate)); 3994 3995 /* 3996 * Use as much of the info from the real frames in the Xing header: 3997 * samplerate, channels, crc, etc... 3998 */ 3999 if (gfp.version == 1) { 4000 /* MPEG1 */ 4001 buffer[1] = 0xff & (abyte | 0x0a); 4002 /* was 0x0b; */ 4003 abyte = 0xff & (buffer[2] & 0x0d); 4004 /* AF keep also private bit */ 4005 buffer[2] = 0xff & (bbyte | abyte); 4006 /* 64kbs MPEG1 frame */ 4007 } else { 4008 /* MPEG2 */ 4009 buffer[1] = 0xff & (abyte | 0x02); 4010 /* was 0x03; */ 4011 abyte = 0xff & (buffer[2] & 0x0d); 4012 /* AF keep also private bit */ 4013 buffer[2] = 0xff & (bbyte | abyte); 4014 /* 64kbs MPEG2 frame */ 4015 } 4016 } 4017 4018 /** 4019 * Get VBR tag information 4020 * 4021 * @param buf 4022 * header to analyze 4023 * @param bufPos 4024 * offset into the header 4025 * @return VBR tag data 4026 */ 4027 this.getVbrTag = function (buf) { 4028 var pTagData = new VBRTagData(); 4029 var bufPos = 0; 4030 4031 /* get Vbr header data */ 4032 pTagData.flags = 0; 4033 4034 /* get selected MPEG header data */ 4035 var hId = (buf[bufPos + 1] >> 3) & 1; 4036 var hSrIndex = (buf[bufPos + 2] >> 2) & 3; 4037 var hMode = (buf[bufPos + 3] >> 6) & 3; 4038 var hBitrate = ((buf[bufPos + 2] >> 4) & 0xf); 4039 hBitrate = Tables.bitrate_table[hId][hBitrate]; 4040 4041 /* check for FFE syncword */ 4042 if ((buf[bufPos + 1] >> 4) == 0xE) 4043 pTagData.samprate = Tables.samplerate_table[2][hSrIndex]; 4044 else 4045 pTagData.samprate = Tables.samplerate_table[hId][hSrIndex]; 4046 4047 /* determine offset of header */ 4048 if (hId != 0) { 4049 /* mpeg1 */ 4050 if (hMode != 3) 4051 bufPos += (32 + 4); 4052 else 4053 bufPos += (17 + 4); 4054 } else { 4055 /* mpeg2 */ 4056 if (hMode != 3) 4057 bufPos += (17 + 4); 4058 else 4059 bufPos += (9 + 4); 4060 } 4061 4062 if (!isVbrTag(buf, bufPos)) 4063 return null; 4064 4065 bufPos += 4; 4066 4067 pTagData.hId = hId; 4068 4069 /* get flags */ 4070 var head_flags = pTagData.flags = extractInteger(buf, bufPos); 4071 bufPos += 4; 4072 4073 if ((head_flags & FRAMES_FLAG) != 0) { 4074 pTagData.frames = extractInteger(buf, bufPos); 4075 bufPos += 4; 4076 } 4077 4078 if ((head_flags & BYTES_FLAG) != 0) { 4079 pTagData.bytes = extractInteger(buf, bufPos); 4080 bufPos += 4; 4081 } 4082 4083 if ((head_flags & TOC_FLAG) != 0) { 4084 if (pTagData.toc != null) { 4085 for (var i = 0; i < NUMTOCENTRIES; i++) 4086 pTagData.toc[i] = buf[bufPos + i]; 4087 } 4088 bufPos += NUMTOCENTRIES; 4089 } 4090 4091 pTagData.vbrScale = -1; 4092 4093 if ((head_flags & VBR_SCALE_FLAG) != 0) { 4094 pTagData.vbrScale = extractInteger(buf, bufPos); 4095 bufPos += 4; 4096 } 4097 4098 pTagData.headersize = ((hId + 1) * 72000 * hBitrate) 4099 / pTagData.samprate; 4100 4101 bufPos += 21; 4102 var encDelay = buf[bufPos + 0] << 4; 4103 encDelay += buf[bufPos + 1] >> 4; 4104 var encPadding = (buf[bufPos + 1] & 0x0F) << 8; 4105 encPadding += buf[bufPos + 2] & 0xff; 4106 /* check for reasonable values (this may be an old Xing header, */ 4107 /* not a INFO tag) */ 4108 if (encDelay < 0 || encDelay > 3000) 4109 encDelay = -1; 4110 if (encPadding < 0 || encPadding > 3000) 4111 encPadding = -1; 4112 4113 pTagData.encDelay = encDelay; 4114 pTagData.encPadding = encPadding; 4115 4116 /* success */ 4117 return pTagData; 4118 } 4119 4120 /** 4121 * Initializes the header 4122 * 4123 * @param gfp 4124 * global flags 4125 */ 4126 this.InitVbrTag = function (gfp) { 4127 var gfc = gfp.internal_flags; 4128 4129 /** 4130 * <PRE> 4131 * Xing VBR pretends to be a 48kbs layer III frame. (at 44.1kHz). 4132 * (at 48kHz they use 56kbs since 48kbs frame not big enough for 4133 * table of contents) 4134 * let's always embed Xing header inside a 64kbs layer III frame. 4135 * this gives us enough room for a LAME version string too. 4136 * size determined by sampling frequency (MPEG1) 4137 * 32kHz: 216 bytes@48kbs 288bytes@ 64kbs 4138 * 44.1kHz: 156 bytes 208bytes@64kbs (+1 if padding = 1) 4139 * 48kHz: 144 bytes 192 4140 * 4141 * MPEG 2 values are the same since the framesize and samplerate 4142 * are each reduced by a factor of 2. 4143 * </PRE> 4144 */ 4145 var kbps_header; 4146 if (1 == gfp.version) { 4147 kbps_header = XING_BITRATE1; 4148 } else { 4149 if (gfp.out_samplerate < 16000) 4150 kbps_header = XING_BITRATE25; 4151 else 4152 kbps_header = XING_BITRATE2; 4153 } 4154 4155 if (gfp.VBR == VbrMode.vbr_off) 4156 kbps_header = gfp.brate; 4157 4158 // make sure LAME Header fits into Frame 4159 var totalFrameSize = ((gfp.version + 1) * 72000 * kbps_header) 4160 / gfp.out_samplerate; 4161 var headerSize = (gfc.sideinfo_len + LAMEHEADERSIZE); 4162 gfc.VBR_seek_table.TotalFrameSize = totalFrameSize; 4163 if (totalFrameSize < headerSize || totalFrameSize > MAXFRAMESIZE) { 4164 /* disable tag, it wont fit */ 4165 gfp.bWriteVbrTag = false; 4166 return; 4167 } 4168 4169 gfc.VBR_seek_table.nVbrNumFrames = 0; 4170 gfc.VBR_seek_table.nBytesWritten = 0; 4171 gfc.VBR_seek_table.sum = 0; 4172 4173 gfc.VBR_seek_table.seen = 0; 4174 gfc.VBR_seek_table.want = 1; 4175 gfc.VBR_seek_table.pos = 0; 4176 4177 if (gfc.VBR_seek_table.bag == null) { 4178 gfc.VBR_seek_table.bag = new int[400]; 4179 gfc.VBR_seek_table.size = 400; 4180 } 4181 4182 // write dummy VBR tag of all 0's into bitstream 4183 var buffer = new_byte(MAXFRAMESIZE); 4184 4185 setLameTagFrameHeader(gfp, buffer); 4186 var n = gfc.VBR_seek_table.TotalFrameSize; 4187 for (var i = 0; i < n; ++i) { 4188 bs.add_dummy_byte(gfp, buffer[i] & 0xff, 1); 4189 } 4190 } 4191 4192 /** 4193 * Fast CRC-16 computation (uses table crc16Lookup). 4194 * 4195 * @param value 4196 * @param crc 4197 * @return 4198 */ 4199 function crcUpdateLookup(value, crc) { 4200 var tmp = crc ^ value; 4201 crc = (crc >> 8) ^ crc16Lookup[tmp & 0xff]; 4202 return crc; 4203 } 4204 4205 this.updateMusicCRC = function (crc, buffer, bufferPos, size) { 4206 for (var i = 0; i < size; ++i) 4207 crc[0] = crcUpdateLookup(buffer[bufferPos + i], crc[0]); 4208 } 4209 4210 /** 4211 * Write LAME info: mini version + info on various switches used (Jonathan 4212 * Dee 2001/08/31). 4213 * 4214 * @param gfp 4215 * global flags 4216 * @param musicLength 4217 * music length 4218 * @param streamBuffer 4219 * pointer to output buffer 4220 * @param streamBufferPos 4221 * offset into the output buffer 4222 * @param crc 4223 * computation of CRC-16 of Lame Tag so far (starting at frame 4224 * sync) 4225 * @return number of bytes written to the stream 4226 */ 4227 function putLameVBR(gfp, musicLength, streamBuffer, streamBufferPos, crc) { 4228 var gfc = gfp.internal_flags; 4229 var bytesWritten = 0; 4230 4231 /* encoder delay */ 4232 var encDelay = gfp.encoder_delay; 4233 /* encoder padding */ 4234 var encPadding = gfp.encoder_padding; 4235 4236 /* recall: gfp.VBR_q is for example set by the switch -V */ 4237 /* gfp.quality by -q, -h, -f, etc */ 4238 var quality = (100 - 10 * gfp.VBR_q - gfp.quality); 4239 4240 var version = v.getLameVeryShortVersion(); 4241 var vbr; 4242 var revision = 0x00; 4243 var revMethod; 4244 // numbering different in vbr_mode vs. Lame tag 4245 var vbrTypeTranslator = [1, 5, 3, 2, 4, 0, 3]; 4246 var lowpass = 0 | (((gfp.lowpassfreq / 100.0) + .5) > 255 ? 255 4247 : (gfp.lowpassfreq / 100.0) + .5); 4248 var peakSignalAmplitude = 0; 4249 var radioReplayGain = 0; 4250 var audiophileReplayGain = 0; 4251 var noiseShaping = gfp.internal_flags.noise_shaping; 4252 var stereoMode = 0; 4253 var nonOptimal = 0; 4254 var sourceFreq = 0; 4255 var misc = 0; 4256 var musicCRC = 0; 4257 4258 // psy model type: Gpsycho or NsPsytune 4259 var expNPsyTune = (gfp.exp_nspsytune & 1) != 0; 4260 var safeJoint = (gfp.exp_nspsytune & 2) != 0; 4261 var noGapMore = false; 4262 var noGapPrevious = false; 4263 var noGapCount = gfp.internal_flags.nogap_total; 4264 var noGapCurr = gfp.internal_flags.nogap_current; 4265 4266 // 4 bits 4267 var athType = gfp.ATHtype; 4268 var flags = 0; 4269 4270 // vbr modes 4271 var abrBitrate; 4272 switch (gfp.VBR) { 4273 case vbr_abr: 4274 abrBitrate = gfp.VBR_mean_bitrate_kbps; 4275 break; 4276 case vbr_off: 4277 abrBitrate = gfp.brate; 4278 break; 4279 default: 4280 abrBitrate = gfp.VBR_min_bitrate_kbps; 4281 } 4282 4283 // revision and vbr method 4284 if (gfp.VBR.ordinal() < vbrTypeTranslator.length) 4285 vbr = vbrTypeTranslator[gfp.VBR.ordinal()]; 4286 else 4287 vbr = 0x00; // unknown 4288 4289 revMethod = 0x10 * revision + vbr; 4290 4291 // ReplayGain 4292 if (gfc.findReplayGain) { 4293 if (gfc.RadioGain > 0x1FE) 4294 gfc.RadioGain = 0x1FE; 4295 if (gfc.RadioGain < -0x1FE) 4296 gfc.RadioGain = -0x1FE; 4297 4298 // set name code 4299 radioReplayGain = 0x2000; 4300 // set originator code to `determined automatically' 4301 radioReplayGain |= 0xC00; 4302 4303 if (gfc.RadioGain >= 0) { 4304 // set gain adjustment 4305 radioReplayGain |= gfc.RadioGain; 4306 } else { 4307 // set the sign bit 4308 radioReplayGain |= 0x200; 4309 // set gain adjustment 4310 radioReplayGain |= -gfc.RadioGain; 4311 } 4312 } 4313 4314 // peak sample 4315 if (gfc.findPeakSample) 4316 peakSignalAmplitude = Math 4317 .abs(0 | ((( gfc.PeakSample) / 32767.0) * Math.pow(2, 23) + .5)); 4318 4319 // nogap 4320 if (noGapCount != -1) { 4321 if (noGapCurr > 0) 4322 noGapPrevious = true; 4323 4324 if (noGapCurr < noGapCount - 1) 4325 noGapMore = true; 4326 } 4327 4328 // flags 4329 flags = athType + ((expNPsyTune ? 1 : 0) << 4) 4330 + ((safeJoint ? 1 : 0) << 5) + ((noGapMore ? 1 : 0) << 6) 4331 + ((noGapPrevious ? 1 : 0) << 7); 4332 4333 if (quality < 0) 4334 quality = 0; 4335 4336 // stereo mode field (Intensity stereo is not implemented) 4337 switch (gfp.mode) { 4338 case MONO: 4339 stereoMode = 0; 4340 break; 4341 case STEREO: 4342 stereoMode = 1; 4343 break; 4344 case DUAL_CHANNEL: 4345 stereoMode = 2; 4346 break; 4347 case JOINT_STEREO: 4348 if (gfp.force_ms) 4349 stereoMode = 4; 4350 else 4351 stereoMode = 3; 4352 break; 4353 case NOT_SET: 4354 //$FALL-THROUGH$ 4355 default: 4356 stereoMode = 7; 4357 break; 4358 } 4359 4360 if (gfp.in_samplerate <= 32000) 4361 sourceFreq = 0x00; 4362 else if (gfp.in_samplerate == 48000) 4363 sourceFreq = 0x02; 4364 else if (gfp.in_samplerate > 48000) 4365 sourceFreq = 0x03; 4366 else { 4367 // default is 44100Hz 4368 sourceFreq = 0x01; 4369 } 4370 4371 // Check if the user overrided the default LAME behavior with some 4372 // nasty options 4373 if (gfp.short_blocks == ShortBlock.short_block_forced 4374 || gfp.short_blocks == ShortBlock.short_block_dispensed 4375 || ((gfp.lowpassfreq == -1) && (gfp.highpassfreq == -1)) || /* "-k" */ 4376 (gfp.scale_left < gfp.scale_right) 4377 || (gfp.scale_left > gfp.scale_right) 4378 || (gfp.disable_reservoir && gfp.brate < 320) || gfp.noATH 4379 || gfp.ATHonly || (athType == 0) || gfp.in_samplerate <= 32000) 4380 nonOptimal = 1; 4381 4382 misc = noiseShaping + (stereoMode << 2) + (nonOptimal << 5) 4383 + (sourceFreq << 6); 4384 4385 musicCRC = gfc.nMusicCRC; 4386 4387 // Write all this information into the stream 4388 4389 createInteger(streamBuffer, streamBufferPos + bytesWritten, quality); 4390 bytesWritten += 4; 4391 4392 for (var j = 0; j < 9; j++) { 4393 streamBuffer[streamBufferPos + bytesWritten + j] = 0xff & version .charAt(j); 4394 } 4395 bytesWritten += 9; 4396 4397 streamBuffer[streamBufferPos + bytesWritten] = 0xff & revMethod; 4398 bytesWritten++; 4399 4400 streamBuffer[streamBufferPos + bytesWritten] = 0xff & lowpass; 4401 bytesWritten++; 4402 4403 createInteger(streamBuffer, streamBufferPos + bytesWritten, 4404 peakSignalAmplitude); 4405 bytesWritten += 4; 4406 4407 createShort(streamBuffer, streamBufferPos + bytesWritten, 4408 radioReplayGain); 4409 bytesWritten += 2; 4410 4411 createShort(streamBuffer, streamBufferPos + bytesWritten, 4412 audiophileReplayGain); 4413 bytesWritten += 2; 4414 4415 streamBuffer[streamBufferPos + bytesWritten] = 0xff & flags; 4416 bytesWritten++; 4417 4418 if (abrBitrate >= 255) 4419 streamBuffer[streamBufferPos + bytesWritten] = 0xFF; 4420 else 4421 streamBuffer[streamBufferPos + bytesWritten] = 0xff & abrBitrate; 4422 bytesWritten++; 4423 4424 streamBuffer[streamBufferPos + bytesWritten] = 0xff & (encDelay >> 4); 4425 streamBuffer[streamBufferPos + bytesWritten + 1] = 0xff & ((encDelay << 4) + (encPadding >> 8)); 4426 streamBuffer[streamBufferPos + bytesWritten + 2] = 0xff & encPadding; 4427 4428 bytesWritten += 3; 4429 4430 streamBuffer[streamBufferPos + bytesWritten] = 0xff & misc; 4431 bytesWritten++; 4432 4433 // unused in rev0 4434 streamBuffer[streamBufferPos + bytesWritten++] = 0; 4435 4436 createShort(streamBuffer, streamBufferPos + bytesWritten, gfp.preset); 4437 bytesWritten += 2; 4438 4439 createInteger(streamBuffer, streamBufferPos + bytesWritten, musicLength); 4440 bytesWritten += 4; 4441 4442 createShort(streamBuffer, streamBufferPos + bytesWritten, musicCRC); 4443 bytesWritten += 2; 4444 4445 // Calculate tag CRC.... must be done here, since it includes previous 4446 // information 4447 4448 for (var i = 0; i < bytesWritten; i++) 4449 crc = crcUpdateLookup(streamBuffer[streamBufferPos + i], crc); 4450 4451 createShort(streamBuffer, streamBufferPos + bytesWritten, crc); 4452 bytesWritten += 2; 4453 4454 return bytesWritten; 4455 } 4456 4457 function skipId3v2(fpStream) { 4458 // seek to the beginning of the stream 4459 fpStream.seek(0); 4460 // read 10 bytes in case there's an ID3 version 2 header here 4461 var id3v2Header = new_byte(10); 4462 fpStream.readFully(id3v2Header); 4463 /* does the stream begin with the ID3 version 2 file identifier? */ 4464 var id3v2TagSize; 4465 if (!new String(id3v2Header, "ISO-8859-1").startsWith("ID3")) { 4466 /* 4467 * the tag size (minus the 10-byte header) is encoded into four 4468 * bytes where the most significant bit is clear in each byte 4469 */ 4470 id3v2TagSize = (((id3v2Header[6] & 0x7f) << 21) 4471 | ((id3v2Header[7] & 0x7f) << 14) 4472 | ((id3v2Header[8] & 0x7f) << 7) | (id3v2Header[9] & 0x7f)) 4473 + id3v2Header.length; 4474 } else { 4475 /* no ID3 version 2 tag in this stream */ 4476 id3v2TagSize = 0; 4477 } 4478 return id3v2TagSize; 4479 } 4480 4481 this.getLameTagFrame = function (gfp, buffer) { 4482 var gfc = gfp.internal_flags; 4483 4484 if (!gfp.bWriteVbrTag) { 4485 return 0; 4486 } 4487 if (gfc.Class_ID != Lame.LAME_ID) { 4488 return 0; 4489 } 4490 if (gfc.VBR_seek_table.pos <= 0) { 4491 return 0; 4492 } 4493 if (buffer.length < gfc.VBR_seek_table.TotalFrameSize) { 4494 return gfc.VBR_seek_table.TotalFrameSize; 4495 } 4496 4497 Arrays.fill(buffer, 0, gfc.VBR_seek_table.TotalFrameSize, 0); 4498 4499 // 4 bytes frame header 4500 setLameTagFrameHeader(gfp, buffer); 4501 4502 // Create TOC entries 4503 var toc = new_byte(NUMTOCENTRIES); 4504 4505 if (gfp.free_format) { 4506 for (var i = 1; i < NUMTOCENTRIES; ++i) 4507 toc[i] = 0xff & (255 * i / 100); 4508 } else { 4509 xingSeekTable(gfc.VBR_seek_table, toc); 4510 } 4511 4512 // Start writing the tag after the zero frame 4513 var streamIndex = gfc.sideinfo_len; 4514 /** 4515 * Note: Xing header specifies that Xing data goes in the ancillary data 4516 * with NO ERROR PROTECTION. If error protecton in enabled, the Xing 4517 * data still starts at the same offset, and now it is in sideinfo data 4518 * block, and thus will not decode correctly by non-Xing tag aware 4519 * players 4520 */ 4521 if (gfp.error_protection) 4522 streamIndex -= 2; 4523 4524 // Put Vbr tag 4525 if (gfp.VBR == VbrMode.vbr_off) { 4526 buffer[streamIndex++] = 0xff & VBRTag1.charAt(0); 4527 buffer[streamIndex++] = 0xff & VBRTag1.charAt(1); 4528 buffer[streamIndex++] = 0xff & VBRTag1.charAt(2); 4529 buffer[streamIndex++] = 0xff & VBRTag1.charAt(3); 4530 4531 } else { 4532 buffer[streamIndex++] = 0xff & VBRTag0.charAt(0); 4533 buffer[streamIndex++] = 0xff & VBRTag0.charAt(1); 4534 buffer[streamIndex++] = 0xff & VBRTag0.charAt(2); 4535 buffer[streamIndex++] = 0xff & VBRTag0.charAt(3); 4536 } 4537 4538 // Put header flags 4539 createInteger(buffer, streamIndex, FRAMES_FLAG + BYTES_FLAG + TOC_FLAG 4540 + VBR_SCALE_FLAG); 4541 streamIndex += 4; 4542 4543 // Put Total Number of frames 4544 createInteger(buffer, streamIndex, gfc.VBR_seek_table.nVbrNumFrames); 4545 streamIndex += 4; 4546 4547 // Put total audio stream size, including Xing/LAME Header 4548 var streamSize = (gfc.VBR_seek_table.nBytesWritten + gfc.VBR_seek_table.TotalFrameSize); 4549 createInteger(buffer, streamIndex, 0 | streamSize); 4550 streamIndex += 4; 4551 4552 /* Put TOC */ 4553 System.arraycopy(toc, 0, buffer, streamIndex, toc.length); 4554 streamIndex += toc.length; 4555 4556 if (gfp.error_protection) { 4557 // (jo) error_protection: add crc16 information to header 4558 bs.CRC_writeheader(gfc, buffer); 4559 } 4560 4561 // work out CRC so far: initially crc = 0 4562 var crc = 0x00; 4563 for (var i = 0; i < streamIndex; i++) 4564 crc = crcUpdateLookup(buffer[i], crc); 4565 // Put LAME VBR info 4566 streamIndex += putLameVBR(gfp, streamSize, buffer, streamIndex, crc); 4567 4568 return gfc.VBR_seek_table.TotalFrameSize; 4569 } 4570 4571 /** 4572 * Write final VBR tag to the file. 4573 * 4574 * @param gfp 4575 * global flags 4576 * @param stream 4577 * stream to add the VBR tag to 4578 * @return 0 (OK), -1 else 4579 * @throws IOException 4580 * I/O error 4581 */ 4582 this.putVbrTag = function (gfp, stream) { 4583 var gfc = gfp.internal_flags; 4584 4585 if (gfc.VBR_seek_table.pos <= 0) 4586 return -1; 4587 4588 // Seek to end of file 4589 stream.seek(stream.length()); 4590 4591 // Get file size, abort if file has zero length. 4592 if (stream.length() == 0) 4593 return -1; 4594 4595 // The VBR tag may NOT be located at the beginning of the stream. If an 4596 // ID3 version 2 tag was added, then it must be skipped to write the VBR 4597 // tag data. 4598 var id3v2TagSize = skipId3v2(stream); 4599 4600 // Seek to the beginning of the stream 4601 stream.seek(id3v2TagSize); 4602 4603 var buffer = new_byte(MAXFRAMESIZE); 4604 var bytes = getLameTagFrame(gfp, buffer); 4605 if (bytes > buffer.length) { 4606 return -1; 4607 } 4608 4609 if (bytes < 1) { 4610 return 0; 4611 } 4612 4613 // Put it all to disk again 4614 stream.write(buffer, 0, bytes); 4615 // success 4616 return 0; 4617 } 4618 4619} 4620 4621function HuffCodeTab(len, max, tab, hl) { 4622 this.xlen = len; 4623 this.linmax = max; 4624 this.table = tab; 4625 this.hlen = hl; 4626} 4627 4628var Tables = {}; 4629 4630 4631Tables.t1HB = [ 4632 1, 1, 4633 1, 0 4634]; 4635 4636Tables.t2HB = [ 4637 1, 2, 1, 4638 3, 1, 1, 4639 3, 2, 0 4640]; 4641 4642Tables.t3HB = [ 4643 3, 2, 1, 4644 1, 1, 1, 4645 3, 2, 0 4646]; 4647 4648Tables.t5HB = [ 4649 1, 2, 6, 5, 4650 3, 1, 4, 4, 4651 7, 5, 7, 1, 4652 6, 1, 1, 0 4653]; 4654 4655Tables.t6HB = [ 4656 7, 3, 5, 1, 4657 6, 2, 3, 2, 4658 5, 4, 4, 1, 4659 3, 3, 2, 0 4660]; 4661 4662Tables.t7HB = [ 4663 1, 2, 10, 19, 16, 10, 4664 3, 3, 7, 10, 5, 3, 4665 11, 4, 13, 17, 8, 4, 4666 12, 11, 18, 15, 11, 2, 4667 7, 6, 9, 14, 3, 1, 4668 6, 4, 5, 3, 2, 0 4669]; 4670 4671Tables.t8HB = [ 4672 3, 4, 6, 18, 12, 5, 4673 5, 1, 2, 16, 9, 3, 4674 7, 3, 5, 14, 7, 3, 4675 19, 17, 15, 13, 10, 4, 4676 13, 5, 8, 11, 5, 1, 4677 12, 4, 4, 1, 1, 0 4678]; 4679 4680Tables.t9HB = [ 4681 7, 5, 9, 14, 15, 7, 4682 6, 4, 5, 5, 6, 7, 4683 7, 6, 8, 8, 8, 5, 4684 15, 6, 9, 10, 5, 1, 4685 11, 7, 9, 6, 4, 1, 4686 14, 4, 6, 2, 6, 0 4687]; 4688 4689Tables.t10HB = [ 4690 1, 2, 10, 23, 35, 30, 12, 17, 4691 3, 3, 8, 12, 18, 21, 12, 7, 4692 11, 9, 15, 21, 32, 40, 19, 6, 4693 14, 13, 22, 34, 46, 23, 18, 7, 4694 20, 19, 33, 47, 27, 22, 9, 3, 4695 31, 22, 41, 26, 21, 20, 5, 3, 4696 14, 13, 10, 11, 16, 6, 5, 1, 4697 9, 8, 7, 8, 4, 4, 2, 0 4698]; 4699 4700Tables.t11HB = [ 4701 3, 4, 10, 24, 34, 33, 21, 15, 4702 5, 3, 4, 10, 32, 17, 11, 10, 4703 11, 7, 13, 18, 30, 31, 20, 5, 4704 25, 11, 19, 59, 27, 18, 12, 5, 4705 35, 33, 31, 58, 30, 16, 7, 5, 4706 28, 26, 32, 19, 17, 15, 8, 14, 4707 14, 12, 9, 13, 14, 9, 4, 1, 4708 11, 4, 6, 6, 6, 3, 2, 0 4709]; 4710 4711Tables.t12HB = [ 4712 9, 6, 16, 33, 41, 39, 38, 26, 4713 7, 5, 6, 9, 23, 16, 26, 11, 4714 17, 7, 11, 14, 21, 30, 10, 7, 4715 17, 10, 15, 12, 18, 28, 14, 5, 4716 32, 13, 22, 19, 18, 16, 9, 5, 4717 40, 17, 31, 29, 17, 13, 4, 2, 4718 27, 12, 11, 15, 10, 7, 4, 1, 4719 27, 12, 8, 12, 6, 3, 1, 0 4720]; 4721 4722Tables.t13HB = [ 4723 1, 5, 14, 21, 34, 51, 46, 71, 42, 52, 68, 52, 67, 44, 43, 19, 4724 3, 4, 12, 19, 31, 26, 44, 33, 31, 24, 32, 24, 31, 35, 22, 14, 4725 15, 13, 23, 36, 59, 49, 77, 65, 29, 40, 30, 40, 27, 33, 42, 16, 4726 22, 20, 37, 61, 56, 79, 73, 64, 43, 76, 56, 37, 26, 31, 25, 14, 4727 35, 16, 60, 57, 97, 75, 114, 91, 54, 73, 55, 41, 48, 53, 23, 24, 4728 58, 27, 50, 96, 76, 70, 93, 84, 77, 58, 79, 29, 74, 49, 41, 17, 4729 47, 45, 78, 74, 115, 94, 90, 79, 69, 83, 71, 50, 59, 38, 36, 15, 4730 72, 34, 56, 95, 92, 85, 91, 90, 86, 73, 77, 65, 51, 44, 43, 42, 4731 43, 20, 30, 44, 55, 78, 72, 87, 78, 61, 46, 54, 37, 30, 20, 16, 4732 53, 25, 41, 37, 44, 59, 54, 81, 66, 76, 57, 54, 37, 18, 39, 11, 4733 35, 33, 31, 57, 42, 82, 72, 80, 47, 58, 55, 21, 22, 26, 38, 22, 4734 53, 25, 23, 38, 70, 60, 51, 36, 55, 26, 34, 23, 27, 14, 9, 7, 4735 34, 32, 28, 39, 49, 75, 30, 52, 48, 40, 52, 28, 18, 17, 9, 5, 4736 45, 21, 34, 64, 56, 50, 49, 45, 31, 19, 12, 15, 10, 7, 6, 3, 4737 48, 23, 20, 39, 36, 35, 53, 21, 16, 23, 13, 10, 6, 1, 4, 2, 4738 16, 15, 17, 27, 25, 20, 29, 11, 17, 12, 16, 8, 1, 1, 0, 1 4739]; 4740 4741Tables.t15HB = [ 4742 7, 12, 18, 53, 47, 76, 124, 108, 89, 123, 108, 119, 107, 81, 122, 63, 4743 13, 5, 16, 27, 46, 36, 61, 51, 42, 70, 52, 83, 65, 41, 59, 36, 4744 19, 17, 15, 24, 41, 34, 59, 48, 40, 64, 50, 78, 62, 80, 56, 33, 4745 29, 28, 25, 43, 39, 63, 55, 93, 76, 59, 93, 72, 54, 75, 50, 29, 4746 52, 22, 42, 40, 67, 57, 95, 79, 72, 57, 89, 69, 49, 66, 46, 27, 4747 77, 37, 35, 66, 58, 52, 91, 74, 62, 48, 79, 63, 90, 62, 40, 38, 4748 125, 32, 60, 56, 50, 92, 78, 65, 55, 87, 71, 51, 73, 51, 70, 30, 4749 109, 53, 49, 94, 88, 75, 66, 122, 91, 73, 56, 42, 64, 44, 21, 25, 4750 90, 43, 41, 77, 73, 63, 56, 92, 77, 66, 47, 67, 48, 53, 36, 20, 4751 71, 34, 67, 60, 58, 49, 88, 76, 67, 106, 71, 54, 38, 39, 23, 15, 4752 109, 53, 51, 47, 90, 82, 58, 57, 48, 72, 57, 41, 23, 27, 62, 9, 4753 86, 42, 40, 37, 70, 64, 52, 43, 70, 55, 42, 25, 29, 18, 11, 11, 4754 118, 68, 30, 55, 50, 46, 74, 65, 49, 39, 24, 16, 22, 13, 14, 7, 4755 91, 44, 39, 38, 34, 63, 52, 45, 31, 52, 28, 19, 14, 8, 9, 3, 4756 123, 60, 58, 53, 47, 43, 32, 22, 37, 24, 17, 12, 15, 10, 2, 1, 4757 71, 37, 34, 30, 28, 20, 17, 26, 21, 16, 10, 6, 8, 6, 2, 0 4758]; 4759 4760Tables.t16HB = [ 4761 1, 5, 14, 44, 74, 63, 110, 93, 172, 149, 138, 242, 225, 195, 376, 17, 4762 3, 4, 12, 20, 35, 62, 53, 47, 83, 75, 68, 119, 201, 107, 207, 9, 4763 15, 13, 23, 38, 67, 58, 103, 90, 161, 72, 127, 117, 110, 209, 206, 16, 4764 45, 21, 39, 69, 64, 114, 99, 87, 158, 140, 252, 212, 199, 387, 365, 26, 4765 75, 36, 68, 65, 115, 101, 179, 164, 155, 264, 246, 226, 395, 382, 362, 9, 4766 66, 30, 59, 56, 102, 185, 173, 265, 142, 253, 232, 400, 388, 378, 445, 16, 4767 111, 54, 52, 100, 184, 178, 160, 133, 257, 244, 228, 217, 385, 366, 715, 10, 4768 98, 48, 91, 88, 165, 157, 148, 261, 248, 407, 397, 372, 380, 889, 884, 8, 4769 85, 84, 81, 159, 156, 143, 260, 249, 427, 401, 392, 383, 727, 713, 708, 7, 4770 154, 76, 73, 141, 131, 256, 245, 426, 406, 394, 384, 735, 359, 710, 352, 11, 4771 139, 129, 67, 125, 247, 233, 229, 219, 393, 743, 737, 720, 885, 882, 439, 4, 4772 243, 120, 118, 115, 227, 223, 396, 746, 742, 736, 721, 712, 706, 223, 436, 6, 4773 202, 224, 222, 218, 216, 389, 386, 381, 364, 888, 443, 707, 440, 437, 1728, 4, 4774 747, 211, 210, 208, 370, 379, 734, 723, 714, 1735, 883, 877, 876, 3459, 865, 2, 4775 377, 369, 102, 187, 726, 722, 358, 711, 709, 866, 1734, 871, 3458, 870, 434, 0, 4776 12, 10, 7, 11, 10, 17, 11, 9, 13, 12, 10, 7, 5, 3, 1, 3 4777]; 4778 4779Tables.t24HB = [ 4780 15, 13, 46, 80, 146, 262, 248, 434, 426, 669, 653, 649, 621, 517, 1032, 88, 4781 14, 12, 21, 38, 71, 130, 122, 216, 209, 198, 327, 345, 319, 297, 279, 42, 4782 47, 22, 41, 74, 68, 128, 120, 221, 207, 194, 182, 340, 315, 295, 541, 18, 4783 81, 39, 75, 70, 134, 125, 116, 220, 204, 190, 178, 325, 311, 293, 271, 16, 4784 147, 72, 69, 135, 127, 118, 112, 210, 200, 188, 352, 323, 306, 285, 540, 14, 4785 263, 66, 129, 126, 119, 114, 214, 202, 192, 180, 341, 317, 301, 281, 262, 12, 4786 249, 123, 121, 117, 113, 215, 206, 195, 185, 347, 330, 308, 291, 272, 520, 10, 4787 435, 115, 111, 109, 211, 203, 196, 187, 353, 332, 313, 298, 283, 531, 381, 17, 4788 427, 212, 208, 205, 201, 193, 186, 177, 169, 320, 303, 286, 268, 514, 377, 16, 4789 335, 199, 197, 191, 189, 181, 174, 333, 321, 305, 289, 275, 521, 379, 371, 11, 4790 668, 184, 183, 179, 175, 344, 331, 314, 304, 290, 277, 530, 383, 373, 366, 10, 4791 652, 346, 171, 168, 164, 318, 309, 299, 287, 276, 263, 513, 375, 368, 362, 6, 4792 648, 322, 316, 312, 307, 302, 292, 284, 269, 261, 512, 376, 370, 364, 359, 4, 4793 620, 300, 296, 294, 288, 282, 273, 266, 515, 380, 374, 369, 365, 361, 357, 2, 4794 1033, 280, 278, 274, 267, 264, 259, 382, 378, 372, 367, 363, 360, 358, 356, 0, 4795 43, 20, 19, 17, 15, 13, 11, 9, 7, 6, 4, 7, 5, 3, 1, 3 4796]; 4797 4798Tables.t32HB = [ 4799 1 << 0, 5 << 1, 4 << 1, 5 << 2, 6 << 1, 5 << 2, 4 << 2, 4 << 3, 4800 7 << 1, 3 << 2, 6 << 2, 0 << 3, 7 << 2, 2 << 3, 3 << 3, 1 << 4 4801]; 4802 4803Tables.t33HB = [ 4804 15 << 0, 14 << 1, 13 << 1, 12 << 2, 11 << 1, 10 << 2, 9 << 2, 8 << 3, 4805 7 << 1, 6 << 2, 5 << 2, 4 << 3, 3 << 2, 2 << 3, 1 << 3, 0 << 4 4806]; 4807 4808Tables.t1l = [ 4809 1, 4, 4810 3, 5 4811]; 4812 4813Tables.t2l = [ 4814 1, 4, 7, 4815 4, 5, 7, 4816 6, 7, 8 4817]; 4818 4819Tables.t3l = [ 4820 2, 3, 7, 4821 4, 4, 7, 4822 6, 7, 8 4823]; 4824 4825Tables.t5l = [ 4826 1, 4, 7, 8, 4827 4, 5, 8, 9, 4828 7, 8, 9, 10, 4829 8, 8, 9, 10 4830]; 4831 4832Tables.t6l = [ 4833 3, 4, 6, 8, 4834 4, 4, 6, 7, 4835 5, 6, 7, 8, 4836 7, 7, 8, 9 4837]; 4838 4839Tables.t7l = [ 4840 1, 4, 7, 9, 9, 10, 4841 4, 6, 8, 9, 9, 10, 4842 7, 7, 9, 10, 10, 11, 4843 8, 9, 10, 11, 11, 11, 4844 8, 9, 10, 11, 11, 12, 4845 9, 10, 11, 12, 12, 12 4846]; 4847 4848Tables.t8l = [ 4849 2, 4, 7, 9, 9, 10, 4850 4, 4, 6, 10, 10, 10, 4851 7, 6, 8, 10, 10, 11, 4852 9, 10, 10, 11, 11, 12, 4853 9, 9, 10, 11, 12, 12, 4854 10, 10, 11, 11, 13, 13 4855]; 4856 4857Tables.t9l = [ 4858 3, 4, 6, 7, 9, 10, 4859 4, 5, 6, 7, 8, 10, 4860 5, 6, 7, 8, 9, 10, 4861 7, 7, 8, 9, 9, 10, 4862 8, 8, 9, 9, 10, 11, 4863 9, 9, 10, 10, 11, 11 4864]; 4865 4866Tables.t10l = [ 4867 1, 4, 7, 9, 10, 10, 10, 11, 4868 4, 6, 8, 9, 10, 11, 10, 10, 4869 7, 8, 9, 10, 11, 12, 11, 11, 4870 8, 9, 10, 11, 12, 12, 11, 12, 4871 9, 10, 11, 12, 12, 12, 12, 12, 4872 10, 11, 12, 12, 13, 13, 12, 13, 4873 9, 10, 11, 12, 12, 12, 13, 13, 4874 10, 10, 11, 12, 12, 13, 13, 13 4875]; 4876 4877Tables.t11l = [ 4878 2, 4, 6, 8, 9, 10, 9, 10, 4879 4, 5, 6, 8, 10, 10, 9, 10, 4880 6, 7, 8, 9, 10, 11, 10, 10, 4881 8, 8, 9, 11, 10, 12, 10, 11, 4882 9, 10, 10, 11, 11, 12, 11, 12, 4883 9, 10, 11, 12, 12, 13, 12, 13, 4884 9, 9, 9, 10, 11, 12, 12, 12, 4885 9, 9, 10, 11, 12, 12, 12, 12 4886]; 4887 4888Tables.t12l = [ 4889 4, 4, 6, 8, 9, 10, 10, 10, 4890 4, 5, 6, 7, 9, 9, 10, 10, 4891 6, 6, 7, 8, 9, 10, 9, 10, 4892 7, 7, 8, 8, 9, 10, 10, 10, 4893 8, 8, 9, 9, 10, 10, 10, 11, 4894 9, 9, 10, 10, 10, 11, 10, 11, 4895 9, 9, 9, 10, 10, 11, 11, 12, 4896 10, 10, 10, 11, 11, 11, 11, 12 4897]; 4898 4899Tables.t13l = [ 4900 1, 5, 7, 8, 9, 10, 10, 11, 10, 11, 12, 12, 13, 13, 14, 14, 4901 4, 6, 8, 9, 10, 10, 11, 11, 11, 11, 12, 12, 13, 14, 14, 14, 4902 7, 8, 9, 10, 11, 11, 12, 12, 11, 12, 12, 13, 13, 14, 15, 15, 4903 8, 9, 10, 11, 11, 12, 12, 12, 12, 13, 13, 13, 13, 14, 15, 15, 4904 9, 9, 11, 11, 12, 12, 13, 13, 12, 13, 13, 14, 14, 15, 15, 16, 4905 10, 10, 11, 12, 12, 12, 13, 13, 13, 13, 14, 13, 15, 15, 16, 16, 4906 10, 11, 12, 12, 13, 13, 13, 13, 13, 14, 14, 14, 15, 15, 16, 16, 4907 11, 11, 12, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 16, 18, 18, 4908 10, 10, 11, 12, 12, 13, 13, 14, 14, 14, 14, 15, 15, 16, 17, 17, 4909 11, 11, 12, 12, 13, 13, 13, 15, 14, 15, 15, 16, 16, 16, 18, 17, 4910 11, 12, 12, 13, 13, 14, 14, 15, 14, 15, 16, 15, 16, 17, 18, 19, 4911 12, 12, 12, 13, 14, 14, 14, 14, 15, 15, 15, 16, 17, 17, 17, 18, 4912 12, 13, 13, 14, 14, 15, 14, 15, 16, 16, 17, 17, 17, 18, 18, 18, 4913 13, 13, 14, 15, 15, 15, 16, 16, 16, 16, 16, 17, 18, 17, 18, 18, 4914 14, 14, 14, 15, 15, 15, 17, 16, 16, 19, 17, 17, 17, 19, 18, 18, 4915 13, 14, 15, 16, 16, 16, 17, 16, 17, 17, 18, 18, 21, 20, 21, 18 4916]; 4917 4918Tables.t15l = [ 4919 3, 5, 6, 8, 8, 9, 10, 10, 10, 11, 11, 12, 12, 12, 13, 14, 4920 5, 5, 7, 8, 9, 9, 10, 10, 10, 11, 11, 12, 12, 12, 13, 13, 4921 6, 7, 7, 8, 9, 9, 10, 10, 10, 11, 11, 12, 12, 13, 13, 13, 4922 7, 8, 8, 9, 9, 10, 10, 11, 11, 11, 12, 12, 12, 13, 13, 13, 4923 8, 8, 9, 9, 10, 10, 11, 11, 11, 11, 12, 12, 12, 13, 13, 13, 4924 9, 9, 9, 10, 10, 10, 11, 11, 11, 11, 12, 12, 13, 13, 13, 14, 4925 10, 9, 10, 10, 10, 11, 11, 11, 11, 12, 12, 12, 13, 13, 14, 14, 4926 10, 10, 10, 11, 11, 11, 11, 12, 12, 12, 12, 12, 13, 13, 13, 14, 4927 10, 10, 10, 11, 11, 11, 11, 12, 12, 12, 12, 13, 13, 14, 14, 14, 4928 10, 10, 11, 11, 11, 11, 12, 12, 12, 13, 13, 13, 13, 14, 14, 14, 4929 11, 11, 11, 11, 12, 12, 12, 12, 12, 13, 13, 13, 13, 14, 15, 14, 4930 11, 11, 11, 11, 12, 12, 12, 12, 13, 13, 13, 13, 14, 14, 14, 15, 4931 12, 12, 11, 12, 12, 12, 13, 13, 13, 13, 13, 13, 14, 14, 15, 15, 4932 12, 12, 12, 12, 12, 13, 13, 13, 13, 14, 14, 14, 14, 14, 15, 15, 4933 13, 13, 13, 13, 13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 14, 15, 4934 13, 13, 13, 13, 13, 13, 13, 14, 14, 14, 14, 14, 15, 15, 15, 15 4935]; 4936 4937Tables.t16_5l = [ 4938 1, 5, 7, 9, 10, 10, 11, 11, 12, 12, 12, 13, 13, 13, 14, 11, 4939 4, 6, 8, 9, 10, 11, 11, 11, 12, 12, 12, 13, 14, 13, 14, 11, 4940 7, 8, 9, 10, 11, 11, 12, 12, 13, 12, 13, 13, 13, 14, 14, 12, 4941 9, 9, 10, 11, 11, 12, 12, 12, 13, 13, 14, 14, 14, 15, 15, 13, 4942 10, 10, 11, 11, 12, 12, 13, 13, 13, 14, 14, 14, 15, 15, 15, 12, 4943 10, 10, 11, 11, 12, 13, 13, 14, 13, 14, 14, 15, 15, 15, 16, 13, 4944 11, 11, 11, 12, 13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 16, 13, 4945 11, 11, 12, 12, 13, 13, 13, 14, 14, 15, 15, 15, 15, 17, 17, 13, 4946 11, 12, 12, 13, 13, 13, 14, 14, 15, 15, 15, 15, 16, 16, 16, 13, 4947 12, 12, 12, 13, 13, 14, 14, 15, 15, 15, 15, 16, 15, 16, 15, 14, 4948 12, 13, 12, 13, 14, 14, 14, 14, 15, 16, 16, 16, 17, 17, 16, 13, 4949 13, 13, 13, 13, 14, 14, 15, 16, 16, 16, 16, 16, 16, 15, 16, 14, 4950 13, 14, 14, 14, 14, 15, 15, 15, 15, 17, 16, 16, 16, 16, 18, 14, 4951 15, 14, 14, 14, 15, 15, 16, 16, 16, 18, 17, 17, 17, 19, 17, 14, 4952 14, 15, 13, 14, 16, 16, 15, 16, 16, 17, 18, 17, 19, 17, 16, 14, 4953 11, 11, 11, 12, 12, 13, 13, 13, 14, 14, 14, 14, 14, 14, 14, 12 4954]; 4955 4956Tables.t16l = [ 4957 1, 5, 7, 9, 10, 10, 11, 11, 12, 12, 12, 13, 13, 13, 14, 10, 4958 4, 6, 8, 9, 10, 11, 11, 11, 12, 12, 12, 13, 14, 13, 14, 10, 4959 7, 8, 9, 10, 11, 11, 12, 12, 13, 12, 13, 13, 13, 14, 14, 11, 4960 9, 9, 10, 11, 11, 12, 12, 12, 13, 13, 14, 14, 14, 15, 15, 12, 4961 10, 10, 11, 11, 12, 12, 13, 13, 13, 14, 14, 14, 15, 15, 15, 11, 4962 10, 10, 11, 11, 12, 13, 13, 14, 13, 14, 14, 15, 15, 15, 16, 12, 4963 11, 11, 11, 12, 13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 16, 12, 4964 11, 11, 12, 12, 13, 13, 13, 14, 14, 15, 15, 15, 15, 17, 17, 12, 4965 11, 12, 12, 13, 13, 13, 14, 14, 15, 15, 15, 15, 16, 16, 16, 12, 4966 12, 12, 12, 13, 13, 14, 14, 15, 15, 15, 15, 16, 15, 16, 15, 13, 4967 12, 13, 12, 13, 14, 14, 14, 14, 15, 16, 16, 16, 17, 17, 16, 12, 4968 13, 13, 13, 13, 14, 14, 15, 16, 16, 16, 16, 16, 16, 15, 16, 13, 4969 13, 14, 14, 14, 14, 15, 15, 15, 15, 17, 16, 16, 16, 16, 18, 13, 4970 15, 14, 14, 14, 15, 15, 16, 16, 16, 18, 17, 17, 17, 19, 17, 13, 4971 14, 15, 13, 14, 16, 16, 15, 16, 16, 17, 18, 17, 19, 17, 16, 13, 4972 10, 10, 10, 11, 11, 12, 12, 12, 13, 13, 13, 13, 13, 13, 13, 10 4973]; 4974 4975Tables.t24l = [ 4976 4, 5, 7, 8, 9, 10, 10, 11, 11, 12, 12, 12, 12, 12, 13, 10, 4977 5, 6, 7, 8, 9, 10, 10, 11, 11, 11, 12, 12, 12, 12, 12, 10, 4978 7, 7, 8, 9, 9, 10, 10, 11, 11, 11, 11, 12, 12, 12, 13, 9, 4979 8, 8, 9, 9, 10, 10, 10, 11, 11, 11, 11, 12, 12, 12, 12, 9, 4980 9, 9, 9, 10, 10, 10, 10, 11, 11, 11, 12, 12, 12, 12, 13, 9, 4981 10, 9, 10, 10, 10, 10, 11, 11, 11, 11, 12, 12, 12, 12, 12, 9, 4982 10, 10, 10, 10, 10, 11, 11, 11, 11, 12, 12, 12, 12, 12, 13, 9, 4983 11, 10, 10, 10, 11, 11, 11, 11, 12, 12, 12, 12, 12, 13, 13, 10, 4984 11, 11, 11, 11, 11, 11, 11, 11, 11, 12, 12, 12, 12, 13, 13, 10, 4985 11, 11, 11, 11, 11, 11, 11, 12, 12, 12, 12, 12, 13, 13, 13, 10, 4986 12, 11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13, 10, 4987 12, 12, 11, 11, 11, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13, 10, 4988 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13, 13, 10, 4989 12, 12, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13, 13, 13, 13, 10, 4990 13, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13, 13, 13, 13, 13, 10, 4991 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10, 6 4992]; 4993 4994Tables.t32l = [ 4995 1 + 0, 4 + 1, 4 + 1, 5 + 2, 4 + 1, 6 + 2, 5 + 2, 6 + 3, 4996 4 + 1, 5 + 2, 5 + 2, 6 + 3, 5 + 2, 6 + 3, 6 + 3, 6 + 4 4997]; 4998 4999Tables.t33l = [ 5000 4 + 0, 4 + 1, 4 + 1, 4 + 2, 4 + 1, 4 + 2, 4 + 2, 4 + 3, 5001 4 + 1, 4 + 2, 4 + 2, 4 + 3, 4 + 2, 4 + 3, 4 + 3, 4 + 4 5002]; 5003 5004Tables.ht = [ 5005 /* xlen, linmax, table, hlen */ 5006 new HuffCodeTab(0, 0, null, null), 5007 new HuffCodeTab(2, 0, Tables.t1HB, Tables.t1l), 5008 new HuffCodeTab(3, 0, Tables.t2HB, Tables.t2l), 5009 new HuffCodeTab(3, 0, Tables.t3HB, Tables.t3l), 5010 new HuffCodeTab(0, 0, null, null), /* Apparently not used */ 5011 new HuffCodeTab(4, 0, Tables.t5HB, Tables.t5l), 5012 new HuffCodeTab(4, 0, Tables.t6HB, Tables.t6l), 5013 new HuffCodeTab(6, 0, Tables.t7HB, Tables.t7l), 5014 new HuffCodeTab(6, 0, Tables.t8HB, Tables.t8l), 5015 new HuffCodeTab(6, 0, Tables.t9HB, Tables.t9l), 5016 new HuffCodeTab(8, 0, Tables.t10HB, Tables.t10l), 5017 new HuffCodeTab(8, 0, Tables.t11HB, Tables.t11l), 5018 new HuffCodeTab(8, 0, Tables.t12HB, Tables.t12l), 5019 new HuffCodeTab(16, 0, Tables.t13HB, Tables.t13l), 5020 new HuffCodeTab(0, 0, null, Tables.t16_5l), /* Apparently not used */ 5021 new HuffCodeTab(16, 0, Tables.t15HB, Tables.t15l), 5022 5023 new HuffCodeTab(1, 1, Tables.t16HB, Tables.t16l), 5024 new HuffCodeTab(2, 3, Tables.t16HB, Tables.t16l), 5025 new HuffCodeTab(3, 7, Tables.t16HB, Tables.t16l), 5026 new HuffCodeTab(4, 15, Tables.t16HB, Tables.t16l), 5027 new HuffCodeTab(6, 63, Tables.t16HB, Tables.t16l), 5028 new HuffCodeTab(8, 255, Tables.t16HB, Tables.t16l), 5029 new HuffCodeTab(10, 1023, Tables.t16HB, Tables.t16l), 5030 new HuffCodeTab(13, 8191, Tables.t16HB, Tables.t16l), 5031 5032 new HuffCodeTab(4, 15, Tables.t24HB, Tables.t24l), 5033 new HuffCodeTab(5, 31, Tables.t24HB, Tables.t24l), 5034 new HuffCodeTab(6, 63, Tables.t24HB, Tables.t24l), 5035 new HuffCodeTab(7, 127, Tables.t24HB, Tables.t24l), 5036 new HuffCodeTab(8, 255, Tables.t24HB, Tables.t24l), 5037 new HuffCodeTab(9, 511, Tables.t24HB, Tables.t24l), 5038 new HuffCodeTab(11, 2047, Tables.t24HB, Tables.t24l), 5039 new HuffCodeTab(13, 8191, Tables.t24HB, Tables.t24l), 5040 5041 new HuffCodeTab(0, 0, Tables.t32HB, Tables.t32l), 5042 new HuffCodeTab(0, 0, Tables.t33HB, Tables.t33l), 5043]; 5044 5045/** 5046 * <CODE> 5047 * for (i = 0; i < 16*16; i++) [ 5048 * largetbl[i] = ((ht[16].hlen[i]) << 16) + ht[24].hlen[i]; 5049 * ] 5050 * </CODE> 5051 * 5052 */ 5053Tables.largetbl = [ 5054 0x010004, 0x050005, 0x070007, 0x090008, 0x0a0009, 0x0a000a, 0x0b000a, 0x0b000b, 5055 0x0c000b, 0x0c000c, 0x0c000c, 0x0d000c, 0x0d000c, 0x0d000c, 0x0e000d, 0x0a000a, 5056 0x040005, 0x060006, 0x080007, 0x090008, 0x0a0009, 0x0b000a, 0x0b000a, 0x0b000b, 5057 0x0c000b, 0x0c000b, 0x0c000c, 0x0d000c, 0x0e000c, 0x0d000c, 0x0e000c, 0x0a000a, 5058 0x070007, 0x080007, 0x090008, 0x0a0009, 0x0b0009, 0x0b000a, 0x0c000a, 0x0c000b, 5059 0x0d000b, 0x0c000b, 0x0d000b, 0x0d000c, 0x0d000c, 0x0e000c, 0x0e000d, 0x0b0009, 5060 0x090008, 0x090008, 0x0a0009, 0x0b0009, 0x0b000a, 0x0c000a, 0x0c000a, 0x0c000b, 5061 0x0d000b, 0x0d000b, 0x0e000b, 0x0e000c, 0x0e000c, 0x0f000c, 0x0f000c, 0x0c0009, 5062 0x0a0009, 0x0a0009, 0x0b0009, 0x0b000a, 0x0c000a, 0x0c000a, 0x0d000a, 0x0d000b, 5063 0x0d000b, 0x0e000b, 0x0e000c, 0x0e000c, 0x0f000c, 0x0f000c, 0x0f000d, 0x0b0009, 5064 0x0a000a, 0x0a0009, 0x0b000a, 0x0b000a, 0x0c000a, 0x0d000a, 0x0d000b, 0x0e000b, 5065 0x0d000b, 0x0e000b, 0x0e000c, 0x0f000c, 0x0f000c, 0x0f000c, 0x10000c, 0x0c0009, 5066 0x0b000a, 0x0b000a, 0x0b000a, 0x0c000a, 0x0d000a, 0x0d000b, 0x0d000b, 0x0d000b, 5067 0x0e000b, 0x0e000c, 0x0e000c, 0x0e000c, 0x0f000c, 0x0f000c, 0x10000d, 0x0c0009, 5068 0x0b000b, 0x0b000a, 0x0c000a, 0x0c000a, 0x0d000b, 0x0d000b, 0x0d000b, 0x0e000b, 5069 0x0e000c, 0x0f000c, 0x0f000c, 0x0f000c, 0x0f000c, 0x11000d, 0x11000d, 0x0c000a, 5070 0x0b000b, 0x0c000b, 0x0c000b, 0x0d000b, 0x0d000b, 0x0d000b, 0x0e000b, 0x0e000b, 5071 0x0f000b, 0x0f000c, 0x0f000c, 0x0f000c, 0x10000c, 0x10000d, 0x10000d, 0x0c000a, 5072 0x0c000b, 0x0c000b, 0x0c000b, 0x0d000b, 0x0d000b, 0x0e000b, 0x0e000b, 0x0f000c, 5073 0x0f000c, 0x0f000c, 0x0f000c, 0x10000c, 0x0f000d, 0x10000d, 0x0f000d, 0x0d000a, 5074 0x0c000c, 0x0d000b, 0x0c000b, 0x0d000b, 0x0e000b, 0x0e000c, 0x0e000c, 0x0e000c, 5075 0x0f000c, 0x10000c, 0x10000c, 0x10000d, 0x11000d, 0x11000d, 0x10000d, 0x0c000a, 5076 0x0d000c, 0x0d000c, 0x0d000b, 0x0d000b, 0x0e000b, 0x0e000c, 0x0f000c, 0x10000c, 5077 0x10000c, 0x10000c, 0x10000c, 0x10000d, 0x10000d, 0x0f000d, 0x10000d, 0x0d000a, 5078 0x0d000c, 0x0e000c, 0x0e000c, 0x0e000c, 0x0e000c, 0x0f000c, 0x0f000c, 0x0f000c, 5079 0x0f000c, 0x11000c, 0x10000d, 0x10000d, 0x10000d, 0x10000d, 0x12000d, 0x0d000a, 5080 0x0f000c, 0x0e000c, 0x0e000c, 0x0e000c, 0x0f000c, 0x0f000c, 0x10000c, 0x10000c, 5081 0x10000d, 0x12000d, 0x11000d, 0x11000d, 0x11000d, 0x13000d, 0x11000d, 0x0d000a, 5082 0x0e000d, 0x0f000c, 0x0d000c, 0x0e000c, 0x10000c, 0x10000c, 0x0f000c, 0x10000d, 5083 0x10000d, 0x11000d, 0x12000d, 0x11000d, 0x13000d, 0x11000d, 0x10000d, 0x0d000a, 5084 0x0a0009, 0x0a0009, 0x0a0009, 0x0b0009, 0x0b0009, 0x0c0009, 0x0c0009, 0x0c0009, 5085 0x0d0009, 0x0d0009, 0x0d0009, 0x0d000a, 0x0d000a, 0x0d000a, 0x0d000a, 0x0a0006 5086]; 5087/** 5088 * <CODE> 5089 * for (i = 0; i < 3*3; i++) [ 5090 * table23[i] = ((ht[2].hlen[i]) << 16) + ht[3].hlen[i]; 5091 * ] 5092 * </CODE> 5093 * 5094 */ 5095Tables.table23 = [ 5096 0x010002, 0x040003, 0x070007, 5097 0x040004, 0x050004, 0x070007, 5098 0x060006, 0x070007, 0x080008 5099]; 5100 5101/** 5102 * <CODE> 5103 * for (i = 0; i < 4*4; i++) [ 5104 * table56[i] = ((ht[5].hlen[i]) << 16) + ht[6].hlen[i]; 5105 * ] 5106 * </CODE> 5107 * 5108 */ 5109Tables.table56 = [ 5110 0x010003, 0x040004, 0x070006, 0x080008, 0x040004, 0x050004, 0x080006, 0x090007, 5111 0x070005, 0x080006, 0x090007, 0x0a0008, 0x080007, 0x080007, 0x090008, 0x0a0009 5112]; 5113 5114Tables.bitrate_table = [ 5115 [0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, -1], /* MPEG 2 */ 5116 [0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, -1], /* MPEG 1 */ 5117 [0, 8, 16, 24, 32, 40, 48, 56, 64, -1, -1, -1, -1, -1, -1, -1], /* MPEG 2.5 */ 5118]; 5119 5120/** 5121 * MPEG 2, MPEG 1, MPEG 2.5. 5122 */ 5123Tables.samplerate_table = [ 5124 [22050, 24000, 16000, -1], 5125 [44100, 48000, 32000, -1], 5126 [11025, 12000, 8000, -1], 5127]; 5128 5129/** 5130 * This is the scfsi_band table from 2.4.2.7 of the IS. 5131 */ 5132Tables.scfsi_band = [0, 6, 11, 16, 21]; 5133 5134function MeanBits(meanBits) { 5135 this.bits = meanBits; 5136} 5137 5138function VBRQuantize() { 5139 var qupvt; 5140 var tak; 5141 5142 this.setModules = function (_qupvt, _tk) { 5143 qupvt = _qupvt; 5144 tak = _tk; 5145 } 5146 //TODO 5147 5148} 5149 5150//package mp3; 5151 5152function CalcNoiseResult() { 5153 /** 5154 * sum of quantization noise > masking 5155 */ 5156 this.over_noise = 0.; 5157 /** 5158 * sum of all quantization noise 5159 */ 5160 this.tot_noise = 0.; 5161 /** 5162 * max quantization noise 5163 */ 5164 this.max_noise = 0.; 5165 /** 5166 * number of quantization noise > masking 5167 */ 5168 this.over_count = 0; 5169 /** 5170 * SSD-like cost of distorted bands 5171 */ 5172 this.over_SSD = 0; 5173 this.bits = 0; 5174} 5175 5176 5177function LameGlobalFlags() { 5178 5179 this.class_id = 0; 5180 5181 /* input description */ 5182 5183 /** 5184 * number of samples. default=-1 5185 */ 5186 this.num_samples = 0; 5187 /** 5188 * input number of channels. default=2 5189 */ 5190 this.num_channels = 0; 5191 /** 5192 * input_samp_rate in Hz. default=44.1 kHz 5193 */ 5194 this.in_samplerate = 0; 5195 /** 5196 * output_samp_rate. default: LAME picks best value at least not used for 5197 * MP3 decoding: Remember 44.1 kHz MP3s and AC97 5198 */ 5199 this.out_samplerate = 0; 5200 /** 5201 * scale input by this amount before encoding at least not used for MP3 5202 * decoding 5203 */ 5204 this.scale = 0.; 5205 /** 5206 * scale input of channel 0 (left) by this amount before encoding 5207 */ 5208 this.scale_left = 0.; 5209 /** 5210 * scale input of channel 1 (right) by this amount before encoding 5211 */ 5212 this.scale_right = 0.; 5213 5214 /* general control params */ 5215 /** 5216 * collect data for a MP3 frame analyzer? 5217 */ 5218 this.analysis = false; 5219 /** 5220 * add Xing VBR tag? 5221 */ 5222 this.bWriteVbrTag = false; 5223 5224 /** 5225 * use lame/mpglib to convert mp3 to wav 5226 */ 5227 this.decode_only = false; 5228 /** 5229 * quality setting 0=best, 9=worst default=5 5230 */ 5231 this.quality = 0; 5232 /** 5233 * see enum default = LAME picks best value 5234 */ 5235 this.mode = MPEGMode.STEREO; 5236 /** 5237 * force M/S mode. requires mode=1 5238 */ 5239 this.force_ms = false; 5240 /** 5241 * use free format? default=0 5242 */ 5243 this.free_format = false; 5244 /** 5245 * find the RG value? default=0 5246 */ 5247 this.findReplayGain = false; 5248 /** 5249 * decode on the fly? default=0 5250 */ 5251 this.decode_on_the_fly = false; 5252 /** 5253 * 1 (default) writes ID3 tags, 0 not 5254 */ 5255 this.write_id3tag_automatic = false; 5256 5257 /* 5258 * set either brate>0 or compression_ratio>0, LAME will compute the value of 5259 * the variable not set. Default is compression_ratio = 11.025 5260 */ 5261 /** 5262 * bitrate 5263 */ 5264 this.brate = 0; 5265 /** 5266 * sizeof(wav file)/sizeof(mp3 file) 5267 */ 5268 this.compression_ratio = 0.; 5269 5270 /* frame params */ 5271 /** 5272 * mark as copyright. default=0 5273 */ 5274 this.copyright = 0; 5275 /** 5276 * mark as original. default=1 5277 */ 5278 this.original = 0; 5279 /** 5280 * the MP3 'private extension' bit. Meaningless 5281 */ 5282 this.extension = 0; 5283 /** 5284 * Input PCM is emphased PCM (for instance from one of the rarely emphased 5285 * CDs), it is STRONGLY not recommended to use this, because psycho does not 5286 * take it into account, and last but not least many decoders don't care 5287 * about these bits 5288 */ 5289 this.emphasis = 0; 5290 /** 5291 * use 2 bytes per frame for a CRC checksum. default=0 5292 */ 5293 this.error_protection = 0; 5294 /** 5295 * enforce ISO spec as much as possible 5296 */ 5297 this.strict_ISO = false; 5298 5299 /** 5300 * use bit reservoir? 5301 */ 5302 this.disable_reservoir = false; 5303 5304 /* quantization/noise shaping */ 5305 this.quant_comp = 0; 5306 this.quant_comp_short = 0; 5307 this.experimentalY = false; 5308 this.experimentalZ = 0; 5309 this.exp_nspsytune = 0; 5310 5311 this.preset = 0; 5312 5313 /* VBR control */ 5314 this.VBR = null; 5315 /** 5316 * Range [0,...,1[ 5317 */ 5318 this.VBR_q_frac = 0.; 5319 /** 5320 * Range [0,...,9] 5321 */ 5322 this.VBR_q = 0; 5323 this.VBR_mean_bitrate_kbps = 0; 5324 this.VBR_min_bitrate_kbps = 0; 5325 this.VBR_max_bitrate_kbps = 0; 5326 /** 5327 * strictly enforce VBR_min_bitrate normaly, it will be violated for analog 5328 * silence 5329 */ 5330 this.VBR_hard_min = 0; 5331 5332 /* resampling and filtering */ 5333 5334 /** 5335 * freq in Hz. 0=lame choses. -1=no filter 5336 */ 5337 this.lowpassfreq = 0; 5338 /** 5339 * freq in Hz. 0=lame choses. -1=no filter 5340 */ 5341 this.highpassfreq = 0; 5342 /** 5343 * freq width of filter, in Hz (default=15%) 5344 */ 5345 this.lowpasswidth = 0; 5346 /** 5347 * freq width of filter, in Hz (default=15%) 5348 */ 5349 this.highpasswidth = 0; 5350 5351 /* 5352 * psycho acoustics and other arguments which you should not change unless 5353 * you know what you are doing 5354 */ 5355 5356 this.maskingadjust = 0.; 5357 this.maskingadjust_short = 0.; 5358 /** 5359 * only use ATH 5360 */ 5361 this.ATHonly = false; 5362 /** 5363 * only use ATH for short blocks 5364 */ 5365 this.ATHshort = false; 5366 /** 5367 * disable ATH 5368 */ 5369 this.noATH = false; 5370 /** 5371 * select ATH formula 5372 */ 5373 this.ATHtype = 0; 5374 /** 5375 * change ATH formula 4 shape 5376 */ 5377 this.ATHcurve = 0.; 5378 /** 5379 * lower ATH by this many db 5380 */ 5381 this.ATHlower = 0.; 5382 /** 5383 * select ATH auto-adjust scheme 5384 */ 5385 this.athaa_type = 0; 5386 /** 5387 * select ATH auto-adjust loudness calc 5388 */ 5389 this.athaa_loudapprox = 0; 5390 /** 5391 * dB, tune active region of auto-level 5392 */ 5393 this.athaa_sensitivity = 0.; 5394 this.short_blocks = null; 5395 /** 5396 * use temporal masking effect 5397 */ 5398 this.useTemporal = false; 5399 this.interChRatio = 0.; 5400 /** 5401 * Naoki's adjustment of Mid/Side maskings 5402 */ 5403 this.msfix = 0.; 5404 5405 /** 5406 * 0 off, 1 on 5407 */ 5408 this.tune = false; 5409 /** 5410 * used to pass values for debugging and stuff 5411 */ 5412 this.tune_value_a = 0.; 5413 5414 /************************************************************************/ 5415 /* internal variables, do not set... */ 5416 /* provided because they may be of use to calling application */ 5417 /************************************************************************/ 5418 5419 /** 5420 * 0=MPEG-2/2.5 1=MPEG-1 5421 */ 5422 this.version = 0; 5423 this.encoder_delay = 0; 5424 /** 5425 * number of samples of padding appended to input 5426 */ 5427 this.encoder_padding = 0; 5428 this.framesize = 0; 5429 /** 5430 * number of frames encoded 5431 */ 5432 this.frameNum = 0; 5433 /** 5434 * is this struct owned by calling program or lame? 5435 */ 5436 this.lame_allocated_gfp = 0; 5437 /**************************************************************************/ 5438 /* more internal variables are stored in this structure: */ 5439 /**************************************************************************/ 5440 this.internal_flags = null; 5441} 5442 5443 5444 5445function ReplayGain() { 5446 this.linprebuf = new_float(GainAnalysis.MAX_ORDER * 2); 5447 /** 5448 * left input samples, with pre-buffer 5449 */ 5450 this.linpre = 0; 5451 this.lstepbuf = new_float(GainAnalysis.MAX_SAMPLES_PER_WINDOW + GainAnalysis.MAX_ORDER); 5452 /** 5453 * left "first step" (i.e. post first filter) samples 5454 */ 5455 this.lstep = 0; 5456 this.loutbuf = new_float(GainAnalysis.MAX_SAMPLES_PER_WINDOW + GainAnalysis.MAX_ORDER); 5457 /** 5458 * left "out" (i.e. post second filter) samples 5459 */ 5460 this.lout = 0; 5461 this.rinprebuf = new_float(GainAnalysis.MAX_ORDER * 2); 5462 /** 5463 * right input samples ... 5464 */ 5465 this.rinpre = 0; 5466 this.rstepbuf = new_float(GainAnalysis.MAX_SAMPLES_PER_WINDOW + GainAnalysis.MAX_ORDER); 5467 this.rstep = 0; 5468 this.routbuf = new_float(GainAnalysis.MAX_SAMPLES_PER_WINDOW + GainAnalysis.MAX_ORDER); 5469 this.rout = 0; 5470 /** 5471 * number of samples required to reach number of milliseconds required 5472 * for RMS window 5473 */ 5474 this.sampleWindow = 0; 5475 this.totsamp = 0; 5476 this.lsum = 0.; 5477 this.rsum = 0.; 5478 this.freqindex = 0; 5479 this.first = 0; 5480 this.A = new_int(0 | (GainAnalysis.STEPS_per_dB * GainAnalysis.MAX_dB)); 5481 this.B = new_int(0 | (GainAnalysis.STEPS_per_dB * GainAnalysis.MAX_dB)); 5482 5483} 5484 5485 5486 5487function CBRNewIterationLoop(_quantize) { 5488 var quantize = _quantize; 5489 this.quantize = quantize; 5490 this.iteration_loop = function(gfp, pe, ms_ener_ratio, ratio) { 5491 var gfc = gfp.internal_flags; 5492 var l3_xmin = new_float(L3Side.SFBMAX); 5493 var xrpow = new_float(576); 5494 var targ_bits = new_int(2); 5495 var mean_bits = 0, max_bits; 5496 var l3_side = gfc.l3_side; 5497 5498 var mb = new MeanBits(mean_bits); 5499 this.quantize.rv.ResvFrameBegin(gfp, mb); 5500 mean_bits = mb.bits; 5501 5502 /* quantize! */ 5503 for (var gr = 0; gr < gfc.mode_gr; gr++) { 5504 5505 /* 5506 * calculate needed bits 5507 */ 5508 max_bits = this.quantize.qupvt.on_pe(gfp, pe, targ_bits, mean_bits, 5509 gr, gr); 5510 5511 if (gfc.mode_ext == Encoder.MPG_MD_MS_LR) { 5512 this.quantize.ms_convert(gfc.l3_side, gr); 5513 this.quantize.qupvt.reduce_side(targ_bits, ms_ener_ratio[gr], 5514 mean_bits, max_bits); 5515 } 5516 5517 for (var ch = 0; ch < gfc.channels_out; ch++) { 5518 var adjust, masking_lower_db; 5519 var cod_info = l3_side.tt[gr][ch]; 5520 5521 if (cod_info.block_type != Encoder.SHORT_TYPE) { 5522 // NORM, START or STOP type 5523 adjust = 0; 5524 masking_lower_db = gfc.PSY.mask_adjust - adjust; 5525 } else { 5526 adjust = 0; 5527 masking_lower_db = gfc.PSY.mask_adjust_short - adjust; 5528 } 5529 gfc.masking_lower = Math.pow(10.0, 5530 masking_lower_db * 0.1); 5531 5532 /* 5533 * init_outer_loop sets up cod_info, scalefac and xrpow 5534 */ 5535 this.quantize.init_outer_loop(gfc, cod_info); 5536 if (this.quantize.init_xrpow(gfc, cod_info, xrpow)) { 5537 /* 5538 * xr contains energy we will have to encode calculate the 5539 * masking abilities find some good quantization in 5540 * outer_loop 5541 */ 5542 this.quantize.qupvt.calc_xmin(gfp, ratio[gr][ch], cod_info, 5543 l3_xmin); 5544 this.quantize.outer_loop(gfp, cod_info, l3_xmin, xrpow, ch, 5545 targ_bits[ch]); 5546 } 5547 5548 this.quantize.iteration_finish_one(gfc, gr, ch); 5549 } /* for ch */ 5550 } /* for gr */ 5551 5552 this.quantize.rv.ResvFrameEnd(gfc, mean_bits); 5553 } 5554} 5555 5556 5557/** 5558 * ATH related stuff, if something new ATH related has to be added, please plug 5559 * it here into the ATH. 5560 */ 5561function ATH() { 5562 /** 5563 * Method for the auto adjustment. 5564 */ 5565 this.useAdjust = 0; 5566 /** 5567 * factor for tuning the (sample power) point below which adaptive threshold 5568 * of hearing adjustment occurs 5569 */ 5570 this.aaSensitivityP = 0.; 5571 /** 5572 * Lowering based on peak volume, 1 = no lowering. 5573 */ 5574 this.adjust = 0.; 5575 /** 5576 * Limit for dynamic ATH adjust. 5577 */ 5578 this.adjustLimit = 0.; 5579 /** 5580 * Determined to lower x dB each second. 5581 */ 5582 this.decay = 0.; 5583 /** 5584 * Lowest ATH value. 5585 */ 5586 this.floor = 0.; 5587 /** 5588 * ATH for sfbs in long blocks. 5589 */ 5590 this.l = new_float(Encoder.SBMAX_l); 5591 /** 5592 * ATH for sfbs in short blocks. 5593 */ 5594 this.s = new_float(Encoder.SBMAX_s); 5595 /** 5596 * ATH for partitioned sfb21 in long blocks. 5597 */ 5598 this.psfb21 = new_float(Encoder.PSFB21); 5599 /** 5600 * ATH for partitioned sfb12 in short blocks. 5601 */ 5602 this.psfb12 = new_float(Encoder.PSFB12); 5603 /** 5604 * ATH for long block convolution bands. 5605 */ 5606 this.cb_l = new_float(Encoder.CBANDS); 5607 /** 5608 * ATH for short block convolution bands. 5609 */ 5610 this.cb_s = new_float(Encoder.CBANDS); 5611 /** 5612 * Equal loudness weights (based on ATH). 5613 */ 5614 this.eql_w = new_float(Encoder.BLKSIZE / 2); 5615} 5616 5617//package mp3; 5618 5619/** 5620 * Layer III side information. 5621 * 5622 * @author Ken 5623 * 5624 */ 5625 5626 5627 5628function ScaleFac(arrL, arrS, arr21, arr12) { 5629 5630 this.l = new_int(1 + Encoder.SBMAX_l); 5631 this.s = new_int(1 + Encoder.SBMAX_s); 5632 this.psfb21 = new_int(1 + Encoder.PSFB21); 5633 this.psfb12 = new_int(1 + Encoder.PSFB12); 5634 var l = this.l; 5635 var s = this.s; 5636 5637 if (arguments.length == 4) { 5638 //public ScaleFac(final int[] arrL, final int[] arrS, final int[] arr21, 5639 // final int[] arr12) { 5640 this.arrL = arguments[0]; 5641 this.arrS = arguments[1]; 5642 this.arr21 = arguments[2]; 5643 this.arr12 = arguments[3]; 5644 5645 System.arraycopy(this.arrL, 0, l, 0, Math.min(this.arrL.length, this.l.length)); 5646 System.arraycopy(this.arrS, 0, s, 0, Math.min(this.arrS.length, this.s.length)); 5647 System.arraycopy(this.arr21, 0, this.psfb21, 0, Math.min(this.arr21.length, this.psfb21.length)); 5648 System.arraycopy(this.arr12, 0, this.psfb12, 0, Math.min(this.arr12.length, this.psfb12.length)); 5649 } 5650} 5651 5652/* 5653 * quantize_pvt source file 5654 * 5655 * Copyright (c) 1999-2002 Takehiro Tominaga 5656 * Copyright (c) 2000-2002 Robert Hegemann 5657 * Copyright (c) 2001 Naoki Shibata 5658 * Copyright (c) 2002-2005 Gabriel Bouvigne 5659 * 5660 * This library is free software; you can redistribute it and/or 5661 * modify it under the terms of the GNU Lesser General Public 5662 * License as published by the Free Software Foundation; either 5663 * version 2 of the License, or (at your option) any later version. 5664 * 5665 * This library is distributed in the hope that it will be useful, 5666 * but WITHOUT ANY WARRANTY; without even the implied warranty of 5667 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 5668 * Library General Public License for more details. 5669 * 5670 * You should have received a copy of the GNU Lesser General Public 5671 * License along with this library; if not, write to the 5672 * Free Software Foundation, Inc., 59 Temple Place - Suite 330, 5673 * Boston, MA 02111-1307, USA. 5674 */ 5675 5676/* $Id: QuantizePVT.java,v 1.24 2011/05/24 20:48:06 kenchis Exp $ */ 5677 5678 5679QuantizePVT.Q_MAX = (256 + 1); 5680QuantizePVT.Q_MAX2 = 116; 5681QuantizePVT.LARGE_BITS = 100000; 5682QuantizePVT.IXMAX_VAL = 8206; 5683 5684function QuantizePVT() { 5685 5686 var tak = null; 5687 var rv = null; 5688 var psy = null; 5689 5690 this.setModules = function (_tk, _rv, _psy) { 5691 tak = _tk; 5692 rv = _rv; 5693 psy = _psy; 5694 }; 5695 5696 function POW20(x) { 5697 return pow20[x + QuantizePVT.Q_MAX2]; 5698 } 5699 5700 this.IPOW20 = function (x) { 5701 return ipow20[x]; 5702 } 5703 5704 /** 5705 * smallest such that 1.0+DBL_EPSILON != 1.0 5706 */ 5707 var DBL_EPSILON = 2.2204460492503131e-016; 5708 5709 /** 5710 * ix always <= 8191+15. see count_bits() 5711 */ 5712 var IXMAX_VAL = QuantizePVT.IXMAX_VAL; 5713 5714 var PRECALC_SIZE = (IXMAX_VAL + 2); 5715 5716 var Q_MAX = QuantizePVT.Q_MAX; 5717 5718 5719 /** 5720 * <CODE> 5721 * minimum possible number of 5722 * -cod_info.global_gain + ((scalefac[] + (cod_info.preflag ? pretab[sfb] : 0)) 5723 * << (cod_info.scalefac_scale + 1)) + cod_info.subblock_gain[cod_info.window[sfb]] * 8; 5724 * 5725 * for long block, 0+((15+3)<<2) = 18*4 = 72 5726 * for short block, 0+(15<<2)+7*8 = 15*4+56 = 116 5727 * </CODE> 5728 */ 5729 var Q_MAX2 = QuantizePVT.Q_MAX2; 5730 5731 var LARGE_BITS = QuantizePVT.LARGE_BITS; 5732 5733 5734 /** 5735 * Assuming dynamic range=96dB, this value should be 92 5736 */ 5737 var NSATHSCALE = 100; 5738 5739 /** 5740 * The following table is used to implement the scalefactor partitioning for 5741 * MPEG2 as described in section 2.4.3.2 of the IS. The indexing corresponds 5742 * to the way the tables are presented in the IS: 5743 * 5744 * [table_number][row_in_table][column of nr_of_sfb] 5745 */ 5746 this.nr_of_sfb_block = [ 5747 [[6, 5, 5, 5], [9, 9, 9, 9], [6, 9, 9, 9]], 5748 [[6, 5, 7, 3], [9, 9, 12, 6], [6, 9, 12, 6]], 5749 [[11, 10, 0, 0], [18, 18, 0, 0], [15, 18, 0, 0]], 5750 [[7, 7, 7, 0], [12, 12, 12, 0], [6, 15, 12, 0]], 5751 [[6, 6, 6, 3], [12, 9, 9, 6], [6, 12, 9, 6]], 5752 [[8, 8, 5, 0], [15, 12, 9, 0], [6, 18, 9, 0]]]; 5753 5754 /** 5755 * Table B.6: layer3 preemphasis 5756 */ 5757 var pretab = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 5758 2, 2, 3, 3, 3, 2, 0]; 5759 this.pretab = pretab; 5760 5761 /** 5762 * Here are MPEG1 Table B.8 and MPEG2 Table B.1 -- Layer III scalefactor 5763 * bands. <BR> 5764 * Index into this using a method such as:<BR> 5765 * idx = fr_ps.header.sampling_frequency + (fr_ps.header.version * 3) 5766 */ 5767 this.sfBandIndex = [ 5768 // Table B.2.b: 22.05 kHz 5769 new ScaleFac([0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464, 5770 522, 576], 5771 [0, 4, 8, 12, 18, 24, 32, 42, 56, 74, 100, 132, 174, 192] 5772 , [0, 0, 0, 0, 0, 0, 0] // sfb21 pseudo sub bands 5773 , [0, 0, 0, 0, 0, 0, 0] // sfb12 pseudo sub bands 5774 ), 5775 /* Table B.2.c: 24 kHz */ /* docs: 332. mpg123(broken): 330 */ 5776 new ScaleFac([0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 114, 136, 162, 194, 232, 278, 332, 394, 464, 5777 540, 576], 5778 [0, 4, 8, 12, 18, 26, 36, 48, 62, 80, 104, 136, 180, 192] 5779 , [0, 0, 0, 0, 0, 0, 0] /* sfb21 pseudo sub bands */ 5780 , [0, 0, 0, 0, 0, 0, 0] /* sfb12 pseudo sub bands */ 5781 ), 5782 /* Table B.2.a: 16 kHz */ 5783 new ScaleFac([0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464, 5784 522, 576], 5785 [0, 4, 8, 12, 18, 26, 36, 48, 62, 80, 104, 134, 174, 192] 5786 , [0, 0, 0, 0, 0, 0, 0] /* sfb21 pseudo sub bands */ 5787 , [0, 0, 0, 0, 0, 0, 0] /* sfb12 pseudo sub bands */ 5788 ), 5789 /* Table B.8.b: 44.1 kHz */ 5790 new ScaleFac([0, 4, 8, 12, 16, 20, 24, 30, 36, 44, 52, 62, 74, 90, 110, 134, 162, 196, 238, 288, 342, 418, 5791 576], 5792 [0, 4, 8, 12, 16, 22, 30, 40, 52, 66, 84, 106, 136, 192] 5793 , [0, 0, 0, 0, 0, 0, 0] /* sfb21 pseudo sub bands */ 5794 , [0, 0, 0, 0, 0, 0, 0] /* sfb12 pseudo sub bands */ 5795 ), 5796 /* Table B.8.c: 48 kHz */ 5797 new ScaleFac([0, 4, 8, 12, 16, 20, 24, 30, 36, 42, 50, 60, 72, 88, 106, 128, 156, 190, 230, 276, 330, 384, 5798 576], 5799 [0, 4, 8, 12, 16, 22, 28, 38, 50, 64, 80, 100, 126, 192] 5800 , [0, 0, 0, 0, 0, 0, 0] /* sfb21 pseudo sub bands */ 5801 , [0, 0, 0, 0, 0, 0, 0] /* sfb12 pseudo sub bands */ 5802 ), 5803 /* Table B.8.a: 32 kHz */ 5804 new ScaleFac([0, 4, 8, 12, 16, 20, 24, 30, 36, 44, 54, 66, 82, 102, 126, 156, 194, 240, 296, 364, 448, 550, 5805 576], 5806 [0, 4, 8, 12, 16, 22, 30, 42, 58, 78, 104, 138, 180, 192] 5807 , [0, 0, 0, 0, 0, 0, 0] /* sfb21 pseudo sub bands */ 5808 , [0, 0, 0, 0, 0, 0, 0] /* sfb12 pseudo sub bands */ 5809 ), 5810 /* MPEG-2.5 11.025 kHz */ 5811 new ScaleFac([0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464, 5812 522, 576], 5813 [0 / 3, 12 / 3, 24 / 3, 36 / 3, 54 / 3, 78 / 3, 108 / 3, 144 / 3, 186 / 3, 240 / 3, 312 / 3, 5814 402 / 3, 522 / 3, 576 / 3] 5815 , [0, 0, 0, 0, 0, 0, 0] /* sfb21 pseudo sub bands */ 5816 , [0, 0, 0, 0, 0, 0, 0] /* sfb12 pseudo sub bands */ 5817 ), 5818 /* MPEG-2.5 12 kHz */ 5819 new ScaleFac([0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464, 5820 522, 576], 5821 [0 / 3, 12 / 3, 24 / 3, 36 / 3, 54 / 3, 78 / 3, 108 / 3, 144 / 3, 186 / 3, 240 / 3, 312 / 3, 5822 402 / 3, 522 / 3, 576 / 3] 5823 , [0, 0, 0, 0, 0, 0, 0] /* sfb21 pseudo sub bands */ 5824 , [0, 0, 0, 0, 0, 0, 0] /* sfb12 pseudo sub bands */ 5825 ), 5826 /* MPEG-2.5 8 kHz */ 5827 new ScaleFac([0, 12, 24, 36, 48, 60, 72, 88, 108, 132, 160, 192, 232, 280, 336, 400, 476, 566, 568, 570, 5828 572, 574, 576], 5829 [0 / 3, 24 / 3, 48 / 3, 72 / 3, 108 / 3, 156 / 3, 216 / 3, 288 / 3, 372 / 3, 480 / 3, 486 / 3, 5830 492 / 3, 498 / 3, 576 / 3] 5831 , [0, 0, 0, 0, 0, 0, 0] /* sfb21 pseudo sub bands */ 5832 , [0, 0, 0, 0, 0, 0, 0] /* sfb12 pseudo sub bands */ 5833 ) 5834 ]; 5835 5836 var pow20 = new_float(Q_MAX + Q_MAX2 + 1); 5837 var ipow20 = new_float(Q_MAX); 5838 var pow43 = new_float(PRECALC_SIZE); 5839 5840 var adj43 = new_float(PRECALC_SIZE); 5841 this.adj43 = adj43; 5842 5843 /** 5844 * <PRE> 5845 * compute the ATH for each scalefactor band cd range: 0..96db 5846 * 5847 * Input: 3.3kHz signal 32767 amplitude (3.3kHz is where ATH is smallest = 5848 * -5db) longblocks: sfb=12 en0/bw=-11db max_en0 = 1.3db shortblocks: sfb=5 5849 * -9db 0db 5850 * 5851 * Input: 1 1 1 1 1 1 1 -1 -1 -1 -1 -1 -1 -1 (repeated) longblocks: amp=1 5852 * sfb=12 en0/bw=-103 db max_en0 = -92db amp=32767 sfb=12 -12 db -1.4db 5853 * 5854 * Input: 1 1 1 1 1 1 1 -1 -1 -1 -1 -1 -1 -1 (repeated) shortblocks: amp=1 5855 * sfb=5 en0/bw= -99 -86 amp=32767 sfb=5 -9 db 4db 5856 * 5857 * 5858 * MAX energy of largest wave at 3.3kHz = 1db AVE energy of largest wave at 5859 * 3.3kHz = -11db Let's take AVE: -11db = maximum signal in sfb=12. Dynamic 5860 * range of CD: 96db. Therefor energy of smallest audible wave in sfb=12 = 5861 * -11 - 96 = -107db = ATH at 3.3kHz. 5862 * 5863 * ATH formula for this wave: -5db. To adjust to LAME scaling, we need ATH = 5864 * ATH_formula - 103 (db) ATH = ATH * 2.5e-10 (ener) 5865 * </PRE> 5866 */ 5867 function ATHmdct(gfp, f) { 5868 var ath = psy.ATHformula(f, gfp); 5869 5870 ath -= NSATHSCALE; 5871 5872 /* modify the MDCT scaling for the ATH and convert to energy */ 5873 ath = Math.pow(10.0, ath / 10.0 + gfp.ATHlower); 5874 return ath; 5875 } 5876 5877 function compute_ath(gfp) { 5878 var ATH_l = gfp.internal_flags.ATH.l; 5879 var ATH_psfb21 = gfp.internal_flags.ATH.psfb21; 5880 var ATH_s = gfp.internal_flags.ATH.s; 5881 var ATH_psfb12 = gfp.internal_flags.ATH.psfb12; 5882 var gfc = gfp.internal_flags; 5883 var samp_freq = gfp.out_samplerate; 5884 5885 for (var sfb = 0; sfb < Encoder.SBMAX_l; sfb++) { 5886 var start = gfc.scalefac_band.l[sfb]; 5887 var end = gfc.scalefac_band.l[sfb + 1]; 5888 ATH_l[sfb] = Float.MAX_VALUE; 5889 for (var i = start; i < end; i++) { 5890 var freq = i * samp_freq / (2 * 576); 5891 var ATH_f = ATHmdct(gfp, freq); 5892 /* freq in kHz */ 5893 ATH_l[sfb] = Math.min(ATH_l[sfb], ATH_f); 5894 } 5895 } 5896 5897 for (var sfb = 0; sfb < Encoder.PSFB21; sfb++) { 5898 var start = gfc.scalefac_band.psfb21[sfb]; 5899 var end = gfc.scalefac_band.psfb21[sfb + 1]; 5900 ATH_psfb21[sfb] = Float.MAX_VALUE; 5901 for (var i = start; i < end; i++) { 5902 var freq = i * samp_freq / (2 * 576); 5903 var ATH_f = ATHmdct(gfp, freq); 5904 /* freq in kHz */ 5905 ATH_psfb21[sfb] = Math.min(ATH_psfb21[sfb], ATH_f); 5906 } 5907 } 5908 5909 for (var sfb = 0; sfb < Encoder.SBMAX_s; sfb++) { 5910 var start = gfc.scalefac_band.s[sfb]; 5911 var end = gfc.scalefac_band.s[sfb + 1]; 5912 ATH_s[sfb] = Float.MAX_VALUE; 5913 for (var i = start; i < end; i++) { 5914 var freq = i * samp_freq / (2 * 192); 5915 var ATH_f = ATHmdct(gfp, freq); 5916 /* freq in kHz */ 5917 ATH_s[sfb] = Math.min(ATH_s[sfb], ATH_f); 5918 } 5919 ATH_s[sfb] *= (gfc.scalefac_band.s[sfb + 1] - gfc.scalefac_band.s[sfb]); 5920 } 5921 5922 for (var sfb = 0; sfb < Encoder.PSFB12; sfb++) { 5923 var start = gfc.scalefac_band.psfb12[sfb]; 5924 var end = gfc.scalefac_band.psfb12[sfb + 1]; 5925 ATH_psfb12[sfb] = Float.MAX_VALUE; 5926 for (var i = start; i < end; i++) { 5927 var freq = i * samp_freq / (2 * 192); 5928 var ATH_f = ATHmdct(gfp, freq); 5929 /* freq in kHz */ 5930 ATH_psfb12[sfb] = Math.min(ATH_psfb12[sfb], ATH_f); 5931 } 5932 /* not sure about the following */ 5933 ATH_psfb12[sfb] *= (gfc.scalefac_band.s[13] - gfc.scalefac_band.s[12]); 5934 } 5935 5936 /* 5937 * no-ATH mode: reduce ATH to -200 dB 5938 */ 5939 if (gfp.noATH) { 5940 for (var sfb = 0; sfb < Encoder.SBMAX_l; sfb++) { 5941 ATH_l[sfb] = 1E-20; 5942 } 5943 for (var sfb = 0; sfb < Encoder.PSFB21; sfb++) { 5944 ATH_psfb21[sfb] = 1E-20; 5945 } 5946 for (var sfb = 0; sfb < Encoder.SBMAX_s; sfb++) { 5947 ATH_s[sfb] = 1E-20; 5948 } 5949 for (var sfb = 0; sfb < Encoder.PSFB12; sfb++) { 5950 ATH_psfb12[sfb] = 1E-20; 5951 } 5952 } 5953 5954 /* 5955 * work in progress, don't rely on it too much 5956 */ 5957 gfc.ATH.floor = 10. * Math.log10(ATHmdct(gfp, -1.)); 5958 } 5959 5960 /** 5961 * initialization for iteration_loop 5962 */ 5963 this.iteration_init = function (gfp) { 5964 var gfc = gfp.internal_flags; 5965 var l3_side = gfc.l3_side; 5966 var i; 5967 5968 if (gfc.iteration_init_init == 0) { 5969 gfc.iteration_init_init = 1; 5970 5971 l3_side.main_data_begin = 0; 5972 compute_ath(gfp); 5973 5974 pow43[0] = 0.0; 5975 for (i = 1; i < PRECALC_SIZE; i++) 5976 pow43[i] = Math.pow(i, 4.0 / 3.0); 5977 5978 for (i = 0; i < PRECALC_SIZE - 1; i++) 5979 adj43[i] = ((i + 1) - Math.pow( 5980 0.5 * (pow43[i] + pow43[i + 1]), 0.75)); 5981 adj43[i] = 0.5; 5982 5983 for (i = 0; i < Q_MAX; i++) 5984 ipow20[i] = Math.pow(2.0, (i - 210) * -0.1875); 5985 for (i = 0; i <= Q_MAX + Q_MAX2; i++) 5986 pow20[i] = Math.pow(2.0, (i - 210 - Q_MAX2) * 0.25); 5987 5988 tak.huffman_init(gfc); 5989 5990 { 5991 var bass, alto, treble, sfb21; 5992 5993 i = (gfp.exp_nspsytune >> 2) & 63; 5994 if (i >= 32) 5995 i -= 64; 5996 bass = Math.pow(10, i / 4.0 / 10.0); 5997 5998 i = (gfp.exp_nspsytune >> 8) & 63; 5999 if (i >= 32) 6000 i -= 64; 6001 alto = Math.pow(10, i / 4.0 / 10.0); 6002 6003 i = (gfp.exp_nspsytune >> 14) & 63; 6004 if (i >= 32) 6005 i -= 64; 6006 treble = Math.pow(10, i / 4.0 / 10.0); 6007 6008 /* 6009 * to be compatible with Naoki's original code, the next 6 bits 6010 * define only the amount of changing treble for sfb21 6011 */ 6012 i = (gfp.exp_nspsytune >> 20) & 63; 6013 if (i >= 32) 6014 i -= 64; 6015 sfb21 = treble * Math.pow(10, i / 4.0 / 10.0); 6016 for (i = 0; i < Encoder.SBMAX_l; i++) { 6017 var f; 6018 if (i <= 6) 6019 f = bass; 6020 else if (i <= 13) 6021 f = alto; 6022 else if (i <= 20) 6023 f = treble; 6024 else 6025 f = sfb21; 6026 6027 gfc.nsPsy.longfact[i] = f; 6028 } 6029 for (i = 0; i < Encoder.SBMAX_s; i++) { 6030 var f; 6031 if (i <= 5) 6032 f = bass; 6033 else if (i <= 10) 6034 f = alto; 6035 else if (i <= 11) 6036 f = treble; 6037 else 6038 f = sfb21; 6039 6040 gfc.nsPsy.shortfact[i] = f; 6041 } 6042 } 6043 } 6044 } 6045 6046 /** 6047 * allocate bits among 2 channels based on PE<BR> 6048 * mt 6/99<BR> 6049 * bugfixes rh 8/01: often allocated more than the allowed 4095 bits 6050 */ 6051 this.on_pe = function (gfp, pe, 6052 targ_bits, mean_bits, gr, cbr) { 6053 var gfc = gfp.internal_flags; 6054 var tbits = 0, bits; 6055 var add_bits = new_int(2); 6056 var ch; 6057 6058 /* allocate targ_bits for granule */ 6059 var mb = new MeanBits(tbits); 6060 var extra_bits = rv.ResvMaxBits(gfp, mean_bits, mb, cbr); 6061 tbits = mb.bits; 6062 /* maximum allowed bits for this granule */ 6063 var max_bits = tbits + extra_bits; 6064 if (max_bits > LameInternalFlags.MAX_BITS_PER_GRANULE) { 6065 // hard limit per granule 6066 max_bits = LameInternalFlags.MAX_BITS_PER_GRANULE; 6067 } 6068 for (bits = 0, ch = 0; ch < gfc.channels_out; ++ch) { 6069 /****************************************************************** 6070 * allocate bits for each channel 6071 ******************************************************************/ 6072 targ_bits[ch] = Math.min(LameInternalFlags.MAX_BITS_PER_CHANNEL, 6073 tbits / gfc.channels_out); 6074 6075 add_bits[ch] = 0 | (targ_bits[ch] * pe[gr][ch] / 700.0 - targ_bits[ch]); 6076 6077 /* at most increase bits by 1.5*average */ 6078 if (add_bits[ch] > mean_bits * 3 / 4) 6079 add_bits[ch] = mean_bits * 3 / 4; 6080 if (add_bits[ch] < 0) 6081 add_bits[ch] = 0; 6082 6083 if (add_bits[ch] + targ_bits[ch] > LameInternalFlags.MAX_BITS_PER_CHANNEL) 6084 add_bits[ch] = Math.max(0, 6085 LameInternalFlags.MAX_BITS_PER_CHANNEL - targ_bits[ch]); 6086 6087 bits += add_bits[ch]; 6088 } 6089 if (bits > extra_bits) { 6090 for (ch = 0; ch < gfc.channels_out; ++ch) { 6091 add_bits[ch] = extra_bits * add_bits[ch] / bits; 6092 } 6093 } 6094 6095 for (ch = 0; ch < gfc.channels_out; ++ch) { 6096 targ_bits[ch] += add_bits[ch]; 6097 extra_bits -= add_bits[ch]; 6098 } 6099 6100 for (bits = 0, ch = 0; ch < gfc.channels_out; ++ch) { 6101 bits += targ_bits[ch]; 6102 } 6103 if (bits > LameInternalFlags.MAX_BITS_PER_GRANULE) { 6104 var sum = 0; 6105 for (ch = 0; ch < gfc.channels_out; ++ch) { 6106 targ_bits[ch] *= LameInternalFlags.MAX_BITS_PER_GRANULE; 6107 targ_bits[ch] /= bits; 6108 sum += targ_bits[ch]; 6109 } 6110 } 6111 6112 return max_bits; 6113 } 6114 6115 this.reduce_side = function (targ_bits, ms_ener_ratio, mean_bits, max_bits) { 6116 6117 /* 6118 * ms_ener_ratio = 0: allocate 66/33 mid/side fac=.33 ms_ener_ratio =.5: 6119 * allocate 50/50 mid/side fac= 0 6120 */ 6121 /* 75/25 split is fac=.5 */ 6122 var fac = .33 * (.5 - ms_ener_ratio) / .5; 6123 if (fac < 0) 6124 fac = 0; 6125 if (fac > .5) 6126 fac = .5; 6127 6128 /* number of bits to move from side channel to mid channel */ 6129 /* move_bits = fac*targ_bits[1]; */ 6130 var move_bits = 0 | (fac * .5 * (targ_bits[0] + targ_bits[1])); 6131 6132 if (move_bits > LameInternalFlags.MAX_BITS_PER_CHANNEL - targ_bits[0]) { 6133 move_bits = LameInternalFlags.MAX_BITS_PER_CHANNEL - targ_bits[0]; 6134 } 6135 if (move_bits < 0) 6136 move_bits = 0; 6137 6138 if (targ_bits[1] >= 125) { 6139 /* dont reduce side channel below 125 bits */ 6140 if (targ_bits[1] - move_bits > 125) { 6141 6142 /* if mid channel already has 2x more than average, dont bother */ 6143 /* mean_bits = bits per granule (for both channels) */ 6144 if (targ_bits[0] < mean_bits) 6145 targ_bits[0] += move_bits; 6146 targ_bits[1] -= move_bits; 6147 } else { 6148 targ_bits[0] += targ_bits[1] - 125; 6149 targ_bits[1] = 125; 6150 } 6151 } 6152 6153 move_bits = targ_bits[0] + targ_bits[1]; 6154 if (move_bits > max_bits) { 6155 targ_bits[0] = (max_bits * targ_bits[0]) / move_bits; 6156 targ_bits[1] = (max_bits * targ_bits[1]) / move_bits; 6157 } 6158 }; 6159 6160 /** 6161 * Robert Hegemann 2001-04-27: 6162 * this adjusts the ATH, keeping the original noise floor 6163 * affects the higher frequencies more than the lower ones 6164 */ 6165 this.athAdjust = function (a, x, athFloor) { 6166 /* 6167 * work in progress 6168 */ 6169 var o = 90.30873362; 6170 var p = 94.82444863; 6171 var u = Util.FAST_LOG10_X(x, 10.0); 6172 var v = a * a; 6173 var w = 0.0; 6174 u -= athFloor; 6175 /* undo scaling */ 6176 if (v > 1E-20) 6177 w = 1. + Util.FAST_LOG10_X(v, 10.0 / o); 6178 if (w < 0) 6179 w = 0.; 6180 u *= w; 6181 u += athFloor + o - p; 6182 /* redo scaling */ 6183 6184 return Math.pow(10., 0.1 * u); 6185 }; 6186 6187 /** 6188 * Calculate the allowed distortion for each scalefactor band, as determined 6189 * by the psychoacoustic model. xmin(sb) = ratio(sb) * en(sb) / bw(sb) 6190 * 6191 * returns number of sfb's with energy > ATH 6192 */ 6193 this.calc_xmin = function (gfp, ratio, cod_info, pxmin) { 6194 var pxminPos = 0; 6195 var gfc = gfp.internal_flags; 6196 var gsfb, j = 0, ath_over = 0; 6197 var ATH = gfc.ATH; 6198 var xr = cod_info.xr; 6199 var enable_athaa_fix = (gfp.VBR == VbrMode.vbr_mtrh) ? 1 : 0; 6200 var masking_lower = gfc.masking_lower; 6201 6202 if (gfp.VBR == VbrMode.vbr_mtrh || gfp.VBR == VbrMode.vbr_mt) { 6203 /* was already done in PSY-Model */ 6204 masking_lower = 1.0; 6205 } 6206 6207 for (gsfb = 0; gsfb < cod_info.psy_lmax; gsfb++) { 6208 var en0, xmin; 6209 var rh1, rh2; 6210 var width, l; 6211 6212 if (gfp.VBR == VbrMode.vbr_rh || gfp.VBR == VbrMode.vbr_mtrh) 6213 xmin = athAdjust(ATH.adjust, ATH.l[gsfb], ATH.floor); 6214 else 6215 xmin = ATH.adjust * ATH.l[gsfb]; 6216 6217 width = cod_info.width[gsfb]; 6218 rh1 = xmin / width; 6219 rh2 = DBL_EPSILON; 6220 l = width >> 1; 6221 en0 = 0.0; 6222 do { 6223 var xa, xb; 6224 xa = xr[j] * xr[j]; 6225 en0 += xa; 6226 rh2 += (xa < rh1) ? xa : rh1; 6227 j++; 6228 xb = xr[j] * xr[j]; 6229 en0 += xb; 6230 rh2 += (xb < rh1) ? xb : rh1; 6231 j++; 6232 } while (--l > 0); 6233 if (en0 > xmin) 6234 ath_over++; 6235 6236 if (gsfb == Encoder.SBPSY_l) { 6237 var x = xmin * gfc.nsPsy.longfact[gsfb]; 6238 if (rh2 < x) { 6239 rh2 = x; 6240 } 6241 } 6242 if (enable_athaa_fix != 0) { 6243 xmin = rh2; 6244 } 6245 if (!gfp.ATHonly) { 6246 var e = ratio.en.l[gsfb]; 6247 if (e > 0.0) { 6248 var x; 6249 x = en0 * ratio.thm.l[gsfb] * masking_lower / e; 6250 if (enable_athaa_fix != 0) 6251 x *= gfc.nsPsy.longfact[gsfb]; 6252 if (xmin < x) 6253 xmin = x; 6254 } 6255 } 6256 if (enable_athaa_fix != 0) 6257 pxmin[pxminPos++] = xmin; 6258 else 6259 pxmin[pxminPos++] = xmin * gfc.nsPsy.longfact[gsfb]; 6260 } 6261 /* end of long block loop */ 6262 6263 /* use this function to determine the highest non-zero coeff */ 6264 var max_nonzero = 575; 6265 if (cod_info.block_type != Encoder.SHORT_TYPE) { 6266 // NORM, START or STOP type, but not SHORT 6267 var k = 576; 6268 while (k-- != 0 && BitStream.EQ(xr[k], 0)) { 6269 max_nonzero = k; 6270 } 6271 } 6272 cod_info.max_nonzero_coeff = max_nonzero; 6273 6274 for (var sfb = cod_info.sfb_smin; gsfb < cod_info.psymax; sfb++, gsfb += 3) { 6275 var width, b; 6276 var tmpATH; 6277 if (gfp.VBR == VbrMode.vbr_rh || gfp.VBR == VbrMode.vbr_mtrh) 6278 tmpATH = athAdjust(ATH.adjust, ATH.s[sfb], ATH.floor); 6279 else 6280 tmpATH = ATH.adjust * ATH.s[sfb]; 6281 6282 width = cod_info.width[gsfb]; 6283 for (b = 0; b < 3; b++) { 6284 var en0 = 0.0, xmin; 6285 var rh1, rh2; 6286 var l = width >> 1; 6287 6288 rh1 = tmpATH / width; 6289 rh2 = DBL_EPSILON; 6290 do { 6291 var xa, xb; 6292 xa = xr[j] * xr[j]; 6293 en0 += xa; 6294 rh2 += (xa < rh1) ? xa : rh1; 6295 j++; 6296 xb = xr[j] * xr[j]; 6297 en0 += xb; 6298 rh2 += (xb < rh1) ? xb : rh1; 6299 j++; 6300 } while (--l > 0); 6301 if (en0 > tmpATH) 6302 ath_over++; 6303 if (sfb == Encoder.SBPSY_s) { 6304 var x = tmpATH * gfc.nsPsy.shortfact[sfb]; 6305 if (rh2 < x) { 6306 rh2 = x; 6307 } 6308 } 6309 if (enable_athaa_fix != 0) 6310 xmin = rh2; 6311 else 6312 xmin = tmpATH; 6313 6314 if (!gfp.ATHonly && !gfp.ATHshort) { 6315 var e = ratio.en.s[sfb][b]; 6316 if (e > 0.0) { 6317 var x; 6318 x = en0 * ratio.thm.s[sfb][b] * masking_lower / e; 6319 if (enable_athaa_fix != 0) 6320 x *= gfc.nsPsy.shortfact[sfb]; 6321 if (xmin < x) 6322 xmin = x; 6323 } 6324 } 6325 if (enable_athaa_fix != 0) 6326 pxmin[pxminPos++] = xmin; 6327 else 6328 pxmin[pxminPos++] = xmin * gfc.nsPsy.shortfact[sfb]; 6329 } 6330 /* b */ 6331 if (gfp.useTemporal) { 6332 if (pxmin[pxminPos - 3] > pxmin[pxminPos - 3 + 1]) 6333 pxmin[pxminPos - 3 + 1] += (pxmin[pxminPos - 3] - pxmin[pxminPos - 3 + 1]) 6334 * gfc.decay; 6335 if (pxmin[pxminPos - 3 + 1] > pxmin[pxminPos - 3 + 2]) 6336 pxmin[pxminPos - 3 + 2] += (pxmin[pxminPos - 3 + 1] - pxmin[pxminPos - 3 + 2]) 6337 * gfc.decay; 6338 } 6339 } 6340 /* end of short block sfb loop */ 6341 6342 return ath_over; 6343 }; 6344 6345 function StartLine(j) { 6346 this.s = j; 6347 } 6348 6349 this.calc_noise_core = function (cod_info, startline, l, step) { 6350 var noise = 0; 6351 var j = startline.s; 6352 var ix = cod_info.l3_enc; 6353 6354 if (j > cod_info.count1) { 6355 while ((l--) != 0) { 6356 var temp; 6357 temp = cod_info.xr[j]; 6358 j++; 6359 noise += temp * temp; 6360 temp = cod_info.xr[j]; 6361 j++; 6362 noise += temp * temp; 6363 } 6364 } else if (j > cod_info.big_values) { 6365 var ix01 = new_float(2); 6366 ix01[0] = 0; 6367 ix01[1] = step; 6368 while ((l--) != 0) { 6369 var temp; 6370 temp = Math.abs(cod_info.xr[j]) - ix01[ix[j]]; 6371 j++; 6372 noise += temp * temp; 6373 temp = Math.abs(cod_info.xr[j]) - ix01[ix[j]]; 6374 j++; 6375 noise += temp * temp; 6376 } 6377 } else { 6378 while ((l--) != 0) { 6379 var temp; 6380 temp = Math.abs(cod_info.xr[j]) - pow43[ix[j]] * step; 6381 j++; 6382 noise += temp * temp; 6383 temp = Math.abs(cod_info.xr[j]) - pow43[ix[j]] * step; 6384 j++; 6385 noise += temp * temp; 6386 } 6387 } 6388 6389 startline.s = j; 6390 return noise; 6391 } 6392 6393 /** 6394 * <PRE> 6395 * -oo dB => -1.00 6396 * - 6 dB => -0.97 6397 * - 3 dB => -0.80 6398 * - 2 dB => -0.64 6399 * - 1 dB => -0.38 6400 * 0 dB => 0.00 6401 * + 1 dB => +0.49 6402 * + 2 dB => +1.06 6403 * + 3 dB => +1.68 6404 * + 6 dB => +3.69 6405 * +10 dB => +6.45 6406 * </PRE> 6407 */ 6408 this.calc_noise = function (cod_info, l3_xmin, distort, res, prev_noise) { 6409 var distortPos = 0; 6410 var l3_xminPos = 0; 6411 var sfb, l, over = 0; 6412 var over_noise_db = 0; 6413 /* 0 dB relative to masking */ 6414 var tot_noise_db = 0; 6415 /* -200 dB relative to masking */ 6416 var max_noise = -20.0; 6417 var j = 0; 6418 var scalefac = cod_info.scalefac; 6419 var scalefacPos = 0; 6420 6421 res.over_SSD = 0; 6422 6423 for (sfb = 0; sfb < cod_info.psymax; sfb++) { 6424 var s = cod_info.global_gain 6425 - (((scalefac[scalefacPos++]) + (cod_info.preflag != 0 ? pretab[sfb] 6426 : 0)) << (cod_info.scalefac_scale + 1)) 6427 - cod_info.subblock_gain[cod_info.window[sfb]] * 8; 6428 var noise = 0.0; 6429 6430 if (prev_noise != null && (prev_noise.step[sfb] == s)) { 6431 6432 /* use previously computed values */ 6433 noise = prev_noise.noise[sfb]; 6434 j += cod_info.width[sfb]; 6435 distort[distortPos++] = noise / l3_xmin[l3_xminPos++]; 6436 6437 noise = prev_noise.noise_log[sfb]; 6438 6439 } else { 6440 var step = POW20(s); 6441 l = cod_info.width[sfb] >> 1; 6442 6443 if ((j + cod_info.width[sfb]) > cod_info.max_nonzero_coeff) { 6444 var usefullsize; 6445 usefullsize = cod_info.max_nonzero_coeff - j + 1; 6446 6447 if (usefullsize > 0) 6448 l = usefullsize >> 1; 6449 else 6450 l = 0; 6451 } 6452 6453 var sl = new StartLine(j); 6454 noise = this.calc_noise_core(cod_info, sl, l, step); 6455 j = sl.s; 6456 6457 if (prev_noise != null) { 6458 /* save noise values */ 6459 prev_noise.step[sfb] = s; 6460 prev_noise.noise[sfb] = noise; 6461 } 6462 6463 noise = distort[distortPos++] = noise / l3_xmin[l3_xminPos++]; 6464 6465 /* multiplying here is adding in dB, but can overflow */ 6466 noise = Util.FAST_LOG10(Math.max(noise, 1E-20)); 6467 6468 if (prev_noise != null) { 6469 /* save noise values */ 6470 prev_noise.noise_log[sfb] = noise; 6471 } 6472 } 6473 6474 if (prev_noise != null) { 6475 /* save noise values */ 6476 prev_noise.global_gain = cod_info.global_gain; 6477 } 6478 6479 tot_noise_db += noise; 6480 6481 if (noise > 0.0) { 6482 var tmp; 6483 6484 tmp = Math.max(0 | (noise * 10 + .5), 1); 6485 res.over_SSD += tmp * tmp; 6486 6487 over++; 6488 /* multiplying here is adding in dB -but can overflow */ 6489 /* over_noise *= noise; */ 6490 over_noise_db += noise; 6491 } 6492 max_noise = Math.max(max_noise, noise); 6493 6494 } 6495 6496 res.over_count = over; 6497 res.tot_noise = tot_noise_db; 6498 res.over_noise = over_noise_db; 6499 res.max_noise = max_noise; 6500 6501 return over; 6502 } 6503 6504 /** 6505 * updates plotting data 6506 * 6507 * Mark Taylor 2000-??-?? 6508 * 6509 * Robert Hegemann: moved noise/distortion calc into it 6510 */ 6511 this.set_pinfo = function (gfp, cod_info, ratio, gr, ch) { 6512 var gfc = gfp.internal_flags; 6513 var sfb, sfb2; 6514 var l; 6515 var en0, en1; 6516 var ifqstep = (cod_info.scalefac_scale == 0) ? .5 : 1.0; 6517 var scalefac = cod_info.scalefac; 6518 6519 var l3_xmin = new_float(L3Side.SFBMAX); 6520 var xfsf = new_float(L3Side.SFBMAX); 6521 var noise = new CalcNoiseResult(); 6522 6523 calc_xmin(gfp, ratio, cod_info, l3_xmin); 6524 calc_noise(cod_info, l3_xmin, xfsf, noise, null); 6525 6526 var j = 0; 6527 sfb2 = cod_info.sfb_lmax; 6528 if (cod_info.block_type != Encoder.SHORT_TYPE 6529 && 0 == cod_info.mixed_block_flag) 6530 sfb2 = 22; 6531 for (sfb = 0; sfb < sfb2; sfb++) { 6532 var start = gfc.scalefac_band.l[sfb]; 6533 var end = gfc.scalefac_band.l[sfb + 1]; 6534 var bw = end - start; 6535 for (en0 = 0.0; j < end; j++) 6536 en0 += cod_info.xr[j] * cod_info.xr[j]; 6537 en0 /= bw; 6538 /* convert to MDCT units */ 6539 /* scaling so it shows up on FFT plot */ 6540 en1 = 1e15; 6541 gfc.pinfo.en[gr][ch][sfb] = en1 * en0; 6542 gfc.pinfo.xfsf[gr][ch][sfb] = en1 * l3_xmin[sfb] * xfsf[sfb] / bw; 6543 6544 if (ratio.en.l[sfb] > 0 && !gfp.ATHonly) 6545 en0 = en0 / ratio.en.l[sfb]; 6546 else 6547 en0 = 0.0; 6548 6549 gfc.pinfo.thr[gr][ch][sfb] = en1 6550 * Math.max(en0 * ratio.thm.l[sfb], gfc.ATH.l[sfb]); 6551 6552 /* there is no scalefactor bands >= SBPSY_l */ 6553 gfc.pinfo.LAMEsfb[gr][ch][sfb] = 0; 6554 if (cod_info.preflag != 0 && sfb >= 11) 6555 gfc.pinfo.LAMEsfb[gr][ch][sfb] = -ifqstep * pretab[sfb]; 6556 6557 if (sfb < Encoder.SBPSY_l) { 6558 /* scfsi should be decoded by caller side */ 6559 gfc.pinfo.LAMEsfb[gr][ch][sfb] -= ifqstep * scalefac[sfb]; 6560 } 6561 } 6562 /* for sfb */ 6563 6564 if (cod_info.block_type == Encoder.SHORT_TYPE) { 6565 sfb2 = sfb; 6566 for (sfb = cod_info.sfb_smin; sfb < Encoder.SBMAX_s; sfb++) { 6567 var start = gfc.scalefac_band.s[sfb]; 6568 var end = gfc.scalefac_band.s[sfb + 1]; 6569 var bw = end - start; 6570 for (var i = 0; i < 3; i++) { 6571 for (en0 = 0.0, l = start; l < end; l++) { 6572 en0 += cod_info.xr[j] * cod_info.xr[j]; 6573 j++; 6574 } 6575 en0 = Math.max(en0 / bw, 1e-20); 6576 /* convert to MDCT units */ 6577 /* scaling so it shows up on FFT plot */ 6578 en1 = 1e15; 6579 6580 gfc.pinfo.en_s[gr][ch][3 * sfb + i] = en1 * en0; 6581 gfc.pinfo.xfsf_s[gr][ch][3 * sfb + i] = en1 * l3_xmin[sfb2] 6582 * xfsf[sfb2] / bw; 6583 if (ratio.en.s[sfb][i] > 0) 6584 en0 = en0 / ratio.en.s[sfb][i]; 6585 else 6586 en0 = 0.0; 6587 if (gfp.ATHonly || gfp.ATHshort) 6588 en0 = 0; 6589 6590 gfc.pinfo.thr_s[gr][ch][3 * sfb + i] = en1 6591 * Math.max(en0 * ratio.thm.s[sfb][i], 6592 gfc.ATH.s[sfb]); 6593 6594 /* there is no scalefactor bands >= SBPSY_s */ 6595 gfc.pinfo.LAMEsfb_s[gr][ch][3 * sfb + i] = -2.0 6596 * cod_info.subblock_gain[i]; 6597 if (sfb < Encoder.SBPSY_s) { 6598 gfc.pinfo.LAMEsfb_s[gr][ch][3 * sfb + i] -= ifqstep 6599 * scalefac[sfb2]; 6600 } 6601 sfb2++; 6602 } 6603 } 6604 } 6605 /* block type short */ 6606 gfc.pinfo.LAMEqss[gr][ch] = cod_info.global_gain; 6607 gfc.pinfo.LAMEmainbits[gr][ch] = cod_info.part2_3_length 6608 + cod_info.part2_length; 6609 gfc.pinfo.LAMEsfbits[gr][ch] = cod_info.part2_length; 6610 6611 gfc.pinfo.over[gr][ch] = noise.over_count; 6612 gfc.pinfo.max_noise[gr][ch] = noise.max_noise * 10.0; 6613 gfc.pinfo.over_noise[gr][ch] = noise.over_noise * 10.0; 6614 gfc.pinfo.tot_noise[gr][ch] = noise.tot_noise * 10.0; 6615 gfc.pinfo.over_SSD[gr][ch] = noise.over_SSD; 6616 } 6617 6618 /** 6619 * updates plotting data for a whole frame 6620 * 6621 * Robert Hegemann 2000-10-21 6622 */ 6623 function set_frame_pinfo(gfp, ratio) { 6624 var gfc = gfp.internal_flags; 6625 6626 gfc.masking_lower = 1.0; 6627 6628 /* 6629 * for every granule and channel patch l3_enc and set info 6630 */ 6631 for (var gr = 0; gr < gfc.mode_gr; gr++) { 6632 for (var ch = 0; ch < gfc.channels_out; ch++) { 6633 var cod_info = gfc.l3_side.tt[gr][ch]; 6634 var scalefac_sav = new_int(L3Side.SFBMAX); 6635 System.arraycopy(cod_info.scalefac, 0, scalefac_sav, 0, 6636 scalefac_sav.length); 6637 6638 /* 6639 * reconstruct the scalefactors in case SCFSI was used 6640 */ 6641 if (gr == 1) { 6642 var sfb; 6643 for (sfb = 0; sfb < cod_info.sfb_lmax; sfb++) { 6644 if (cod_info.scalefac[sfb] < 0) /* scfsi */ 6645 cod_info.scalefac[sfb] = gfc.l3_side.tt[0][ch].scalefac[sfb]; 6646 } 6647 } 6648 6649 set_pinfo(gfp, cod_info, ratio[gr][ch], gr, ch); 6650 System.arraycopy(scalefac_sav, 0, cod_info.scalefac, 0, 6651 scalefac_sav.length); 6652 } 6653 /* for ch */ 6654 } 6655 /* for gr */ 6656 } 6657 6658} 6659 6660 6661function CalcNoiseData() { 6662 this.global_gain = 0; 6663 this.sfb_count1 = 0; 6664 this.step = new_int(39); 6665 this.noise = new_float(39); 6666 this.noise_log = new_float(39); 6667} 6668 6669//package mp3; 6670 6671 6672function GrInfo() { 6673 //float xr[] = new float[576]; 6674 this.xr = new_float(576); 6675 //int l3_enc[] = new int[576]; 6676 this.l3_enc = new_int(576); 6677 //int scalefac[] = new int[L3Side.SFBMAX]; 6678 this.scalefac = new_int(L3Side.SFBMAX); 6679 this.xrpow_max = 0.; 6680 6681 this.part2_3_length = 0; 6682 this.big_values = 0; 6683 this.count1 = 0; 6684 this.global_gain = 0; 6685 this.scalefac_compress = 0; 6686 this.block_type = 0; 6687 this.mixed_block_flag = 0; 6688 this.table_select = new_int(3); 6689 this.subblock_gain = new_int(3 + 1); 6690 this.region0_count = 0; 6691 this.region1_count = 0; 6692 this.preflag = 0; 6693 this.scalefac_scale = 0; 6694 this.count1table_select = 0; 6695 6696 this.part2_length = 0; 6697 this.sfb_lmax = 0; 6698 this.sfb_smin = 0; 6699 this.psy_lmax = 0; 6700 this.sfbmax = 0; 6701 this.psymax = 0; 6702 this.sfbdivide = 0; 6703 this.width = new_int(L3Side.SFBMAX); 6704 this.window = new_int(L3Side.SFBMAX); 6705 this.count1bits = 0; 6706 /** 6707 * added for LSF 6708 */ 6709 this.sfb_partition_table = null; 6710 this.slen = new_int(4); 6711 6712 this.max_nonzero_coeff = 0; 6713 6714 var self = this; 6715 function clone_int(array) { 6716 return new Int32Array(array); 6717 } 6718 function clone_float(array) { 6719 return new Float32Array(array); 6720 } 6721 this.assign = function (other) { 6722 self.xr = clone_float(other.xr); //.slice(0); //clone(); 6723 self.l3_enc = clone_int(other.l3_enc); //.slice(0); //clone(); 6724 self.scalefac = clone_int(other.scalefac);//.slice(0); //clone(); 6725 self.xrpow_max = other.xrpow_max; 6726 6727 self.part2_3_length = other.part2_3_length; 6728 self.big_values = other.big_values; 6729 self.count1 = other.count1; 6730 self.global_gain = other.global_gain; 6731 self.scalefac_compress = other.scalefac_compress; 6732 self.block_type = other.block_type; 6733 self.mixed_block_flag = other.mixed_block_flag; 6734 self.table_select = clone_int(other.table_select);//.slice(0); //clone(); 6735 self.subblock_gain = clone_int(other.subblock_gain); //.slice(0); //.clone(); 6736 self.region0_count = other.region0_count; 6737 self.region1_count = other.region1_count; 6738 self.preflag = other.preflag; 6739 self.scalefac_scale = other.scalefac_scale; 6740 self.count1table_select = other.count1table_select; 6741 6742 self.part2_length = other.part2_length; 6743 self.sfb_lmax = other.sfb_lmax; 6744 self.sfb_smin = other.sfb_smin; 6745 self.psy_lmax = other.psy_lmax; 6746 self.sfbmax = other.sfbmax; 6747 self.psymax = other.psymax; 6748 self.sfbdivide = other.sfbdivide; 6749 self.width = clone_int(other.width); //.slice(0); //.clone(); 6750 self.window = clone_int(other.window); //.slice(0); //.clone(); 6751 self.count1bits = other.count1bits; 6752 6753 self.sfb_partition_table = other.sfb_partition_table.slice(0); //.clone(); 6754 self.slen = clone_int(other.slen); //.slice(0); //.clone(); 6755 self.max_nonzero_coeff = other.max_nonzero_coeff; 6756 } 6757} 6758 6759 6760var L3Side = {}; 6761 6762 6763 /** 6764 * max scalefactor band, max(SBMAX_l, SBMAX_s*3, (SBMAX_s-3)*3+8) 6765 */ 6766L3Side.SFBMAX = (Encoder.SBMAX_s * 3); 6767 6768/* 6769 * MP3 quantization 6770 * 6771 * Copyright (c) 1999-2000 Mark Taylor 6772 * Copyright (c) 1999-2003 Takehiro Tominaga 6773 * Copyright (c) 2000-2007 Robert Hegemann 6774 * Copyright (c) 2001-2005 Gabriel Bouvigne 6775 * 6776 * This library is free software; you can redistribute it and/or 6777 * modify it under the terms of the GNU Lesser General Public 6778 * License as published by the Free Software Foundation; either 6779 * version 2 of the License, or (at your option) any later version. 6780 * 6781 * This library is distributed in the hope that it will be useful, 6782 * but WITHOUT ANY WARRANTY; without even the implied warranty of 6783 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 6784 * Library General Public License for more details. 6785 * 6786 * You should have received a copy of the GNU Lesser General Public 6787 * License along with this library; if not, write to the 6788 * Free Software Foundation, Inc., 59 Temple Place - Suite 330, 6789 * Boston, MA 02111-1307, USA. 6790 */ 6791 6792/* $Id: Quantize.java,v 1.24 2011/05/24 20:48:06 kenchis Exp $ */ 6793 6794//package mp3; 6795 6796//import java.util.Arrays; 6797 6798 6799function Quantize() { 6800 var bs; 6801 this.rv = null; 6802 var rv; 6803 this.qupvt = null; 6804 var qupvt; 6805 6806 var vbr = new VBRQuantize(); 6807 var tk; 6808 6809 this.setModules = function (_bs, _rv, _qupvt, _tk) { 6810 bs = _bs; 6811 rv = _rv; 6812 this.rv = _rv; 6813 qupvt = _qupvt; 6814 this.qupvt = _qupvt; 6815 tk = _tk; 6816 vbr.setModules(qupvt, tk); 6817 } 6818 6819 /** 6820 * convert from L/R <. Mid/Side 6821 */ 6822 this.ms_convert = function (l3_side, gr) { 6823 for (var i = 0; i < 576; ++i) { 6824 var l = l3_side.tt[gr][0].xr[i]; 6825 var r = l3_side.tt[gr][1].xr[i]; 6826 l3_side.tt[gr][0].xr[i] = (l + r) * (Util.SQRT2 * 0.5); 6827 l3_side.tt[gr][1].xr[i] = (l - r) * (Util.SQRT2 * 0.5); 6828 } 6829 }; 6830 6831 /** 6832 * mt 6/99 6833 * 6834 * initializes cod_info, scalefac and xrpow 6835 * 6836 * returns 0 if all energies in xr are zero, else 1 6837 */ 6838 function init_xrpow_core(cod_info, xrpow, upper, sum) { 6839 sum = 0; 6840 for (var i = 0; i <= upper; ++i) { 6841 var tmp = Math.abs(cod_info.xr[i]); 6842 sum += tmp; 6843 xrpow[i] = Math.sqrt(tmp * Math.sqrt(tmp)); 6844 6845 if (xrpow[i] > cod_info.xrpow_max) 6846 cod_info.xrpow_max = xrpow[i]; 6847 } 6848 return sum; 6849 } 6850 6851 this.init_xrpow = function (gfc, cod_info, xrpow) { 6852 var sum = 0; 6853 var upper = 0 | cod_info.max_nonzero_coeff; 6854 6855 cod_info.xrpow_max = 0; 6856 6857 /* 6858 * check if there is some energy we have to quantize and calculate xrpow 6859 * matching our fresh scalefactors 6860 */ 6861 6862 Arrays.fill(xrpow, upper, 576, 0); 6863 6864 sum = init_xrpow_core(cod_info, xrpow, upper, sum); 6865 6866 /* 6867 * return 1 if we have something to quantize, else 0 6868 */ 6869 if (sum > 1E-20) { 6870 var j = 0; 6871 if ((gfc.substep_shaping & 2) != 0) 6872 j = 1; 6873 6874 for (var i = 0; i < cod_info.psymax; i++) 6875 gfc.pseudohalf[i] = j; 6876 6877 return true; 6878 } 6879 6880 Arrays.fill(cod_info.l3_enc, 0, 576, 0); 6881 return false; 6882 } 6883 6884 /** 6885 * Gabriel Bouvigne feb/apr 2003<BR> 6886 * Analog silence detection in partitionned sfb21 or sfb12 for short blocks 6887 * 6888 * From top to bottom of sfb, changes to 0 coeffs which are below ath. It 6889 * stops on the first coeff higher than ath. 6890 */ 6891 function psfb21_analogsilence(gfc, cod_info) { 6892 var ath = gfc.ATH; 6893 var xr = cod_info.xr; 6894 6895 if (cod_info.block_type != Encoder.SHORT_TYPE) { 6896 /* NORM, START or STOP type, but not SHORT blocks */ 6897 var stop = false; 6898 for (var gsfb = Encoder.PSFB21 - 1; gsfb >= 0 && !stop; gsfb--) { 6899 var start = gfc.scalefac_band.psfb21[gsfb]; 6900 var end = gfc.scalefac_band.psfb21[gsfb + 1]; 6901 var ath21 = qupvt.athAdjust(ath.adjust, ath.psfb21[gsfb], 6902 ath.floor); 6903 6904 if (gfc.nsPsy.longfact[21] > 1e-12) 6905 ath21 *= gfc.nsPsy.longfact[21]; 6906 6907 for (var j = end - 1; j >= start; j--) { 6908 if (Math.abs(xr[j]) < ath21) 6909 xr[j] = 0; 6910 else { 6911 stop = true; 6912 break; 6913 } 6914 } 6915 } 6916 } else { 6917 /* note: short blocks coeffs are reordered */ 6918 for (var block = 0; block < 3; block++) { 6919 var stop = false; 6920 for (var gsfb = Encoder.PSFB12 - 1; gsfb >= 0 && !stop; gsfb--) { 6921 var start = gfc.scalefac_band.s[12] 6922 * 3 6923 + (gfc.scalefac_band.s[13] - gfc.scalefac_band.s[12]) 6924 * block 6925 + (gfc.scalefac_band.psfb12[gsfb] - gfc.scalefac_band.psfb12[0]); 6926 var end = start 6927 + (gfc.scalefac_band.psfb12[gsfb + 1] - gfc.scalefac_band.psfb12[gsfb]); 6928 var ath12 = qupvt.athAdjust(ath.adjust, ath.psfb12[gsfb], 6929 ath.floor); 6930 6931 if (gfc.nsPsy.shortfact[12] > 1e-12) 6932 ath12 *= gfc.nsPsy.shortfact[12]; 6933 6934 for (var j = end - 1; j >= start; j--) { 6935 if (Math.abs(xr[j]) < ath12) 6936 xr[j] = 0; 6937 else { 6938 stop = true; 6939 break; 6940 } 6941 } 6942 } 6943 } 6944 } 6945 6946 } 6947 6948 this.init_outer_loop = function (gfc, cod_info) { 6949 /* 6950 * initialize fresh cod_info 6951 */ 6952 cod_info.part2_3_length = 0; 6953 cod_info.big_values = 0; 6954 cod_info.count1 = 0; 6955 cod_info.global_gain = 210; 6956 cod_info.scalefac_compress = 0; 6957 /* mixed_block_flag, block_type was set in psymodel.c */ 6958 cod_info.table_select[0] = 0; 6959 cod_info.table_select[1] = 0; 6960 cod_info.table_select[2] = 0; 6961 cod_info.subblock_gain[0] = 0; 6962 cod_info.subblock_gain[1] = 0; 6963 cod_info.subblock_gain[2] = 0; 6964 cod_info.subblock_gain[3] = 0; 6965 /* this one is always 0 */ 6966 cod_info.region0_count = 0; 6967 cod_info.region1_count = 0; 6968 cod_info.preflag = 0; 6969 cod_info.scalefac_scale = 0; 6970 cod_info.count1table_select = 0; 6971 cod_info.part2_length = 0; 6972 cod_info.sfb_lmax = Encoder.SBPSY_l; 6973 cod_info.sfb_smin = Encoder.SBPSY_s; 6974 cod_info.psy_lmax = gfc.sfb21_extra ? Encoder.SBMAX_l : Encoder.SBPSY_l; 6975 cod_info.psymax = cod_info.psy_lmax; 6976 cod_info.sfbmax = cod_info.sfb_lmax; 6977 cod_info.sfbdivide = 11; 6978 for (var sfb = 0; sfb < Encoder.SBMAX_l; sfb++) { 6979 cod_info.width[sfb] = gfc.scalefac_band.l[sfb + 1] 6980 - gfc.scalefac_band.l[sfb]; 6981 /* which is always 0. */ 6982 cod_info.window[sfb] = 3; 6983 } 6984 if (cod_info.block_type == Encoder.SHORT_TYPE) { 6985 var ixwork = new_float(576); 6986 6987 cod_info.sfb_smin = 0; 6988 cod_info.sfb_lmax = 0; 6989 if (cod_info.mixed_block_flag != 0) { 6990 /* 6991 * MPEG-1: sfbs 0-7 long block, 3-12 short blocks MPEG-2(.5): 6992 * sfbs 0-5 long block, 3-12 short blocks 6993 */ 6994 cod_info.sfb_smin = 3; 6995 cod_info.sfb_lmax = gfc.mode_gr * 2 + 4; 6996 } 6997 cod_info.psymax = cod_info.sfb_lmax 6998 + 3 6999 * ((gfc.sfb21_extra ? Encoder.SBMAX_s : Encoder.SBPSY_s) - cod_info.sfb_smin); 7000 cod_info.sfbmax = cod_info.sfb_lmax + 3 7001 * (Encoder.SBPSY_s - cod_info.sfb_smin); 7002 cod_info.sfbdivide = cod_info.sfbmax - 18; 7003 cod_info.psy_lmax = cod_info.sfb_lmax; 7004 /* re-order the short blocks, for more efficient encoding below */ 7005 /* By Takehiro TOMINAGA */ 7006 /* 7007 * Within each scalefactor band, data is given for successive time 7008 * windows, beginning with window 0 and ending with window 2. Within 7009 * each window, the quantized values are then arranged in order of 7010 * increasing frequency... 7011 */ 7012 var ix = gfc.scalefac_band.l[cod_info.sfb_lmax]; 7013 System.arraycopy(cod_info.xr, 0, ixwork, 0, 576); 7014 for (var sfb = cod_info.sfb_smin; sfb < Encoder.SBMAX_s; sfb++) { 7015 var start = gfc.scalefac_band.s[sfb]; 7016 var end = gfc.scalefac_band.s[sfb + 1]; 7017 for (var window = 0; window < 3; window++) { 7018 for (var l = start; l < end; l++) { 7019 cod_info.xr[ix++] = ixwork[3 * l + window]; 7020 } 7021 } 7022 } 7023 7024 var j = cod_info.sfb_lmax; 7025 for (var sfb = cod_info.sfb_smin; sfb < Encoder.SBMAX_s; sfb++) { 7026 cod_info.width[j] = cod_info.width[j + 1] = cod_info.width[j + 2] = gfc.scalefac_band.s[sfb + 1] 7027 - gfc.scalefac_band.s[sfb]; 7028 cod_info.window[j] = 0; 7029 cod_info.window[j + 1] = 1; 7030 cod_info.window[j + 2] = 2; 7031 j += 3; 7032 } 7033 } 7034 7035 cod_info.count1bits = 0; 7036 cod_info.sfb_partition_table = qupvt.nr_of_sfb_block[0][0]; 7037 cod_info.slen[0] = 0; 7038 cod_info.slen[1] = 0; 7039 cod_info.slen[2] = 0; 7040 cod_info.slen[3] = 0; 7041 7042 cod_info.max_nonzero_coeff = 575; 7043 7044 /* 7045 * fresh scalefactors are all zero 7046 */ 7047 Arrays.fill(cod_info.scalefac, 0); 7048 7049 psfb21_analogsilence(gfc, cod_info); 7050 }; 7051 7052 function BinSearchDirection(ordinal) { 7053 this.ordinal = ordinal; 7054 } 7055 7056 BinSearchDirection.BINSEARCH_NONE = new BinSearchDirection(0); 7057 BinSearchDirection.BINSEARCH_UP = new BinSearchDirection(1); 7058 BinSearchDirection.BINSEARCH_DOWN = new BinSearchDirection(2); 7059 7060 /** 7061 * author/date?? 7062 * 7063 * binary step size search used by outer_loop to get a quantizer step size 7064 * to start with 7065 */ 7066 function bin_search_StepSize(gfc, cod_info, desired_rate, ch, xrpow) { 7067 var nBits; 7068 var CurrentStep = gfc.CurrentStep[ch]; 7069 var flagGoneOver = false; 7070 var start = gfc.OldValue[ch]; 7071 var Direction = BinSearchDirection.BINSEARCH_NONE; 7072 cod_info.global_gain = start; 7073 desired_rate -= cod_info.part2_length; 7074 7075 for (; ;) { 7076 var step; 7077 nBits = tk.count_bits(gfc, xrpow, cod_info, null); 7078 7079 if (CurrentStep == 1 || nBits == desired_rate) 7080 break; 7081 /* nothing to adjust anymore */ 7082 7083 if (nBits > desired_rate) { 7084 /* increase Quantize_StepSize */ 7085 if (Direction == BinSearchDirection.BINSEARCH_DOWN) 7086 flagGoneOver = true; 7087 7088 if (flagGoneOver) 7089 CurrentStep /= 2; 7090 Direction = BinSearchDirection.BINSEARCH_UP; 7091 step = CurrentStep; 7092 } else { 7093 /* decrease Quantize_StepSize */ 7094 if (Direction == BinSearchDirection.BINSEARCH_UP) 7095 flagGoneOver = true; 7096 7097 if (flagGoneOver) 7098 CurrentStep /= 2; 7099 Direction = BinSearchDirection.BINSEARCH_DOWN; 7100 step = -CurrentStep; 7101 } 7102 cod_info.global_gain += step; 7103 if (cod_info.global_gain < 0) { 7104 cod_info.global_gain = 0; 7105 flagGoneOver = true; 7106 } 7107 if (cod_info.global_gain > 255) { 7108 cod_info.global_gain = 255; 7109 flagGoneOver = true; 7110 } 7111 } 7112 7113 7114 while (nBits > desired_rate && cod_info.global_gain < 255) { 7115 cod_info.global_gain++; 7116 nBits = tk.count_bits(gfc, xrpow, cod_info, null); 7117 } 7118 gfc.CurrentStep[ch] = (start - cod_info.global_gain >= 4) ? 4 : 2; 7119 gfc.OldValue[ch] = cod_info.global_gain; 7120 cod_info.part2_3_length = nBits; 7121 return nBits; 7122 } 7123 7124 this.trancate_smallspectrums = function (gfc, gi, l3_xmin, work) { 7125 var distort = new_float(L3Side.SFBMAX); 7126 7127 if ((0 == (gfc.substep_shaping & 4) && gi.block_type == Encoder.SHORT_TYPE) 7128 || (gfc.substep_shaping & 0x80) != 0) 7129 return; 7130 qupvt.calc_noise(gi, l3_xmin, distort, new CalcNoiseResult(), null); 7131 for (var j = 0; j < 576; j++) { 7132 var xr = 0.0; 7133 if (gi.l3_enc[j] != 0) 7134 xr = Math.abs(gi.xr[j]); 7135 work[j] = xr; 7136 } 7137 7138 var j = 0; 7139 var sfb = 8; 7140 if (gi.block_type == Encoder.SHORT_TYPE) 7141 sfb = 6; 7142 do { 7143 var allowedNoise, trancateThreshold; 7144 var nsame, start; 7145 7146 var width = gi.width[sfb]; 7147 j += width; 7148 if (distort[sfb] >= 1.0) 7149 continue; 7150 7151 Arrays.sort(work, j - width, width); 7152 if (BitStream.EQ(work[j - 1], 0.0)) 7153 continue; 7154 /* all zero sfb */ 7155 7156 allowedNoise = (1.0 - distort[sfb]) * l3_xmin[sfb]; 7157 trancateThreshold = 0.0; 7158 start = 0; 7159 do { 7160 var noise; 7161 for (nsame = 1; start + nsame < width; nsame++) 7162 if (BitStream.NEQ(work[start + j - width], work[start + j 7163 + nsame - width])) 7164 break; 7165 7166 noise = work[start + j - width] * work[start + j - width] 7167 * nsame; 7168 if (allowedNoise < noise) { 7169 if (start != 0) 7170 trancateThreshold = work[start + j - width - 1]; 7171 break; 7172 } 7173 allowedNoise -= noise; 7174 start += nsame; 7175 } while (start < width); 7176 if (BitStream.EQ(trancateThreshold, 0.0)) 7177 continue; 7178 7179 do { 7180 if (Math.abs(gi.xr[j - width]) <= trancateThreshold) 7181 gi.l3_enc[j - width] = 0; 7182 } while (--width > 0); 7183 } while (++sfb < gi.psymax); 7184 7185 gi.part2_3_length = tk.noquant_count_bits(gfc, gi, null); 7186 }; 7187 7188 /** 7189 * author/date?? 7190 * 7191 * Function: Returns zero if there is a scalefac which has not been 7192 * amplified. Otherwise it returns one. 7193 */ 7194 function loop_break(cod_info) { 7195 for (var sfb = 0; sfb < cod_info.sfbmax; sfb++) 7196 if (cod_info.scalefac[sfb] 7197 + cod_info.subblock_gain[cod_info.window[sfb]] == 0) 7198 return false; 7199 7200 return true; 7201 } 7202 7203 /* mt 5/99: Function: Improved calc_noise for a single channel */ 7204 7205 function penalties(noise) { 7206 return Util.FAST_LOG10((0.368 + 0.632 * noise * noise * noise)); 7207 } 7208 7209 /** 7210 * author/date?? 7211 * 7212 * several different codes to decide which quantization is better 7213 */ 7214 function get_klemm_noise(distort, gi) { 7215 var klemm_noise = 1E-37; 7216 for (var sfb = 0; sfb < gi.psymax; sfb++) 7217 klemm_noise += penalties(distort[sfb]); 7218 7219 return Math.max(1e-20, klemm_noise); 7220 } 7221 7222 function quant_compare(quant_comp, best, calc, gi, distort) { 7223 /** 7224 * noise is given in decibels (dB) relative to masking thesholds.<BR> 7225 * 7226 * over_noise: ??? (the previous comment is fully wrong)<BR> 7227 * tot_noise: ??? (the previous comment is fully wrong)<BR> 7228 * max_noise: max quantization noise 7229 */ 7230 var better; 7231 7232 switch (quant_comp) { 7233 default: 7234 case 9: 7235 { 7236 if (best.over_count > 0) { 7237 /* there are distorted sfb */ 7238 better = calc.over_SSD <= best.over_SSD; 7239 if (calc.over_SSD == best.over_SSD) 7240 better = calc.bits < best.bits; 7241 } else { 7242 /* no distorted sfb */ 7243 better = ((calc.max_noise < 0) && ((calc.max_noise * 10 + calc.bits) <= (best.max_noise * 10 + best.bits))); 7244 } 7245 break; 7246 } 7247 7248 case 0: 7249 better = calc.over_count < best.over_count 7250 || (calc.over_count == best.over_count && calc.over_noise < best.over_noise) 7251 || (calc.over_count == best.over_count 7252 && BitStream.EQ(calc.over_noise, best.over_noise) && calc.tot_noise < best.tot_noise); 7253 break; 7254 7255 case 8: 7256 calc.max_noise = get_klemm_noise(distort, gi); 7257 //$FALL-THROUGH$ 7258 case 1: 7259 better = calc.max_noise < best.max_noise; 7260 break; 7261 case 2: 7262 better = calc.tot_noise < best.tot_noise; 7263 break; 7264 case 3: 7265 better = (calc.tot_noise < best.tot_noise) 7266 && (calc.max_noise < best.max_noise); 7267 break; 7268 case 4: 7269 better = (calc.max_noise <= 0.0 && best.max_noise > 0.2) 7270 || (calc.max_noise <= 0.0 && best.max_noise < 0.0 7271 && best.max_noise > calc.max_noise - 0.2 && calc.tot_noise < best.tot_noise) 7272 || (calc.max_noise <= 0.0 && best.max_noise > 0.0 7273 && best.max_noise > calc.max_noise - 0.2 && calc.tot_noise < best.tot_noise 7274 + best.over_noise) 7275 || (calc.max_noise > 0.0 && best.max_noise > -0.05 7276 && best.max_noise > calc.max_noise - 0.1 && calc.tot_noise 7277 + calc.over_noise < best.tot_noise 7278 + best.over_noise) 7279 || (calc.max_noise > 0.0 && best.max_noise > -0.1 7280 && best.max_noise > calc.max_noise - 0.15 && calc.tot_noise 7281 + calc.over_noise + calc.over_noise < best.tot_noise 7282 + best.over_noise + best.over_noise); 7283 break; 7284 case 5: 7285 better = calc.over_noise < best.over_noise 7286 || (BitStream.EQ(calc.over_noise, best.over_noise) && calc.tot_noise < best.tot_noise); 7287 break; 7288 case 6: 7289 better = calc.over_noise < best.over_noise 7290 || (BitStream.EQ(calc.over_noise, best.over_noise) && (calc.max_noise < best.max_noise || (BitStream 7291 .EQ(calc.max_noise, best.max_noise) && calc.tot_noise <= best.tot_noise))); 7292 break; 7293 case 7: 7294 better = calc.over_count < best.over_count 7295 || calc.over_noise < best.over_noise; 7296 break; 7297 } 7298 7299 if (best.over_count == 0) { 7300 /* 7301 * If no distorted bands, only use this quantization if it is 7302 * better, and if it uses less bits. Unfortunately, part2_3_length 7303 * is sometimes a poor estimator of the final size at low bitrates. 7304 */ 7305 better = better && calc.bits < best.bits; 7306 } 7307 7308 return better; 7309 } 7310 7311 /** 7312 * author/date?? 7313 * 7314 * <PRE> 7315 * Amplify the scalefactor bands that violate the masking threshold. 7316 * See ISO 11172-3 Section C.1.5.4.3.5 7317 * 7318 * distort[] = noise/masking 7319 * distort[] > 1 ==> noise is not masked 7320 * distort[] < 1 ==> noise is masked 7321 * max_dist = maximum value of distort[] 7322 * 7323 * Three algorithms: 7324 * noise_shaping_amp 7325 * 0 Amplify all bands with distort[]>1. 7326 * 7327 * 1 Amplify all bands with distort[] >= max_dist^(.5); 7328 * ( 50% in the db scale) 7329 * 7330 * 2 Amplify first band with distort[] >= max_dist; 7331 * 7332 * 7333 * For algorithms 0 and 1, if max_dist < 1, then amplify all bands 7334 * with distort[] >= .95*max_dist. This is to make sure we always 7335 * amplify at least one band. 7336 * </PRE> 7337 */ 7338 function amp_scalefac_bands(gfp, cod_info, distort, xrpow, bRefine) { 7339 var gfc = gfp.internal_flags; 7340 var ifqstep34; 7341 7342 if (cod_info.scalefac_scale == 0) { 7343 ifqstep34 = 1.29683955465100964055; 7344 /* 2**(.75*.5) */ 7345 } else { 7346 ifqstep34 = 1.68179283050742922612; 7347 /* 2**(.75*1) */ 7348 } 7349 7350 /* compute maximum value of distort[] */ 7351 var trigger = 0; 7352 for (var sfb = 0; sfb < cod_info.sfbmax; sfb++) { 7353 if (trigger < distort[sfb]) 7354 trigger = distort[sfb]; 7355 } 7356 7357 var noise_shaping_amp = gfc.noise_shaping_amp; 7358 if (noise_shaping_amp == 3) { 7359 if (bRefine) 7360 noise_shaping_amp = 2; 7361 else 7362 noise_shaping_amp = 1; 7363 } 7364 switch (noise_shaping_amp) { 7365 case 2: 7366 /* amplify exactly 1 band */ 7367 break; 7368 7369 case 1: 7370 /* amplify bands within 50% of max (on db scale) */ 7371 if (trigger > 1.0) 7372 trigger = Math.pow(trigger, .5); 7373 else 7374 trigger *= .95; 7375 break; 7376 7377 case 0: 7378 default: 7379 /* ISO algorithm. amplify all bands with distort>1 */ 7380 if (trigger > 1.0) 7381 trigger = 1.0; 7382 else 7383 trigger *= .95; 7384 break; 7385 } 7386 7387 var j = 0; 7388 for (var sfb = 0; sfb < cod_info.sfbmax; sfb++) { 7389 var width = cod_info.width[sfb]; 7390 var l; 7391 j += width; 7392 if (distort[sfb] < trigger) 7393 continue; 7394 7395 if ((gfc.substep_shaping & 2) != 0) { 7396 gfc.pseudohalf[sfb] = (0 == gfc.pseudohalf[sfb]) ? 1 : 0; 7397 if (0 == gfc.pseudohalf[sfb] && gfc.noise_shaping_amp == 2) 7398 return; 7399 } 7400 cod_info.scalefac[sfb]++; 7401 for (l = -width; l < 0; l++) { 7402 xrpow[j + l] *= ifqstep34; 7403 if (xrpow[j + l] > cod_info.xrpow_max) 7404 cod_info.xrpow_max = xrpow[j + l]; 7405 } 7406 7407 if (gfc.noise_shaping_amp == 2) 7408 return; 7409 } 7410 } 7411 7412 /** 7413 * Takehiro Tominaga 2000-xx-xx 7414 * 7415 * turns on scalefac scale and adjusts scalefactors 7416 */ 7417 function inc_scalefac_scale(cod_info, xrpow) { 7418 var ifqstep34 = 1.29683955465100964055; 7419 7420 var j = 0; 7421 for (var sfb = 0; sfb < cod_info.sfbmax; sfb++) { 7422 var width = cod_info.width[sfb]; 7423 var s = cod_info.scalefac[sfb]; 7424 if (cod_info.preflag != 0) 7425 s += qupvt.pretab[sfb]; 7426 j += width; 7427 if ((s & 1) != 0) { 7428 s++; 7429 for (var l = -width; l < 0; l++) { 7430 xrpow[j + l] *= ifqstep34; 7431 if (xrpow[j + l] > cod_info.xrpow_max) 7432 cod_info.xrpow_max = xrpow[j + l]; 7433 } 7434 } 7435 cod_info.scalefac[sfb] = s >> 1; 7436 } 7437 cod_info.preflag = 0; 7438 cod_info.scalefac_scale = 1; 7439 } 7440 7441 /** 7442 * Takehiro Tominaga 2000-xx-xx 7443 * 7444 * increases the subblock gain and adjusts scalefactors 7445 */ 7446 function inc_subblock_gain(gfc, cod_info, xrpow) { 7447 var sfb; 7448 var scalefac = cod_info.scalefac; 7449 7450 /* subbloc_gain can't do anything in the long block region */ 7451 for (sfb = 0; sfb < cod_info.sfb_lmax; sfb++) { 7452 if (scalefac[sfb] >= 16) 7453 return true; 7454 } 7455 7456 for (var window = 0; window < 3; window++) { 7457 var s1 = 0; 7458 var s2 = 0; 7459 7460 for (sfb = cod_info.sfb_lmax + window; sfb < cod_info.sfbdivide; sfb += 3) { 7461 if (s1 < scalefac[sfb]) 7462 s1 = scalefac[sfb]; 7463 } 7464 for (; sfb < cod_info.sfbmax; sfb += 3) { 7465 if (s2 < scalefac[sfb]) 7466 s2 = scalefac[sfb]; 7467 } 7468 7469 if (s1 < 16 && s2 < 8) 7470 continue; 7471 7472 if (cod_info.subblock_gain[window] >= 7) 7473 return true; 7474 7475 /* 7476 * even though there is no scalefactor for sfb12 subblock gain 7477 * affects upper frequencies too, that's why we have to go up to 7478 * SBMAX_s 7479 */ 7480 cod_info.subblock_gain[window]++; 7481 var j = gfc.scalefac_band.l[cod_info.sfb_lmax]; 7482 for (sfb = cod_info.sfb_lmax + window; sfb < cod_info.sfbmax; sfb += 3) { 7483 var amp; 7484 var width = cod_info.width[sfb]; 7485 var s = scalefac[sfb]; 7486 s = s - (4 >> cod_info.scalefac_scale); 7487 if (s >= 0) { 7488 scalefac[sfb] = s; 7489 j += width * 3; 7490 continue; 7491 } 7492 7493 scalefac[sfb] = 0; 7494 { 7495 var gain = 210 + (s << (cod_info.scalefac_scale + 1)); 7496 amp = qupvt.IPOW20(gain); 7497 } 7498 j += width * (window + 1); 7499 for (var l = -width; l < 0; l++) { 7500 xrpow[j + l] *= amp; 7501 if (xrpow[j + l] > cod_info.xrpow_max) 7502 cod_info.xrpow_max = xrpow[j + l]; 7503 } 7504 j += width * (3 - window - 1); 7505 } 7506 7507 { 7508 var amp = qupvt.IPOW20(202); 7509 j += cod_info.width[sfb] * (window + 1); 7510 for (var l = -cod_info.width[sfb]; l < 0; l++) { 7511 xrpow[j + l] *= amp; 7512 if (xrpow[j + l] > cod_info.xrpow_max) 7513 cod_info.xrpow_max = xrpow[j + l]; 7514 } 7515 } 7516 } 7517 return false; 7518 } 7519 7520 /** 7521 * <PRE> 7522 * Takehiro Tominaga /date?? 7523 * Robert Hegemann 2000-09-06: made a function of it 7524 * 7525 * amplifies scalefactor bands, 7526 * - if all are already amplified returns 0 7527 * - if some bands are amplified too much: 7528 * * try to increase scalefac_scale 7529 * * if already scalefac_scale was set 7530 * try on short blocks to increase subblock gain 7531 * </PRE> 7532 */ 7533 function balance_noise(gfp, cod_info, distort, xrpow, bRefine) { 7534 var gfc = gfp.internal_flags; 7535 7536 amp_scalefac_bands(gfp, cod_info, distort, xrpow, bRefine); 7537 7538 /* 7539 * check to make sure we have not amplified too much loop_break returns 7540 * 0 if there is an unamplified scalefac scale_bitcount returns 0 if no 7541 * scalefactors are too large 7542 */ 7543 7544 var status = loop_break(cod_info); 7545 7546 if (status) 7547 return false; 7548 /* all bands amplified */ 7549 7550 /* 7551 * not all scalefactors have been amplified. so these scalefacs are 7552 * possibly valid. encode them: 7553 */ 7554 if (gfc.mode_gr == 2) 7555 status = tk.scale_bitcount(cod_info); 7556 else 7557 status = tk.scale_bitcount_lsf(gfc, cod_info); 7558 7559 if (!status) 7560 return true; 7561 /* amplified some bands not exceeding limits */ 7562 7563 /* 7564 * some scalefactors are too large. lets try setting scalefac_scale=1 7565 */ 7566 if (gfc.noise_shaping > 1) { 7567 Arrays.fill(gfc.pseudohalf, 0); 7568 if (0 == cod_info.scalefac_scale) { 7569 inc_scalefac_scale(cod_info, xrpow); 7570 status = false; 7571 } else { 7572 if (cod_info.block_type == Encoder.SHORT_TYPE 7573 && gfc.subblock_gain > 0) { 7574 status = (inc_subblock_gain(gfc, cod_info, xrpow) || loop_break(cod_info)); 7575 } 7576 } 7577 } 7578 7579 if (!status) { 7580 if (gfc.mode_gr == 2) 7581 status = tk.scale_bitcount(cod_info); 7582 else 7583 status = tk.scale_bitcount_lsf(gfc, cod_info); 7584 } 7585 return !status; 7586 } 7587 7588 /** 7589 * <PRE> 7590 * Function: The outer iteration loop controls the masking conditions 7591 * of all scalefactorbands. It computes the best scalefac and 7592 * global gain. This module calls the inner iteration loop 7593 * 7594 * mt 5/99 completely rewritten to allow for bit reservoir control, 7595 * mid/side channels with L/R or mid/side masking thresholds, 7596 * and chooses best quantization instead of last quantization when 7597 * no distortion free quantization can be found. 7598 * 7599 * added VBR support mt 5/99 7600 * 7601 * some code shuffle rh 9/00 7602 * </PRE> 7603 * 7604 * @param l3_xmin 7605 * allowed distortion 7606 * @param xrpow 7607 * coloured magnitudes of spectral 7608 * @param targ_bits 7609 * maximum allowed bits 7610 */ 7611 this.outer_loop = function (gfp, cod_info, l3_xmin, xrpow, ch, targ_bits) { 7612 var gfc = gfp.internal_flags; 7613 var cod_info_w = new GrInfo(); 7614 var save_xrpow = new_float(576); 7615 var distort = new_float(L3Side.SFBMAX); 7616 var best_noise_info = new CalcNoiseResult(); 7617 var better; 7618 var prev_noise = new CalcNoiseData(); 7619 var best_part2_3_length = 9999999; 7620 var bEndOfSearch = false; 7621 var bRefine = false; 7622 var best_ggain_pass1 = 0; 7623 7624 bin_search_StepSize(gfc, cod_info, targ_bits, ch, xrpow); 7625 7626 if (0 == gfc.noise_shaping) 7627 /* fast mode, no noise shaping, we are ready */ 7628 return 100; 7629 /* default noise_info.over_count */ 7630 7631 /* compute the distortion in this quantization */ 7632 /* coefficients and thresholds both l/r (or both mid/side) */ 7633 qupvt.calc_noise(cod_info, l3_xmin, distort, best_noise_info, 7634 prev_noise); 7635 best_noise_info.bits = cod_info.part2_3_length; 7636 7637 cod_info_w.assign(cod_info); 7638 var age = 0; 7639 System.arraycopy(xrpow, 0, save_xrpow, 0, 576); 7640 7641 while (!bEndOfSearch) { 7642 /* BEGIN MAIN LOOP */ 7643 do { 7644 var noise_info = new CalcNoiseResult(); 7645 var search_limit; 7646 var maxggain = 255; 7647 7648 /* 7649 * When quantization with no distorted bands is found, allow up 7650 * to X new unsuccesful tries in serial. This gives us more 7651 * possibilities for different quant_compare modes. Much more 7652 * than 3 makes not a big difference, it is only slower. 7653 */ 7654 7655 if ((gfc.substep_shaping & 2) != 0) { 7656 search_limit = 20; 7657 } else { 7658 search_limit = 3; 7659 } 7660 7661 /* 7662 * Check if the last scalefactor band is distorted. in VBR mode 7663 * we can't get rid of the distortion, so quit now and VBR mode 7664 * will try again with more bits. (makes a 10% speed increase, 7665 * the files I tested were binary identical, 2000/05/20 Robert 7666 * Hegemann) distort[] > 1 means noise > allowed noise 7667 */ 7668 if (gfc.sfb21_extra) { 7669 if (distort[cod_info_w.sfbmax] > 1.0) 7670 break; 7671 if (cod_info_w.block_type == Encoder.SHORT_TYPE 7672 && (distort[cod_info_w.sfbmax + 1] > 1.0 || distort[cod_info_w.sfbmax + 2] > 1.0)) 7673 break; 7674 } 7675 7676 /* try a new scalefactor conbination on cod_info_w */ 7677 if (!balance_noise(gfp, cod_info_w, distort, xrpow, bRefine)) 7678 break; 7679 if (cod_info_w.scalefac_scale != 0) 7680 maxggain = 254; 7681 7682 /* 7683 * inner_loop starts with the initial quantization step computed 7684 * above and slowly increases until the bits < huff_bits. Thus 7685 * it is important not to start with too large of an inital 7686 * quantization step. Too small is ok, but inner_loop will take 7687 * longer 7688 */ 7689 var huff_bits = targ_bits - cod_info_w.part2_length; 7690 if (huff_bits <= 0) 7691 break; 7692 7693 /* 7694 * increase quantizer stepsize until needed bits are below 7695 * maximum 7696 */ 7697 while ((cod_info_w.part2_3_length = tk.count_bits(gfc, xrpow, 7698 cod_info_w, prev_noise)) > huff_bits 7699 && cod_info_w.global_gain <= maxggain) 7700 cod_info_w.global_gain++; 7701 7702 if (cod_info_w.global_gain > maxggain) 7703 break; 7704 7705 if (best_noise_info.over_count == 0) { 7706 7707 while ((cod_info_w.part2_3_length = tk.count_bits(gfc, 7708 xrpow, cod_info_w, prev_noise)) > best_part2_3_length 7709 && cod_info_w.global_gain <= maxggain) 7710 cod_info_w.global_gain++; 7711 7712 if (cod_info_w.global_gain > maxggain) 7713 break; 7714 } 7715 7716 /* compute the distortion in this quantization */ 7717 qupvt.calc_noise(cod_info_w, l3_xmin, distort, noise_info, 7718 prev_noise); 7719 noise_info.bits = cod_info_w.part2_3_length; 7720 7721 /* 7722 * check if this quantization is better than our saved 7723 * quantization 7724 */ 7725 if (cod_info.block_type != Encoder.SHORT_TYPE) { 7726 // NORM, START or STOP type 7727 better = gfp.quant_comp; 7728 } else 7729 better = gfp.quant_comp_short; 7730 7731 better = quant_compare(better, best_noise_info, noise_info, 7732 cod_info_w, distort) ? 1 : 0; 7733 7734 /* save data so we can restore this quantization later */ 7735 if (better != 0) { 7736 best_part2_3_length = cod_info.part2_3_length; 7737 best_noise_info = noise_info; 7738 cod_info.assign(cod_info_w); 7739 age = 0; 7740 /* save data so we can restore this quantization later */ 7741 /* store for later reuse */ 7742 System.arraycopy(xrpow, 0, save_xrpow, 0, 576); 7743 } else { 7744 /* early stop? */ 7745 if (gfc.full_outer_loop == 0) { 7746 if (++age > search_limit 7747 && best_noise_info.over_count == 0) 7748 break; 7749 if ((gfc.noise_shaping_amp == 3) && bRefine && age > 30) 7750 break; 7751 if ((gfc.noise_shaping_amp == 3) 7752 && bRefine 7753 && (cod_info_w.global_gain - best_ggain_pass1) > 15) 7754 break; 7755 } 7756 } 7757 } while ((cod_info_w.global_gain + cod_info_w.scalefac_scale) < 255); 7758 7759 if (gfc.noise_shaping_amp == 3) { 7760 if (!bRefine) { 7761 /* refine search */ 7762 cod_info_w.assign(cod_info); 7763 System.arraycopy(save_xrpow, 0, xrpow, 0, 576); 7764 age = 0; 7765 best_ggain_pass1 = cod_info_w.global_gain; 7766 7767 bRefine = true; 7768 } else { 7769 /* search already refined, stop */ 7770 bEndOfSearch = true; 7771 } 7772 7773 } else { 7774 bEndOfSearch = true; 7775 } 7776 } 7777 7778 /* 7779 * finish up 7780 */ 7781 if (gfp.VBR == VbrMode.vbr_rh || gfp.VBR == VbrMode.vbr_mtrh) 7782 /* restore for reuse on next try */ 7783 System.arraycopy(save_xrpow, 0, xrpow, 0, 576); 7784 /* 7785 * do the 'substep shaping' 7786 */ 7787 else if ((gfc.substep_shaping & 1) != 0) 7788 trancate_smallspectrums(gfc, cod_info, l3_xmin, xrpow); 7789 7790 return best_noise_info.over_count; 7791 } 7792 7793 /** 7794 * Robert Hegemann 2000-09-06 7795 * 7796 * update reservoir status after FINAL quantization/bitrate 7797 */ 7798 this.iteration_finish_one = function (gfc, gr, ch) { 7799 var l3_side = gfc.l3_side; 7800 var cod_info = l3_side.tt[gr][ch]; 7801 7802 /* 7803 * try some better scalefac storage 7804 */ 7805 tk.best_scalefac_store(gfc, gr, ch, l3_side); 7806 7807 /* 7808 * best huffman_divide may save some bits too 7809 */ 7810 if (gfc.use_best_huffman == 1) 7811 tk.best_huffman_divide(gfc, cod_info); 7812 7813 /* 7814 * update reservoir status after FINAL quantization/bitrate 7815 */ 7816 rv.ResvAdjust(gfc, cod_info); 7817 }; 7818 7819 /** 7820 * 7821 * 2000-09-04 Robert Hegemann 7822 * 7823 * @param l3_xmin 7824 * allowed distortion of the scalefactor 7825 * @param xrpow 7826 * coloured magnitudes of spectral values 7827 */ 7828 this.VBR_encode_granule = function (gfp, cod_info, l3_xmin, xrpow, ch, min_bits, max_bits) { 7829 var gfc = gfp.internal_flags; 7830 var bst_cod_info = new GrInfo(); 7831 var bst_xrpow = new_float(576); 7832 var Max_bits = max_bits; 7833 var real_bits = max_bits + 1; 7834 var this_bits = (max_bits + min_bits) / 2; 7835 var dbits, over, found = 0; 7836 var sfb21_extra = gfc.sfb21_extra; 7837 7838 Arrays.fill(bst_cod_info.l3_enc, 0); 7839 7840 /* 7841 * search within round about 40 bits of optimal 7842 */ 7843 do { 7844 7845 if (this_bits > Max_bits - 42) 7846 gfc.sfb21_extra = false; 7847 else 7848 gfc.sfb21_extra = sfb21_extra; 7849 7850 over = outer_loop(gfp, cod_info, l3_xmin, xrpow, ch, this_bits); 7851 7852 /* 7853 * is quantization as good as we are looking for ? in this case: is 7854 * no scalefactor band distorted? 7855 */ 7856 if (over <= 0) { 7857 found = 1; 7858 /* 7859 * now we know it can be done with "real_bits" and maybe we can 7860 * skip some iterations 7861 */ 7862 real_bits = cod_info.part2_3_length; 7863 7864 /* 7865 * store best quantization so far 7866 */ 7867 bst_cod_info.assign(cod_info); 7868 System.arraycopy(xrpow, 0, bst_xrpow, 0, 576); 7869 7870 /* 7871 * try with fewer bits 7872 */ 7873 max_bits = real_bits - 32; 7874 dbits = max_bits - min_bits; 7875 this_bits = (max_bits + min_bits) / 2; 7876 } else { 7877 /* 7878 * try with more bits 7879 */ 7880 min_bits = this_bits + 32; 7881 dbits = max_bits - min_bits; 7882 this_bits = (max_bits + min_bits) / 2; 7883 7884 if (found != 0) { 7885 found = 2; 7886 /* 7887 * start again with best quantization so far 7888 */ 7889 cod_info.assign(bst_cod_info); 7890 System.arraycopy(bst_xrpow, 0, xrpow, 0, 576); 7891 } 7892 } 7893 } while (dbits > 12); 7894 7895 gfc.sfb21_extra = sfb21_extra; 7896 7897 /* 7898 * found=0 => nothing found, use last one found=1 => we just found the 7899 * best and left the loop found=2 => we restored a good one and have now 7900 * l3_enc to restore too 7901 */ 7902 if (found == 2) { 7903 System.arraycopy(bst_cod_info.l3_enc, 0, cod_info.l3_enc, 0, 576); 7904 } 7905 } 7906 7907 /** 7908 * Robert Hegemann 2000-09-05 7909 * 7910 * calculates * how many bits are available for analog silent granules * how 7911 * many bits to use for the lowest allowed bitrate * how many bits each 7912 * bitrate would provide 7913 */ 7914 this.get_framebits = function (gfp, frameBits) { 7915 var gfc = gfp.internal_flags; 7916 7917 /* 7918 * always use at least this many bits per granule per channel unless we 7919 * detect analog silence, see below 7920 */ 7921 gfc.bitrate_index = gfc.VBR_min_bitrate; 7922 var bitsPerFrame = bs.getframebits(gfp); 7923 7924 /* 7925 * bits for analog silence 7926 */ 7927 gfc.bitrate_index = 1; 7928 bitsPerFrame = bs.getframebits(gfp); 7929 7930 for (var i = 1; i <= gfc.VBR_max_bitrate; i++) { 7931 gfc.bitrate_index = i; 7932 var mb = new MeanBits(bitsPerFrame); 7933 frameBits[i] = rv.ResvFrameBegin(gfp, mb); 7934 bitsPerFrame = mb.bits; 7935 } 7936 }; 7937 7938 /* RH: this one needs to be overhauled sometime */ 7939 7940 /** 7941 * <PRE> 7942 * 2000-09-04 Robert Hegemann 7943 * 7944 * * converts LR to MS coding when necessary 7945 * * calculates allowed/adjusted quantization noise amounts 7946 * * detects analog silent frames 7947 * 7948 * some remarks: 7949 * - lower masking depending on Quality setting 7950 * - quality control together with adjusted ATH MDCT scaling 7951 * on lower quality setting allocate more noise from 7952 * ATH masking, and on higher quality setting allocate 7953 * less noise from ATH masking. 7954 * - experiments show that going more than 2dB over GPSYCHO's 7955 * limits ends up in very annoying artefacts 7956 * </PRE> 7957 */ 7958 this.VBR_old_prepare = function (gfp, pe, ms_ener_ratio, ratio, l3_xmin, frameBits, min_bits, 7959 max_bits, bands) { 7960 var gfc = gfp.internal_flags; 7961 7962 var masking_lower_db, adjust = 0.0; 7963 var analog_silence = 1; 7964 var bits = 0; 7965 7966 gfc.bitrate_index = gfc.VBR_max_bitrate; 7967 var avg = rv.ResvFrameBegin(gfp, new MeanBits(0)) / gfc.mode_gr; 7968 7969 get_framebits(gfp, frameBits); 7970 7971 for (var gr = 0; gr < gfc.mode_gr; gr++) { 7972 var mxb = qupvt.on_pe(gfp, pe, max_bits[gr], avg, gr, 0); 7973 if (gfc.mode_ext == Encoder.MPG_MD_MS_LR) { 7974 ms_convert(gfc.l3_side, gr); 7975 qupvt.reduce_side(max_bits[gr], ms_ener_ratio[gr], avg, mxb); 7976 } 7977 for (var ch = 0; ch < gfc.channels_out; ++ch) { 7978 var cod_info = gfc.l3_side.tt[gr][ch]; 7979 7980 if (cod_info.block_type != Encoder.SHORT_TYPE) { 7981 // NORM, START or STOP type 7982 adjust = 1.28 / (1 + Math 7983 .exp(3.5 - pe[gr][ch] / 300.)) - 0.05; 7984 masking_lower_db = gfc.PSY.mask_adjust - adjust; 7985 } else { 7986 adjust = 2.56 / (1 + Math 7987 .exp(3.5 - pe[gr][ch] / 300.)) - 0.14; 7988 masking_lower_db = gfc.PSY.mask_adjust_short - adjust; 7989 } 7990 gfc.masking_lower = Math.pow(10.0, 7991 masking_lower_db * 0.1); 7992 7993 init_outer_loop(gfc, cod_info); 7994 bands[gr][ch] = qupvt.calc_xmin(gfp, ratio[gr][ch], cod_info, 7995 l3_xmin[gr][ch]); 7996 if (bands[gr][ch] != 0) 7997 analog_silence = 0; 7998 7999 min_bits[gr][ch] = 126; 8000 8001 bits += max_bits[gr][ch]; 8002 } 8003 } 8004 for (var gr = 0; gr < gfc.mode_gr; gr++) { 8005 for (var ch = 0; ch < gfc.channels_out; ch++) { 8006 if (bits > frameBits[gfc.VBR_max_bitrate]) { 8007 max_bits[gr][ch] *= frameBits[gfc.VBR_max_bitrate]; 8008 max_bits[gr][ch] /= bits; 8009 } 8010 if (min_bits[gr][ch] > max_bits[gr][ch]) 8011 min_bits[gr][ch] = max_bits[gr][ch]; 8012 8013 } 8014 /* for ch */ 8015 } 8016 /* for gr */ 8017 8018 return analog_silence; 8019 }; 8020 8021 this.bitpressure_strategy = function (gfc, l3_xmin, min_bits, max_bits) { 8022 for (var gr = 0; gr < gfc.mode_gr; gr++) { 8023 for (var ch = 0; ch < gfc.channels_out; ch++) { 8024 var gi = gfc.l3_side.tt[gr][ch]; 8025 var pxmin = l3_xmin[gr][ch]; 8026 var pxminPos = 0; 8027 for (var sfb = 0; sfb < gi.psy_lmax; sfb++) 8028 pxmin[pxminPos++] *= 1. + .029 * sfb * sfb 8029 / Encoder.SBMAX_l / Encoder.SBMAX_l; 8030 8031 if (gi.block_type == Encoder.SHORT_TYPE) { 8032 for (var sfb = gi.sfb_smin; sfb < Encoder.SBMAX_s; sfb++) { 8033 pxmin[pxminPos++] *= 1. + .029 * sfb * sfb 8034 / Encoder.SBMAX_s / Encoder.SBMAX_s; 8035 pxmin[pxminPos++] *= 1. + .029 * sfb * sfb 8036 / Encoder.SBMAX_s / Encoder.SBMAX_s; 8037 pxmin[pxminPos++] *= 1. + .029 * sfb * sfb 8038 / Encoder.SBMAX_s / Encoder.SBMAX_s; 8039 } 8040 } 8041 max_bits[gr][ch] = 0 | Math.max(min_bits[gr][ch], 8042 0.9 * max_bits[gr][ch]); 8043 } 8044 } 8045 }; 8046 8047 this.VBR_new_prepare = function (gfp, pe, ratio, l3_xmin, frameBits, max_bits) { 8048 var gfc = gfp.internal_flags; 8049 8050 var analog_silence = 1; 8051 var avg = 0, bits = 0; 8052 var maximum_framebits; 8053 8054 if (!gfp.free_format) { 8055 gfc.bitrate_index = gfc.VBR_max_bitrate; 8056 8057 var mb = new MeanBits(avg); 8058 rv.ResvFrameBegin(gfp, mb); 8059 avg = mb.bits; 8060 8061 get_framebits(gfp, frameBits); 8062 maximum_framebits = frameBits[gfc.VBR_max_bitrate]; 8063 } else { 8064 gfc.bitrate_index = 0; 8065 var mb = new MeanBits(avg); 8066 maximum_framebits = rv.ResvFrameBegin(gfp, mb); 8067 avg = mb.bits; 8068 frameBits[0] = maximum_framebits; 8069 } 8070 8071 for (var gr = 0; gr < gfc.mode_gr; gr++) { 8072 qupvt.on_pe(gfp, pe, max_bits[gr], avg, gr, 0); 8073 if (gfc.mode_ext == Encoder.MPG_MD_MS_LR) { 8074 ms_convert(gfc.l3_side, gr); 8075 } 8076 for (var ch = 0; ch < gfc.channels_out; ++ch) { 8077 var cod_info = gfc.l3_side.tt[gr][ch]; 8078 8079 gfc.masking_lower = Math.pow(10.0, 8080 gfc.PSY.mask_adjust * 0.1); 8081 8082 init_outer_loop(gfc, cod_info); 8083 if (0 != qupvt.calc_xmin(gfp, ratio[gr][ch], cod_info, 8084 l3_xmin[gr][ch])) 8085 analog_silence = 0; 8086 8087 bits += max_bits[gr][ch]; 8088 } 8089 } 8090 for (var gr = 0; gr < gfc.mode_gr; gr++) { 8091 for (var ch = 0; ch < gfc.channels_out; ch++) { 8092 if (bits > maximum_framebits) { 8093 max_bits[gr][ch] *= maximum_framebits; 8094 max_bits[gr][ch] /= bits; 8095 } 8096 8097 } 8098 /* for ch */ 8099 } 8100 /* for gr */ 8101 8102 return analog_silence; 8103 }; 8104 8105 /** 8106 * calculates target bits for ABR encoding 8107 * 8108 * mt 2000/05/31 8109 */ 8110 this.calc_target_bits = function (gfp, pe, ms_ener_ratio, targ_bits, analog_silence_bits, max_frame_bits) { 8111 var gfc = gfp.internal_flags; 8112 var l3_side = gfc.l3_side; 8113 var res_factor; 8114 var gr, ch, totbits, mean_bits = 0; 8115 8116 gfc.bitrate_index = gfc.VBR_max_bitrate; 8117 var mb = new MeanBits(mean_bits); 8118 max_frame_bits[0] = rv.ResvFrameBegin(gfp, mb); 8119 mean_bits = mb.bits; 8120 8121 gfc.bitrate_index = 1; 8122 mean_bits = bs.getframebits(gfp) - gfc.sideinfo_len * 8; 8123 analog_silence_bits[0] = mean_bits / (gfc.mode_gr * gfc.channels_out); 8124 8125 mean_bits = gfp.VBR_mean_bitrate_kbps * gfp.framesize * 1000; 8126 if ((gfc.substep_shaping & 1) != 0) 8127 mean_bits *= 1.09; 8128 mean_bits /= gfp.out_samplerate; 8129 mean_bits -= gfc.sideinfo_len * 8; 8130 mean_bits /= (gfc.mode_gr * gfc.channels_out); 8131 8132 /** 8133 * <PRE> 8134 * res_factor is the percentage of the target bitrate that should 8135 * be used on average. the remaining bits are added to the 8136 * bitreservoir and used for difficult to encode frames. 8137 * 8138 * Since we are tracking the average bitrate, we should adjust 8139 * res_factor "on the fly", increasing it if the average bitrate 8140 * is greater than the requested bitrate, and decreasing it 8141 * otherwise. Reasonable ranges are from .9 to 1.0 8142 * 8143 * Until we get the above suggestion working, we use the following 8144 * tuning: 8145 * compression ratio res_factor 8146 * 5.5 (256kbps) 1.0 no need for bitreservoir 8147 * 11 (128kbps) .93 7% held for reservoir 8148 * 8149 * with linear interpolation for other values. 8150 * </PRE> 8151 */ 8152 res_factor = .93 + .07 * (11.0 - gfp.compression_ratio) 8153 / (11.0 - 5.5); 8154 if (res_factor < .90) 8155 res_factor = .90; 8156 if (res_factor > 1.00) 8157 res_factor = 1.00; 8158 8159 for (gr = 0; gr < gfc.mode_gr; gr++) { 8160 var sum = 0; 8161 for (ch = 0; ch < gfc.channels_out; ch++) { 8162 targ_bits[gr][ch] = (int)(res_factor * mean_bits); 8163 8164 if (pe[gr][ch] > 700) { 8165 var add_bits = (int)((pe[gr][ch] - 700) / 1.4); 8166 8167 var cod_info = l3_side.tt[gr][ch]; 8168 targ_bits[gr][ch] = (int)(res_factor * mean_bits); 8169 8170 /* short blocks use a little extra, no matter what the pe */ 8171 if (cod_info.block_type == Encoder.SHORT_TYPE) { 8172 if (add_bits < mean_bits / 2) 8173 add_bits = mean_bits / 2; 8174 } 8175 /* at most increase bits by 1.5*average */ 8176 if (add_bits > mean_bits * 3 / 2) 8177 add_bits = mean_bits * 3 / 2; 8178 else if (add_bits < 0) 8179 add_bits = 0; 8180 8181 targ_bits[gr][ch] += add_bits; 8182 } 8183 if (targ_bits[gr][ch] > LameInternalFlags.MAX_BITS_PER_CHANNEL) { 8184 targ_bits[gr][ch] = LameInternalFlags.MAX_BITS_PER_CHANNEL; 8185 } 8186 sum += targ_bits[gr][ch]; 8187 } 8188 /* for ch */ 8189 if (sum > LameInternalFlags.MAX_BITS_PER_GRANULE) { 8190 for (ch = 0; ch < gfc.channels_out; ++ch) { 8191 targ_bits[gr][ch] *= LameInternalFlags.MAX_BITS_PER_GRANULE; 8192 targ_bits[gr][ch] /= sum; 8193 } 8194 } 8195 } 8196 /* for gr */ 8197 8198 if (gfc.mode_ext == Encoder.MPG_MD_MS_LR) 8199 for (gr = 0; gr < gfc.mode_gr; gr++) { 8200 qupvt.reduce_side(targ_bits[gr], ms_ener_ratio[gr], mean_bits 8201 * gfc.channels_out, 8202 LameInternalFlags.MAX_BITS_PER_GRANULE); 8203 } 8204 8205 /* 8206 * sum target bits 8207 */ 8208 totbits = 0; 8209 for (gr = 0; gr < gfc.mode_gr; gr++) { 8210 for (ch = 0; ch < gfc.channels_out; ch++) { 8211 if (targ_bits[gr][ch] > LameInternalFlags.MAX_BITS_PER_CHANNEL) 8212 targ_bits[gr][ch] = LameInternalFlags.MAX_BITS_PER_CHANNEL; 8213 totbits += targ_bits[gr][ch]; 8214 } 8215 } 8216 8217 /* 8218 * repartion target bits if needed 8219 */ 8220 if (totbits > max_frame_bits[0]) { 8221 for (gr = 0; gr < gfc.mode_gr; gr++) { 8222 for (ch = 0; ch < gfc.channels_out; ch++) { 8223 targ_bits[gr][ch] *= max_frame_bits[0]; 8224 targ_bits[gr][ch] /= totbits; 8225 } 8226 } 8227 } 8228 } 8229 8230} 8231 8232/* 8233 * MP3 window subband -> subband filtering -> mdct routine 8234 * 8235 * Copyright (c) 1999-2000 Takehiro Tominaga 8236 * 8237 * 8238 * This library is free software; you can redistribute it and/or 8239 * modify it under the terms of the GNU Lesser General Public 8240 * License as published by the Free Software Foundation; either 8241 * version 2 of the License, or (at your option) any later version. 8242 * 8243 * This library is distributed in the hope that it will be useful, 8244 * but WITHOUT ANY WARRANTY; without even the implied warranty of 8245 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 8246 * Library General Public License for more details. 8247 * 8248 * You should have received a copy of the GNU Library General Public 8249 * License along with this library; if not, write to the 8250 * Free Software Foundation, Inc., 59 Temple Place - Suite 330, 8251 * Boston, MA 02111-1307, USA. 8252 */ 8253/* 8254 * Special Thanks to Patrick De Smet for your advices. 8255 */ 8256 8257/* $Id: NewMDCT.java,v 1.11 2011/05/24 20:48:06 kenchis Exp $ */ 8258 8259//package mp3; 8260 8261//import java.util.Arrays; 8262 8263 8264 8265function NewMDCT() { 8266 8267 var enwindow = [ 8268 -4.77e-07 * 0.740951125354959 / 2.384e-06, 8269 1.03951e-04 * 0.740951125354959 / 2.384e-06, 8270 9.53674e-04 * 0.740951125354959 / 2.384e-06, 8271 2.841473e-03 * 0.740951125354959 / 2.384e-06, 8272 3.5758972e-02 * 0.740951125354959 / 2.384e-06, 8273 3.401756e-03 * 0.740951125354959 / 2.384e-06, 8274 9.83715e-04 * 0.740951125354959 / 2.384e-06, 8275 9.9182e-05 * 0.740951125354959 / 2.384e-06, /* 15 */ 8276 1.2398e-05 * 0.740951125354959 / 2.384e-06, 8277 1.91212e-04 * 0.740951125354959 / 2.384e-06, 8278 2.283096e-03 * 0.740951125354959 / 2.384e-06, 8279 1.6994476e-02 * 0.740951125354959 / 2.384e-06, 8280 -1.8756866e-02 * 0.740951125354959 / 2.384e-06, 8281 -2.630711e-03 * 0.740951125354959 / 2.384e-06, 8282 -2.47478e-04 * 0.740951125354959 / 2.384e-06, 8283 -1.4782e-05 * 0.740951125354959 / 2.384e-06, 8284 9.063471690191471e-01, 1.960342806591213e-01, 8285 8286 -4.77e-07 * 0.773010453362737 / 2.384e-06, 8287 1.05858e-04 * 0.773010453362737 / 2.384e-06, 8288 9.30786e-04 * 0.773010453362737 / 2.384e-06, 8289 2.521515e-03 * 0.773010453362737 / 2.384e-06, 8290 3.5694122e-02 * 0.773010453362737 / 2.384e-06, 8291 3.643036e-03 * 0.773010453362737 / 2.384e-06, 8292 9.91821e-04 * 0.773010453362737 / 2.384e-06, 8293 9.6321e-05 * 0.773010453362737 / 2.384e-06, /* 14 */ 8294 1.1444e-05 * 0.773010453362737 / 2.384e-06, 8295 1.65462e-04 * 0.773010453362737 / 2.384e-06, 8296 2.110004e-03 * 0.773010453362737 / 2.384e-06, 8297 1.6112804e-02 * 0.773010453362737 / 2.384e-06, 8298 -1.9634247e-02 * 0.773010453362737 / 2.384e-06, 8299 -2.803326e-03 * 0.773010453362737 / 2.384e-06, 8300 -2.77042e-04 * 0.773010453362737 / 2.384e-06, 8301 -1.6689e-05 * 0.773010453362737 / 2.384e-06, 8302 8.206787908286602e-01, 3.901806440322567e-01, 8303 8304 -4.77e-07 * 0.803207531480645 / 2.384e-06, 8305 1.07288e-04 * 0.803207531480645 / 2.384e-06, 8306 9.02653e-04 * 0.803207531480645 / 2.384e-06, 8307 2.174854e-03 * 0.803207531480645 / 2.384e-06, 8308 3.5586357e-02 * 0.803207531480645 / 2.384e-06, 8309 3.858566e-03 * 0.803207531480645 / 2.384e-06, 8310 9.95159e-04 * 0.803207531480645 / 2.384e-06, 8311 9.3460e-05 * 0.803207531480645 / 2.384e-06, /* 13 */ 8312 1.0014e-05 * 0.803207531480645 / 2.384e-06, 8313 1.40190e-04 * 0.803207531480645 / 2.384e-06, 8314 1.937389e-03 * 0.803207531480645 / 2.384e-06, 8315 1.5233517e-02 * 0.803207531480645 / 2.384e-06, 8316 -2.0506859e-02 * 0.803207531480645 / 2.384e-06, 8317 -2.974033e-03 * 0.803207531480645 / 2.384e-06, 8318 -3.07560e-04 * 0.803207531480645 / 2.384e-06, 8319 -1.8120e-05 * 0.803207531480645 / 2.384e-06, 8320 7.416505462720353e-01, 5.805693545089249e-01, 8321 8322 -4.77e-07 * 0.831469612302545 / 2.384e-06, 8323 1.08242e-04 * 0.831469612302545 / 2.384e-06, 8324 8.68797e-04 * 0.831469612302545 / 2.384e-06, 8325 1.800537e-03 * 0.831469612302545 / 2.384e-06, 8326 3.5435200e-02 * 0.831469612302545 / 2.384e-06, 8327 4.049301e-03 * 0.831469612302545 / 2.384e-06, 8328 9.94205e-04 * 0.831469612302545 / 2.384e-06, 8329 9.0599e-05 * 0.831469612302545 / 2.384e-06, /* 12 */ 8330 9.060e-06 * 0.831469612302545 / 2.384e-06, 8331 1.16348e-04 * 0.831469612302545 / 2.384e-06, 8332 1.766682e-03 * 0.831469612302545 / 2.384e-06, 8333 1.4358521e-02 * 0.831469612302545 / 2.384e-06, 8334 -2.1372318e-02 * 0.831469612302545 / 2.384e-06, 8335 -3.14188e-03 * 0.831469612302545 / 2.384e-06, 8336 -3.39031e-04 * 0.831469612302545 / 2.384e-06, 8337 -1.9550e-05 * 0.831469612302545 / 2.384e-06, 8338 6.681786379192989e-01, 7.653668647301797e-01, 8339 8340 -4.77e-07 * 0.857728610000272 / 2.384e-06, 8341 1.08719e-04 * 0.857728610000272 / 2.384e-06, 8342 8.29220e-04 * 0.857728610000272 / 2.384e-06, 8343 1.399517e-03 * 0.857728610000272 / 2.384e-06, 8344 3.5242081e-02 * 0.857728610000272 / 2.384e-06, 8345 4.215240e-03 * 0.857728610000272 / 2.384e-06, 8346 9.89437e-04 * 0.857728610000272 / 2.384e-06, 8347 8.7261e-05 * 0.857728610000272 / 2.384e-06, /* 11 */ 8348 8.106e-06 * 0.857728610000272 / 2.384e-06, 8349 9.3937e-05 * 0.857728610000272 / 2.384e-06, 8350 1.597881e-03 * 0.857728610000272 / 2.384e-06, 8351 1.3489246e-02 * 0.857728610000272 / 2.384e-06, 8352 -2.2228718e-02 * 0.857728610000272 / 2.384e-06, 8353 -3.306866e-03 * 0.857728610000272 / 2.384e-06, 8354 -3.71456e-04 * 0.857728610000272 / 2.384e-06, 8355 -2.1458e-05 * 0.857728610000272 / 2.384e-06, 8356 5.993769336819237e-01, 9.427934736519954e-01, 8357 8358 -4.77e-07 * 0.881921264348355 / 2.384e-06, 8359 1.08719e-04 * 0.881921264348355 / 2.384e-06, 8360 7.8392e-04 * 0.881921264348355 / 2.384e-06, 8361 9.71317e-04 * 0.881921264348355 / 2.384e-06, 8362 3.5007000e-02 * 0.881921264348355 / 2.384e-06, 8363 4.357815e-03 * 0.881921264348355 / 2.384e-06, 8364 9.80854e-04 * 0.881921264348355 / 2.384e-06, 8365 8.3923e-05 * 0.881921264348355 / 2.384e-06, /* 10 */ 8366 7.629e-06 * 0.881921264348355 / 2.384e-06, 8367 7.2956e-05 * 0.881921264348355 / 2.384e-06, 8368 1.432419e-03 * 0.881921264348355 / 2.384e-06, 8369 1.2627602e-02 * 0.881921264348355 / 2.384e-06, 8370 -2.3074150e-02 * 0.881921264348355 / 2.384e-06, 8371 -3.467083e-03 * 0.881921264348355 / 2.384e-06, 8372 -4.04358e-04 * 0.881921264348355 / 2.384e-06, 8373 -2.3365e-05 * 0.881921264348355 / 2.384e-06, 8374 5.345111359507916e-01, 1.111140466039205e+00, 8375 8376 -9.54e-07 * 0.903989293123443 / 2.384e-06, 8377 1.08242e-04 * 0.903989293123443 / 2.384e-06, 8378 7.31945e-04 * 0.903989293123443 / 2.384e-06, 8379 5.15938e-04 * 0.903989293123443 / 2.384e-06, 8380 3.4730434e-02 * 0.903989293123443 / 2.384e-06, 8381 4.477024e-03 * 0.903989293123443 / 2.384e-06, 8382 9.68933e-04 * 0.903989293123443 / 2.384e-06, 8383 8.0585e-05 * 0.903989293123443 / 2.384e-06, /* 9 */ 8384 6.676e-06 * 0.903989293123443 / 2.384e-06, 8385 5.2929e-05 * 0.903989293123443 / 2.384e-06, 8386 1.269817e-03 * 0.903989293123443 / 2.384e-06, 8387 1.1775017e-02 * 0.903989293123443 / 2.384e-06, 8388 -2.3907185e-02 * 0.903989293123443 / 2.384e-06, 8389 -3.622532e-03 * 0.903989293123443 / 2.384e-06, 8390 -4.38213e-04 * 0.903989293123443 / 2.384e-06, 8391 -2.5272e-05 * 0.903989293123443 / 2.384e-06, 8392 4.729647758913199e-01, 1.268786568327291e+00, 8393 8394 -9.54e-07 * 0.92387953251128675613 / 2.384e-06, 8395 1.06812e-04 * 0.92387953251128675613 / 2.384e-06, 8396 6.74248e-04 * 0.92387953251128675613 / 2.384e-06, 8397 3.3379e-05 * 0.92387953251128675613 / 2.384e-06, 8398 3.4412861e-02 * 0.92387953251128675613 / 2.384e-06, 8399 4.573822e-03 * 0.92387953251128675613 / 2.384e-06, 8400 9.54151e-04 * 0.92387953251128675613 / 2.384e-06, 8401 7.6771e-05 * 0.92387953251128675613 / 2.384e-06, 8402 6.199e-06 * 0.92387953251128675613 / 2.384e-06, 8403 3.4332e-05 * 0.92387953251128675613 / 2.384e-06, 8404 1.111031e-03 * 0.92387953251128675613 / 2.384e-06, 8405 1.0933399e-02 * 0.92387953251128675613 / 2.384e-06, 8406 -2.4725437e-02 * 0.92387953251128675613 / 2.384e-06, 8407 -3.771782e-03 * 0.92387953251128675613 / 2.384e-06, 8408 -4.72546e-04 * 0.92387953251128675613 / 2.384e-06, 8409 -2.7657e-05 * 0.92387953251128675613 / 2.384e-06, 8410 4.1421356237309504879e-01, /* tan(PI/8) */ 8411 1.414213562373095e+00, 8412 8413 -9.54e-07 * 0.941544065183021 / 2.384e-06, 8414 1.05381e-04 * 0.941544065183021 / 2.384e-06, 8415 6.10352e-04 * 0.941544065183021 / 2.384e-06, 8416 -4.75883e-04 * 0.941544065183021 / 2.384e-06, 8417 3.4055710e-02 * 0.941544065183021 / 2.384e-06, 8418 4.649162e-03 * 0.941544065183021 / 2.384e-06, 8419 9.35555e-04 * 0.941544065183021 / 2.384e-06, 8420 7.3433e-05 * 0.941544065183021 / 2.384e-06, /* 7 */ 8421 5.245e-06 * 0.941544065183021 / 2.384e-06, 8422 1.7166e-05 * 0.941544065183021 / 2.384e-06, 8423 9.56535e-04 * 0.941544065183021 / 2.384e-06, 8424 1.0103703e-02 * 0.941544065183021 / 2.384e-06, 8425 -2.5527000e-02 * 0.941544065183021 / 2.384e-06, 8426 -3.914356e-03 * 0.941544065183021 / 2.384e-06, 8427 -5.07355e-04 * 0.941544065183021 / 2.384e-06, 8428 -3.0041e-05 * 0.941544065183021 / 2.384e-06, 8429 3.578057213145241e-01, 1.546020906725474e+00, 8430 8431 -9.54e-07 * 0.956940335732209 / 2.384e-06, 8432 1.02520e-04 * 0.956940335732209 / 2.384e-06, 8433 5.39303e-04 * 0.956940335732209 / 2.384e-06, 8434 -1.011848e-03 * 0.956940335732209 / 2.384e-06, 8435 3.3659935e-02 * 0.956940335732209 / 2.384e-06, 8436 4.703045e-03 * 0.956940335732209 / 2.384e-06, 8437 9.15051e-04 * 0.956940335732209 / 2.384e-06, 8438 7.0095e-05 * 0.956940335732209 / 2.384e-06, /* 6 */ 8439 4.768e-06 * 0.956940335732209 / 2.384e-06, 8440 9.54e-07 * 0.956940335732209 / 2.384e-06, 8441 8.06808e-04 * 0.956940335732209 / 2.384e-06, 8442 9.287834e-03 * 0.956940335732209 / 2.384e-06, 8443 -2.6310921e-02 * 0.956940335732209 / 2.384e-06, 8444 -4.048824e-03 * 0.956940335732209 / 2.384e-06, 8445 -5.42164e-04 * 0.956940335732209 / 2.384e-06, 8446 -3.2425e-05 * 0.956940335732209 / 2.384e-06, 8447 3.033466836073424e-01, 1.662939224605090e+00, 8448 8449 -1.431e-06 * 0.970031253194544 / 2.384e-06, 8450 9.9182e-05 * 0.970031253194544 / 2.384e-06, 8451 4.62532e-04 * 0.970031253194544 / 2.384e-06, 8452 -1.573563e-03 * 0.970031253194544 / 2.384e-06, 8453 3.3225536e-02 * 0.970031253194544 / 2.384e-06, 8454 4.737377e-03 * 0.970031253194544 / 2.384e-06, 8455 8.91685e-04 * 0.970031253194544 / 2.384e-06, 8456 6.6280e-05 * 0.970031253194544 / 2.384e-06, /* 5 */ 8457 4.292e-06 * 0.970031253194544 / 2.384e-06, 8458 -1.3828e-05 * 0.970031253194544 / 2.384e-06, 8459 6.61850e-04 * 0.970031253194544 / 2.384e-06, 8460 8.487225e-03 * 0.970031253194544 / 2.384e-06, 8461 -2.7073860e-02 * 0.970031253194544 / 2.384e-06, 8462 -4.174709e-03 * 0.970031253194544 / 2.384e-06, 8463 -5.76973e-04 * 0.970031253194544 / 2.384e-06, 8464 -3.4809e-05 * 0.970031253194544 / 2.384e-06, 8465 2.504869601913055e-01, 1.763842528696710e+00, 8466 8467 -1.431e-06 * 0.98078528040323 / 2.384e-06, 8468 9.5367e-05 * 0.98078528040323 / 2.384e-06, 8469 3.78609e-04 * 0.98078528040323 / 2.384e-06, 8470 -2.161503e-03 * 0.98078528040323 / 2.384e-06, 8471 3.2754898e-02 * 0.98078528040323 / 2.384e-06, 8472 4.752159e-03 * 0.98078528040323 / 2.384e-06, 8473 8.66413e-04 * 0.98078528040323 / 2.384e-06, 8474 6.2943e-05 * 0.98078528040323 / 2.384e-06, /* 4 */ 8475 3.815e-06 * 0.98078528040323 / 2.384e-06, 8476 -2.718e-05 * 0.98078528040323 / 2.384e-06, 8477 5.22137e-04 * 0.98078528040323 / 2.384e-06, 8478 7.703304e-03 * 0.98078528040323 / 2.384e-06, 8479 -2.7815342e-02 * 0.98078528040323 / 2.384e-06, 8480 -4.290581e-03 * 0.98078528040323 / 2.384e-06, 8481 -6.11782e-04 * 0.98078528040323 / 2.384e-06, 8482 -3.7670e-05 * 0.98078528040323 / 2.384e-06, 8483 1.989123673796580e-01, 1.847759065022573e+00, 8484 8485 -1.907e-06 * 0.989176509964781 / 2.384e-06, 8486 9.0122e-05 * 0.989176509964781 / 2.384e-06, 8487 2.88486e-04 * 0.989176509964781 / 2.384e-06, 8488 -2.774239e-03 * 0.989176509964781 / 2.384e-06, 8489 3.2248020e-02 * 0.989176509964781 / 2.384e-06, 8490 4.748821e-03 * 0.989176509964781 / 2.384e-06, 8491 8.38757e-04 * 0.989176509964781 / 2.384e-06, 8492 5.9605e-05 * 0.989176509964781 / 2.384e-06, /* 3 */ 8493 3.338e-06 * 0.989176509964781 / 2.384e-06, 8494 -3.9577e-05 * 0.989176509964781 / 2.384e-06, 8495 3.88145e-04 * 0.989176509964781 / 2.384e-06, 8496 6.937027e-03 * 0.989176509964781 / 2.384e-06, 8497 -2.8532982e-02 * 0.989176509964781 / 2.384e-06, 8498 -4.395962e-03 * 0.989176509964781 / 2.384e-06, 8499 -6.46591e-04 * 0.989176509964781 / 2.384e-06, 8500 -4.0531e-05 * 0.989176509964781 / 2.384e-06, 8501 1.483359875383474e-01, 1.913880671464418e+00, 8502 8503 -1.907e-06 * 0.995184726672197 / 2.384e-06, 8504 8.4400e-05 * 0.995184726672197 / 2.384e-06, 8505 1.91689e-04 * 0.995184726672197 / 2.384e-06, 8506 -3.411293e-03 * 0.995184726672197 / 2.384e-06, 8507 3.1706810e-02 * 0.995184726672197 / 2.384e-06, 8508 4.728317e-03 * 0.995184726672197 / 2.384e-06, 8509 8.09669e-04 * 0.995184726672197 / 2.384e-06, 8510 5.579e-05 * 0.995184726672197 / 2.384e-06, 8511 3.338e-06 * 0.995184726672197 / 2.384e-06, 8512 -5.0545e-05 * 0.995184726672197 / 2.384e-06, 8513 2.59876e-04 * 0.995184726672197 / 2.384e-06, 8514 6.189346e-03 * 0.995184726672197 / 2.384e-06, 8515 -2.9224873e-02 * 0.995184726672197 / 2.384e-06, 8516 -4.489899e-03 * 0.995184726672197 / 2.384e-06, 8517 -6.80923e-04 * 0.995184726672197 / 2.384e-06, 8518 -4.3392e-05 * 0.995184726672197 / 2.384e-06, 8519 9.849140335716425e-02, 1.961570560806461e+00, 8520 8521 -2.384e-06 * 0.998795456205172 / 2.384e-06, 8522 7.7724e-05 * 0.998795456205172 / 2.384e-06, 8523 8.8215e-05 * 0.998795456205172 / 2.384e-06, 8524 -4.072189e-03 * 0.998795456205172 / 2.384e-06, 8525 3.1132698e-02 * 0.998795456205172 / 2.384e-06, 8526 4.691124e-03 * 0.998795456205172 / 2.384e-06, 8527 7.79152e-04 * 0.998795456205172 / 2.384e-06, 8528 5.2929e-05 * 0.998795456205172 / 2.384e-06, 8529 2.861e-06 * 0.998795456205172 / 2.384e-06, 8530 -6.0558e-05 * 0.998795456205172 / 2.384e-06, 8531 1.37329e-04 * 0.998795456205172 / 2.384e-06, 8532 5.462170e-03 * 0.998795456205172 / 2.384e-06, 8533 -2.9890060e-02 * 0.998795456205172 / 2.384e-06, 8534 -4.570484e-03 * 0.998795456205172 / 2.384e-06, 8535 -7.14302e-04 * 0.998795456205172 / 2.384e-06, 8536 -4.6253e-05 * 0.998795456205172 / 2.384e-06, 8537 4.912684976946725e-02, 1.990369453344394e+00, 8538 8539 3.5780907e-02 * Util.SQRT2 * 0.5 / 2.384e-06, 8540 1.7876148e-02 * Util.SQRT2 * 0.5 / 2.384e-06, 8541 3.134727e-03 * Util.SQRT2 * 0.5 / 2.384e-06, 8542 2.457142e-03 * Util.SQRT2 * 0.5 / 2.384e-06, 8543 9.71317e-04 * Util.SQRT2 * 0.5 / 2.384e-06, 8544 2.18868e-04 * Util.SQRT2 * 0.5 / 2.384e-06, 8545 1.01566e-04 * Util.SQRT2 * 0.5 / 2.384e-06, 8546 1.3828e-05 * Util.SQRT2 * 0.5 / 2.384e-06, 8547 8548 3.0526638e-02 / 2.384e-06, 4.638195e-03 / 2.384e-06, 8549 7.47204e-04 / 2.384e-06, 4.9591e-05 / 2.384e-06, 8550 4.756451e-03 / 2.384e-06, 2.1458e-05 / 2.384e-06, 8551 -6.9618e-05 / 2.384e-06, /* 2.384e-06/2.384e-06 */ 8552 ]; 8553 8554 var NS = 12; 8555 var NL = 36; 8556 8557 var win = [ 8558 [ 8559 2.382191739347913e-13, 8560 6.423305872147834e-13, 8561 9.400849094049688e-13, 8562 1.122435026096556e-12, 8563 1.183840321267481e-12, 8564 1.122435026096556e-12, 8565 9.400849094049690e-13, 8566 6.423305872147839e-13, 8567 2.382191739347918e-13, 8568 8569 5.456116108943412e-12, 8570 4.878985199565852e-12, 8571 4.240448995017367e-12, 8572 3.559909094758252e-12, 8573 2.858043359288075e-12, 8574 2.156177623817898e-12, 8575 1.475637723558783e-12, 8576 8.371015190102974e-13, 8577 2.599706096327376e-13, 8578 8579 -5.456116108943412e-12, 8580 -4.878985199565852e-12, 8581 -4.240448995017367e-12, 8582 -3.559909094758252e-12, 8583 -2.858043359288076e-12, 8584 -2.156177623817898e-12, 8585 -1.475637723558783e-12, 8586 -8.371015190102975e-13, 8587 -2.599706096327376e-13, 8588 8589 -2.382191739347923e-13, 8590 -6.423305872147843e-13, 8591 -9.400849094049696e-13, 8592 -1.122435026096556e-12, 8593 -1.183840321267481e-12, 8594 -1.122435026096556e-12, 8595 -9.400849094049694e-13, 8596 -6.423305872147840e-13, 8597 -2.382191739347918e-13, 8598 ], 8599 [ 8600 2.382191739347913e-13, 8601 6.423305872147834e-13, 8602 9.400849094049688e-13, 8603 1.122435026096556e-12, 8604 1.183840321267481e-12, 8605 1.122435026096556e-12, 8606 9.400849094049688e-13, 8607 6.423305872147841e-13, 8608 2.382191739347918e-13, 8609 8610 5.456116108943413e-12, 8611 4.878985199565852e-12, 8612 4.240448995017367e-12, 8613 3.559909094758253e-12, 8614 2.858043359288075e-12, 8615 2.156177623817898e-12, 8616 1.475637723558782e-12, 8617 8.371015190102975e-13, 8618 2.599706096327376e-13, 8619 8620 -5.461314069809755e-12, 8621 -4.921085770524055e-12, 8622 -4.343405037091838e-12, 8623 -3.732668368707687e-12, 8624 -3.093523840190885e-12, 8625 -2.430835727329465e-12, 8626 -1.734679010007751e-12, 8627 -9.748253656609281e-13, 8628 -2.797435120168326e-13, 8629 8630 0.000000000000000e+00, 8631 0.000000000000000e+00, 8632 0.000000000000000e+00, 8633 0.000000000000000e+00, 8634 0.000000000000000e+00, 8635 0.000000000000000e+00, 8636 -2.283748241799531e-13, 8637 -4.037858874020686e-13, 8638 -2.146547464825323e-13, 8639 ], 8640 [ 8641 1.316524975873958e-01, /* win[SHORT_TYPE] */ 8642 4.142135623730950e-01, 8643 7.673269879789602e-01, 8644 8645 1.091308501069271e+00, /* tantab_l */ 8646 1.303225372841206e+00, 8647 1.569685577117490e+00, 8648 1.920982126971166e+00, 8649 2.414213562373094e+00, 8650 3.171594802363212e+00, 8651 4.510708503662055e+00, 8652 7.595754112725146e+00, 8653 2.290376554843115e+01, 8654 8655 0.98480775301220802032, /* cx */ 8656 0.64278760968653936292, 8657 0.34202014332566882393, 8658 0.93969262078590842791, 8659 -0.17364817766693030343, 8660 -0.76604444311897790243, 8661 0.86602540378443870761, 8662 0.500000000000000e+00, 8663 8664 -5.144957554275265e-01, /* ca */ 8665 -4.717319685649723e-01, 8666 -3.133774542039019e-01, 8667 -1.819131996109812e-01, 8668 -9.457419252642064e-02, 8669 -4.096558288530405e-02, 8670 -1.419856857247115e-02, 8671 -3.699974673760037e-03, 8672 8673 8.574929257125442e-01, /* cs */ 8674 8.817419973177052e-01, 8675 9.496286491027329e-01, 8676 9.833145924917901e-01, 8677 9.955178160675857e-01, 8678 9.991605581781475e-01, 8679 9.998991952444470e-01, 8680 9.999931550702802e-01, 8681 ], 8682 [ 8683 0.000000000000000e+00, 8684 0.000000000000000e+00, 8685 0.000000000000000e+00, 8686 0.000000000000000e+00, 8687 0.000000000000000e+00, 8688 0.000000000000000e+00, 8689 2.283748241799531e-13, 8690 4.037858874020686e-13, 8691 2.146547464825323e-13, 8692 8693 5.461314069809755e-12, 8694 4.921085770524055e-12, 8695 4.343405037091838e-12, 8696 3.732668368707687e-12, 8697 3.093523840190885e-12, 8698 2.430835727329466e-12, 8699 1.734679010007751e-12, 8700 9.748253656609281e-13, 8701 2.797435120168326e-13, 8702 8703 -5.456116108943413e-12, 8704 -4.878985199565852e-12, 8705 -4.240448995017367e-12, 8706 -3.559909094758253e-12, 8707 -2.858043359288075e-12, 8708 -2.156177623817898e-12, 8709 -1.475637723558782e-12, 8710 -8.371015190102975e-13, 8711 -2.599706096327376e-13, 8712 8713 -2.382191739347913e-13, 8714 -6.423305872147834e-13, 8715 -9.400849094049688e-13, 8716 -1.122435026096556e-12, 8717 -1.183840321267481e-12, 8718 -1.122435026096556e-12, 8719 -9.400849094049688e-13, 8720 -6.423305872147841e-13, 8721 -2.382191739347918e-13, 8722 ] 8723 ]; 8724 8725 var tantab_l = win[Encoder.SHORT_TYPE]; 8726 var cx = win[Encoder.SHORT_TYPE]; 8727 var ca = win[Encoder.SHORT_TYPE]; 8728 var cs = win[Encoder.SHORT_TYPE]; 8729 8730 /** 8731 * new IDCT routine written by Takehiro TOMINAGA 8732 * 8733 * PURPOSE: Overlapping window on PCM samples<BR> 8734 * 8735 * SEMANTICS:<BR> 8736 * 32 16-bit pcm samples are scaled to fractional 2's complement and 8737 * concatenated to the end of the window buffer #x#. The updated window 8738 * buffer #x# is then windowed by the analysis window #c# to produce the 8739 * windowed sample #z# 8740 */ 8741 var order = [ 8742 0, 1, 16, 17, 8, 9, 24, 25, 4, 5, 20, 21, 12, 13, 28, 29, 8743 2, 3, 18, 19, 10, 11, 26, 27, 6, 7, 22, 23, 14, 15, 30, 31 8744 ]; 8745 8746 /** 8747 * returns sum_j=0^31 a[j]*cos(PI*j*(k+1/2)/32), 0<=k<32 8748 */ 8749 function window_subband(x1, x1Pos, a) { 8750 var wp = 10; 8751 8752 var x2 = x1Pos + 238 - 14 - 286; 8753 8754 for (var i = -15; i < 0; i++) { 8755 var w, s, t; 8756 8757 w = enwindow[wp + -10]; 8758 s = x1[x2 + -224] * w; 8759 t = x1[x1Pos + 224] * w; 8760 w = enwindow[wp + -9]; 8761 s += x1[x2 + -160] * w; 8762 t += x1[x1Pos + 160] * w; 8763 w = enwindow[wp + -8]; 8764 s += x1[x2 + -96] * w; 8765 t += x1[x1Pos + 96] * w; 8766 w = enwindow[wp + -7]; 8767 s += x1[x2 + -32] * w; 8768 t += x1[x1Pos + 32] * w; 8769 w = enwindow[wp + -6]; 8770 s += x1[x2 + 32] * w; 8771 t += x1[x1Pos + -32] * w; 8772 w = enwindow[wp + -5]; 8773 s += x1[x2 + 96] * w; 8774 t += x1[x1Pos + -96] * w; 8775 w = enwindow[wp + -4]; 8776 s += x1[x2 + 160] * w; 8777 t += x1[x1Pos + -160] * w; 8778 w = enwindow[wp + -3]; 8779 s += x1[x2 + 224] * w; 8780 t += x1[x1Pos + -224] * w; 8781 8782 w = enwindow[wp + -2]; 8783 s += x1[x1Pos + -256] * w; 8784 t -= x1[x2 + 256] * w; 8785 w = enwindow[wp + -1]; 8786 s += x1[x1Pos + -192] * w; 8787 t -= x1[x2 + 192] * w; 8788 w = enwindow[wp + 0]; 8789 s += x1[x1Pos + -128] * w; 8790 t -= x1[x2 + 128] * w; 8791 w = enwindow[wp + 1]; 8792 s += x1[x1Pos + -64] * w; 8793 t -= x1[x2 + 64] * w; 8794 w = enwindow[wp + 2]; 8795 s += x1[x1Pos + 0] * w; 8796 t -= x1[x2 + 0] * w; 8797 w = enwindow[wp + 3]; 8798 s += x1[x1Pos + 64] * w; 8799 t -= x1[x2 + -64] * w; 8800 w = enwindow[wp + 4]; 8801 s += x1[x1Pos + 128] * w; 8802 t -= x1[x2 + -128] * w; 8803 w = enwindow[wp + 5]; 8804 s += x1[x1Pos + 192] * w; 8805 t -= x1[x2 + -192] * w; 8806 8807 /* 8808 * this multiplyer could be removed, but it needs more 256 FLOAT 8809 * data. thinking about the data cache performance, I think we 8810 * should not use such a huge table. tt 2000/Oct/25 8811 */ 8812 s *= enwindow[wp + 6]; 8813 w = t - s; 8814 a[30 + i * 2] = t + s; 8815 a[31 + i * 2] = enwindow[wp + 7] * w; 8816 wp += 18; 8817 x1Pos--; 8818 x2++; 8819 } 8820 { 8821 var s, t, u, v; 8822 t = x1[x1Pos + -16] * enwindow[wp + -10]; 8823 s = x1[x1Pos + -32] * enwindow[wp + -2]; 8824 t += (x1[x1Pos + -48] - x1[x1Pos + 16]) * enwindow[wp + -9]; 8825 s += x1[x1Pos + -96] * enwindow[wp + -1]; 8826 t += (x1[x1Pos + -80] + x1[x1Pos + 48]) * enwindow[wp + -8]; 8827 s += x1[x1Pos + -160] * enwindow[wp + 0]; 8828 t += (x1[x1Pos + -112] - x1[x1Pos + 80]) * enwindow[wp + -7]; 8829 s += x1[x1Pos + -224] * enwindow[wp + 1]; 8830 t += (x1[x1Pos + -144] + x1[x1Pos + 112]) * enwindow[wp + -6]; 8831 s -= x1[x1Pos + 32] * enwindow[wp + 2]; 8832 t += (x1[x1Pos + -176] - x1[x1Pos + 144]) * enwindow[wp + -5]; 8833 s -= x1[x1Pos + 96] * enwindow[wp + 3]; 8834 t += (x1[x1Pos + -208] + x1[x1Pos + 176]) * enwindow[wp + -4]; 8835 s -= x1[x1Pos + 160] * enwindow[wp + 4]; 8836 t += (x1[x1Pos + -240] - x1[x1Pos + 208]) * enwindow[wp + -3]; 8837 s -= x1[x1Pos + 224]; 8838 8839 u = s - t; 8840 v = s + t; 8841 8842 t = a[14]; 8843 s = a[15] - t; 8844 8845 a[31] = v + t; /* A0 */ 8846 a[30] = u + s; /* A1 */ 8847 a[15] = u - s; /* A2 */ 8848 a[14] = v - t; /* A3 */ 8849 } 8850 { 8851 var xr; 8852 xr = a[28] - a[0]; 8853 a[0] += a[28]; 8854 a[28] = xr * enwindow[wp + -2 * 18 + 7]; 8855 xr = a[29] - a[1]; 8856 a[1] += a[29]; 8857 a[29] = xr * enwindow[wp + -2 * 18 + 7]; 8858 8859 xr = a[26] - a[2]; 8860 a[2] += a[26]; 8861 a[26] = xr * enwindow[wp + -4 * 18 + 7]; 8862 xr = a[27] - a[3]; 8863 a[3] += a[27]; 8864 a[27] = xr * enwindow[wp + -4 * 18 + 7]; 8865 8866 xr = a[24] - a[4]; 8867 a[4] += a[24]; 8868 a[24] = xr * enwindow[wp + -6 * 18 + 7]; 8869 xr = a[25] - a[5]; 8870 a[5] += a[25]; 8871 a[25] = xr * enwindow[wp + -6 * 18 + 7]; 8872 8873 xr = a[22] - a[6]; 8874 a[6] += a[22]; 8875 a[22] = xr * Util.SQRT2; 8876 xr = a[23] - a[7]; 8877 a[7] += a[23]; 8878 a[23] = xr * Util.SQRT2 - a[7]; 8879 a[7] -= a[6]; 8880 a[22] -= a[7]; 8881 a[23] -= a[22]; 8882 8883 xr = a[6]; 8884 a[6] = a[31] - xr; 8885 a[31] = a[31] + xr; 8886 xr = a[7]; 8887 a[7] = a[30] - xr; 8888 a[30] = a[30] + xr; 8889 xr = a[22]; 8890 a[22] = a[15] - xr; 8891 a[15] = a[15] + xr; 8892 xr = a[23]; 8893 a[23] = a[14] - xr; 8894 a[14] = a[14] + xr; 8895 8896 xr = a[20] - a[8]; 8897 a[8] += a[20]; 8898 a[20] = xr * enwindow[wp + -10 * 18 + 7]; 8899 xr = a[21] - a[9]; 8900 a[9] += a[21]; 8901 a[21] = xr * enwindow[wp + -10 * 18 + 7]; 8902 8903 xr = a[18] - a[10]; 8904 a[10] += a[18]; 8905 a[18] = xr * enwindow[wp + -12 * 18 + 7]; 8906 xr = a[19] - a[11]; 8907 a[11] += a[19]; 8908 a[19] = xr * enwindow[wp + -12 * 18 + 7]; 8909 8910 xr = a[16] - a[12]; 8911 a[12] += a[16]; 8912 a[16] = xr * enwindow[wp + -14 * 18 + 7]; 8913 xr = a[17] - a[13]; 8914 a[13] += a[17]; 8915 a[17] = xr * enwindow[wp + -14 * 18 + 7]; 8916 8917 xr = -a[20] + a[24]; 8918 a[20] += a[24]; 8919 a[24] = xr * enwindow[wp + -12 * 18 + 7]; 8920 xr = -a[21] + a[25]; 8921 a[21] += a[25]; 8922 a[25] = xr * enwindow[wp + -12 * 18 + 7]; 8923 8924 xr = a[4] - a[8]; 8925 a[4] += a[8]; 8926 a[8] = xr * enwindow[wp + -12 * 18 + 7]; 8927 xr = a[5] - a[9]; 8928 a[5] += a[9]; 8929 a[9] = xr * enwindow[wp + -12 * 18 + 7]; 8930 8931 xr = a[0] - a[12]; 8932 a[0] += a[12]; 8933 a[12] = xr * enwindow[wp + -4 * 18 + 7]; 8934 xr = a[1] - a[13]; 8935 a[1] += a[13]; 8936 a[13] = xr * enwindow[wp + -4 * 18 + 7]; 8937 xr = a[16] - a[28]; 8938 a[16] += a[28]; 8939 a[28] = xr * enwindow[wp + -4 * 18 + 7]; 8940 xr = -a[17] + a[29]; 8941 a[17] += a[29]; 8942 a[29] = xr * enwindow[wp + -4 * 18 + 7]; 8943 8944 xr = Util.SQRT2 * (a[2] - a[10]); 8945 a[2] += a[10]; 8946 a[10] = xr; 8947 xr = Util.SQRT2 * (a[3] - a[11]); 8948 a[3] += a[11]; 8949 a[11] = xr; 8950 xr = Util.SQRT2 * (-a[18] + a[26]); 8951 a[18] += a[26]; 8952 a[26] = xr - a[18]; 8953 xr = Util.SQRT2 * (-a[19] + a[27]); 8954 a[19] += a[27]; 8955 a[27] = xr - a[19]; 8956 8957 xr = a[2]; 8958 a[19] -= a[3]; 8959 a[3] -= xr; 8960 a[2] = a[31] - xr; 8961 a[31] += xr; 8962 xr = a[3]; 8963 a[11] -= a[19]; 8964 a[18] -= xr; 8965 a[3] = a[30] - xr; 8966 a[30] += xr; 8967 xr = a[18]; 8968 a[27] -= a[11]; 8969 a[19] -= xr; 8970 a[18] = a[15] - xr; 8971 a[15] += xr; 8972 8973 xr = a[19]; 8974 a[10] -= xr; 8975 a[19] = a[14] - xr; 8976 a[14] += xr; 8977 xr = a[10]; 8978 a[11] -= xr; 8979 a[10] = a[23] - xr; 8980 a[23] += xr; 8981 xr = a[11]; 8982 a[26] -= xr; 8983 a[11] = a[22] - xr; 8984 a[22] += xr; 8985 xr = a[26]; 8986 a[27] -= xr; 8987 a[26] = a[7] - xr; 8988 a[7] += xr; 8989 8990 xr = a[27]; 8991 a[27] = a[6] - xr; 8992 a[6] += xr; 8993 8994 xr = Util.SQRT2 * (a[0] - a[4]); 8995 a[0] += a[4]; 8996 a[4] = xr; 8997 xr = Util.SQRT2 * (a[1] - a[5]); 8998 a[1] += a[5]; 8999 a[5] = xr; 9000 xr = Util.SQRT2 * (a[16] - a[20]); 9001 a[16] += a[20]; 9002 a[20] = xr; 9003 xr = Util.SQRT2 * (a[17] - a[21]); 9004 a[17] += a[21]; 9005 a[21] = xr; 9006 9007 xr = -Util.SQRT2 * (a[8] - a[12]); 9008 a[8] += a[12]; 9009 a[12] = xr - a[8]; 9010 xr = -Util.SQRT2 * (a[9] - a[13]); 9011 a[9] += a[13]; 9012 a[13] = xr - a[9]; 9013 xr = -Util.SQRT2 * (a[25] - a[29]); 9014 a[25] += a[29]; 9015 a[29] = xr - a[25]; 9016 xr = -Util.SQRT2 * (a[24] + a[28]); 9017 a[24] -= a[28]; 9018 a[28] = xr - a[24]; 9019 9020 xr = a[24] - a[16]; 9021 a[24] = xr; 9022 xr = a[20] - xr; 9023 a[20] = xr; 9024 xr = a[28] - xr; 9025 a[28] = xr; 9026 9027 xr = a[25] - a[17]; 9028 a[25] = xr; 9029 xr = a[21] - xr; 9030 a[21] = xr; 9031 xr = a[29] - xr; 9032 a[29] = xr; 9033 9034 xr = a[17] - a[1]; 9035 a[17] = xr; 9036 xr = a[9] - xr; 9037 a[9] = xr; 9038 xr = a[25] - xr; 9039 a[25] = xr; 9040 xr = a[5] - xr; 9041 a[5] = xr; 9042 xr = a[21] - xr; 9043 a[21] = xr; 9044 xr = a[13] - xr; 9045 a[13] = xr; 9046 xr = a[29] - xr; 9047 a[29] = xr; 9048 9049 xr = a[1] - a[0]; 9050 a[1] = xr; 9051 xr = a[16] - xr; 9052 a[16] = xr; 9053 xr = a[17] - xr; 9054 a[17] = xr; 9055 xr = a[8] - xr; 9056 a[8] = xr; 9057 xr = a[9] - xr; 9058 a[9] = xr; 9059 xr = a[24] - xr; 9060 a[24] = xr; 9061 xr = a[25] - xr; 9062 a[25] = xr; 9063 xr = a[4] - xr; 9064 a[4] = xr; 9065 xr = a[5] - xr; 9066 a[5] = xr; 9067 xr = a[20] - xr; 9068 a[20] = xr; 9069 xr = a[21] - xr; 9070 a[21] = xr; 9071 xr = a[12] - xr; 9072 a[12] = xr; 9073 xr = a[13] - xr; 9074 a[13] = xr; 9075 xr = a[28] - xr; 9076 a[28] = xr; 9077 xr = a[29] - xr; 9078 a[29] = xr; 9079 9080 xr = a[0]; 9081 a[0] += a[31]; 9082 a[31] -= xr; 9083 xr = a[1]; 9084 a[1] += a[30]; 9085 a[30] -= xr; 9086 xr = a[16]; 9087 a[16] += a[15]; 9088 a[15] -= xr; 9089 xr = a[17]; 9090 a[17] += a[14]; 9091 a[14] -= xr; 9092 xr = a[8]; 9093 a[8] += a[23]; 9094 a[23] -= xr; 9095 xr = a[9]; 9096 a[9] += a[22]; 9097 a[22] -= xr; 9098 xr = a[24]; 9099 a[24] += a[7]; 9100 a[7] -= xr; 9101 xr = a[25]; 9102 a[25] += a[6]; 9103 a[6] -= xr; 9104 xr = a[4]; 9105 a[4] += a[27]; 9106 a[27] -= xr; 9107 xr = a[5]; 9108 a[5] += a[26]; 9109 a[26] -= xr; 9110 xr = a[20]; 9111 a[20] += a[11]; 9112 a[11] -= xr; 9113 xr = a[21]; 9114 a[21] += a[10]; 9115 a[10] -= xr; 9116 xr = a[12]; 9117 a[12] += a[19]; 9118 a[19] -= xr; 9119 xr = a[13]; 9120 a[13] += a[18]; 9121 a[18] -= xr; 9122 xr = a[28]; 9123 a[28] += a[3]; 9124 a[3] -= xr; 9125 xr = a[29]; 9126 a[29] += a[2]; 9127 a[2] -= xr; 9128 } 9129 } 9130 9131 /** 9132 * Function: Calculation of the MDCT In the case of long blocks (type 0,1,3) 9133 * there are 36 coefficents in the time domain and 18 in the frequency 9134 * domain.<BR> 9135 * In the case of short blocks (type 2) there are 3 transformations with 9136 * short length. This leads to 12 coefficents in the time and 6 in the 9137 * frequency domain. In this case the results are stored side by side in the 9138 * vector out[]. 9139 * 9140 * New layer3 9141 */ 9142 function mdct_short(inout, inoutPos) { 9143 for (var l = 0; l < 3; l++) { 9144 var tc0, tc1, tc2, ts0, ts1, ts2; 9145 9146 ts0 = inout[inoutPos + 2 * 3] * win[Encoder.SHORT_TYPE][0] 9147 - inout[inoutPos + 5 * 3]; 9148 tc0 = inout[inoutPos + 0 * 3] * win[Encoder.SHORT_TYPE][2] 9149 - inout[inoutPos + 3 * 3]; 9150 tc1 = ts0 + tc0; 9151 tc2 = ts0 - tc0; 9152 9153 ts0 = inout[inoutPos + 5 * 3] * win[Encoder.SHORT_TYPE][0] 9154 + inout[inoutPos + 2 * 3]; 9155 tc0 = inout[inoutPos + 3 * 3] * win[Encoder.SHORT_TYPE][2] 9156 + inout[inoutPos + 0 * 3]; 9157 ts1 = ts0 + tc0; 9158 ts2 = -ts0 + tc0; 9159 9160 tc0 = (inout[inoutPos + 1 * 3] * win[Encoder.SHORT_TYPE][1] - inout[inoutPos + 4 * 3]) * 2.069978111953089e-11; 9161 /* 9162 * tritab_s [ 1 ] 9163 */ 9164 ts0 = (inout[inoutPos + 4 * 3] * win[Encoder.SHORT_TYPE][1] + inout[inoutPos + 1 * 3]) * 2.069978111953089e-11; 9165 /* 9166 * tritab_s [ 1 ] 9167 */ 9168 inout[inoutPos + 3 * 0] = tc1 * 1.907525191737280e-11 + tc0; 9169 /* 9170 * tritab_s[ 2 ] 9171 */ 9172 inout[inoutPos + 3 * 5] = -ts1 * 1.907525191737280e-11 + ts0; 9173 /* 9174 * tritab_s[0 ] 9175 */ 9176 tc2 = tc2 * 0.86602540378443870761 * 1.907525191737281e-11; 9177 /* 9178 * tritab_s[ 2] 9179 */ 9180 ts1 = ts1 * 0.5 * 1.907525191737281e-11 + ts0; 9181 inout[inoutPos + 3 * 1] = tc2 - ts1; 9182 inout[inoutPos + 3 * 2] = tc2 + ts1; 9183 9184 tc1 = tc1 * 0.5 * 1.907525191737281e-11 - tc0; 9185 ts2 = ts2 * 0.86602540378443870761 * 1.907525191737281e-11; 9186 /* 9187 * tritab_s[ 0] 9188 */ 9189 inout[inoutPos + 3 * 3] = tc1 + ts2; 9190 inout[inoutPos + 3 * 4] = tc1 - ts2; 9191 9192 inoutPos++; 9193 } 9194 } 9195 9196 function mdct_long(out, outPos, _in) { 9197 var ct, st; 9198 { 9199 var tc1, tc2, tc3, tc4, ts5, ts6, ts7, ts8; 9200 /* 1,2, 5,6, 9,10, 13,14, 17 */ 9201 tc1 = _in[17] - _in[9]; 9202 tc3 = _in[15] - _in[11]; 9203 tc4 = _in[14] - _in[12]; 9204 ts5 = _in[0] + _in[8]; 9205 ts6 = _in[1] + _in[7]; 9206 ts7 = _in[2] + _in[6]; 9207 ts8 = _in[3] + _in[5]; 9208 9209 out[outPos + 17] = (ts5 + ts7 - ts8) - (ts6 - _in[4]); 9210 st = (ts5 + ts7 - ts8) * cx[12 + 7] + (ts6 - _in[4]); 9211 ct = (tc1 - tc3 - tc4) * cx[12 + 6]; 9212 out[outPos + 5] = ct + st; 9213 out[outPos + 6] = ct - st; 9214 9215 tc2 = (_in[16] - _in[10]) * cx[12 + 6]; 9216 ts6 = ts6 * cx[12 + 7] + _in[4]; 9217 ct = tc1 * cx[12 + 0] + tc2 + tc3 * cx[12 + 1] + tc4 * cx[12 + 2]; 9218 st = -ts5 * cx[12 + 4] + ts6 - ts7 * cx[12 + 5] + ts8 * cx[12 + 3]; 9219 out[outPos + 1] = ct + st; 9220 out[outPos + 2] = ct - st; 9221 9222 ct = tc1 * cx[12 + 1] - tc2 - tc3 * cx[12 + 2] + tc4 * cx[12 + 0]; 9223 st = -ts5 * cx[12 + 5] + ts6 - ts7 * cx[12 + 3] + ts8 * cx[12 + 4]; 9224 out[outPos + 9] = ct + st; 9225 out[outPos + 10] = ct - st; 9226 9227 ct = tc1 * cx[12 + 2] - tc2 + tc3 * cx[12 + 0] - tc4 * cx[12 + 1]; 9228 st = ts5 * cx[12 + 3] - ts6 + ts7 * cx[12 + 4] - ts8 * cx[12 + 5]; 9229 out[outPos + 13] = ct + st; 9230 out[outPos + 14] = ct - st; 9231 } 9232 { 9233 var ts1, ts2, ts3, ts4, tc5, tc6, tc7, tc8; 9234 9235 ts1 = _in[8] - _in[0]; 9236 ts3 = _in[6] - _in[2]; 9237 ts4 = _in[5] - _in[3]; 9238 tc5 = _in[17] + _in[9]; 9239 tc6 = _in[16] + _in[10]; 9240 tc7 = _in[15] + _in[11]; 9241 tc8 = _in[14] + _in[12]; 9242 9243 out[outPos + 0] = (tc5 + tc7 + tc8) + (tc6 + _in[13]); 9244 ct = (tc5 + tc7 + tc8) * cx[12 + 7] - (tc6 + _in[13]); 9245 st = (ts1 - ts3 + ts4) * cx[12 + 6]; 9246 out[outPos + 11] = ct + st; 9247 out[outPos + 12] = ct - st; 9248 9249 ts2 = (_in[7] - _in[1]) * cx[12 + 6]; 9250 tc6 = _in[13] - tc6 * cx[12 + 7]; 9251 ct = tc5 * cx[12 + 3] - tc6 + tc7 * cx[12 + 4] + tc8 * cx[12 + 5]; 9252 st = ts1 * cx[12 + 2] + ts2 + ts3 * cx[12 + 0] + ts4 * cx[12 + 1]; 9253 out[outPos + 3] = ct + st; 9254 out[outPos + 4] = ct - st; 9255 9256 ct = -tc5 * cx[12 + 5] + tc6 - tc7 * cx[12 + 3] - tc8 * cx[12 + 4]; 9257 st = ts1 * cx[12 + 1] + ts2 - ts3 * cx[12 + 2] - ts4 * cx[12 + 0]; 9258 out[outPos + 7] = ct + st; 9259 out[outPos + 8] = ct - st; 9260 9261 ct = -tc5 * cx[12 + 4] + tc6 - tc7 * cx[12 + 5] - tc8 * cx[12 + 3]; 9262 st = ts1 * cx[12 + 0] - ts2 + ts3 * cx[12 + 1] - ts4 * cx[12 + 2]; 9263 out[outPos + 15] = ct + st; 9264 out[outPos + 16] = ct - st; 9265 } 9266 } 9267 9268 this.mdct_sub48 = function(gfc, w0, w1) { 9269 var wk = w0; 9270 var wkPos = 286; 9271 /* thinking cache performance, ch->gr loop is better than gr->ch loop */ 9272 for (var ch = 0; ch < gfc.channels_out; ch++) { 9273 for (var gr = 0; gr < gfc.mode_gr; gr++) { 9274 var band; 9275 var gi = (gfc.l3_side.tt[gr][ch]); 9276 var mdct_enc = gi.xr; 9277 var mdct_encPos = 0; 9278 var samp = gfc.sb_sample[ch][1 - gr]; 9279 var sampPos = 0; 9280 9281 for (var k = 0; k < 18 / 2; k++) { 9282 window_subband(wk, wkPos, samp[sampPos]); 9283 window_subband(wk, wkPos + 32, samp[sampPos + 1]); 9284 sampPos += 2; 9285 wkPos += 64; 9286 /* 9287 * Compensate for inversion in the analysis filter 9288 */ 9289 for (band = 1; band < 32; band += 2) { 9290 samp[sampPos - 1][band] *= -1; 9291 } 9292 } 9293 9294 /* 9295 * Perform imdct of 18 previous subband samples + 18 current 9296 * subband samples 9297 */ 9298 for (band = 0; band < 32; band++, mdct_encPos += 18) { 9299 var type = gi.block_type; 9300 var band0 = gfc.sb_sample[ch][gr]; 9301 var band1 = gfc.sb_sample[ch][1 - gr]; 9302 if (gi.mixed_block_flag != 0 && band < 2) 9303 type = 0; 9304 if (gfc.amp_filter[band] < 1e-12) { 9305 Arrays.fill(mdct_enc, mdct_encPos + 0, 9306 mdct_encPos + 18, 0); 9307 } else { 9308 if (gfc.amp_filter[band] < 1.0) { 9309 for (var k = 0; k < 18; k++) 9310 band1[k][order[band]] *= gfc.amp_filter[band]; 9311 } 9312 if (type == Encoder.SHORT_TYPE) { 9313 for (var k = -NS / 4; k < 0; k++) { 9314 var w = win[Encoder.SHORT_TYPE][k + 3]; 9315 mdct_enc[mdct_encPos + k * 3 + 9] = band0[9 + k][order[band]] 9316 * w - band0[8 - k][order[band]]; 9317 mdct_enc[mdct_encPos + k * 3 + 18] = band0[14 - k][order[band]] 9318 * w + band0[15 + k][order[band]]; 9319 mdct_enc[mdct_encPos + k * 3 + 10] = band0[15 + k][order[band]] 9320 * w - band0[14 - k][order[band]]; 9321 mdct_enc[mdct_encPos + k * 3 + 19] = band1[2 - k][order[band]] 9322 * w + band1[3 + k][order[band]]; 9323 mdct_enc[mdct_encPos + k * 3 + 11] = band1[3 + k][order[band]] 9324 * w - band1[2 - k][order[band]]; 9325 mdct_enc[mdct_encPos + k * 3 + 20] = band1[8 - k][order[band]] 9326 * w + band1[9 + k][order[band]]; 9327 } 9328 mdct_short(mdct_enc, mdct_encPos); 9329 } else { 9330 var work = new_float(18); 9331 for (var k = -NL / 4; k < 0; k++) { 9332 var a, b; 9333 a = win[type][k + 27] 9334 * band1[k + 9][order[band]] 9335 + win[type][k + 36] 9336 * band1[8 - k][order[band]]; 9337 b = win[type][k + 9] 9338 * band0[k + 9][order[band]] 9339 - win[type][k + 18] 9340 * band0[8 - k][order[band]]; 9341 work[k + 9] = a - b * tantab_l[3 + k + 9]; 9342 work[k + 18] = a * tantab_l[3 + k + 9] + b; 9343 } 9344 9345 mdct_long(mdct_enc, mdct_encPos, work); 9346 } 9347 } 9348 /* 9349 * Perform aliasing reduction butterfly 9350 */ 9351 if (type != Encoder.SHORT_TYPE && band != 0) { 9352 for (var k = 7; k >= 0; --k) { 9353 var bu, bd; 9354 bu = mdct_enc[mdct_encPos + k] * ca[20 + k] 9355 + mdct_enc[mdct_encPos + -1 - k] 9356 * cs[28 + k]; 9357 bd = mdct_enc[mdct_encPos + k] * cs[28 + k] 9358 - mdct_enc[mdct_encPos + -1 - k] 9359 * ca[20 + k]; 9360 9361 mdct_enc[mdct_encPos + -1 - k] = bu; 9362 mdct_enc[mdct_encPos + k] = bd; 9363 } 9364 } 9365 } 9366 } 9367 wk = w1; 9368 wkPos = 286; 9369 if (gfc.mode_gr == 1) { 9370 for (var i = 0; i < 18; i++) { 9371 System.arraycopy(gfc.sb_sample[ch][1][i], 0, 9372 gfc.sb_sample[ch][0][i], 0, 32); 9373 } 9374 } 9375 } 9376 } 9377} 9378 9379//package mp3; 9380 9381 9382function III_psy_ratio() { 9383 this.thm = new III_psy_xmin(); 9384 this.en = new III_psy_xmin(); 9385} 9386 9387 9388/** 9389 * ENCDELAY The encoder delay. 9390 * 9391 * Minimum allowed is MDCTDELAY (see below) 9392 * 9393 * The first 96 samples will be attenuated, so using a value less than 96 9394 * will result in corrupt data for the first 96-ENCDELAY samples. 9395 * 9396 * suggested: 576 set to 1160 to sync with FhG. 9397 */ 9398Encoder.ENCDELAY = 576; 9399/** 9400 * make sure there is at least one complete frame after the last frame 9401 * containing real data 9402 * 9403 * Using a value of 288 would be sufficient for a a very sophisticated 9404 * decoder that can decode granule-by-granule instead of frame by frame. But 9405 * lets not assume this, and assume the decoder will not decode frame N 9406 * unless it also has data for frame N+1 9407 */ 9408Encoder.POSTDELAY = 1152; 9409 9410/** 9411 * delay of the MDCT used in mdct.c original ISO routines had a delay of 9412 * 528! Takehiro's routines: 9413 */ 9414Encoder.MDCTDELAY = 48; 9415Encoder.FFTOFFSET = (224 + Encoder.MDCTDELAY); 9416 9417/** 9418 * Most decoders, including the one we use, have a delay of 528 samples. 9419 */ 9420Encoder.DECDELAY = 528; 9421 9422/** 9423 * number of subbands 9424 */ 9425Encoder.SBLIMIT = 32; 9426 9427/** 9428 * parition bands bands 9429 */ 9430Encoder.CBANDS = 64; 9431 9432/** 9433 * number of critical bands/scale factor bands where masking is computed 9434 */ 9435Encoder.SBPSY_l = 21; 9436Encoder.SBPSY_s = 12; 9437 9438/** 9439 * total number of scalefactor bands encoded 9440 */ 9441Encoder.SBMAX_l = 22; 9442Encoder.SBMAX_s = 13; 9443Encoder.PSFB21 = 6; 9444Encoder.PSFB12 = 6; 9445 9446/** 9447 * FFT sizes 9448 */ 9449Encoder.BLKSIZE = 1024; 9450Encoder.HBLKSIZE = (Encoder.BLKSIZE / 2 + 1); 9451Encoder.BLKSIZE_s = 256; 9452Encoder.HBLKSIZE_s = (Encoder.BLKSIZE_s / 2 + 1); 9453 9454Encoder.NORM_TYPE = 0; 9455Encoder.START_TYPE = 1; 9456Encoder.SHORT_TYPE = 2; 9457Encoder.STOP_TYPE = 3; 9458 9459/** 9460 * <PRE> 9461 * Mode Extention: 9462 * When we are in stereo mode, there are 4 possible methods to store these 9463 * two channels. The stereo modes -m? are using a subset of them. 9464 * 9465 * -ms: MPG_MD_LR_LR 9466 * -mj: MPG_MD_LR_LR and MPG_MD_MS_LR 9467 * -mf: MPG_MD_MS_LR 9468 * -mi: all 9469 * </PRE> 9470 */ 9471Encoder.MPG_MD_LR_LR = 0; 9472Encoder.MPG_MD_LR_I = 1; 9473Encoder.MPG_MD_MS_LR = 2; 9474Encoder.MPG_MD_MS_I = 3; 9475 9476Encoder.fircoef = [-0.0207887 * 5, -0.0378413 * 5, 9477 -0.0432472 * 5, -0.031183 * 5, 7.79609e-18 * 5, 0.0467745 * 5, 9478 0.10091 * 5, 0.151365 * 5, 0.187098 * 5]; 9479 9480function Encoder() { 9481 9482 var FFTOFFSET = Encoder.FFTOFFSET; 9483 var MPG_MD_MS_LR = Encoder.MPG_MD_MS_LR; 9484 //BitStream bs; 9485 //PsyModel psy; 9486 //VBRTag vbr; 9487 //QuantizePVT qupvt; 9488 var bs = null; 9489 this.psy = null; 9490 var psy = null; 9491 var vbr = null; 9492 var qupvt = null; 9493 9494 //public final void setModules(BitStream bs, PsyModel psy, QuantizePVT qupvt, 9495 // VBRTag vbr) { 9496 this.setModules = function (_bs, _psy, _qupvt, _vbr) { 9497 bs = _bs; 9498 this.psy = _psy; 9499 psy = _psy; 9500 vbr = _vbr; 9501 qupvt = _qupvt; 9502 }; 9503 9504 var newMDCT = new NewMDCT(); 9505 9506 /*********************************************************************** 9507 * 9508 * encoder and decoder delays 9509 * 9510 ***********************************************************************/ 9511 9512 /** 9513 * <PRE> 9514 * layer III enc->dec delay: 1056 (1057?) (observed) 9515 * layer II enc->dec delay: 480 (481?) (observed) 9516 * 9517 * polyphase 256-16 (dec or enc) = 240 9518 * mdct 256+32 (9*32) (dec or enc) = 288 9519 * total: 512+16 9520 * 9521 * My guess is that delay of polyphase filterbank is actualy 240.5 9522 * (there are technical reasons for this, see postings in mp3encoder). 9523 * So total Encode+Decode delay = ENCDELAY + 528 + 1 9524 * </PRE> 9525 */ 9526 9527 9528 /** 9529 * auto-adjust of ATH, useful for low volume Gabriel Bouvigne 3 feb 2001 9530 * 9531 * modifies some values in gfp.internal_flags.ATH (gfc.ATH) 9532 */ 9533//private void adjust_ATH(final LameInternalFlags gfc) { 9534 function adjust_ATH(gfc) { 9535 var gr2_max, max_pow; 9536 9537 if (gfc.ATH.useAdjust == 0) { 9538 gfc.ATH.adjust = 1.0; 9539 /* no adjustment */ 9540 return; 9541 } 9542 9543 /* jd - 2001 mar 12, 27, jun 30 */ 9544 /* loudness based on equal loudness curve; */ 9545 /* use granule with maximum combined loudness */ 9546 max_pow = gfc.loudness_sq[0][0]; 9547 gr2_max = gfc.loudness_sq[1][0]; 9548 if (gfc.channels_out == 2) { 9549 max_pow += gfc.loudness_sq[0][1]; 9550 gr2_max += gfc.loudness_sq[1][1]; 9551 } else { 9552 max_pow += max_pow; 9553 gr2_max += gr2_max; 9554 } 9555 if (gfc.mode_gr == 2) { 9556 max_pow = Math.max(max_pow, gr2_max); 9557 } 9558 max_pow *= 0.5; 9559 /* max_pow approaches 1.0 for full band noise */ 9560 9561 /* jd - 2001 mar 31, jun 30 */ 9562 /* user tuning of ATH adjustment region */ 9563 max_pow *= gfc.ATH.aaSensitivityP; 9564 9565 /* 9566 * adjust ATH depending on range of maximum value 9567 */ 9568 9569 /* jd - 2001 feb27, mar12,20, jun30, jul22 */ 9570 /* continuous curves based on approximation */ 9571 /* to GB's original values. */ 9572 /* For an increase in approximate loudness, */ 9573 /* set ATH adjust to adjust_limit immediately */ 9574 /* after a delay of one frame. */ 9575 /* For a loudness decrease, reduce ATH adjust */ 9576 /* towards adjust_limit gradually. */ 9577 /* max_pow is a loudness squared or a power. */ 9578 if (max_pow > 0.03125) { /* ((1 - 0.000625)/ 31.98) from curve below */ 9579 if (gfc.ATH.adjust >= 1.0) { 9580 gfc.ATH.adjust = 1.0; 9581 } else { 9582 /* preceding frame has lower ATH adjust; */ 9583 /* ascend only to the preceding adjust_limit */ 9584 /* in case there is leading low volume */ 9585 if (gfc.ATH.adjust < gfc.ATH.adjustLimit) { 9586 gfc.ATH.adjust = gfc.ATH.adjustLimit; 9587 } 9588 } 9589 gfc.ATH.adjustLimit = 1.0; 9590 } else { /* adjustment curve */ 9591 /* about 32 dB maximum adjust (0.000625) */ 9592 var adj_lim_new = 31.98 * max_pow + 0.000625; 9593 if (gfc.ATH.adjust >= adj_lim_new) { /* descend gradually */ 9594 gfc.ATH.adjust *= adj_lim_new * 0.075 + 0.925; 9595 if (gfc.ATH.adjust < adj_lim_new) { /* stop descent */ 9596 gfc.ATH.adjust = adj_lim_new; 9597 } 9598 } else { /* ascend */ 9599 if (gfc.ATH.adjustLimit >= adj_lim_new) { 9600 gfc.ATH.adjust = adj_lim_new; 9601 } else { 9602 /* preceding frame has lower ATH adjust; */ 9603 /* ascend only to the preceding adjust_limit */ 9604 if (gfc.ATH.adjust < gfc.ATH.adjustLimit) { 9605 gfc.ATH.adjust = gfc.ATH.adjustLimit; 9606 } 9607 } 9608 } 9609 gfc.ATH.adjustLimit = adj_lim_new; 9610 } 9611 } 9612 9613 /** 9614 * <PRE> 9615 * some simple statistics 9616 * 9617 * bitrate index 0: free bitrate . not allowed in VBR mode 9618 * : bitrates, kbps depending on MPEG version 9619 * bitrate index 15: forbidden 9620 * 9621 * mode_ext: 9622 * 0: LR 9623 * 1: LR-i 9624 * 2: MS 9625 * 3: MS-i 9626 * </PRE> 9627 */ 9628 function updateStats(gfc) { 9629 var gr, ch; 9630 9631 /* count bitrate indices */ 9632 gfc.bitrate_stereoMode_Hist[gfc.bitrate_index][4]++; 9633 gfc.bitrate_stereoMode_Hist[15][4]++; 9634 9635 /* count 'em for every mode extension in case of 2 channel encoding */ 9636 if (gfc.channels_out == 2) { 9637 gfc.bitrate_stereoMode_Hist[gfc.bitrate_index][gfc.mode_ext]++; 9638 gfc.bitrate_stereoMode_Hist[15][gfc.mode_ext]++; 9639 } 9640 for (gr = 0; gr < gfc.mode_gr; ++gr) { 9641 for (ch = 0; ch < gfc.channels_out; ++ch) { 9642 var bt = gfc.l3_side.tt[gr][ch].block_type | 0; 9643 if (gfc.l3_side.tt[gr][ch].mixed_block_flag != 0) 9644 bt = 4; 9645 gfc.bitrate_blockType_Hist[gfc.bitrate_index][bt]++; 9646 gfc.bitrate_blockType_Hist[gfc.bitrate_index][5]++; 9647 gfc.bitrate_blockType_Hist[15][bt]++; 9648 gfc.bitrate_blockType_Hist[15][5]++; 9649 } 9650 } 9651 } 9652 9653 function lame_encode_frame_init(gfp, inbuf) { 9654 var gfc = gfp.internal_flags; 9655 9656 var ch, gr; 9657 9658 if (gfc.lame_encode_frame_init == 0) { 9659 /* prime the MDCT/polyphase filterbank with a short block */ 9660 var i, j; 9661 var primebuff0 = new_float(286 + 1152 + 576); 9662 var primebuff1 = new_float(286 + 1152 + 576); 9663 gfc.lame_encode_frame_init = 1; 9664 for (i = 0, j = 0; i < 286 + 576 * (1 + gfc.mode_gr); ++i) { 9665 if (i < 576 * gfc.mode_gr) { 9666 primebuff0[i] = 0; 9667 if (gfc.channels_out == 2) 9668 primebuff1[i] = 0; 9669 } else { 9670 primebuff0[i] = inbuf[0][j]; 9671 if (gfc.channels_out == 2) 9672 primebuff1[i] = inbuf[1][j]; 9673 ++j; 9674 } 9675 } 9676 /* polyphase filtering / mdct */ 9677 for (gr = 0; gr < gfc.mode_gr; gr++) { 9678 for (ch = 0; ch < gfc.channels_out; ch++) { 9679 gfc.l3_side.tt[gr][ch].block_type = Encoder.SHORT_TYPE; 9680 } 9681 } 9682 newMDCT.mdct_sub48(gfc, primebuff0, primebuff1); 9683 9684 /* check FFT will not use a negative starting offset */ 9685 /* check if we have enough data for FFT */ 9686 /* check if we have enough data for polyphase filterbank */ 9687 } 9688 9689 } 9690 9691 /** 9692 * <PRE> 9693 * encodeframe() Layer 3 9694 * 9695 * encode a single frame 9696 * 9697 * 9698 * lame_encode_frame() 9699 * 9700 * 9701 * gr 0 gr 1 9702 * inbuf: |--------------|--------------|--------------| 9703 * 9704 * 9705 * Polyphase (18 windows, each shifted 32) 9706 * gr 0: 9707 * window1 <----512---. 9708 * window18 <----512---. 9709 * 9710 * gr 1: 9711 * window1 <----512---. 9712 * window18 <----512---. 9713 * 9714 * 9715 * 9716 * MDCT output: |--------------|--------------|--------------| 9717 * 9718 * FFT's <---------1024---------. 9719 * <---------1024-------. 9720 * 9721 * 9722 * 9723 * inbuf = buffer of PCM data size=MP3 framesize 9724 * encoder acts on inbuf[ch][0], but output is delayed by MDCTDELAY 9725 * so the MDCT coefficints are from inbuf[ch][-MDCTDELAY] 9726 * 9727 * psy-model FFT has a 1 granule delay, so we feed it data for the 9728 * next granule. 9729 * FFT is centered over granule: 224+576+224 9730 * So FFT starts at: 576-224-MDCTDELAY 9731 * 9732 * MPEG2: FFT ends at: BLKSIZE+576-224-MDCTDELAY (1328) 9733 * MPEG1: FFT ends at: BLKSIZE+2*576-224-MDCTDELAY (1904) 9734 * 9735 * MPEG2: polyphase first window: [0..511] 9736 * 18th window: [544..1055] (1056) 9737 * MPEG1: 36th window: [1120..1631] (1632) 9738 * data needed: 512+framesize-32 9739 * 9740 * A close look newmdct.c shows that the polyphase filterbank 9741 * only uses data from [0..510] for each window. Perhaps because the window 9742 * used by the filterbank is zero for the last point, so Takehiro's 9743 * code doesn't bother to compute with it. 9744 * 9745 * FFT starts at 576-224-MDCTDELAY (304) = 576-FFTOFFSET 9746 * 9747 * </PRE> 9748 */ 9749 9750 9751 this.lame_encode_mp3_frame = function (gfp, inbuf_l, inbuf_r, mp3buf, mp3bufPos, mp3buf_size) { 9752 var mp3count; 9753 var masking_LR = new_array_n([2, 2]); 9754 /* 9755 * LR masking & 9756 * energy 9757 */ 9758 masking_LR[0][0] = new III_psy_ratio(); 9759 masking_LR[0][1] = new III_psy_ratio(); 9760 masking_LR[1][0] = new III_psy_ratio(); 9761 masking_LR[1][1] = new III_psy_ratio(); 9762 var masking_MS = new_array_n([2, 2]); 9763 /* MS masking & energy */ 9764 masking_MS[0][0] = new III_psy_ratio(); 9765 masking_MS[0][1] = new III_psy_ratio(); 9766 masking_MS[1][0] = new III_psy_ratio(); 9767 masking_MS[1][1] = new III_psy_ratio(); 9768 //III_psy_ratio masking[][]; 9769 var masking; 9770 /* pointer to selected maskings */ 9771 var inbuf = [null, null]; 9772 var gfc = gfp.internal_flags; 9773 9774 var tot_ener = new_float_n([2, 4]); 9775 var ms_ener_ratio = [.5, .5]; 9776 var pe = [[0., 0.], [0., 0.]]; 9777 var pe_MS = [[0., 0.], [0., 0.]]; 9778 9779//float[][] pe_use; 9780 var pe_use; 9781 9782 var ch, gr; 9783 9784 inbuf[0] = inbuf_l; 9785 inbuf[1] = inbuf_r; 9786 9787 if (gfc.lame_encode_frame_init == 0) { 9788 /* first run? */ 9789 lame_encode_frame_init(gfp, inbuf); 9790 9791 } 9792 9793 /********************** padding *****************************/ 9794 /** 9795 * <PRE> 9796 * padding method as described in 9797 * "MPEG-Layer3 / Bitstream Syntax and Decoding" 9798 * by Martin Sieler, Ralph Sperschneider 9799 * 9800 * note: there is no padding for the very first frame 9801 * 9802 * Robert Hegemann 2000-06-22 9803 * </PRE> 9804 */ 9805 gfc.padding = 0; 9806 if ((gfc.slot_lag -= gfc.frac_SpF) < 0) { 9807 gfc.slot_lag += gfp.out_samplerate; 9808 gfc.padding = 1; 9809 } 9810 9811 /**************************************** 9812 * Stage 1: psychoacoustic model * 9813 ****************************************/ 9814 9815 if (gfc.psymodel != 0) { 9816 /* 9817 * psychoacoustic model psy model has a 1 granule (576) delay that 9818 * we must compensate for (mt 6/99). 9819 */ 9820 var ret; 9821 var bufp = [null, null]; 9822 /* address of beginning of left & right granule */ 9823 var bufpPos = 0; 9824 /* address of beginning of left & right granule */ 9825 var blocktype = new_int(2); 9826 9827 for (gr = 0; gr < gfc.mode_gr; gr++) { 9828 9829 for (ch = 0; ch < gfc.channels_out; ch++) { 9830 bufp[ch] = inbuf[ch]; 9831 bufpPos = 576 + gr * 576 - Encoder.FFTOFFSET; 9832 } 9833 if (gfp.VBR == VbrMode.vbr_mtrh || gfp.VBR == VbrMode.vbr_mt) { 9834 ret = psy.L3psycho_anal_vbr(gfp, bufp, bufpPos, gr, 9835 masking_LR, masking_MS, pe[gr], pe_MS[gr], 9836 tot_ener[gr], blocktype); 9837 } else { 9838 ret = psy.L3psycho_anal_ns(gfp, bufp, bufpPos, gr, 9839 masking_LR, masking_MS, pe[gr], pe_MS[gr], 9840 tot_ener[gr], blocktype); 9841 } 9842 if (ret != 0) 9843 return -4; 9844 9845 if (gfp.mode == MPEGMode.JOINT_STEREO) { 9846 ms_ener_ratio[gr] = tot_ener[gr][2] + tot_ener[gr][3]; 9847 if (ms_ener_ratio[gr] > 0) 9848 ms_ener_ratio[gr] = tot_ener[gr][3] / ms_ener_ratio[gr]; 9849 } 9850 9851 /* block type flags */ 9852 for (ch = 0; ch < gfc.channels_out; ch++) { 9853 var cod_info = gfc.l3_side.tt[gr][ch]; 9854 cod_info.block_type = blocktype[ch]; 9855 cod_info.mixed_block_flag = 0; 9856 } 9857 } 9858 } else { 9859 /* no psy model */ 9860 for (gr = 0; gr < gfc.mode_gr; gr++) 9861 for (ch = 0; ch < gfc.channels_out; ch++) { 9862 gfc.l3_side.tt[gr][ch].block_type = Encoder.NORM_TYPE; 9863 gfc.l3_side.tt[gr][ch].mixed_block_flag = 0; 9864 pe_MS[gr][ch] = pe[gr][ch] = 700; 9865 } 9866 } 9867 9868 /* auto-adjust of ATH, useful for low volume */ 9869 adjust_ATH(gfc); 9870 9871 /**************************************** 9872 * Stage 2: MDCT * 9873 ****************************************/ 9874 9875 /* polyphase filtering / mdct */ 9876 newMDCT.mdct_sub48(gfc, inbuf[0], inbuf[1]); 9877 9878 /**************************************** 9879 * Stage 3: MS/LR decision * 9880 ****************************************/ 9881 9882 /* Here will be selected MS or LR coding of the 2 stereo channels */ 9883 gfc.mode_ext = Encoder.MPG_MD_LR_LR; 9884 9885 if (gfp.force_ms) { 9886 gfc.mode_ext = Encoder.MPG_MD_MS_LR; 9887 } else if (gfp.mode == MPEGMode.JOINT_STEREO) { 9888 /* 9889 * ms_ratio = is scaled, for historical reasons, to look like a 9890 * ratio of side_channel / total. 0 = signal is 100% mono .5 = L & R 9891 * uncorrelated 9892 */ 9893 9894 /** 9895 * <PRE> 9896 * [0] and [1] are the results for the two granules in MPEG-1, 9897 * in MPEG-2 it's only a faked averaging of the same value 9898 * _prev is the value of the last granule of the previous frame 9899 * _next is the value of the first granule of the next frame 9900 * </PRE> 9901 */ 9902 9903 var sum_pe_MS = 0.; 9904 var sum_pe_LR = 0.; 9905 for (gr = 0; gr < gfc.mode_gr; gr++) { 9906 for (ch = 0; ch < gfc.channels_out; ch++) { 9907 sum_pe_MS += pe_MS[gr][ch]; 9908 sum_pe_LR += pe[gr][ch]; 9909 } 9910 } 9911 9912 /* based on PE: M/S coding would not use much more bits than L/R */ 9913 if (sum_pe_MS <= 1.00 * sum_pe_LR) { 9914 9915 var gi0 = gfc.l3_side.tt[0]; 9916 var gi1 = gfc.l3_side.tt[gfc.mode_gr - 1]; 9917 9918 if (gi0[0].block_type == gi0[1].block_type 9919 && gi1[0].block_type == gi1[1].block_type) { 9920 9921 gfc.mode_ext = Encoder.MPG_MD_MS_LR; 9922 } 9923 } 9924 } 9925 9926 /* bit and noise allocation */ 9927 if (gfc.mode_ext == MPG_MD_MS_LR) { 9928 masking = masking_MS; 9929 /* use MS masking */ 9930 pe_use = pe_MS; 9931 } else { 9932 masking = masking_LR; 9933 /* use LR masking */ 9934 pe_use = pe; 9935 } 9936 9937 /* copy data for MP3 frame analyzer */ 9938 if (gfp.analysis && gfc.pinfo != null) { 9939 for (gr = 0; gr < gfc.mode_gr; gr++) { 9940 for (ch = 0; ch < gfc.channels_out; ch++) { 9941 gfc.pinfo.ms_ratio[gr] = gfc.ms_ratio[gr]; 9942 gfc.pinfo.ms_ener_ratio[gr] = ms_ener_ratio[gr]; 9943 gfc.pinfo.blocktype[gr][ch] = gfc.l3_side.tt[gr][ch].block_type; 9944 gfc.pinfo.pe[gr][ch] = pe_use[gr][ch]; 9945 System.arraycopy(gfc.l3_side.tt[gr][ch].xr, 0, 9946 gfc.pinfo.xr[gr][ch], 0, 576); 9947 /* 9948 * in psymodel, LR and MS data was stored in pinfo. switch 9949 * to MS data: 9950 */ 9951 if (gfc.mode_ext == MPG_MD_MS_LR) { 9952 gfc.pinfo.ers[gr][ch] = gfc.pinfo.ers[gr][ch + 2]; 9953 System.arraycopy(gfc.pinfo.energy[gr][ch + 2], 0, 9954 gfc.pinfo.energy[gr][ch], 0, 9955 gfc.pinfo.energy[gr][ch].length); 9956 } 9957 } 9958 } 9959 } 9960 9961 /**************************************** 9962 * Stage 4: quantization loop * 9963 ****************************************/ 9964 9965 if (gfp.VBR == VbrMode.vbr_off || gfp.VBR == VbrMode.vbr_abr) { 9966 9967 var i; 9968 var f; 9969 9970 for (i = 0; i < 18; i++) 9971 gfc.nsPsy.pefirbuf[i] = gfc.nsPsy.pefirbuf[i + 1]; 9972 9973 f = 0.0; 9974 for (gr = 0; gr < gfc.mode_gr; gr++) 9975 for (ch = 0; ch < gfc.channels_out; ch++) 9976 f += pe_use[gr][ch]; 9977 gfc.nsPsy.pefirbuf[18] = f; 9978 9979 f = gfc.nsPsy.pefirbuf[9]; 9980 for (i = 0; i < 9; i++) 9981 f += (gfc.nsPsy.pefirbuf[i] + gfc.nsPsy.pefirbuf[18 - i]) 9982 * Encoder.fircoef[i]; 9983 9984 f = (670 * 5 * gfc.mode_gr * gfc.channels_out) / f; 9985 for (gr = 0; gr < gfc.mode_gr; gr++) { 9986 for (ch = 0; ch < gfc.channels_out; ch++) { 9987 pe_use[gr][ch] *= f; 9988 } 9989 } 9990 } 9991 gfc.iteration_loop.iteration_loop(gfp, pe_use, ms_ener_ratio, masking); 9992 9993 /**************************************** 9994 * Stage 5: bitstream formatting * 9995 ****************************************/ 9996 9997 /* write the frame to the bitstream */ 9998 bs.format_bitstream(gfp); 9999 10000 /* copy mp3 bit buffer into array */ 10001 mp3count = bs.copy_buffer(gfc, mp3buf, mp3bufPos, mp3buf_size, 1); 10002 10003 if (gfp.bWriteVbrTag) 10004 vbr.addVbrFrame(gfp); 10005 10006 if (gfp.analysis && gfc.pinfo != null) { 10007 for (ch = 0; ch < gfc.channels_out; ch++) { 10008 var j; 10009 for (j = 0; j < FFTOFFSET; j++) 10010 gfc.pinfo.pcmdata[ch][j] = gfc.pinfo.pcmdata[ch][j 10011 + gfp.framesize]; 10012 for (j = FFTOFFSET; j < 1600; j++) { 10013 gfc.pinfo.pcmdata[ch][j] = inbuf[ch][j - FFTOFFSET]; 10014 } 10015 } 10016 qupvt.set_frame_pinfo(gfp, masking); 10017 } 10018 10019 updateStats(gfc); 10020 10021 return mp3count; 10022 } 10023} 10024 10025 10026//package mp3; 10027 10028function VBRSeekInfo() { 10029 /** 10030 * What we have seen so far. 10031 */ 10032 this.sum = 0; 10033 /** 10034 * How many frames we have seen in this chunk. 10035 */ 10036 this.seen = 0; 10037 /** 10038 * How many frames we want to collect into one chunk. 10039 */ 10040 this.want = 0; 10041 /** 10042 * Actual position in our bag. 10043 */ 10044 this.pos = 0; 10045 /** 10046 * Size of our bag. 10047 */ 10048 this.size = 0; 10049 /** 10050 * Pointer to our bag. 10051 */ 10052 this.bag = null; 10053 this.nVbrNumFrames = 0; 10054 this.nBytesWritten = 0; 10055 /* VBR tag data */ 10056 this.TotalFrameSize = 0; 10057} 10058 10059 10060 10061function IIISideInfo() { 10062 this.tt = [[null, null], [null, null]]; 10063 this.main_data_begin = 0; 10064 this.private_bits = 0; 10065 this.resvDrain_pre = 0; 10066 this.resvDrain_post = 0; 10067 this.scfsi = [new_int(4), new_int(4)]; 10068 10069 for (var gr = 0; gr < 2; gr++) { 10070 for (var ch = 0; ch < 2; ch++) { 10071 this.tt[gr][ch] = new GrInfo(); 10072 } 10073 } 10074} 10075 10076 10077 10078//package mp3; 10079 10080/** 10081 * Variables used for --nspsytune 10082 * 10083 * @author Ken 10084 * 10085 */ 10086function NsPsy() { 10087 this.last_en_subshort = new_float_n([4, 9]); 10088 this.lastAttacks = new_int(4); 10089 this.pefirbuf = new_float(19); 10090 this.longfact = new_float(Encoder.SBMAX_l); 10091 this.shortfact = new_float(Encoder.SBMAX_s); 10092 10093 /** 10094 * short block tuning 10095 */ 10096 this.attackthre = 0.; 10097 this.attackthre_s = 0.; 10098} 10099 10100 10101function III_psy_xmin() { 10102 this.l = new_float(Encoder.SBMAX_l); 10103 this.s = new_float_n([Encoder.SBMAX_s, 3]); 10104 10105 var self = this; 10106 this.assign = function (iii_psy_xmin) { 10107 System.arraycopy(iii_psy_xmin.l, 0, self.l, 0, Encoder.SBMAX_l); 10108 for (var i = 0; i < Encoder.SBMAX_s; i++) { 10109 for (var j = 0; j < 3; j++) { 10110 self.s[i][j] = iii_psy_xmin.s[i][j]; 10111 } 10112 } 10113 } 10114} 10115 10116 10117 10118 10119LameInternalFlags.MFSIZE = (3 * 1152 + Encoder.ENCDELAY - Encoder.MDCTDELAY); 10120LameInternalFlags.MAX_HEADER_BUF = 256; 10121LameInternalFlags.MAX_BITS_PER_CHANNEL = 4095; 10122LameInternalFlags.MAX_BITS_PER_GRANULE = 7680; 10123LameInternalFlags.BPC = 320; 10124 10125function LameInternalFlags() { 10126 var MAX_HEADER_LEN = 40; 10127 10128 10129 /******************************************************************** 10130 * internal variables NOT set by calling program, and should not be * 10131 * modified by the calling program * 10132 ********************************************************************/ 10133 10134 /** 10135 * Some remarks to the Class_ID field: The Class ID is an Identifier for a 10136 * pointer to this struct. It is very unlikely that a pointer to 10137 * lame_global_flags has the same 32 bits in it's structure (large and other 10138 * special properties, for instance prime). 10139 * 10140 * To test that the structure is right and initialized, use: if ( gfc . 10141 * Class_ID == LAME_ID ) ... Other remark: If you set a flag to 0 for uninit 10142 * data and 1 for init data, the right test should be "if (flag == 1)" and 10143 * NOT "if (flag)". Unintended modification of this element will be 10144 * otherwise misinterpreted as an init. 10145 */ 10146 this.Class_ID = 0; 10147 10148 this.lame_encode_frame_init = 0; 10149 this.iteration_init_init = 0; 10150 this.fill_buffer_resample_init = 0; 10151 10152 //public float mfbuf[][] = new float[2][MFSIZE]; 10153 this.mfbuf = new_float_n([2, LameInternalFlags.MFSIZE]); 10154 10155 /** 10156 * granules per frame 10157 */ 10158 this.mode_gr = 0; 10159 /** 10160 * number of channels in the input data stream (PCM or decoded PCM) 10161 */ 10162 this.channels_in = 0; 10163 /** 10164 * number of channels in the output data stream (not used for decoding) 10165 */ 10166 this.channels_out = 0; 10167 /** 10168 * input_samp_rate/output_samp_rate 10169 */ 10170 //public double resample_ratio; 10171 this.resample_ratio = 0.; 10172 10173 this.mf_samples_to_encode = 0; 10174 this.mf_size = 0; 10175 /** 10176 * min bitrate index 10177 */ 10178 this.VBR_min_bitrate = 0; 10179 /** 10180 * max bitrate index 10181 */ 10182 this.VBR_max_bitrate = 0; 10183 this.bitrate_index = 0; 10184 this.samplerate_index = 0; 10185 this.mode_ext = 0; 10186 10187 /* lowpass and highpass filter control */ 10188 /** 10189 * normalized frequency bounds of passband 10190 */ 10191 this.lowpass1 = 0.; 10192 this.lowpass2 = 0.; 10193 /** 10194 * normalized frequency bounds of passband 10195 */ 10196 this.highpass1 = 0.; 10197 this.highpass2 = 0.; 10198 10199 /** 10200 * 0 = none 1 = ISO AAC model 2 = allow scalefac_select=1 10201 */ 10202 this.noise_shaping = 0; 10203 10204 /** 10205 * 0 = ISO model: amplify all distorted bands<BR> 10206 * 1 = amplify within 50% of max (on db scale)<BR> 10207 * 2 = amplify only most distorted band<BR> 10208 * 3 = method 1 and refine with method 2<BR> 10209 */ 10210 this.noise_shaping_amp = 0; 10211 /** 10212 * 0 = no substep<BR> 10213 * 1 = use substep shaping at last step(VBR only)<BR> 10214 * (not implemented yet)<BR> 10215 * 2 = use substep inside loop<BR> 10216 * 3 = use substep inside loop and last step<BR> 10217 */ 10218 this.substep_shaping = 0; 10219 10220 /** 10221 * 1 = gpsycho. 0 = none 10222 */ 10223 this.psymodel = 0; 10224 /** 10225 * 0 = stop at over=0, all scalefacs amplified or<BR> 10226 * a scalefac has reached max value<BR> 10227 * 1 = stop when all scalefacs amplified or a scalefac has reached max value<BR> 10228 * 2 = stop when all scalefacs amplified 10229 */ 10230 this.noise_shaping_stop = 0; 10231 10232 /** 10233 * 0 = no, 1 = yes 10234 */ 10235 this.subblock_gain = 0; 10236 /** 10237 * 0 = no. 1=outside loop 2=inside loop(slow) 10238 */ 10239 this.use_best_huffman = 0; 10240 10241 /** 10242 * 0 = stop early after 0 distortion found. 1 = full search 10243 */ 10244 this.full_outer_loop = 0; 10245 10246 //public IIISideInfo l3_side = new IIISideInfo(); 10247 this.l3_side = new IIISideInfo(); 10248 this.ms_ratio = new_float(2); 10249 10250 /* used for padding */ 10251 /** 10252 * padding for the current frame? 10253 */ 10254 this.padding = 0; 10255 this.frac_SpF = 0; 10256 this.slot_lag = 0; 10257 10258 /** 10259 * optional ID3 tags 10260 */ 10261 //public ID3TagSpec tag_spec; 10262 this.tag_spec = null; 10263 this.nMusicCRC = 0; 10264 10265 /* variables used by Quantize */ 10266 //public int OldValue[] = new int[2]; 10267 this.OldValue = new_int(2); 10268 //public int CurrentStep[] = new int[2]; 10269 this.CurrentStep = new_int(2); 10270 10271 this.masking_lower = 0.; 10272 //public int bv_scf[] = new int[576]; 10273 this.bv_scf = new_int(576); 10274 //public int pseudohalf[] = new int[L3Side.SFBMAX]; 10275 this.pseudohalf = new_int(L3Side.SFBMAX); 10276 10277 /** 10278 * will be set in lame_init_params 10279 */ 10280 this.sfb21_extra = false; 10281 10282 /* BPC = maximum number of filter convolution windows to precompute */ 10283 //public float[][] inbuf_old = new float[2][]; 10284 this.inbuf_old = new Array(2); 10285 //public float[][] blackfilt = new float[2 * BPC + 1][]; 10286 this.blackfilt = new Array(2 * LameInternalFlags.BPC + 1); 10287 //public double itime[] = new double[2]; 10288 this.itime = new_double(2); 10289 this.sideinfo_len = 0; 10290 10291 /* variables for newmdct.c */ 10292 //public float sb_sample[][][][] = new float[2][2][18][Encoder.SBLIMIT]; 10293 this.sb_sample = new_float_n([2, 2, 18, Encoder.SBLIMIT]); 10294 this.amp_filter = new_float(32); 10295 10296 /* variables for BitStream */ 10297 10298 /** 10299 * <PRE> 10300 * mpeg1: buffer=511 bytes smallest frame: 96-38(sideinfo)=58 10301 * max number of frames in reservoir: 8 10302 * mpeg2: buffer=255 bytes. smallest frame: 24-23bytes=1 10303 * with VBR, if you are encoding all silence, it is possible to 10304 * have 8kbs/24khz frames with 1byte of data each, which means we need 10305 * to buffer up to 255 headers! 10306 * </PRE> 10307 */ 10308 /** 10309 * also, max_header_buf has to be a power of two 10310 */ 10311 /** 10312 * max size of header is 38 10313 */ 10314 10315 function Header() { 10316 this.write_timing = 0; 10317 this.ptr = 0; 10318 //public byte buf[] = new byte[MAX_HEADER_LEN]; 10319 this.buf = new_byte(MAX_HEADER_LEN); 10320 } 10321 10322 this.header = new Array(LameInternalFlags.MAX_HEADER_BUF); 10323 10324 this.h_ptr = 0; 10325 this.w_ptr = 0; 10326 this.ancillary_flag = 0; 10327 10328 /* variables for Reservoir */ 10329 /** 10330 * in bits 10331 */ 10332 this.ResvSize = 0; 10333 /** 10334 * in bits 10335 */ 10336 this.ResvMax = 0; 10337 10338 //public ScaleFac scalefac_band = new ScaleFac(); 10339 this.scalefac_band = new ScaleFac(); 10340 10341 /* daa from PsyModel */ 10342 /* The static variables "r", "phi_sav", "new", "old" and "oldest" have */ 10343 /* to be remembered for the unpredictability measure. For "r" and */ 10344 /* "phi_sav", the first index from the left is the channel select and */ 10345 /* the second index is the "age" of the data. */ 10346 this.minval_l = new_float(Encoder.CBANDS); 10347 this.minval_s = new_float(Encoder.CBANDS); 10348 this.nb_1 = new_float_n([4, Encoder.CBANDS]); 10349 this.nb_2 = new_float_n([4, Encoder.CBANDS]); 10350 this.nb_s1 = new_float_n([4, Encoder.CBANDS]); 10351 this.nb_s2 = new_float_n([4, Encoder.CBANDS]); 10352 this.s3_ss = null; 10353 this.s3_ll = null; 10354 this.decay = 0.; 10355 10356 //public III_psy_xmin[] thm = new III_psy_xmin[4]; 10357 //public III_psy_xmin[] en = new III_psy_xmin[4]; 10358 this.thm = new Array(4); 10359 this.en = new Array(4); 10360 10361 /** 10362 * fft and energy calculation 10363 */ 10364 this.tot_ener = new_float(4); 10365 10366 /* loudness calculation (for adaptive threshold of hearing) */ 10367 /** 10368 * loudness^2 approx. per granule and channel 10369 */ 10370 this.loudness_sq = new_float_n([2, 2]); 10371 /** 10372 * account for granule delay of L3psycho_anal 10373 */ 10374 this.loudness_sq_save = new_float(2); 10375 10376 /** 10377 * Scale Factor Bands 10378 */ 10379 this.mld_l = new_float(Encoder.SBMAX_l); 10380 this.mld_s = new_float(Encoder.SBMAX_s); 10381 this.bm_l = new_int(Encoder.SBMAX_l); 10382 this.bo_l = new_int(Encoder.SBMAX_l); 10383 this.bm_s = new_int(Encoder.SBMAX_s); 10384 this.bo_s = new_int(Encoder.SBMAX_s); 10385 this.npart_l = 0; 10386 this.npart_s = 0; 10387 10388 this.s3ind = new_int_n([Encoder.CBANDS, 2]); 10389 this.s3ind_s = new_int_n([Encoder.CBANDS, 2]); 10390 10391 this.numlines_s = new_int(Encoder.CBANDS); 10392 this.numlines_l = new_int(Encoder.CBANDS); 10393 this.rnumlines_l = new_float(Encoder.CBANDS); 10394 this.mld_cb_l = new_float(Encoder.CBANDS); 10395 this.mld_cb_s = new_float(Encoder.CBANDS); 10396 this.numlines_s_num1 = 0; 10397 this.numlines_l_num1 = 0; 10398 10399 /* ratios */ 10400 this.pe = new_float(4); 10401 this.ms_ratio_s_old = 0.; 10402 this.ms_ratio_l_old = 0.; 10403 this.ms_ener_ratio_old = 0.; 10404 10405 /** 10406 * block type 10407 */ 10408 this.blocktype_old = new_int(2); 10409 10410 /** 10411 * variables used for --nspsytune 10412 */ 10413 this.nsPsy = new NsPsy(); 10414 10415 /** 10416 * used for Xing VBR header 10417 */ 10418 this.VBR_seek_table = new VBRSeekInfo(); 10419 10420 /** 10421 * all ATH related stuff 10422 */ 10423 //public ATH ATH; 10424 this.ATH = null; 10425 10426 this.PSY = null; 10427 10428 this.nogap_total = 0; 10429 this.nogap_current = 0; 10430 10431 /* ReplayGain */ 10432 this.decode_on_the_fly = true; 10433 this.findReplayGain = true; 10434 this.findPeakSample = true; 10435 this.PeakSample = 0.; 10436 this.RadioGain = 0; 10437 this.AudiophileGain = 0; 10438 //public ReplayGain rgdata; 10439 this.rgdata = null; 10440 10441 /** 10442 * gain change required for preventing clipping 10443 */ 10444 this.noclipGainChange = 0; 10445 /** 10446 * user-specified scale factor required for preventing clipping 10447 */ 10448 this.noclipScale = 0.; 10449 10450 /* simple statistics */ 10451 this.bitrate_stereoMode_Hist = new_int_n([16, 4 + 1]); 10452 /** 10453 * norm/start/short/stop/mixed(short)/sum 10454 */ 10455 this.bitrate_blockType_Hist = new_int_n([16, 4 + 1 + 1]); 10456 10457 //public PlottingData pinfo; 10458 //public MPGLib.mpstr_tag hip; 10459 this.pinfo = null; 10460 this.hip = null; 10461 10462 this.in_buffer_nsamples = 0; 10463 //public float[] in_buffer_0; 10464 //public float[] in_buffer_1; 10465 this.in_buffer_0 = null; 10466 this.in_buffer_1 = null; 10467 10468 //public IIterationLoop iteration_loop; 10469 this.iteration_loop = null; 10470 10471 for (var i = 0; i < this.en.length; i++) { 10472 this.en[i] = new III_psy_xmin(); 10473 } 10474 for (var i = 0; i < this.thm.length; i++) { 10475 this.thm[i] = new III_psy_xmin(); 10476 } 10477 for (var i = 0; i < this.header.length; i++) { 10478 this.header[i] = new Header(); 10479 } 10480 10481} 10482 10483 10484 10485function FFT() { 10486 10487 var window = new_float(Encoder.BLKSIZE); 10488 var window_s = new_float(Encoder.BLKSIZE_s / 2); 10489 10490 var costab = [ 10491 9.238795325112867e-01, 3.826834323650898e-01, 10492 9.951847266721969e-01, 9.801714032956060e-02, 10493 9.996988186962042e-01, 2.454122852291229e-02, 10494 9.999811752826011e-01, 6.135884649154475e-03 10495 ]; 10496 10497 function fht(fz, fzPos, n) { 10498 var tri = 0; 10499 var k4; 10500 var fi; 10501 var gi; 10502 10503 n <<= 1; 10504 /* to get BLKSIZE, because of 3DNow! ASM routine */ 10505 var fn = fzPos + n; 10506 k4 = 4; 10507 do { 10508 var s1, c1; 10509 var i, k1, k2, k3, kx; 10510 kx = k4 >> 1; 10511 k1 = k4; 10512 k2 = k4 << 1; 10513 k3 = k2 + k1; 10514 k4 = k2 << 1; 10515 fi = fzPos; 10516 gi = fi + kx; 10517 do { 10518 var f0, f1, f2, f3; 10519 f1 = fz[fi + 0] - fz[fi + k1]; 10520 f0 = fz[fi + 0] + fz[fi + k1]; 10521 f3 = fz[fi + k2] - fz[fi + k3]; 10522 f2 = fz[fi + k2] + fz[fi + k3]; 10523 fz[fi + k2] = f0 - f2; 10524 fz[fi + 0] = f0 + f2; 10525 fz[fi + k3] = f1 - f3; 10526 fz[fi + k1] = f1 + f3; 10527 f1 = fz[gi + 0] - fz[gi + k1]; 10528 f0 = fz[gi + 0] + fz[gi + k1]; 10529 f3 = (Util.SQRT2 * fz[gi + k3]); 10530 f2 = (Util.SQRT2 * fz[gi + k2]); 10531 fz[gi + k2] = f0 - f2; 10532 fz[gi + 0] = f0 + f2; 10533 fz[gi + k3] = f1 - f3; 10534 fz[gi + k1] = f1 + f3; 10535 gi += k4; 10536 fi += k4; 10537 } while (fi < fn); 10538 c1 = costab[tri + 0]; 10539 s1 = costab[tri + 1]; 10540 for (i = 1; i < kx; i++) { 10541 var c2, s2; 10542 c2 = 1 - (2 * s1) * s1; 10543 s2 = (2 * s1) * c1; 10544 fi = fzPos + i; 10545 gi = fzPos + k1 - i; 10546 do { 10547 var a, b, g0, f0, f1, g1, f2, g2, f3, g3; 10548 b = s2 * fz[fi + k1] - c2 * fz[gi + k1]; 10549 a = c2 * fz[fi + k1] + s2 * fz[gi + k1]; 10550 f1 = fz[fi + 0] - a; 10551 f0 = fz[fi + 0] + a; 10552 g1 = fz[gi + 0] - b; 10553 g0 = fz[gi + 0] + b; 10554 b = s2 * fz[fi + k3] - c2 * fz[gi + k3]; 10555 a = c2 * fz[fi + k3] + s2 * fz[gi + k3]; 10556 f3 = fz[fi + k2] - a; 10557 f2 = fz[fi + k2] + a; 10558 g3 = fz[gi + k2] - b; 10559 g2 = fz[gi + k2] + b; 10560 b = s1 * f2 - c1 * g3; 10561 a = c1 * f2 + s1 * g3; 10562 fz[fi + k2] = f0 - a; 10563 fz[fi + 0] = f0 + a; 10564 fz[gi + k3] = g1 - b; 10565 fz[gi + k1] = g1 + b; 10566 b = c1 * g2 - s1 * f3; 10567 a = s1 * g2 + c1 * f3; 10568 fz[gi + k2] = g0 - a; 10569 fz[gi + 0] = g0 + a; 10570 fz[fi + k3] = f1 - b; 10571 fz[fi + k1] = f1 + b; 10572 gi += k4; 10573 fi += k4; 10574 } while (fi < fn); 10575 c2 = c1; 10576 c1 = c2 * costab[tri + 0] - s1 * costab[tri + 1]; 10577 s1 = c2 * costab[tri + 1] + s1 * costab[tri + 0]; 10578 } 10579 tri += 2; 10580 } while (k4 < n); 10581 } 10582 10583 var rv_tbl = [0x00, 0x80, 0x40, 10584 0xc0, 0x20, 0xa0, 0x60, 0xe0, 0x10, 10585 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 10586 0xf0, 0x08, 0x88, 0x48, 0xc8, 0x28, 10587 0xa8, 0x68, 0xe8, 0x18, 0x98, 0x58, 10588 0xd8, 0x38, 0xb8, 0x78, 0xf8, 0x04, 10589 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 10590 0xe4, 0x14, 0x94, 0x54, 0xd4, 0x34, 10591 0xb4, 0x74, 0xf4, 0x0c, 0x8c, 0x4c, 10592 0xcc, 0x2c, 0xac, 0x6c, 0xec, 0x1c, 10593 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 10594 0xfc, 0x02, 0x82, 0x42, 0xc2, 0x22, 10595 0xa2, 0x62, 0xe2, 0x12, 0x92, 0x52, 10596 0xd2, 0x32, 0xb2, 0x72, 0xf2, 0x0a, 10597 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 10598 0xea, 0x1a, 0x9a, 0x5a, 0xda, 0x3a, 10599 0xba, 0x7a, 0xfa, 0x06, 0x86, 0x46, 10600 0xc6, 0x26, 0xa6, 0x66, 0xe6, 0x16, 10601 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 10602 0xf6, 0x0e, 0x8e, 0x4e, 0xce, 0x2e, 10603 0xae, 0x6e, 0xee, 0x1e, 0x9e, 0x5e, 10604 0xde, 0x3e, 0xbe, 0x7e, 0xfe]; 10605 10606 this.fft_short = function (gfc, x_real, chn, buffer, bufPos) { 10607 for (var b = 0; b < 3; b++) { 10608 var x = Encoder.BLKSIZE_s / 2; 10609 var k = 0xffff & ((576 / 3) * (b + 1)); 10610 var j = Encoder.BLKSIZE_s / 8 - 1; 10611 do { 10612 var f0, f1, f2, f3, w; 10613 var i = rv_tbl[j << 2] & 0xff; 10614 10615 f0 = window_s[i] * buffer[chn][bufPos + i + k]; 10616 w = window_s[0x7f - i] * buffer[chn][bufPos + i + k + 0x80]; 10617 f1 = f0 - w; 10618 f0 = f0 + w; 10619 f2 = window_s[i + 0x40] * buffer[chn][bufPos + i + k + 0x40]; 10620 w = window_s[0x3f - i] * buffer[chn][bufPos + i + k + 0xc0]; 10621 f3 = f2 - w; 10622 f2 = f2 + w; 10623 10624 x -= 4; 10625 x_real[b][x + 0] = f0 + f2; 10626 x_real[b][x + 2] = f0 - f2; 10627 x_real[b][x + 1] = f1 + f3; 10628 x_real[b][x + 3] = f1 - f3; 10629 10630 f0 = window_s[i + 0x01] * buffer[chn][bufPos + i + k + 0x01]; 10631 w = window_s[0x7e - i] * buffer[chn][bufPos + i + k + 0x81]; 10632 f1 = f0 - w; 10633 f0 = f0 + w; 10634 f2 = window_s[i + 0x41] * buffer[chn][bufPos + i + k + 0x41]; 10635 w = window_s[0x3e - i] * buffer[chn][bufPos + i + k + 0xc1]; 10636 f3 = f2 - w; 10637 f2 = f2 + w; 10638 10639 x_real[b][x + Encoder.BLKSIZE_s / 2 + 0] = f0 + f2; 10640 x_real[b][x + Encoder.BLKSIZE_s / 2 + 2] = f0 - f2; 10641 x_real[b][x + Encoder.BLKSIZE_s / 2 + 1] = f1 + f3; 10642 x_real[b][x + Encoder.BLKSIZE_s / 2 + 3] = f1 - f3; 10643 } while (--j >= 0); 10644 10645 fht(x_real[b], x, Encoder.BLKSIZE_s / 2); 10646 /* BLKSIZE_s/2 because of 3DNow! ASM routine */ 10647 /* BLKSIZE/2 because of 3DNow! ASM routine */ 10648 } 10649 } 10650 10651 this.fft_long = function (gfc, y, chn, buffer, bufPos) { 10652 var jj = Encoder.BLKSIZE / 8 - 1; 10653 var x = Encoder.BLKSIZE / 2; 10654 10655 do { 10656 var f0, f1, f2, f3, w; 10657 var i = rv_tbl[jj] & 0xff; 10658 f0 = window[i] * buffer[chn][bufPos + i]; 10659 w = window[i + 0x200] * buffer[chn][bufPos + i + 0x200]; 10660 f1 = f0 - w; 10661 f0 = f0 + w; 10662 f2 = window[i + 0x100] * buffer[chn][bufPos + i + 0x100]; 10663 w = window[i + 0x300] * buffer[chn][bufPos + i + 0x300]; 10664 f3 = f2 - w; 10665 f2 = f2 + w; 10666 10667 x -= 4; 10668 y[x + 0] = f0 + f2; 10669 y[x + 2] = f0 - f2; 10670 y[x + 1] = f1 + f3; 10671 y[x + 3] = f1 - f3; 10672 10673 f0 = window[i + 0x001] * buffer[chn][bufPos + i + 0x001]; 10674 w = window[i + 0x201] * buffer[chn][bufPos + i + 0x201]; 10675 f1 = f0 - w; 10676 f0 = f0 + w; 10677 f2 = window[i + 0x101] * buffer[chn][bufPos + i + 0x101]; 10678 w = window[i + 0x301] * buffer[chn][bufPos + i + 0x301]; 10679 f3 = f2 - w; 10680 f2 = f2 + w; 10681 10682 y[x + Encoder.BLKSIZE / 2 + 0] = f0 + f2; 10683 y[x + Encoder.BLKSIZE / 2 + 2] = f0 - f2; 10684 y[x + Encoder.BLKSIZE / 2 + 1] = f1 + f3; 10685 y[x + Encoder.BLKSIZE / 2 + 3] = f1 - f3; 10686 } while (--jj >= 0); 10687 10688 fht(y, x, Encoder.BLKSIZE / 2); 10689 /* BLKSIZE/2 because of 3DNow! ASM routine */ 10690 } 10691 10692 this.init_fft = function (gfc) { 10693 /* The type of window used here will make no real difference, but */ 10694 /* 10695 * in the interest of merging nspsytune stuff - switch to blackman 10696 * window 10697 */ 10698 for (var i = 0; i < Encoder.BLKSIZE; i++) 10699 /* blackman window */ 10700 window[i] = (0.42 - 0.5 * Math.cos(2 * Math.PI * (i + .5) 10701 / Encoder.BLKSIZE) + 0.08 * Math.cos(4 * Math.PI * (i + .5) 10702 / Encoder.BLKSIZE)); 10703 10704 for (var i = 0; i < Encoder.BLKSIZE_s / 2; i++) 10705 window_s[i] = (0.5 * (1.0 - Math.cos(2.0 * Math.PI 10706 * (i + 0.5) / Encoder.BLKSIZE_s))); 10707 10708 } 10709 10710} 10711 10712/* 10713 * psymodel.c 10714 * 10715 * Copyright (c) 1999-2000 Mark Taylor 10716 * Copyright (c) 2001-2002 Naoki Shibata 10717 * Copyright (c) 2000-2003 Takehiro Tominaga 10718 * Copyright (c) 2000-2008 Robert Hegemann 10719 * Copyright (c) 2000-2005 Gabriel Bouvigne 10720 * Copyright (c) 2000-2005 Alexander Leidinger 10721 * 10722 * This library is free software; you can redistribute it and/or 10723 * modify it under the terms of the GNU Lesser General Public 10724 * License as published by the Free Software Foundation; either 10725 * version 2 of the License, or (at your option) any later version. 10726 * 10727 * This library is distributed in the hope that it will be useful, 10728 * but WITHOUT ANY WARRANTY; without even the implied warranty of 10729 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 10730 * Library General Public License for more details. 10731 * 10732 * You should have received a copy of the GNU Lesser General Public 10733 * License along with this library; if not, write to the 10734 * Free Software Foundation, Inc., 59 Temple Place - Suite 330, 10735 * Boston, MA 02111-1307, USA. 10736 */ 10737 10738/* $Id: PsyModel.java,v 1.27 2011/05/24 20:48:06 kenchis Exp $ */ 10739 10740 10741/* 10742 PSYCHO ACOUSTICS 10743 10744 10745 This routine computes the psycho acoustics, delayed by one granule. 10746 10747 Input: buffer of PCM data (1024 samples). 10748 10749 This window should be centered over the 576 sample granule window. 10750 The routine will compute the psycho acoustics for 10751 this granule, but return the psycho acoustics computed 10752 for the *previous* granule. This is because the block 10753 type of the previous granule can only be determined 10754 after we have computed the psycho acoustics for the following 10755 granule. 10756 10757 Output: maskings and energies for each scalefactor band. 10758 block type, PE, and some correlation measures. 10759 The PE is used by CBR modes to determine if extra bits 10760 from the bit reservoir should be used. The correlation 10761 measures are used to determine mid/side or regular stereo. 10762 */ 10763/* 10764 Notation: 10765 10766 barks: a non-linear frequency scale. Mapping from frequency to 10767 barks is given by freq2bark() 10768 10769 scalefactor bands: The spectrum (frequencies) are broken into 10770 SBMAX "scalefactor bands". Thes bands 10771 are determined by the MPEG ISO spec. In 10772 the noise shaping/quantization code, we allocate 10773 bits among the partition bands to achieve the 10774 best possible quality 10775 10776 partition bands: The spectrum is also broken into about 10777 64 "partition bands". Each partition 10778 band is about .34 barks wide. There are about 2-5 10779 partition bands for each scalefactor band. 10780 10781 LAME computes all psycho acoustic information for each partition 10782 band. Then at the end of the computations, this information 10783 is mapped to scalefactor bands. The energy in each scalefactor 10784 band is taken as the sum of the energy in all partition bands 10785 which overlap the scalefactor band. The maskings can be computed 10786 in the same way (and thus represent the average masking in that band) 10787 or by taking the minmum value multiplied by the number of 10788 partition bands used (which represents a minimum masking in that band). 10789 */ 10790/* 10791 The general outline is as follows: 10792 10793 1. compute the energy in each partition band 10794 2. compute the tonality in each partition band 10795 3. compute the strength of each partion band "masker" 10796 4. compute the masking (via the spreading function applied to each masker) 10797 5. Modifications for mid/side masking. 10798 10799 Each partition band is considiered a "masker". The strength 10800 of the i'th masker in band j is given by: 10801 10802 s3(bark(i)-bark(j))*strength(i) 10803 10804 The strength of the masker is a function of the energy and tonality. 10805 The more tonal, the less masking. LAME uses a simple linear formula 10806 (controlled by NMT and TMN) which says the strength is given by the 10807 energy divided by a linear function of the tonality. 10808 */ 10809/* 10810 s3() is the "spreading function". It is given by a formula 10811 determined via listening tests. 10812 10813 The total masking in the j'th partition band is the sum over 10814 all maskings i. It is thus given by the convolution of 10815 the strength with s3(), the "spreading function." 10816 10817 masking(j) = sum_over_i s3(i-j)*strength(i) = s3 o strength 10818 10819 where "o" = convolution operator. s3 is given by a formula determined 10820 via listening tests. It is normalized so that s3 o 1 = 1. 10821 10822 Note: instead of a simple convolution, LAME also has the 10823 option of using "additive masking" 10824 10825 The most critical part is step 2, computing the tonality of each 10826 partition band. LAME has two tonality estimators. The first 10827 is based on the ISO spec, and measures how predictiable the 10828 signal is over time. The more predictable, the more tonal. 10829 The second measure is based on looking at the spectrum of 10830 a single granule. The more peaky the spectrum, the more 10831 tonal. By most indications, the latter approach is better. 10832 10833 Finally, in step 5, the maskings for the mid and side 10834 channel are possibly increased. Under certain circumstances, 10835 noise in the mid & side channels is assumed to also 10836 be masked by strong maskers in the L or R channels. 10837 10838 10839 Other data computed by the psy-model: 10840 10841 ms_ratio side-channel / mid-channel masking ratio (for previous granule) 10842 ms_ratio_next side-channel / mid-channel masking ratio for this granule 10843 10844 percep_entropy[2] L and R values (prev granule) of PE - A measure of how 10845 much pre-echo is in the previous granule 10846 percep_entropy_MS[2] mid and side channel values (prev granule) of percep_entropy 10847 energy[4] L,R,M,S energy in each channel, prev granule 10848 blocktype_d[2] block type to use for previous granule 10849 */ 10850//package mp3; 10851 10852//import java.util.Arrays; 10853 10854 10855function PsyModel() { 10856 10857 var fft = new FFT(); 10858 10859 var LOG10 = 2.30258509299404568402; 10860 10861 var rpelev = 2; 10862 var rpelev2 = 16; 10863 var rpelev_s = 2; 10864 var rpelev2_s = 16; 10865 10866 /* size of each partition band, in barks: */ 10867 var DELBARK = .34; 10868 10869 /* tuned for output level (sensitive to energy scale) */ 10870 var VO_SCALE = (1. / (14752 * 14752) / (Encoder.BLKSIZE / 2)); 10871 10872 var temporalmask_sustain_sec = 0.01; 10873 10874 var NS_PREECHO_ATT0 = 0.8; 10875 var NS_PREECHO_ATT1 = 0.6; 10876 var NS_PREECHO_ATT2 = 0.3; 10877 10878 var NS_MSFIX = 3.5; 10879 10880 var NSATTACKTHRE = 4.4; 10881 var NSATTACKTHRE_S = 25; 10882 10883 var NSFIRLEN = 21; 10884 10885 /* size of each partition band, in barks: */ 10886 var LN_TO_LOG10 = 0.2302585093; 10887 10888 function NON_LINEAR_SCALE_ENERGY(x) { 10889 return x; 10890 } 10891 10892 /** 10893 * <PRE> 10894 * L3psycho_anal. Compute psycho acoustics. 10895 * 10896 * Data returned to the calling program must be delayed by one 10897 * granule. 10898 * 10899 * This is done in two places. 10900 * If we do not need to know the blocktype, the copying 10901 * can be done here at the top of the program: we copy the data for 10902 * the last granule (computed during the last call) before it is 10903 * overwritten with the new data. It looks like this: 10904 * 10905 * 0. static psymodel_data 10906 * 1. calling_program_data = psymodel_data 10907 * 2. compute psymodel_data 10908 * 10909 * For data which needs to know the blocktype, the copying must be 10910 * done at the end of this loop, and the old values must be saved: 10911 * 10912 * 0. static psymodel_data_old 10913 * 1. compute psymodel_data 10914 * 2. compute possible block type of this granule 10915 * 3. compute final block type of previous granule based on #2. 10916 * 4. calling_program_data = psymodel_data_old 10917 * 5. psymodel_data_old = psymodel_data 10918 * psycho_loudness_approx 10919 * jd - 2001 mar 12 10920 * in: energy - BLKSIZE/2 elements of frequency magnitudes ^ 2 10921 * gfp - uses out_samplerate, ATHtype (also needed for ATHformula) 10922 * returns: loudness^2 approximation, a positive value roughly tuned for a value 10923 * of 1.0 for signals near clipping. 10924 * notes: When calibrated, feeding this function binary white noise at sample 10925 * values +32767 or -32768 should return values that approach 3. 10926 * ATHformula is used to approximate an equal loudness curve. 10927 * future: Data indicates that the shape of the equal loudness curve varies 10928 * with intensity. This function might be improved by using an equal 10929 * loudness curve shaped for typical playback levels (instead of the 10930 * ATH, that is shaped for the threshold). A flexible realization might 10931 * simply bend the existing ATH curve to achieve the desired shape. 10932 * However, the potential gain may not be enough to justify an effort. 10933 * </PRE> 10934 */ 10935 function psycho_loudness_approx(energy, gfc) { 10936 var loudness_power = 0.0; 10937 /* apply weights to power in freq. bands */ 10938 for (var i = 0; i < Encoder.BLKSIZE / 2; ++i) 10939 loudness_power += energy[i] * gfc.ATH.eql_w[i]; 10940 loudness_power *= VO_SCALE; 10941 10942 return loudness_power; 10943 } 10944 10945 function compute_ffts(gfp, fftenergy, fftenergy_s, wsamp_l, wsamp_lPos, wsamp_s, wsamp_sPos, gr_out, chn, buffer, bufPos) { 10946 var gfc = gfp.internal_flags; 10947 if (chn < 2) { 10948 fft.fft_long(gfc, wsamp_l[wsamp_lPos], chn, buffer, bufPos); 10949 fft.fft_short(gfc, wsamp_s[wsamp_sPos], chn, buffer, bufPos); 10950 } 10951 /* FFT data for mid and side channel is derived from L & R */ 10952 else if (chn == 2) { 10953 for (var j = Encoder.BLKSIZE - 1; j >= 0; --j) { 10954 var l = wsamp_l[wsamp_lPos + 0][j]; 10955 var r = wsamp_l[wsamp_lPos + 1][j]; 10956 wsamp_l[wsamp_lPos + 0][j] = (l + r) * Util.SQRT2 * 0.5; 10957 wsamp_l[wsamp_lPos + 1][j] = (l - r) * Util.SQRT2 * 0.5; 10958 } 10959 for (var b = 2; b >= 0; --b) { 10960 for (var j = Encoder.BLKSIZE_s - 1; j >= 0; --j) { 10961 var l = wsamp_s[wsamp_sPos + 0][b][j]; 10962 var r = wsamp_s[wsamp_sPos + 1][b][j]; 10963 wsamp_s[wsamp_sPos + 0][b][j] = (l + r) * Util.SQRT2 * 0.5; 10964 wsamp_s[wsamp_sPos + 1][b][j] = (l - r) * Util.SQRT2 * 0.5; 10965 } 10966 } 10967 } 10968 10969 /********************************************************************* 10970 * compute energies 10971 *********************************************************************/ 10972 fftenergy[0] = NON_LINEAR_SCALE_ENERGY(wsamp_l[wsamp_lPos + 0][0]); 10973 fftenergy[0] *= fftenergy[0]; 10974 10975 for (var j = Encoder.BLKSIZE / 2 - 1; j >= 0; --j) { 10976 var re = (wsamp_l[wsamp_lPos + 0])[Encoder.BLKSIZE / 2 - j]; 10977 var im = (wsamp_l[wsamp_lPos + 0])[Encoder.BLKSIZE / 2 + j]; 10978 fftenergy[Encoder.BLKSIZE / 2 - j] = NON_LINEAR_SCALE_ENERGY((re 10979 * re + im * im) * 0.5); 10980 } 10981 for (var b = 2; b >= 0; --b) { 10982 fftenergy_s[b][0] = (wsamp_s[wsamp_sPos + 0])[b][0]; 10983 fftenergy_s[b][0] *= fftenergy_s[b][0]; 10984 for (var j = Encoder.BLKSIZE_s / 2 - 1; j >= 0; --j) { 10985 var re = (wsamp_s[wsamp_sPos + 0])[b][Encoder.BLKSIZE_s 10986 / 2 - j]; 10987 var im = (wsamp_s[wsamp_sPos + 0])[b][Encoder.BLKSIZE_s 10988 / 2 + j]; 10989 fftenergy_s[b][Encoder.BLKSIZE_s / 2 - j] = NON_LINEAR_SCALE_ENERGY((re 10990 * re + im * im) * 0.5); 10991 } 10992 } 10993 /* total energy */ 10994 { 10995 var totalenergy = 0.0; 10996 for (var j = 11; j < Encoder.HBLKSIZE; j++) 10997 totalenergy += fftenergy[j]; 10998 10999 gfc.tot_ener[chn] = totalenergy; 11000 } 11001 11002 if (gfp.analysis) { 11003 for (var j = 0; j < Encoder.HBLKSIZE; j++) { 11004 gfc.pinfo.energy[gr_out][chn][j] = gfc.pinfo.energy_save[chn][j]; 11005 gfc.pinfo.energy_save[chn][j] = fftenergy[j]; 11006 } 11007 gfc.pinfo.pe[gr_out][chn] = gfc.pe[chn]; 11008 } 11009 11010 /********************************************************************* 11011 * compute loudness approximation (used for ATH auto-level adjustment) 11012 *********************************************************************/ 11013 if (gfp.athaa_loudapprox == 2 && chn < 2) { 11014 // no loudness for mid/side ch 11015 gfc.loudness_sq[gr_out][chn] = gfc.loudness_sq_save[chn]; 11016 gfc.loudness_sq_save[chn] = psycho_loudness_approx(fftenergy, gfc); 11017 } 11018 } 11019 11020 /* mask_add optimization */ 11021 /* init the limit values used to avoid computing log in mask_add when it is not necessary */ 11022 11023 /** 11024 * <PRE> 11025 * For example, with i = 10*log10(m2/m1)/10*16 (= log10(m2/m1)*16) 11026 * 11027 * abs(i)>8 is equivalent (as i is an integer) to 11028 * abs(i)>=9 11029 * i>=9 || i<=-9 11030 * equivalent to (as i is the biggest integer smaller than log10(m2/m1)*16 11031 * or the smallest integer bigger than log10(m2/m1)*16 depending on the sign of log10(m2/m1)*16) 11032 * log10(m2/m1)>=9/16 || log10(m2/m1)<=-9/16 11033 * exp10 is strictly increasing thus this is equivalent to 11034 * m2/m1 >= 10^(9/16) || m2/m1<=10^(-9/16) which are comparisons to constants 11035 * </PRE> 11036 */ 11037 11038 /** 11039 * as in if(i>8) 11040 */ 11041 var I1LIMIT = 8; 11042 /** 11043 * as in if(i>24) . changed 23 11044 */ 11045 var I2LIMIT = 23; 11046 /** 11047 * as in if(m<15) 11048 */ 11049 var MLIMIT = 15; 11050 11051 var ma_max_i1; 11052 var ma_max_i2; 11053 var ma_max_m; 11054 11055 /** 11056 * This is the masking table:<BR> 11057 * According to tonality, values are going from 0dB (TMN) to 9.3dB (NMT).<BR> 11058 * After additive masking computation, 8dB are added, so final values are 11059 * going from 8dB to 17.3dB 11060 * 11061 * pow(10, -0.0..-0.6) 11062 */ 11063 var tab = [1.0, 0.79433, 0.63096, 0.63096, 11064 0.63096, 0.63096, 0.63096, 0.25119, 0.11749]; 11065 11066 function init_mask_add_max_values() { 11067 ma_max_i1 = Math.pow(10, (I1LIMIT + 1) / 16.0); 11068 ma_max_i2 = Math.pow(10, (I2LIMIT + 1) / 16.0); 11069 ma_max_m = Math.pow(10, (MLIMIT) / 10.0); 11070 } 11071 11072 var table1 = [3.3246 * 3.3246, 11073 3.23837 * 3.23837, 3.15437 * 3.15437, 3.00412 * 3.00412, 11074 2.86103 * 2.86103, 2.65407 * 2.65407, 2.46209 * 2.46209, 11075 2.284 * 2.284, 2.11879 * 2.11879, 1.96552 * 1.96552, 11076 1.82335 * 1.82335, 1.69146 * 1.69146, 1.56911 * 1.56911, 11077 1.46658 * 1.46658, 1.37074 * 1.37074, 1.31036 * 1.31036, 11078 1.25264 * 1.25264, 1.20648 * 1.20648, 1.16203 * 1.16203, 11079 1.12765 * 1.12765, 1.09428 * 1.09428, 1.0659 * 1.0659, 11080 1.03826 * 1.03826, 1.01895 * 1.01895, 1]; 11081 11082 var table2 = [1.33352 * 1.33352, 11083 1.35879 * 1.35879, 1.38454 * 1.38454, 1.39497 * 1.39497, 11084 1.40548 * 1.40548, 1.3537 * 1.3537, 1.30382 * 1.30382, 11085 1.22321 * 1.22321, 1.14758 * 1.14758, 1]; 11086 11087 var table3 = [2.35364 * 2.35364, 11088 2.29259 * 2.29259, 2.23313 * 2.23313, 2.12675 * 2.12675, 11089 2.02545 * 2.02545, 1.87894 * 1.87894, 1.74303 * 1.74303, 11090 1.61695 * 1.61695, 1.49999 * 1.49999, 1.39148 * 1.39148, 11091 1.29083 * 1.29083, 1.19746 * 1.19746, 1.11084 * 1.11084, 11092 1.03826 * 1.03826]; 11093 11094 /** 11095 * addition of simultaneous masking Naoki Shibata 2000/7 11096 */ 11097 function mask_add(m1, m2, kk, b, gfc, shortblock) { 11098 var ratio; 11099 11100 if (m2 > m1) { 11101 if (m2 < (m1 * ma_max_i2)) 11102 ratio = m2 / m1; 11103 else 11104 return (m1 + m2); 11105 } else { 11106 if (m1 >= (m2 * ma_max_i2)) 11107 return (m1 + m2); 11108 ratio = m1 / m2; 11109 } 11110 11111 /* Should always be true, just checking */ 11112 11113 m1 += m2; 11114 //if (((long)(b + 3) & 0xffffffff) <= 3 + 3) { 11115 if ((b + 3) <= 3 + 3) { 11116 /* approximately, 1 bark = 3 partitions */ 11117 /* 65% of the cases */ 11118 /* originally 'if(i > 8)' */ 11119 if (ratio >= ma_max_i1) { 11120 /* 43% of the total */ 11121 return m1; 11122 } 11123 11124 /* 22% of the total */ 11125 var i = 0 | (Util.FAST_LOG10_X(ratio, 16.0)); 11126 return m1 * table2[i]; 11127 } 11128 11129 /** 11130 * <PRE> 11131 * m<15 equ log10((m1+m2)/gfc.ATH.cb[k])<1.5 11132 * equ (m1+m2)/gfc.ATH.cb[k]<10^1.5 11133 * equ (m1+m2)<10^1.5 * gfc.ATH.cb[k] 11134 * </PRE> 11135 */ 11136 var i = 0 | Util.FAST_LOG10_X(ratio, 16.0); 11137 if (shortblock != 0) { 11138 m2 = gfc.ATH.cb_s[kk] * gfc.ATH.adjust; 11139 } else { 11140 m2 = gfc.ATH.cb_l[kk] * gfc.ATH.adjust; 11141 } 11142 if (m1 < ma_max_m * m2) { 11143 /* 3% of the total */ 11144 /* Originally if (m > 0) { */ 11145 if (m1 > m2) { 11146 var f, r; 11147 11148 f = 1.0; 11149 if (i <= 13) 11150 f = table3[i]; 11151 11152 r = Util.FAST_LOG10_X(m1 / m2, 10.0 / 15.0); 11153 return m1 * ((table1[i] - f) * r + f); 11154 } 11155 11156 if (i > 13) 11157 return m1; 11158 11159 return m1 * table3[i]; 11160 } 11161 11162 /* 10% of total */ 11163 return m1 * table1[i]; 11164 } 11165 11166 var table2_ = [1.33352 * 1.33352, 11167 1.35879 * 1.35879, 1.38454 * 1.38454, 1.39497 * 1.39497, 11168 1.40548 * 1.40548, 1.3537 * 1.3537, 1.30382 * 1.30382, 11169 1.22321 * 1.22321, 1.14758 * 1.14758, 1]; 11170 11171 /** 11172 * addition of simultaneous masking Naoki Shibata 2000/7 11173 */ 11174 function vbrpsy_mask_add(m1, m2, b) { 11175 var ratio; 11176 11177 if (m1 < 0) { 11178 m1 = 0; 11179 } 11180 if (m2 < 0) { 11181 m2 = 0; 11182 } 11183 if (m1 <= 0) { 11184 return m2; 11185 } 11186 if (m2 <= 0) { 11187 return m1; 11188 } 11189 if (m2 > m1) { 11190 ratio = m2 / m1; 11191 } else { 11192 ratio = m1 / m2; 11193 } 11194 if (-2 <= b && b <= 2) { 11195 /* approximately, 1 bark = 3 partitions */ 11196 /* originally 'if(i > 8)' */ 11197 if (ratio >= ma_max_i1) { 11198 return m1 + m2; 11199 } else { 11200 var i = 0 | (Util.FAST_LOG10_X(ratio, 16.0)); 11201 return (m1 + m2) * table2_[i]; 11202 } 11203 } 11204 if (ratio < ma_max_i2) { 11205 return m1 + m2; 11206 } 11207 if (m1 < m2) { 11208 m1 = m2; 11209 } 11210 return m1; 11211 } 11212 11213 /** 11214 * compute interchannel masking effects 11215 */ 11216 function calc_interchannel_masking(gfp, ratio) { 11217 var gfc = gfp.internal_flags; 11218 if (gfc.channels_out > 1) { 11219 for (var sb = 0; sb < Encoder.SBMAX_l; sb++) { 11220 var l = gfc.thm[0].l[sb]; 11221 var r = gfc.thm[1].l[sb]; 11222 gfc.thm[0].l[sb] += r * ratio; 11223 gfc.thm[1].l[sb] += l * ratio; 11224 } 11225 for (var sb = 0; sb < Encoder.SBMAX_s; sb++) { 11226 for (var sblock = 0; sblock < 3; sblock++) { 11227 var l = gfc.thm[0].s[sb][sblock]; 11228 var r = gfc.thm[1].s[sb][sblock]; 11229 gfc.thm[0].s[sb][sblock] += r * ratio; 11230 gfc.thm[1].s[sb][sblock] += l * ratio; 11231 } 11232 } 11233 } 11234 } 11235 11236 /** 11237 * compute M/S thresholds from Johnston & Ferreira 1992 ICASSP paper 11238 */ 11239 function msfix1(gfc) { 11240 for (var sb = 0; sb < Encoder.SBMAX_l; sb++) { 11241 /* use this fix if L & R masking differs by 2db or less */ 11242 /* if db = 10*log10(x2/x1) < 2 */ 11243 /* if (x2 < 1.58*x1) { */ 11244 if (gfc.thm[0].l[sb] > 1.58 * gfc.thm[1].l[sb] 11245 || gfc.thm[1].l[sb] > 1.58 * gfc.thm[0].l[sb]) 11246 continue; 11247 var mld = gfc.mld_l[sb] * gfc.en[3].l[sb]; 11248 var rmid = Math.max(gfc.thm[2].l[sb], 11249 Math.min(gfc.thm[3].l[sb], mld)); 11250 11251 mld = gfc.mld_l[sb] * gfc.en[2].l[sb]; 11252 var rside = Math.max(gfc.thm[3].l[sb], 11253 Math.min(gfc.thm[2].l[sb], mld)); 11254 gfc.thm[2].l[sb] = rmid; 11255 gfc.thm[3].l[sb] = rside; 11256 } 11257 11258 for (var sb = 0; sb < Encoder.SBMAX_s; sb++) { 11259 for (var sblock = 0; sblock < 3; sblock++) { 11260 if (gfc.thm[0].s[sb][sblock] > 1.58 * gfc.thm[1].s[sb][sblock] 11261 || gfc.thm[1].s[sb][sblock] > 1.58 * gfc.thm[0].s[sb][sblock]) 11262 continue; 11263 var mld = gfc.mld_s[sb] * gfc.en[3].s[sb][sblock]; 11264 var rmid = Math.max(gfc.thm[2].s[sb][sblock], 11265 Math.min(gfc.thm[3].s[sb][sblock], mld)); 11266 11267 mld = gfc.mld_s[sb] * gfc.en[2].s[sb][sblock]; 11268 var rside = Math.max(gfc.thm[3].s[sb][sblock], 11269 Math.min(gfc.thm[2].s[sb][sblock], mld)); 11270 11271 gfc.thm[2].s[sb][sblock] = rmid; 11272 gfc.thm[3].s[sb][sblock] = rside; 11273 } 11274 } 11275 } 11276 11277 /** 11278 * Adjust M/S maskings if user set "msfix" 11279 * 11280 * Naoki Shibata 2000 11281 */ 11282 function ns_msfix(gfc, msfix, athadjust) { 11283 var msfix2 = msfix; 11284 var athlower = Math.pow(10, athadjust); 11285 11286 msfix *= 2.0; 11287 msfix2 *= 2.0; 11288 for (var sb = 0; sb < Encoder.SBMAX_l; sb++) { 11289 var thmLR, thmM, thmS, ath; 11290 ath = (gfc.ATH.cb_l[gfc.bm_l[sb]]) * athlower; 11291 thmLR = Math.min(Math.max(gfc.thm[0].l[sb], ath), 11292 Math.max(gfc.thm[1].l[sb], ath)); 11293 thmM = Math.max(gfc.thm[2].l[sb], ath); 11294 thmS = Math.max(gfc.thm[3].l[sb], ath); 11295 if (thmLR * msfix < thmM + thmS) { 11296 var f = thmLR * msfix2 / (thmM + thmS); 11297 thmM *= f; 11298 thmS *= f; 11299 } 11300 gfc.thm[2].l[sb] = Math.min(thmM, gfc.thm[2].l[sb]); 11301 gfc.thm[3].l[sb] = Math.min(thmS, gfc.thm[3].l[sb]); 11302 } 11303 11304 athlower *= ( Encoder.BLKSIZE_s / Encoder.BLKSIZE); 11305 for (var sb = 0; sb < Encoder.SBMAX_s; sb++) { 11306 for (var sblock = 0; sblock < 3; sblock++) { 11307 var thmLR, thmM, thmS, ath; 11308 ath = (gfc.ATH.cb_s[gfc.bm_s[sb]]) * athlower; 11309 thmLR = Math.min(Math.max(gfc.thm[0].s[sb][sblock], ath), 11310 Math.max(gfc.thm[1].s[sb][sblock], ath)); 11311 thmM = Math.max(gfc.thm[2].s[sb][sblock], ath); 11312 thmS = Math.max(gfc.thm[3].s[sb][sblock], ath); 11313 11314 if (thmLR * msfix < thmM + thmS) { 11315 var f = thmLR * msfix / (thmM + thmS); 11316 thmM *= f; 11317 thmS *= f; 11318 } 11319 gfc.thm[2].s[sb][sblock] = Math.min(gfc.thm[2].s[sb][sblock], 11320 thmM); 11321 gfc.thm[3].s[sb][sblock] = Math.min(gfc.thm[3].s[sb][sblock], 11322 thmS); 11323 } 11324 } 11325 } 11326 11327 /** 11328 * short block threshold calculation (part 2) 11329 * 11330 * partition band bo_s[sfb] is at the transition from scalefactor band sfb 11331 * to the next one sfb+1; enn and thmm have to be split between them 11332 */ 11333 function convert_partition2scalefac_s(gfc, eb, thr, chn, sblock) { 11334 var sb, b; 11335 var enn = 0.0; 11336 var thmm = 0.0; 11337 for (sb = b = 0; sb < Encoder.SBMAX_s; ++b, ++sb) { 11338 var bo_s_sb = gfc.bo_s[sb]; 11339 var npart_s = gfc.npart_s; 11340 var b_lim = bo_s_sb < npart_s ? bo_s_sb : npart_s; 11341 while (b < b_lim) { 11342 // iff failed, it may indicate some index error elsewhere 11343 enn += eb[b]; 11344 thmm += thr[b]; 11345 b++; 11346 } 11347 gfc.en[chn].s[sb][sblock] = enn; 11348 gfc.thm[chn].s[sb][sblock] = thmm; 11349 11350 if (b >= npart_s) { 11351 ++sb; 11352 break; 11353 } 11354 // iff failed, it may indicate some index error elsewhere 11355 { 11356 /* at transition sfb . sfb+1 */ 11357 var w_curr = gfc.PSY.bo_s_weight[sb]; 11358 var w_next = 1.0 - w_curr; 11359 enn = w_curr * eb[b]; 11360 thmm = w_curr * thr[b]; 11361 gfc.en[chn].s[sb][sblock] += enn; 11362 gfc.thm[chn].s[sb][sblock] += thmm; 11363 enn = w_next * eb[b]; 11364 thmm = w_next * thr[b]; 11365 } 11366 } 11367 /* zero initialize the rest */ 11368 for (; sb < Encoder.SBMAX_s; ++sb) { 11369 gfc.en[chn].s[sb][sblock] = 0; 11370 gfc.thm[chn].s[sb][sblock] = 0; 11371 } 11372 } 11373 11374 /** 11375 * longblock threshold calculation (part 2) 11376 */ 11377 function convert_partition2scalefac_l(gfc, eb, thr, chn) { 11378 var sb, b; 11379 var enn = 0.0; 11380 var thmm = 0.0; 11381 for (sb = b = 0; sb < Encoder.SBMAX_l; ++b, ++sb) { 11382 var bo_l_sb = gfc.bo_l[sb]; 11383 var npart_l = gfc.npart_l; 11384 var b_lim = bo_l_sb < npart_l ? bo_l_sb : npart_l; 11385 while (b < b_lim) { 11386 // iff failed, it may indicate some index error elsewhere 11387 enn += eb[b]; 11388 thmm += thr[b]; 11389 b++; 11390 } 11391 gfc.en[chn].l[sb] = enn; 11392 gfc.thm[chn].l[sb] = thmm; 11393 11394 if (b >= npart_l) { 11395 ++sb; 11396 break; 11397 } 11398 { 11399 /* at transition sfb . sfb+1 */ 11400 var w_curr = gfc.PSY.bo_l_weight[sb]; 11401 var w_next = 1.0 - w_curr; 11402 enn = w_curr * eb[b]; 11403 thmm = w_curr * thr[b]; 11404 gfc.en[chn].l[sb] += enn; 11405 gfc.thm[chn].l[sb] += thmm; 11406 enn = w_next * eb[b]; 11407 thmm = w_next * thr[b]; 11408 } 11409 } 11410 /* zero initialize the rest */ 11411 for (; sb < Encoder.SBMAX_l; ++sb) { 11412 gfc.en[chn].l[sb] = 0; 11413 gfc.thm[chn].l[sb] = 0; 11414 } 11415 } 11416 11417 function compute_masking_s(gfp, fftenergy_s, eb, thr, chn, sblock) { 11418 var gfc = gfp.internal_flags; 11419 var j, b; 11420 11421 for (b = j = 0; b < gfc.npart_s; ++b) { 11422 var ebb = 0, m = 0; 11423 var n = gfc.numlines_s[b]; 11424 for (var i = 0; i < n; ++i, ++j) { 11425 var el = fftenergy_s[sblock][j]; 11426 ebb += el; 11427 if (m < el) 11428 m = el; 11429 } 11430 eb[b] = ebb; 11431 } 11432 for (j = b = 0; b < gfc.npart_s; b++) { 11433 var kk = gfc.s3ind_s[b][0]; 11434 var ecb = gfc.s3_ss[j++] * eb[kk]; 11435 ++kk; 11436 while (kk <= gfc.s3ind_s[b][1]) { 11437 ecb += gfc.s3_ss[j] * eb[kk]; 11438 ++j; 11439 ++kk; 11440 } 11441 11442 { /* limit calculated threshold by previous granule */ 11443 var x = rpelev_s * gfc.nb_s1[chn][b]; 11444 thr[b] = Math.min(ecb, x); 11445 } 11446 if (gfc.blocktype_old[chn & 1] == Encoder.SHORT_TYPE) { 11447 /* limit calculated threshold by even older granule */ 11448 var x = rpelev2_s * gfc.nb_s2[chn][b]; 11449 var y = thr[b]; 11450 thr[b] = Math.min(x, y); 11451 } 11452 11453 gfc.nb_s2[chn][b] = gfc.nb_s1[chn][b]; 11454 gfc.nb_s1[chn][b] = ecb; 11455 } 11456 for (; b <= Encoder.CBANDS; ++b) { 11457 eb[b] = 0; 11458 thr[b] = 0; 11459 } 11460 } 11461 11462 function block_type_set(gfp, uselongblock, blocktype_d, blocktype) { 11463 var gfc = gfp.internal_flags; 11464 11465 if (gfp.short_blocks == ShortBlock.short_block_coupled 11466 /* force both channels to use the same block type */ 11467 /* this is necessary if the frame is to be encoded in ms_stereo. */ 11468 /* But even without ms_stereo, FhG does this */ 11469 && !(uselongblock[0] != 0 && uselongblock[1] != 0)) 11470 uselongblock[0] = uselongblock[1] = 0; 11471 11472 /* 11473 * update the blocktype of the previous granule, since it depends on 11474 * what happend in this granule 11475 */ 11476 for (var chn = 0; chn < gfc.channels_out; chn++) { 11477 blocktype[chn] = Encoder.NORM_TYPE; 11478 /* disable short blocks */ 11479 if (gfp.short_blocks == ShortBlock.short_block_dispensed) 11480 uselongblock[chn] = 1; 11481 if (gfp.short_blocks == ShortBlock.short_block_forced) 11482 uselongblock[chn] = 0; 11483 11484 if (uselongblock[chn] != 0) { 11485 /* no attack : use long blocks */ 11486 if (gfc.blocktype_old[chn] == Encoder.SHORT_TYPE) 11487 blocktype[chn] = Encoder.STOP_TYPE; 11488 } else { 11489 /* attack : use short blocks */ 11490 blocktype[chn] = Encoder.SHORT_TYPE; 11491 if (gfc.blocktype_old[chn] == Encoder.NORM_TYPE) { 11492 gfc.blocktype_old[chn] = Encoder.START_TYPE; 11493 } 11494 if (gfc.blocktype_old[chn] == Encoder.STOP_TYPE) 11495 gfc.blocktype_old[chn] = Encoder.SHORT_TYPE; 11496 } 11497 11498 blocktype_d[chn] = gfc.blocktype_old[chn]; 11499 // value returned to calling program 11500 gfc.blocktype_old[chn] = blocktype[chn]; 11501 // save for next call to l3psy_anal 11502 } 11503 } 11504 11505 function NS_INTERP(x, y, r) { 11506 /* was pow((x),(r))*pow((y),1-(r)) */ 11507 if (r >= 1.0) { 11508 /* 99.7% of the time */ 11509 return x; 11510 } 11511 if (r <= 0.0) 11512 return y; 11513 if (y > 0.0) { 11514 /* rest of the time */ 11515 return (Math.pow(x / y, r) * y); 11516 } 11517 /* never happens */ 11518 return 0.0; 11519 } 11520 11521 /** 11522 * these values are tuned only for 44.1kHz... 11523 */ 11524 var regcoef_s = [11.8, 13.6, 17.2, 32, 46.5, 11525 51.3, 57.5, 67.1, 71.5, 84.6, 97.6, 130, 11526 /* 255.8 */ 11527 ]; 11528 11529 function pecalc_s(mr, masking_lower) { 11530 var pe_s = 1236.28 / 4; 11531 for (var sb = 0; sb < Encoder.SBMAX_s - 1; sb++) { 11532 for (var sblock = 0; sblock < 3; sblock++) { 11533 var thm = mr.thm.s[sb][sblock]; 11534 if (thm > 0.0) { 11535 var x = thm * masking_lower; 11536 var en = mr.en.s[sb][sblock]; 11537 if (en > x) { 11538 if (en > x * 1e10) { 11539 pe_s += regcoef_s[sb] * (10.0 * LOG10); 11540 } else { 11541 pe_s += regcoef_s[sb] * Util.FAST_LOG10(en / x); 11542 } 11543 } 11544 } 11545 } 11546 } 11547 11548 return pe_s; 11549 } 11550 11551 /** 11552 * these values are tuned only for 44.1kHz... 11553 */ 11554 var regcoef_l = [6.8, 5.8, 5.8, 6.4, 6.5, 9.9, 11555 12.1, 14.4, 15, 18.9, 21.6, 26.9, 34.2, 40.2, 46.8, 56.5, 11556 60.7, 73.9, 85.7, 93.4, 126.1, 11557 /* 241.3 */ 11558 ]; 11559 11560 function pecalc_l(mr, masking_lower) { 11561 var pe_l = 1124.23 / 4; 11562 for (var sb = 0; sb < Encoder.SBMAX_l - 1; sb++) { 11563 var thm = mr.thm.l[sb]; 11564 if (thm > 0.0) { 11565 var x = thm * masking_lower; 11566 var en = mr.en.l[sb]; 11567 if (en > x) { 11568 if (en > x * 1e10) { 11569 pe_l += regcoef_l[sb] * (10.0 * LOG10); 11570 } else { 11571 pe_l += regcoef_l[sb] * Util.FAST_LOG10(en / x); 11572 } 11573 } 11574 } 11575 } 11576 return pe_l; 11577 } 11578 11579 function calc_energy(gfc, fftenergy, eb, max, avg) { 11580 var b, j; 11581 11582 for (b = j = 0; b < gfc.npart_l; ++b) { 11583 var ebb = 0, m = 0; 11584 var i; 11585 for (i = 0; i < gfc.numlines_l[b]; ++i, ++j) { 11586 var el = fftenergy[j]; 11587 ebb += el; 11588 if (m < el) 11589 m = el; 11590 } 11591 eb[b] = ebb; 11592 max[b] = m; 11593 avg[b] = ebb * gfc.rnumlines_l[b]; 11594 } 11595 } 11596 11597 function calc_mask_index_l(gfc, max, avg, mask_idx) { 11598 var last_tab_entry = tab.length - 1; 11599 var b = 0; 11600 var a = avg[b] + avg[b + 1]; 11601 if (a > 0.0) { 11602 var m = max[b]; 11603 if (m < max[b + 1]) 11604 m = max[b + 1]; 11605 a = 20.0 * (m * 2.0 - a) 11606 / (a * (gfc.numlines_l[b] + gfc.numlines_l[b + 1] - 1)); 11607 var k = 0 | a; 11608 if (k > last_tab_entry) 11609 k = last_tab_entry; 11610 mask_idx[b] = k; 11611 } else { 11612 mask_idx[b] = 0; 11613 } 11614 11615 for (b = 1; b < gfc.npart_l - 1; b++) { 11616 a = avg[b - 1] + avg[b] + avg[b + 1]; 11617 if (a > 0.0) { 11618 var m = max[b - 1]; 11619 if (m < max[b]) 11620 m = max[b]; 11621 if (m < max[b + 1]) 11622 m = max[b + 1]; 11623 a = 20.0 11624 * (m * 3.0 - a) 11625 / (a * (gfc.numlines_l[b - 1] + gfc.numlines_l[b] 11626 + gfc.numlines_l[b + 1] - 1)); 11627 var k = 0 | a; 11628 if (k > last_tab_entry) 11629 k = last_tab_entry; 11630 mask_idx[b] = k; 11631 } else { 11632 mask_idx[b] = 0; 11633 } 11634 } 11635 11636 a = avg[b - 1] + avg[b]; 11637 if (a > 0.0) { 11638 var m = max[b - 1]; 11639 if (m < max[b]) 11640 m = max[b]; 11641 a = 20.0 * (m * 2.0 - a) 11642 / (a * (gfc.numlines_l[b - 1] + gfc.numlines_l[b] - 1)); 11643 var k = 0 | a; 11644 if (k > last_tab_entry) 11645 k = last_tab_entry; 11646 mask_idx[b] = k; 11647 } else { 11648 mask_idx[b] = 0; 11649 } 11650 } 11651 11652 var fircoef = [ 11653 -8.65163e-18 * 2, -0.00851586 * 2, -6.74764e-18 * 2, 0.0209036 * 2, 11654 -3.36639e-17 * 2, -0.0438162 * 2, -1.54175e-17 * 2, 0.0931738 * 2, 11655 -5.52212e-17 * 2, -0.313819 * 2 11656 ]; 11657 11658 this.L3psycho_anal_ns = function (gfp, buffer, bufPos, gr_out, masking_ratio, masking_MS_ratio, percep_entropy, percep_MS_entropy, energy, blocktype_d) { 11659 /* 11660 * to get a good cache performance, one has to think about the sequence, 11661 * in which the variables are used. 11662 */ 11663 var gfc = gfp.internal_flags; 11664 11665 /* fft and energy calculation */ 11666 var wsamp_L = new_float_n([2, Encoder.BLKSIZE]); 11667 var wsamp_S = new_float_n([2, 3, Encoder.BLKSIZE_s]); 11668 11669 /* convolution */ 11670 var eb_l = new_float(Encoder.CBANDS + 1); 11671 var eb_s = new_float(Encoder.CBANDS + 1); 11672 var thr = new_float(Encoder.CBANDS + 2); 11673 11674 /* block type */ 11675 var blocktype = new_int(2), uselongblock = new_int(2); 11676 11677 /* usual variables like loop indices, etc.. */ 11678 var numchn, chn; 11679 var b, i, j, k; 11680 var sb, sblock; 11681 11682 /* variables used for --nspsytune */ 11683 var ns_hpfsmpl = new_float_n([2, 576]); 11684 var pcfact; 11685 var mask_idx_l = new_int(Encoder.CBANDS + 2), mask_idx_s = new_int(Encoder.CBANDS + 2); 11686 11687 Arrays.fill(mask_idx_s, 0); 11688 11689 numchn = gfc.channels_out; 11690 /* chn=2 and 3 = Mid and Side channels */ 11691 if (gfp.mode == MPEGMode.JOINT_STEREO) 11692 numchn = 4; 11693 11694 if (gfp.VBR == VbrMode.vbr_off) 11695 pcfact = gfc.ResvMax == 0 ? 0 : ( gfc.ResvSize) 11696 / gfc.ResvMax * 0.5; 11697 else if (gfp.VBR == VbrMode.vbr_rh || gfp.VBR == VbrMode.vbr_mtrh 11698 || gfp.VBR == VbrMode.vbr_mt) { 11699 pcfact = 0.6; 11700 } else 11701 pcfact = 1.0; 11702 11703 /********************************************************************** 11704 * Apply HPF of fs/4 to the input signal. This is used for attack 11705 * detection / handling. 11706 **********************************************************************/ 11707 /* Don't copy the input buffer into a temporary buffer */ 11708 /* unroll the loop 2 times */ 11709 for (chn = 0; chn < gfc.channels_out; chn++) { 11710 /* apply high pass filter of fs/4 */ 11711 var firbuf = buffer[chn]; 11712 var firbufPos = bufPos + 576 - 350 - NSFIRLEN + 192; 11713 for (i = 0; i < 576; i++) { 11714 var sum1, sum2; 11715 sum1 = firbuf[firbufPos + i + 10]; 11716 sum2 = 0.0; 11717 for (j = 0; j < ((NSFIRLEN - 1) / 2) - 1; j += 2) { 11718 sum1 += fircoef[j] 11719 * (firbuf[firbufPos + i + j] + firbuf[firbufPos + i 11720 + NSFIRLEN - j]); 11721 sum2 += fircoef[j + 1] 11722 * (firbuf[firbufPos + i + j + 1] + firbuf[firbufPos 11723 + i + NSFIRLEN - j - 1]); 11724 } 11725 ns_hpfsmpl[chn][i] = sum1 + sum2; 11726 } 11727 masking_ratio[gr_out][chn].en.assign(gfc.en[chn]); 11728 masking_ratio[gr_out][chn].thm.assign(gfc.thm[chn]); 11729 if (numchn > 2) { 11730 /* MS maskings */ 11731 /* percep_MS_entropy [chn-2] = gfc . pe [chn]; */ 11732 masking_MS_ratio[gr_out][chn].en.assign(gfc.en[chn + 2]); 11733 masking_MS_ratio[gr_out][chn].thm.assign(gfc.thm[chn + 2]); 11734 } 11735 } 11736 11737 for (chn = 0; chn < numchn; chn++) { 11738 var wsamp_l; 11739 var wsamp_s; 11740 var en_subshort = new_float(12); 11741 var en_short = [0, 0, 0, 0]; 11742 var attack_intensity = new_float(12); 11743 var ns_uselongblock = 1; 11744 var attackThreshold; 11745 var max = new_float(Encoder.CBANDS), avg = new_float(Encoder.CBANDS); 11746 var ns_attacks = [0, 0, 0, 0]; 11747 var fftenergy = new_float(Encoder.HBLKSIZE); 11748 var fftenergy_s = new_float_n([3, Encoder.HBLKSIZE_s]); 11749 11750 /* 11751 * rh 20040301: the following loops do access one off the limits so 11752 * I increase the array dimensions by one and initialize the 11753 * accessed values to zero 11754 */ 11755 11756 /*************************************************************** 11757 * determine the block type (window type) 11758 ***************************************************************/ 11759 /* calculate energies of each sub-shortblocks */ 11760 for (i = 0; i < 3; i++) { 11761 en_subshort[i] = gfc.nsPsy.last_en_subshort[chn][i + 6]; 11762 attack_intensity[i] = en_subshort[i] 11763 / gfc.nsPsy.last_en_subshort[chn][i + 4]; 11764 en_short[0] += en_subshort[i]; 11765 } 11766 11767 if (chn == 2) { 11768 for (i = 0; i < 576; i++) { 11769 var l, r; 11770 l = ns_hpfsmpl[0][i]; 11771 r = ns_hpfsmpl[1][i]; 11772 ns_hpfsmpl[0][i] = l + r; 11773 ns_hpfsmpl[1][i] = l - r; 11774 } 11775 } 11776 { 11777 var pf = ns_hpfsmpl[chn & 1]; 11778 var pfPos = 0; 11779 for (i = 0; i < 9; i++) { 11780 var pfe = pfPos + 576 / 9; 11781 var p = 1.; 11782 for (; pfPos < pfe; pfPos++) 11783 if (p < Math.abs(pf[pfPos])) 11784 p = Math.abs(pf[pfPos]); 11785 11786 gfc.nsPsy.last_en_subshort[chn][i] = en_subshort[i + 3] = p; 11787 en_short[1 + i / 3] += p; 11788 if (p > en_subshort[i + 3 - 2]) { 11789 p = p / en_subshort[i + 3 - 2]; 11790 } else if (en_subshort[i + 3 - 2] > p * 10.0) { 11791 p = en_subshort[i + 3 - 2] / (p * 10.0); 11792 } else 11793 p = 0.0; 11794 attack_intensity[i + 3] = p; 11795 } 11796 } 11797 11798 if (gfp.analysis) { 11799 var x = attack_intensity[0]; 11800 for (i = 1; i < 12; i++) 11801 if (x < attack_intensity[i]) 11802 x = attack_intensity[i]; 11803 gfc.pinfo.ers[gr_out][chn] = gfc.pinfo.ers_save[chn]; 11804 gfc.pinfo.ers_save[chn] = x; 11805 } 11806 11807 /* compare energies between sub-shortblocks */ 11808 attackThreshold = (chn == 3) ? gfc.nsPsy.attackthre_s 11809 : gfc.nsPsy.attackthre; 11810 for (i = 0; i < 12; i++) 11811 if (0 == ns_attacks[i / 3] 11812 && attack_intensity[i] > attackThreshold) 11813 ns_attacks[i / 3] = (i % 3) + 1; 11814 11815 /* 11816 * should have energy change between short blocks, in order to avoid 11817 * periodic signals 11818 */ 11819 for (i = 1; i < 4; i++) { 11820 var ratio; 11821 if (en_short[i - 1] > en_short[i]) { 11822 ratio = en_short[i - 1] / en_short[i]; 11823 } else { 11824 ratio = en_short[i] / en_short[i - 1]; 11825 } 11826 if (ratio < 1.7) { 11827 ns_attacks[i] = 0; 11828 if (i == 1) 11829 ns_attacks[0] = 0; 11830 } 11831 } 11832 11833 if (ns_attacks[0] != 0 && gfc.nsPsy.lastAttacks[chn] != 0) 11834 ns_attacks[0] = 0; 11835 11836 if (gfc.nsPsy.lastAttacks[chn] == 3 11837 || (ns_attacks[0] + ns_attacks[1] + ns_attacks[2] + ns_attacks[3]) != 0) { 11838 ns_uselongblock = 0; 11839 11840 if (ns_attacks[1] != 0 && ns_attacks[0] != 0) 11841 ns_attacks[1] = 0; 11842 if (ns_attacks[2] != 0 && ns_attacks[1] != 0) 11843 ns_attacks[2] = 0; 11844 if (ns_attacks[3] != 0 && ns_attacks[2] != 0) 11845 ns_attacks[3] = 0; 11846 } 11847 11848 if (chn < 2) { 11849 uselongblock[chn] = ns_uselongblock; 11850 } else { 11851 if (ns_uselongblock == 0) { 11852 uselongblock[0] = uselongblock[1] = 0; 11853 } 11854 } 11855 11856 /* 11857 * there is a one granule delay. Copy maskings computed last call 11858 * into masking_ratio to return to calling program. 11859 */ 11860 energy[chn] = gfc.tot_ener[chn]; 11861 11862 /********************************************************************* 11863 * compute FFTs 11864 *********************************************************************/ 11865 wsamp_s = wsamp_S; 11866 wsamp_l = wsamp_L; 11867 compute_ffts(gfp, fftenergy, fftenergy_s, wsamp_l, (chn & 1), 11868 wsamp_s, (chn & 1), gr_out, chn, buffer, bufPos); 11869 11870 /********************************************************************* 11871 * Calculate the energy and the tonality of each partition. 11872 *********************************************************************/ 11873 calc_energy(gfc, fftenergy, eb_l, max, avg); 11874 calc_mask_index_l(gfc, max, avg, mask_idx_l); 11875 /* compute masking thresholds for short blocks */ 11876 for (sblock = 0; sblock < 3; sblock++) { 11877 var enn, thmm; 11878 compute_masking_s(gfp, fftenergy_s, eb_s, thr, chn, sblock); 11879 convert_partition2scalefac_s(gfc, eb_s, thr, chn, sblock); 11880 /**** short block pre-echo control ****/ 11881 for (sb = 0; sb < Encoder.SBMAX_s; sb++) { 11882 thmm = gfc.thm[chn].s[sb][sblock]; 11883 11884 thmm *= NS_PREECHO_ATT0; 11885 if (ns_attacks[sblock] >= 2 || ns_attacks[sblock + 1] == 1) { 11886 var idx = (sblock != 0) ? sblock - 1 : 2; 11887 var p = NS_INTERP(gfc.thm[chn].s[sb][idx], thmm, 11888 NS_PREECHO_ATT1 * pcfact); 11889 thmm = Math.min(thmm, p); 11890 } 11891 11892 if (ns_attacks[sblock] == 1) { 11893 var idx = (sblock != 0) ? sblock - 1 : 2; 11894 var p = NS_INTERP(gfc.thm[chn].s[sb][idx], thmm, 11895 NS_PREECHO_ATT2 * pcfact); 11896 thmm = Math.min(thmm, p); 11897 } else if ((sblock != 0 && ns_attacks[sblock - 1] == 3) 11898 || (sblock == 0 && gfc.nsPsy.lastAttacks[chn] == 3)) { 11899 var idx = (sblock != 2) ? sblock + 1 : 0; 11900 var p = NS_INTERP(gfc.thm[chn].s[sb][idx], thmm, 11901 NS_PREECHO_ATT2 * pcfact); 11902 thmm = Math.min(thmm, p); 11903 } 11904 11905 /* pulse like signal detection for fatboy.wav and so on */ 11906 enn = en_subshort[sblock * 3 + 3] 11907 + en_subshort[sblock * 3 + 4] 11908 + en_subshort[sblock * 3 + 5]; 11909 if (en_subshort[sblock * 3 + 5] * 6 < enn) { 11910 thmm *= 0.5; 11911 if (en_subshort[sblock * 3 + 4] * 6 < enn) 11912 thmm *= 0.5; 11913 } 11914 11915 gfc.thm[chn].s[sb][sblock] = thmm; 11916 } 11917 } 11918 gfc.nsPsy.lastAttacks[chn] = ns_attacks[2]; 11919 11920 /********************************************************************* 11921 * convolve the partitioned energy and unpredictability with the 11922 * spreading function, s3_l[b][k] 11923 ********************************************************************/ 11924 k = 0; 11925 { 11926 for (b = 0; b < gfc.npart_l; b++) { 11927 /* 11928 * convolve the partitioned energy with the spreading 11929 * function 11930 */ 11931 var kk = gfc.s3ind[b][0]; 11932 var eb2 = eb_l[kk] * tab[mask_idx_l[kk]]; 11933 var ecb = gfc.s3_ll[k++] * eb2; 11934 while (++kk <= gfc.s3ind[b][1]) { 11935 eb2 = eb_l[kk] * tab[mask_idx_l[kk]]; 11936 ecb = mask_add(ecb, gfc.s3_ll[k++] * eb2, kk, kk - b, 11937 gfc, 0); 11938 } 11939 ecb *= 0.158489319246111; 11940 /* pow(10,-0.8) */ 11941 11942 /**** long block pre-echo control ****/ 11943 /** 11944 * <PRE> 11945 * dont use long block pre-echo control if previous granule was 11946 * a short block. This is to avoid the situation: 11947 * frame0: quiet (very low masking) 11948 * frame1: surge (triggers short blocks) 11949 * frame2: regular frame. looks like pre-echo when compared to 11950 * frame0, but all pre-echo was in frame1. 11951 * </PRE> 11952 */ 11953 /* 11954 * chn=0,1 L and R channels 11955 * 11956 * chn=2,3 S and M channels. 11957 */ 11958 11959 if (gfc.blocktype_old[chn & 1] == Encoder.SHORT_TYPE) 11960 thr[b] = ecb; 11961 else 11962 thr[b] = NS_INTERP( 11963 Math.min(ecb, Math.min(rpelev 11964 * gfc.nb_1[chn][b], rpelev2 11965 * gfc.nb_2[chn][b])), ecb, pcfact); 11966 11967 gfc.nb_2[chn][b] = gfc.nb_1[chn][b]; 11968 gfc.nb_1[chn][b] = ecb; 11969 } 11970 } 11971 for (; b <= Encoder.CBANDS; ++b) { 11972 eb_l[b] = 0; 11973 thr[b] = 0; 11974 } 11975 /* compute masking thresholds for long blocks */ 11976 convert_partition2scalefac_l(gfc, eb_l, thr, chn); 11977 } 11978 /* end loop over chn */ 11979 11980 if (gfp.mode == MPEGMode.STEREO || gfp.mode == MPEGMode.JOINT_STEREO) { 11981 if (gfp.interChRatio > 0.0) { 11982 calc_interchannel_masking(gfp, gfp.interChRatio); 11983 } 11984 } 11985 11986 if (gfp.mode == MPEGMode.JOINT_STEREO) { 11987 var msfix; 11988 msfix1(gfc); 11989 msfix = gfp.msfix; 11990 if (Math.abs(msfix) > 0.0) 11991 ns_msfix(gfc, msfix, gfp.ATHlower * gfc.ATH.adjust); 11992 } 11993 11994 /*************************************************************** 11995 * determine final block type 11996 ***************************************************************/ 11997 block_type_set(gfp, uselongblock, blocktype_d, blocktype); 11998 11999 /********************************************************************* 12000 * compute the value of PE to return ... no delay and advance 12001 *********************************************************************/ 12002 for (chn = 0; chn < numchn; chn++) { 12003 var ppe; 12004 var ppePos = 0; 12005 var type; 12006 var mr; 12007 12008 if (chn > 1) { 12009 ppe = percep_MS_entropy; 12010 ppePos = -2; 12011 type = Encoder.NORM_TYPE; 12012 if (blocktype_d[0] == Encoder.SHORT_TYPE 12013 || blocktype_d[1] == Encoder.SHORT_TYPE) 12014 type = Encoder.SHORT_TYPE; 12015 mr = masking_MS_ratio[gr_out][chn - 2]; 12016 } else { 12017 ppe = percep_entropy; 12018 ppePos = 0; 12019 type = blocktype_d[chn]; 12020 mr = masking_ratio[gr_out][chn]; 12021 } 12022 12023 if (type == Encoder.SHORT_TYPE) 12024 ppe[ppePos + chn] = pecalc_s(mr, gfc.masking_lower); 12025 else 12026 ppe[ppePos + chn] = pecalc_l(mr, gfc.masking_lower); 12027 12028 if (gfp.analysis) 12029 gfc.pinfo.pe[gr_out][chn] = ppe[ppePos + chn]; 12030 12031 } 12032 return 0; 12033 } 12034 12035 function vbrpsy_compute_fft_l(gfp, buffer, bufPos, chn, gr_out, fftenergy, wsamp_l, wsamp_lPos) { 12036 var gfc = gfp.internal_flags; 12037 if (chn < 2) { 12038 fft.fft_long(gfc, wsamp_l[wsamp_lPos], chn, buffer, bufPos); 12039 } else if (chn == 2) { 12040 /* FFT data for mid and side channel is derived from L & R */ 12041 for (var j = Encoder.BLKSIZE - 1; j >= 0; --j) { 12042 var l = wsamp_l[wsamp_lPos + 0][j]; 12043 var r = wsamp_l[wsamp_lPos + 1][j]; 12044 wsamp_l[wsamp_lPos + 0][j] = (l + r) * Util.SQRT2 * 0.5; 12045 wsamp_l[wsamp_lPos + 1][j] = (l - r) * Util.SQRT2 * 0.5; 12046 } 12047 } 12048 12049 /********************************************************************* 12050 * compute energies 12051 *********************************************************************/ 12052 fftenergy[0] = NON_LINEAR_SCALE_ENERGY(wsamp_l[wsamp_lPos + 0][0]); 12053 fftenergy[0] *= fftenergy[0]; 12054 12055 for (var j = Encoder.BLKSIZE / 2 - 1; j >= 0; --j) { 12056 var re = wsamp_l[wsamp_lPos + 0][Encoder.BLKSIZE / 2 - j]; 12057 var im = wsamp_l[wsamp_lPos + 0][Encoder.BLKSIZE / 2 + j]; 12058 fftenergy[Encoder.BLKSIZE / 2 - j] = NON_LINEAR_SCALE_ENERGY((re 12059 * re + im * im) * 0.5); 12060 } 12061 /* total energy */ 12062 { 12063 var totalenergy = 0.0; 12064 for (var j = 11; j < Encoder.HBLKSIZE; j++) 12065 totalenergy += fftenergy[j]; 12066 12067 gfc.tot_ener[chn] = totalenergy; 12068 } 12069 12070 if (gfp.analysis) { 12071 for (var j = 0; j < Encoder.HBLKSIZE; j++) { 12072 gfc.pinfo.energy[gr_out][chn][j] = gfc.pinfo.energy_save[chn][j]; 12073 gfc.pinfo.energy_save[chn][j] = fftenergy[j]; 12074 } 12075 gfc.pinfo.pe[gr_out][chn] = gfc.pe[chn]; 12076 } 12077 } 12078 12079 function vbrpsy_compute_fft_s(gfp, buffer, bufPos, chn, sblock, fftenergy_s, wsamp_s, wsamp_sPos) { 12080 var gfc = gfp.internal_flags; 12081 12082 if (sblock == 0 && chn < 2) { 12083 fft.fft_short(gfc, wsamp_s[wsamp_sPos], chn, buffer, bufPos); 12084 } 12085 if (chn == 2) { 12086 /* FFT data for mid and side channel is derived from L & R */ 12087 for (var j = Encoder.BLKSIZE_s - 1; j >= 0; --j) { 12088 var l = wsamp_s[wsamp_sPos + 0][sblock][j]; 12089 var r = wsamp_s[wsamp_sPos + 1][sblock][j]; 12090 wsamp_s[wsamp_sPos + 0][sblock][j] = (l + r) * Util.SQRT2 * 0.5; 12091 wsamp_s[wsamp_sPos + 1][sblock][j] = (l - r) * Util.SQRT2 * 0.5; 12092 } 12093 } 12094 12095 /********************************************************************* 12096 * compute energies 12097 *********************************************************************/ 12098 fftenergy_s[sblock][0] = wsamp_s[wsamp_sPos + 0][sblock][0]; 12099 fftenergy_s[sblock][0] *= fftenergy_s[sblock][0]; 12100 for (var j = Encoder.BLKSIZE_s / 2 - 1; j >= 0; --j) { 12101 var re = wsamp_s[wsamp_sPos + 0][sblock][Encoder.BLKSIZE_s / 2 - j]; 12102 var im = wsamp_s[wsamp_sPos + 0][sblock][Encoder.BLKSIZE_s / 2 + j]; 12103 fftenergy_s[sblock][Encoder.BLKSIZE_s / 2 - j] = NON_LINEAR_SCALE_ENERGY((re 12104 * re + im * im) * 0.5); 12105 } 12106 } 12107 12108 /** 12109 * compute loudness approximation (used for ATH auto-level adjustment) 12110 */ 12111 function vbrpsy_compute_loudness_approximation_l(gfp, gr_out, chn, fftenergy) { 12112 var gfc = gfp.internal_flags; 12113 if (gfp.athaa_loudapprox == 2 && chn < 2) { 12114 // no loudness for mid/side ch 12115 gfc.loudness_sq[gr_out][chn] = gfc.loudness_sq_save[chn]; 12116 gfc.loudness_sq_save[chn] = psycho_loudness_approx(fftenergy, gfc); 12117 } 12118 } 12119 12120 var fircoef_ = [-8.65163e-18 * 2, 12121 -0.00851586 * 2, -6.74764e-18 * 2, 0.0209036 * 2, 12122 -3.36639e-17 * 2, -0.0438162 * 2, -1.54175e-17 * 2, 12123 0.0931738 * 2, -5.52212e-17 * 2, -0.313819 * 2]; 12124 12125 /** 12126 * Apply HPF of fs/4 to the input signal. This is used for attack detection 12127 * / handling. 12128 */ 12129 function vbrpsy_attack_detection(gfp, buffer, bufPos, gr_out, masking_ratio, masking_MS_ratio, energy, sub_short_factor, ns_attacks, uselongblock) { 12130 var ns_hpfsmpl = new_float_n([2, 576]); 12131 var gfc = gfp.internal_flags; 12132 var n_chn_out = gfc.channels_out; 12133 /* chn=2 and 3 = Mid and Side channels */ 12134 var n_chn_psy = (gfp.mode == MPEGMode.JOINT_STEREO) ? 4 : n_chn_out; 12135 /* Don't copy the input buffer into a temporary buffer */ 12136 /* unroll the loop 2 times */ 12137 for (var chn = 0; chn < n_chn_out; chn++) { 12138 /* apply high pass filter of fs/4 */ 12139 firbuf = buffer[chn]; 12140 var firbufPos = bufPos + 576 - 350 - NSFIRLEN + 192; 12141 for (var i = 0; i < 576; i++) { 12142 var sum1, sum2; 12143 sum1 = firbuf[firbufPos + i + 10]; 12144 sum2 = 0.0; 12145 for (var j = 0; j < ((NSFIRLEN - 1) / 2) - 1; j += 2) { 12146 sum1 += fircoef_[j] 12147 * (firbuf[firbufPos + i + j] + firbuf[firbufPos + i 12148 + NSFIRLEN - j]); 12149 sum2 += fircoef_[j + 1] 12150 * (firbuf[firbufPos + i + j + 1] + firbuf[firbufPos 12151 + i + NSFIRLEN - j - 1]); 12152 } 12153 ns_hpfsmpl[chn][i] = sum1 + sum2; 12154 } 12155 masking_ratio[gr_out][chn].en.assign(gfc.en[chn]); 12156 masking_ratio[gr_out][chn].thm.assign(gfc.thm[chn]); 12157 if (n_chn_psy > 2) { 12158 /* MS maskings */ 12159 /* percep_MS_entropy [chn-2] = gfc . pe [chn]; */ 12160 masking_MS_ratio[gr_out][chn].en.assign(gfc.en[chn + 2]); 12161 masking_MS_ratio[gr_out][chn].thm.assign(gfc.thm[chn + 2]); 12162 } 12163 } 12164 for (var chn = 0; chn < n_chn_psy; chn++) { 12165 var attack_intensity = new_float(12); 12166 var en_subshort = new_float(12); 12167 var en_short = [0, 0, 0, 0]; 12168 var pf = ns_hpfsmpl[chn & 1]; 12169 var pfPos = 0; 12170 var attackThreshold = (chn == 3) ? gfc.nsPsy.attackthre_s 12171 : gfc.nsPsy.attackthre; 12172 var ns_uselongblock = 1; 12173 12174 if (chn == 2) { 12175 for (var i = 0, j = 576; j > 0; ++i, --j) { 12176 var l = ns_hpfsmpl[0][i]; 12177 var r = ns_hpfsmpl[1][i]; 12178 ns_hpfsmpl[0][i] = l + r; 12179 ns_hpfsmpl[1][i] = l - r; 12180 } 12181 } 12182 /*************************************************************** 12183 * determine the block type (window type) 12184 ***************************************************************/ 12185 /* calculate energies of each sub-shortblocks */ 12186 for (var i = 0; i < 3; i++) { 12187 en_subshort[i] = gfc.nsPsy.last_en_subshort[chn][i + 6]; 12188 attack_intensity[i] = en_subshort[i] 12189 / gfc.nsPsy.last_en_subshort[chn][i + 4]; 12190 en_short[0] += en_subshort[i]; 12191 } 12192 12193 for (var i = 0; i < 9; i++) { 12194 var pfe = pfPos + 576 / 9; 12195 var p = 1.; 12196 for (; pfPos < pfe; pfPos++) 12197 if (p < Math.abs(pf[pfPos])) 12198 p = Math.abs(pf[pfPos]); 12199 12200 gfc.nsPsy.last_en_subshort[chn][i] = en_subshort[i + 3] = p; 12201 en_short[1 + i / 3] += p; 12202 if (p > en_subshort[i + 3 - 2]) { 12203 p = p / en_subshort[i + 3 - 2]; 12204 } else if (en_subshort[i + 3 - 2] > p * 10.0) { 12205 p = en_subshort[i + 3 - 2] / (p * 10.0); 12206 } else { 12207 p = 0.0; 12208 } 12209 attack_intensity[i + 3] = p; 12210 } 12211 /* pulse like signal detection for fatboy.wav and so on */ 12212 for (var i = 0; i < 3; ++i) { 12213 var enn = en_subshort[i * 3 + 3] 12214 + en_subshort[i * 3 + 4] + en_subshort[i * 3 + 5]; 12215 var factor = 1.; 12216 if (en_subshort[i * 3 + 5] * 6 < enn) { 12217 factor *= 0.5; 12218 if (en_subshort[i * 3 + 4] * 6 < enn) { 12219 factor *= 0.5; 12220 } 12221 } 12222 sub_short_factor[chn][i] = factor; 12223 } 12224 12225 if (gfp.analysis) { 12226 var x = attack_intensity[0]; 12227 for (var i = 1; i < 12; i++) { 12228 if (x < attack_intensity[i]) { 12229 x = attack_intensity[i]; 12230 } 12231 } 12232 gfc.pinfo.ers[gr_out][chn] = gfc.pinfo.ers_save[chn]; 12233 gfc.pinfo.ers_save[chn] = x; 12234 } 12235 12236 /* compare energies between sub-shortblocks */ 12237 for (var i = 0; i < 12; i++) { 12238 if (0 == ns_attacks[chn][i / 3] 12239 && attack_intensity[i] > attackThreshold) { 12240 ns_attacks[chn][i / 3] = (i % 3) + 1; 12241 } 12242 } 12243 12244 /* 12245 * should have energy change between short blocks, in order to avoid 12246 * periodic signals 12247 */ 12248 /* Good samples to show the effect are Trumpet test songs */ 12249 /* 12250 * GB: tuned (1) to avoid too many short blocks for test sample 12251 * TRUMPET 12252 */ 12253 /* 12254 * RH: tuned (2) to let enough short blocks through for test sample 12255 * FSOL and SNAPS 12256 */ 12257 for (var i = 1; i < 4; i++) { 12258 var u = en_short[i - 1]; 12259 var v = en_short[i]; 12260 var m = Math.max(u, v); 12261 if (m < 40000) { /* (2) */ 12262 if (u < 1.7 * v && v < 1.7 * u) { /* (1) */ 12263 if (i == 1 && ns_attacks[chn][0] <= ns_attacks[chn][i]) { 12264 ns_attacks[chn][0] = 0; 12265 } 12266 ns_attacks[chn][i] = 0; 12267 } 12268 } 12269 } 12270 12271 if (ns_attacks[chn][0] <= gfc.nsPsy.lastAttacks[chn]) { 12272 ns_attacks[chn][0] = 0; 12273 } 12274 12275 if (gfc.nsPsy.lastAttacks[chn] == 3 12276 || (ns_attacks[chn][0] + ns_attacks[chn][1] 12277 + ns_attacks[chn][2] + ns_attacks[chn][3]) != 0) { 12278 ns_uselongblock = 0; 12279 12280 if (ns_attacks[chn][1] != 0 && ns_attacks[chn][0] != 0) { 12281 ns_attacks[chn][1] = 0; 12282 } 12283 if (ns_attacks[chn][2] != 0 && ns_attacks[chn][1] != 0) { 12284 ns_attacks[chn][2] = 0; 12285 } 12286 if (ns_attacks[chn][3] != 0 && ns_attacks[chn][2] != 0) { 12287 ns_attacks[chn][3] = 0; 12288 } 12289 } 12290 if (chn < 2) { 12291 uselongblock[chn] = ns_uselongblock; 12292 } else { 12293 if (ns_uselongblock == 0) { 12294 uselongblock[0] = uselongblock[1] = 0; 12295 } 12296 } 12297 12298 /* 12299 * there is a one granule delay. Copy maskings computed last call 12300 * into masking_ratio to return to calling program. 12301 */ 12302 energy[chn] = gfc.tot_ener[chn]; 12303 } 12304 } 12305 12306 function vbrpsy_skip_masking_s(gfc, chn, sblock) { 12307 if (sblock == 0) { 12308 for (var b = 0; b < gfc.npart_s; b++) { 12309 gfc.nb_s2[chn][b] = gfc.nb_s1[chn][b]; 12310 gfc.nb_s1[chn][b] = 0; 12311 } 12312 } 12313 } 12314 12315 function vbrpsy_skip_masking_l(gfc, chn) { 12316 for (var b = 0; b < gfc.npart_l; b++) { 12317 gfc.nb_2[chn][b] = gfc.nb_1[chn][b]; 12318 gfc.nb_1[chn][b] = 0; 12319 } 12320 } 12321 12322 function psyvbr_calc_mask_index_s(gfc, max, avg, mask_idx) { 12323 var last_tab_entry = tab.length - 1; 12324 var b = 0; 12325 var a = avg[b] + avg[b + 1]; 12326 if (a > 0.0) { 12327 var m = max[b]; 12328 if (m < max[b + 1]) 12329 m = max[b + 1]; 12330 a = 20.0 * (m * 2.0 - a) 12331 / (a * (gfc.numlines_s[b] + gfc.numlines_s[b + 1] - 1)); 12332 var k = 0 | a; 12333 if (k > last_tab_entry) 12334 k = last_tab_entry; 12335 mask_idx[b] = k; 12336 } else { 12337 mask_idx[b] = 0; 12338 } 12339 12340 for (b = 1; b < gfc.npart_s - 1; b++) { 12341 a = avg[b - 1] + avg[b] + avg[b + 1]; 12342 if (a > 0.0) { 12343 var m = max[b - 1]; 12344 if (m < max[b]) 12345 m = max[b]; 12346 if (m < max[b + 1]) 12347 m = max[b + 1]; 12348 a = 20.0 12349 * (m * 3.0 - a) 12350 / (a * (gfc.numlines_s[b - 1] + gfc.numlines_s[b] 12351 + gfc.numlines_s[b + 1] - 1)); 12352 var k = 0 | a; 12353 if (k > last_tab_entry) 12354 k = last_tab_entry; 12355 mask_idx[b] = k; 12356 } else { 12357 mask_idx[b] = 0; 12358 } 12359 } 12360 12361 a = avg[b - 1] + avg[b]; 12362 if (a > 0.0) { 12363 var m = max[b - 1]; 12364 if (m < max[b]) 12365 m = max[b]; 12366 a = 20.0 * (m * 2.0 - a) 12367 / (a * (gfc.numlines_s[b - 1] + gfc.numlines_s[b] - 1)); 12368 var k = 0 | a; 12369 if (k > last_tab_entry) 12370 k = last_tab_entry; 12371 mask_idx[b] = k; 12372 } else { 12373 mask_idx[b] = 0; 12374 } 12375 } 12376 12377 function vbrpsy_compute_masking_s(gfp, fftenergy_s, eb, thr, chn, sblock) { 12378 var gfc = gfp.internal_flags; 12379 var max = new float[Encoder.CBANDS], avg = new_float(Encoder.CBANDS); 12380 var i, j, b; 12381 var mask_idx_s = new int[Encoder.CBANDS]; 12382 12383 for (b = j = 0; b < gfc.npart_s; ++b) { 12384 var ebb = 0, m = 0; 12385 var n = gfc.numlines_s[b]; 12386 for (i = 0; i < n; ++i, ++j) { 12387 var el = fftenergy_s[sblock][j]; 12388 ebb += el; 12389 if (m < el) 12390 m = el; 12391 } 12392 eb[b] = ebb; 12393 max[b] = m; 12394 avg[b] = ebb / n; 12395 } 12396 for (; b < Encoder.CBANDS; ++b) { 12397 max[b] = 0; 12398 avg[b] = 0; 12399 } 12400 psyvbr_calc_mask_index_s(gfc, max, avg, mask_idx_s); 12401 for (j = b = 0; b < gfc.npart_s; b++) { 12402 var kk = gfc.s3ind_s[b][0]; 12403 var last = gfc.s3ind_s[b][1]; 12404 var dd, dd_n; 12405 var x, ecb, avg_mask; 12406 dd = mask_idx_s[kk]; 12407 dd_n = 1; 12408 ecb = gfc.s3_ss[j] * eb[kk] * tab[mask_idx_s[kk]]; 12409 ++j; 12410 ++kk; 12411 while (kk <= last) { 12412 dd += mask_idx_s[kk]; 12413 dd_n += 1; 12414 x = gfc.s3_ss[j] * eb[kk] * tab[mask_idx_s[kk]]; 12415 ecb = vbrpsy_mask_add(ecb, x, kk - b); 12416 ++j; 12417 ++kk; 12418 } 12419 dd = (1 + 2 * dd) / (2 * dd_n); 12420 avg_mask = tab[dd] * 0.5; 12421 ecb *= avg_mask; 12422 thr[b] = ecb; 12423 gfc.nb_s2[chn][b] = gfc.nb_s1[chn][b]; 12424 gfc.nb_s1[chn][b] = ecb; 12425 { 12426 /* 12427 * if THR exceeds EB, the quantization routines will take the 12428 * difference from other bands. in case of strong tonal samples 12429 * (tonaltest.wav) this leads to heavy distortions. that's why 12430 * we limit THR here. 12431 */ 12432 x = max[b]; 12433 x *= gfc.minval_s[b]; 12434 x *= avg_mask; 12435 if (thr[b] > x) { 12436 thr[b] = x; 12437 } 12438 } 12439 if (gfc.masking_lower > 1) { 12440 thr[b] *= gfc.masking_lower; 12441 } 12442 if (thr[b] > eb[b]) { 12443 thr[b] = eb[b]; 12444 } 12445 if (gfc.masking_lower < 1) { 12446 thr[b] *= gfc.masking_lower; 12447 } 12448 12449 } 12450 for (; b < Encoder.CBANDS; ++b) { 12451 eb[b] = 0; 12452 thr[b] = 0; 12453 } 12454 } 12455 12456 function vbrpsy_compute_masking_l(gfc, fftenergy, eb_l, thr, chn) { 12457 var max = new_float(Encoder.CBANDS), avg = new_float(Encoder.CBANDS); 12458 var mask_idx_l = new_int(Encoder.CBANDS + 2); 12459 var b; 12460 12461 /********************************************************************* 12462 * Calculate the energy and the tonality of each partition. 12463 *********************************************************************/ 12464 calc_energy(gfc, fftenergy, eb_l, max, avg); 12465 calc_mask_index_l(gfc, max, avg, mask_idx_l); 12466 12467 /********************************************************************* 12468 * convolve the partitioned energy and unpredictability with the 12469 * spreading function, s3_l[b][k] 12470 ********************************************************************/ 12471 var k = 0; 12472 for (b = 0; b < gfc.npart_l; b++) { 12473 var x, ecb, avg_mask, t; 12474 /* convolve the partitioned energy with the spreading function */ 12475 var kk = gfc.s3ind[b][0]; 12476 var last = gfc.s3ind[b][1]; 12477 var dd = 0, dd_n = 0; 12478 dd = mask_idx_l[kk]; 12479 dd_n += 1; 12480 ecb = gfc.s3_ll[k] * eb_l[kk] * tab[mask_idx_l[kk]]; 12481 ++k; 12482 ++kk; 12483 while (kk <= last) { 12484 dd += mask_idx_l[kk]; 12485 dd_n += 1; 12486 x = gfc.s3_ll[k] * eb_l[kk] * tab[mask_idx_l[kk]]; 12487 t = vbrpsy_mask_add(ecb, x, kk - b); 12488 ecb = t; 12489 ++k; 12490 ++kk; 12491 } 12492 dd = (1 + 2 * dd) / (2 * dd_n); 12493 avg_mask = tab[dd] * 0.5; 12494 ecb *= avg_mask; 12495 12496 /**** long block pre-echo control ****/ 12497 /** 12498 * <PRE> 12499 * dont use long block pre-echo control if previous granule was 12500 * a short block. This is to avoid the situation: 12501 * frame0: quiet (very low masking) 12502 * frame1: surge (triggers short blocks) 12503 * frame2: regular frame. looks like pre-echo when compared to 12504 * frame0, but all pre-echo was in frame1. 12505 * </PRE> 12506 */ 12507 /* 12508 * chn=0,1 L and R channels chn=2,3 S and M channels. 12509 */ 12510 if (gfc.blocktype_old[chn & 0x01] == Encoder.SHORT_TYPE) { 12511 var ecb_limit = rpelev * gfc.nb_1[chn][b]; 12512 if (ecb_limit > 0) { 12513 thr[b] = Math.min(ecb, ecb_limit); 12514 } else { 12515 /** 12516 * <PRE> 12517 * Robert 071209: 12518 * Because we don't calculate long block psy when we know a granule 12519 * should be of short blocks, we don't have any clue how the granule 12520 * before would have looked like as a long block. So we have to guess 12521 * a little bit for this END_TYPE block. 12522 * Most of the time we get away with this sloppyness. (fingers crossed :) 12523 * The speed increase is worth it. 12524 * </PRE> 12525 */ 12526 thr[b] = Math.min(ecb, eb_l[b] * NS_PREECHO_ATT2); 12527 } 12528 } else { 12529 var ecb_limit_2 = rpelev2 * gfc.nb_2[chn][b]; 12530 var ecb_limit_1 = rpelev * gfc.nb_1[chn][b]; 12531 var ecb_limit; 12532 if (ecb_limit_2 <= 0) { 12533 ecb_limit_2 = ecb; 12534 } 12535 if (ecb_limit_1 <= 0) { 12536 ecb_limit_1 = ecb; 12537 } 12538 if (gfc.blocktype_old[chn & 0x01] == Encoder.NORM_TYPE) { 12539 ecb_limit = Math.min(ecb_limit_1, ecb_limit_2); 12540 } else { 12541 ecb_limit = ecb_limit_1; 12542 } 12543 thr[b] = Math.min(ecb, ecb_limit); 12544 } 12545 gfc.nb_2[chn][b] = gfc.nb_1[chn][b]; 12546 gfc.nb_1[chn][b] = ecb; 12547 { 12548 /* 12549 * if THR exceeds EB, the quantization routines will take the 12550 * difference from other bands. in case of strong tonal samples 12551 * (tonaltest.wav) this leads to heavy distortions. that's why 12552 * we limit THR here. 12553 */ 12554 x = max[b]; 12555 x *= gfc.minval_l[b]; 12556 x *= avg_mask; 12557 if (thr[b] > x) { 12558 thr[b] = x; 12559 } 12560 } 12561 if (gfc.masking_lower > 1) { 12562 thr[b] *= gfc.masking_lower; 12563 } 12564 if (thr[b] > eb_l[b]) { 12565 thr[b] = eb_l[b]; 12566 } 12567 if (gfc.masking_lower < 1) { 12568 thr[b] *= gfc.masking_lower; 12569 } 12570 } 12571 for (; b < Encoder.CBANDS; ++b) { 12572 eb_l[b] = 0; 12573 thr[b] = 0; 12574 } 12575 } 12576 12577 function vbrpsy_compute_block_type(gfp, uselongblock) { 12578 var gfc = gfp.internal_flags; 12579 12580 if (gfp.short_blocks == ShortBlock.short_block_coupled 12581 /* force both channels to use the same block type */ 12582 /* this is necessary if the frame is to be encoded in ms_stereo. */ 12583 /* But even without ms_stereo, FhG does this */ 12584 && !(uselongblock[0] != 0 && uselongblock[1] != 0)) 12585 uselongblock[0] = uselongblock[1] = 0; 12586 12587 for (var chn = 0; chn < gfc.channels_out; chn++) { 12588 /* disable short blocks */ 12589 if (gfp.short_blocks == ShortBlock.short_block_dispensed) { 12590 uselongblock[chn] = 1; 12591 } 12592 if (gfp.short_blocks == ShortBlock.short_block_forced) { 12593 uselongblock[chn] = 0; 12594 } 12595 } 12596 } 12597 12598 function vbrpsy_apply_block_type(gfp, uselongblock, blocktype_d) { 12599 var gfc = gfp.internal_flags; 12600 12601 /* 12602 * update the blocktype of the previous granule, since it depends on 12603 * what happend in this granule 12604 */ 12605 for (var chn = 0; chn < gfc.channels_out; chn++) { 12606 var blocktype = Encoder.NORM_TYPE; 12607 /* disable short blocks */ 12608 12609 if (uselongblock[chn] != 0) { 12610 /* no attack : use long blocks */ 12611 if (gfc.blocktype_old[chn] == Encoder.SHORT_TYPE) 12612 blocktype = Encoder.STOP_TYPE; 12613 } else { 12614 /* attack : use short blocks */ 12615 blocktype = Encoder.SHORT_TYPE; 12616 if (gfc.blocktype_old[chn] == Encoder.NORM_TYPE) { 12617 gfc.blocktype_old[chn] = Encoder.START_TYPE; 12618 } 12619 if (gfc.blocktype_old[chn] == Encoder.STOP_TYPE) 12620 gfc.blocktype_old[chn] = Encoder.SHORT_TYPE; 12621 } 12622 12623 blocktype_d[chn] = gfc.blocktype_old[chn]; 12624 // value returned to calling program 12625 gfc.blocktype_old[chn] = blocktype; 12626 // save for next call to l3psy_anal 12627 } 12628 } 12629 12630 /** 12631 * compute M/S thresholds from Johnston & Ferreira 1992 ICASSP paper 12632 */ 12633 function vbrpsy_compute_MS_thresholds(eb, thr, cb_mld, ath_cb, athadjust, msfix, n) { 12634 var msfix2 = msfix * 2; 12635 var athlower = msfix > 0 ? Math.pow(10, athadjust) : 1; 12636 var rside, rmid; 12637 for (var b = 0; b < n; ++b) { 12638 var ebM = eb[2][b]; 12639 var ebS = eb[3][b]; 12640 var thmL = thr[0][b]; 12641 var thmR = thr[1][b]; 12642 var thmM = thr[2][b]; 12643 var thmS = thr[3][b]; 12644 12645 /* use this fix if L & R masking differs by 2db or less */ 12646 if (thmL <= 1.58 * thmR && thmR <= 1.58 * thmL) { 12647 var mld_m = cb_mld[b] * ebS; 12648 var mld_s = cb_mld[b] * ebM; 12649 rmid = Math.max(thmM, Math.min(thmS, mld_m)); 12650 rside = Math.max(thmS, Math.min(thmM, mld_s)); 12651 } else { 12652 rmid = thmM; 12653 rside = thmS; 12654 } 12655 if (msfix > 0) { 12656 /***************************************************************/ 12657 /* Adjust M/S maskings if user set "msfix" */ 12658 /***************************************************************/ 12659 /* Naoki Shibata 2000 */ 12660 var thmLR, thmMS; 12661 var ath = ath_cb[b] * athlower; 12662 thmLR = Math.min(Math.max(thmL, ath), Math.max(thmR, ath)); 12663 thmM = Math.max(rmid, ath); 12664 thmS = Math.max(rside, ath); 12665 thmMS = thmM + thmS; 12666 if (thmMS > 0 && (thmLR * msfix2) < thmMS) { 12667 var f = thmLR * msfix2 / thmMS; 12668 thmM *= f; 12669 thmS *= f; 12670 } 12671 rmid = Math.min(thmM, rmid); 12672 rside = Math.min(thmS, rside); 12673 } 12674 if (rmid > ebM) { 12675 rmid = ebM; 12676 } 12677 if (rside > ebS) { 12678 rside = ebS; 12679 } 12680 thr[2][b] = rmid; 12681 thr[3][b] = rside; 12682 } 12683 } 12684 12685 this.L3psycho_anal_vbr = function (gfp, buffer, bufPos, gr_out, masking_ratio, masking_MS_ratio, percep_entropy, percep_MS_entropy, energy, blocktype_d) { 12686 var gfc = gfp.internal_flags; 12687 12688 /* fft and energy calculation */ 12689 var wsamp_l; 12690 var wsamp_s; 12691 var fftenergy = new_float(Encoder.HBLKSIZE); 12692 var fftenergy_s = new_float_n([3, Encoder.HBLKSIZE_s]); 12693 var wsamp_L = new_float_n([2, Encoder.BLKSIZE]); 12694 var wsamp_S = new_float_n([2, 3, Encoder.BLKSIZE_s]); 12695 var eb = new_float_n([4, Encoder.CBANDS]), thr = new_float_n([4, Encoder.CBANDS]); 12696 var sub_short_factor = new_float_n([4, 3]); 12697 var pcfact = 0.6; 12698 12699 /* block type */ 12700 var ns_attacks = [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], 12701 [0, 0, 0, 0]]; 12702 var uselongblock = new_int(2); 12703 12704 /* usual variables like loop indices, etc.. */ 12705 12706 /* chn=2 and 3 = Mid and Side channels */ 12707 var n_chn_psy = (gfp.mode == MPEGMode.JOINT_STEREO) ? 4 12708 : gfc.channels_out; 12709 12710 vbrpsy_attack_detection(gfp, buffer, bufPos, gr_out, masking_ratio, 12711 masking_MS_ratio, energy, sub_short_factor, ns_attacks, 12712 uselongblock); 12713 12714 vbrpsy_compute_block_type(gfp, uselongblock); 12715 12716 /* LONG BLOCK CASE */ 12717 { 12718 for (var chn = 0; chn < n_chn_psy; chn++) { 12719 var ch01 = chn & 0x01; 12720 wsamp_l = wsamp_L; 12721 vbrpsy_compute_fft_l(gfp, buffer, bufPos, chn, gr_out, 12722 fftenergy, wsamp_l, ch01); 12723 12724 vbrpsy_compute_loudness_approximation_l(gfp, gr_out, chn, 12725 fftenergy); 12726 12727 if (uselongblock[ch01] != 0) { 12728 vbrpsy_compute_masking_l(gfc, fftenergy, eb[chn], thr[chn], 12729 chn); 12730 } else { 12731 vbrpsy_skip_masking_l(gfc, chn); 12732 } 12733 } 12734 if ((uselongblock[0] + uselongblock[1]) == 2) { 12735 /* M/S channel */ 12736 if (gfp.mode == MPEGMode.JOINT_STEREO) { 12737 vbrpsy_compute_MS_thresholds(eb, thr, gfc.mld_cb_l, 12738 gfc.ATH.cb_l, gfp.ATHlower * gfc.ATH.adjust, 12739 gfp.msfix, gfc.npart_l); 12740 } 12741 } 12742 /* TODO: apply adaptive ATH masking here ?? */ 12743 for (var chn = 0; chn < n_chn_psy; chn++) { 12744 var ch01 = chn & 0x01; 12745 if (uselongblock[ch01] != 0) { 12746 convert_partition2scalefac_l(gfc, eb[chn], thr[chn], chn); 12747 } 12748 } 12749 } 12750 12751 /* SHORT BLOCKS CASE */ 12752 { 12753 for (var sblock = 0; sblock < 3; sblock++) { 12754 for (var chn = 0; chn < n_chn_psy; ++chn) { 12755 var ch01 = chn & 0x01; 12756 12757 if (uselongblock[ch01] != 0) { 12758 vbrpsy_skip_masking_s(gfc, chn, sblock); 12759 } else { 12760 /* compute masking thresholds for short blocks */ 12761 wsamp_s = wsamp_S; 12762 vbrpsy_compute_fft_s(gfp, buffer, bufPos, chn, sblock, 12763 fftenergy_s, wsamp_s, ch01); 12764 vbrpsy_compute_masking_s(gfp, fftenergy_s, eb[chn], 12765 thr[chn], chn, sblock); 12766 } 12767 } 12768 if ((uselongblock[0] + uselongblock[1]) == 0) { 12769 /* M/S channel */ 12770 if (gfp.mode == MPEGMode.JOINT_STEREO) { 12771 vbrpsy_compute_MS_thresholds(eb, thr, gfc.mld_cb_s, 12772 gfc.ATH.cb_s, gfp.ATHlower * gfc.ATH.adjust, 12773 gfp.msfix, gfc.npart_s); 12774 } 12775 /* L/R channel */ 12776 } 12777 /* TODO: apply adaptive ATH masking here ?? */ 12778 for (var chn = 0; chn < n_chn_psy; ++chn) { 12779 var ch01 = chn & 0x01; 12780 if (0 == uselongblock[ch01]) { 12781 convert_partition2scalefac_s(gfc, eb[chn], thr[chn], 12782 chn, sblock); 12783 } 12784 } 12785 } 12786 12787 /**** short block pre-echo control ****/ 12788 for (var chn = 0; chn < n_chn_psy; chn++) { 12789 var ch01 = chn & 0x01; 12790 12791 if (uselongblock[ch01] != 0) { 12792 continue; 12793 } 12794 for (var sb = 0; sb < Encoder.SBMAX_s; sb++) { 12795 var new_thmm = new_float(3); 12796 for (var sblock = 0; sblock < 3; sblock++) { 12797 var thmm = gfc.thm[chn].s[sb][sblock]; 12798 thmm *= NS_PREECHO_ATT0; 12799 12800 if (ns_attacks[chn][sblock] >= 2 12801 || ns_attacks[chn][sblock + 1] == 1) { 12802 var idx = (sblock != 0) ? sblock - 1 : 2; 12803 var p = NS_INTERP(gfc.thm[chn].s[sb][idx], thmm, 12804 NS_PREECHO_ATT1 * pcfact); 12805 thmm = Math.min(thmm, p); 12806 } else if (ns_attacks[chn][sblock] == 1) { 12807 var idx = (sblock != 0) ? sblock - 1 : 2; 12808 var p = NS_INTERP(gfc.thm[chn].s[sb][idx], thmm, 12809 NS_PREECHO_ATT2 * pcfact); 12810 thmm = Math.min(thmm, p); 12811 } else if ((sblock != 0 && ns_attacks[chn][sblock - 1] == 3) 12812 || (sblock == 0 && gfc.nsPsy.lastAttacks[chn] == 3)) { 12813 var idx = (sblock != 2) ? sblock + 1 : 0; 12814 var p = NS_INTERP(gfc.thm[chn].s[sb][idx], thmm, 12815 NS_PREECHO_ATT2 * pcfact); 12816 thmm = Math.min(thmm, p); 12817 } 12818 12819 /* pulse like signal detection for fatboy.wav and so on */ 12820 thmm *= sub_short_factor[chn][sblock]; 12821 12822 new_thmm[sblock] = thmm; 12823 } 12824 for (var sblock = 0; sblock < 3; sblock++) { 12825 gfc.thm[chn].s[sb][sblock] = new_thmm[sblock]; 12826 } 12827 } 12828 } 12829 } 12830 for (var chn = 0; chn < n_chn_psy; chn++) { 12831 gfc.nsPsy.lastAttacks[chn] = ns_attacks[chn][2]; 12832 } 12833 12834 /*************************************************************** 12835 * determine final block type 12836 ***************************************************************/ 12837 vbrpsy_apply_block_type(gfp, uselongblock, blocktype_d); 12838 12839 /********************************************************************* 12840 * compute the value of PE to return ... no delay and advance 12841 *********************************************************************/ 12842 for (var chn = 0; chn < n_chn_psy; chn++) { 12843 var ppe; 12844 var ppePos; 12845 var type; 12846 var mr; 12847 12848 if (chn > 1) { 12849 ppe = percep_MS_entropy; 12850 ppePos = -2; 12851 type = Encoder.NORM_TYPE; 12852 if (blocktype_d[0] == Encoder.SHORT_TYPE 12853 || blocktype_d[1] == Encoder.SHORT_TYPE) 12854 type = Encoder.SHORT_TYPE; 12855 mr = masking_MS_ratio[gr_out][chn - 2]; 12856 } else { 12857 ppe = percep_entropy; 12858 ppePos = 0; 12859 type = blocktype_d[chn]; 12860 mr = masking_ratio[gr_out][chn]; 12861 } 12862 12863 if (type == Encoder.SHORT_TYPE) { 12864 ppe[ppePos + chn] = pecalc_s(mr, gfc.masking_lower); 12865 } else { 12866 ppe[ppePos + chn] = pecalc_l(mr, gfc.masking_lower); 12867 } 12868 12869 if (gfp.analysis) { 12870 gfc.pinfo.pe[gr_out][chn] = ppe[ppePos + chn]; 12871 } 12872 } 12873 return 0; 12874 } 12875 12876 function s3_func_x(bark, hf_slope) { 12877 var tempx = bark, tempy; 12878 12879 if (tempx >= 0) { 12880 tempy = -tempx * 27; 12881 } else { 12882 tempy = tempx * hf_slope; 12883 } 12884 if (tempy <= -72.0) { 12885 return 0; 12886 } 12887 return Math.exp(tempy * LN_TO_LOG10); 12888 } 12889 12890 function norm_s3_func_x(hf_slope) { 12891 var lim_a = 0, lim_b = 0; 12892 { 12893 var x = 0, l, h; 12894 for (x = 0; s3_func_x(x, hf_slope) > 1e-20; x -= 1) 12895 ; 12896 l = x; 12897 h = 0; 12898 while (Math.abs(h - l) > 1e-12) { 12899 x = (h + l) / 2; 12900 if (s3_func_x(x, hf_slope) > 0) { 12901 h = x; 12902 } else { 12903 l = x; 12904 } 12905 } 12906 lim_a = l; 12907 } 12908 { 12909 var x = 0, l, h; 12910 for (x = 0; s3_func_x(x, hf_slope) > 1e-20; x += 1) 12911 ; 12912 l = 0; 12913 h = x; 12914 while (Math.abs(h - l) > 1e-12) { 12915 x = (h + l) / 2; 12916 if (s3_func_x(x, hf_slope) > 0) { 12917 l = x; 12918 } else { 12919 h = x; 12920 } 12921 } 12922 lim_b = h; 12923 } 12924 { 12925 var sum = 0; 12926 var m = 1000; 12927 var i; 12928 for (i = 0; i <= m; ++i) { 12929 var x = lim_a + i * (lim_b - lim_a) / m; 12930 var y = s3_func_x(x, hf_slope); 12931 sum += y; 12932 } 12933 { 12934 var norm = (m + 1) / (sum * (lim_b - lim_a)); 12935 /* printf( "norm = %lf\n",norm); */ 12936 return norm; 12937 } 12938 } 12939 } 12940 12941 /** 12942 * The spreading function. Values returned in units of energy 12943 */ 12944 function s3_func(bark) { 12945 var tempx, x, tempy, temp; 12946 tempx = bark; 12947 if (tempx >= 0) 12948 tempx *= 3; 12949 else 12950 tempx *= 1.5; 12951 12952 if (tempx >= 0.5 && tempx <= 2.5) { 12953 temp = tempx - 0.5; 12954 x = 8.0 * (temp * temp - 2.0 * temp); 12955 } else 12956 x = 0.0; 12957 tempx += 0.474; 12958 tempy = 15.811389 + 7.5 * tempx - 17.5 12959 * Math.sqrt(1.0 + tempx * tempx); 12960 12961 if (tempy <= -60.0) 12962 return 0.0; 12963 12964 tempx = Math.exp((x + tempy) * LN_TO_LOG10); 12965 12966 /** 12967 * <PRE> 12968 * Normalization. The spreading function should be normalized so that: 12969 * +inf 12970 * / 12971 * | s3 [ bark ] d(bark) = 1 12972 * / 12973 * -inf 12974 * </PRE> 12975 */ 12976 tempx /= .6609193; 12977 return tempx; 12978 } 12979 12980 /** 12981 * see for example "Zwicker: Psychoakustik, 1982; ISBN 3-540-11401-7 12982 */ 12983 function freq2bark(freq) { 12984 /* input: freq in hz output: barks */ 12985 if (freq < 0) 12986 freq = 0; 12987 freq = freq * 0.001; 12988 return 13.0 * Math.atan(.76 * freq) + 3.5 12989 * Math.atan(freq * freq / (7.5 * 7.5)); 12990 } 12991 12992 function init_numline(numlines, bo, bm, bval, bval_width, mld, bo_w, sfreq, blksize, scalepos, deltafreq, sbmax) { 12993 var b_frq = new_float(Encoder.CBANDS + 1); 12994 var sample_freq_frac = sfreq / (sbmax > 15 ? 2 * 576 : 2 * 192); 12995 var partition = new_int(Encoder.HBLKSIZE); 12996 var i; 12997 sfreq /= blksize; 12998 var j = 0; 12999 var ni = 0; 13000 /* compute numlines, the number of spectral lines in each partition band */ 13001 /* each partition band should be about DELBARK wide. */ 13002 for (i = 0; i < Encoder.CBANDS; i++) { 13003 var bark1; 13004 var j2; 13005 bark1 = freq2bark(sfreq * j); 13006 13007 b_frq[i] = sfreq * j; 13008 13009 for (j2 = j; freq2bark(sfreq * j2) - bark1 < DELBARK 13010 && j2 <= blksize / 2; j2++) 13011 ; 13012 13013 numlines[i] = j2 - j; 13014 ni = i + 1; 13015 13016 while (j < j2) { 13017 partition[j++] = i; 13018 } 13019 if (j > blksize / 2) { 13020 j = blksize / 2; 13021 ++i; 13022 break; 13023 } 13024 } 13025 b_frq[i] = sfreq * j; 13026 13027 for (var sfb = 0; sfb < sbmax; sfb++) { 13028 var i1, i2, start, end; 13029 var arg; 13030 start = scalepos[sfb]; 13031 end = scalepos[sfb + 1]; 13032 13033 i1 = 0 | Math.floor(.5 + deltafreq * (start - .5)); 13034 if (i1 < 0) 13035 i1 = 0; 13036 i2 = 0 | Math.floor(.5 + deltafreq * (end - .5)); 13037 13038 if (i2 > blksize / 2) 13039 i2 = blksize / 2; 13040 13041 bm[sfb] = (partition[i1] + partition[i2]) / 2; 13042 bo[sfb] = partition[i2]; 13043 var f_tmp = sample_freq_frac * end; 13044 /* 13045 * calculate how much of this band belongs to current scalefactor 13046 * band 13047 */ 13048 bo_w[sfb] = (f_tmp - b_frq[bo[sfb]]) 13049 / (b_frq[bo[sfb] + 1] - b_frq[bo[sfb]]); 13050 if (bo_w[sfb] < 0) { 13051 bo_w[sfb] = 0; 13052 } else { 13053 if (bo_w[sfb] > 1) { 13054 bo_w[sfb] = 1; 13055 } 13056 } 13057 /* setup stereo demasking thresholds */ 13058 /* formula reverse enginerred from plot in paper */ 13059 arg = freq2bark(sfreq * scalepos[sfb] * deltafreq); 13060 arg = ( Math.min(arg, 15.5) / 15.5); 13061 13062 mld[sfb] = Math.pow(10.0, 13063 1.25 * (1 - Math.cos(Math.PI * arg)) - 2.5); 13064 } 13065 13066 /* compute bark values of each critical band */ 13067 j = 0; 13068 for (var k = 0; k < ni; k++) { 13069 var w = numlines[k]; 13070 var bark1, bark2; 13071 13072 bark1 = freq2bark(sfreq * (j)); 13073 bark2 = freq2bark(sfreq * (j + w - 1)); 13074 bval[k] = .5 * (bark1 + bark2); 13075 13076 bark1 = freq2bark(sfreq * (j - .5)); 13077 bark2 = freq2bark(sfreq * (j + w - .5)); 13078 bval_width[k] = bark2 - bark1; 13079 j += w; 13080 } 13081 13082 return ni; 13083 } 13084 13085 function init_s3_values(s3ind, npart, bval, bval_width, norm, use_old_s3) { 13086 var s3 = new_float_n([Encoder.CBANDS, Encoder.CBANDS]); 13087 /* 13088 * The s3 array is not linear in the bark scale. 13089 * 13090 * bval[x] should be used to get the bark value. 13091 */ 13092 var j; 13093 var numberOfNoneZero = 0; 13094 13095 /** 13096 * <PRE> 13097 * s[i][j], the value of the spreading function, 13098 * centered at band j (masker), for band i (maskee) 13099 * 13100 * i.e.: sum over j to spread into signal barkval=i 13101 * NOTE: i and j are used opposite as in the ISO docs 13102 * </PRE> 13103 */ 13104 if (use_old_s3) { 13105 for (var i = 0; i < npart; i++) { 13106 for (j = 0; j < npart; j++) { 13107 var v = s3_func(bval[i] - bval[j]) * bval_width[j]; 13108 s3[i][j] = v * norm[i]; 13109 } 13110 } 13111 } else { 13112 for (j = 0; j < npart; j++) { 13113 var hf_slope = 15 + Math.min(21 / bval[j], 12); 13114 var s3_x_norm = norm_s3_func_x(hf_slope); 13115 for (var i = 0; i < npart; i++) { 13116 var v = s3_x_norm 13117 * s3_func_x(bval[i] - bval[j], hf_slope) 13118 * bval_width[j]; 13119 s3[i][j] = v * norm[i]; 13120 } 13121 } 13122 } 13123 for (var i = 0; i < npart; i++) { 13124 for (j = 0; j < npart; j++) { 13125 if (s3[i][j] > 0.0) 13126 break; 13127 } 13128 s3ind[i][0] = j; 13129 13130 for (j = npart - 1; j > 0; j--) { 13131 if (s3[i][j] > 0.0) 13132 break; 13133 } 13134 s3ind[i][1] = j; 13135 numberOfNoneZero += (s3ind[i][1] - s3ind[i][0] + 1); 13136 } 13137 13138 var p = new_float(numberOfNoneZero); 13139 var k = 0; 13140 for (var i = 0; i < npart; i++) 13141 for (j = s3ind[i][0]; j <= s3ind[i][1]; j++) 13142 p[k++] = s3[i][j]; 13143 13144 return p; 13145 } 13146 13147 function stereo_demask(f) { 13148 /* setup stereo demasking thresholds */ 13149 /* formula reverse enginerred from plot in paper */ 13150 var arg = freq2bark(f); 13151 arg = (Math.min(arg, 15.5) / 15.5); 13152 13153 return Math.pow(10.0, 13154 1.25 * (1 - Math.cos(Math.PI * arg)) - 2.5); 13155 } 13156 13157 /** 13158 * NOTE: the bitrate reduction from the inter-channel masking effect is low 13159 * compared to the chance of getting annyoing artefacts. L3psycho_anal_vbr 13160 * does not use this feature. (Robert 071216) 13161 */ 13162 this.psymodel_init = function (gfp) { 13163 var gfc = gfp.internal_flags; 13164 var i; 13165 var useOldS3 = true; 13166 var bvl_a = 13, bvl_b = 24; 13167 var snr_l_a = 0, snr_l_b = 0; 13168 var snr_s_a = -8.25, snr_s_b = -4.5; 13169 var bval = new_float(Encoder.CBANDS); 13170 var bval_width = new_float(Encoder.CBANDS); 13171 var norm = new_float(Encoder.CBANDS); 13172 var sfreq = gfp.out_samplerate; 13173 13174 switch (gfp.experimentalZ) { 13175 default: 13176 case 0: 13177 useOldS3 = true; 13178 break; 13179 case 1: 13180 useOldS3 = (gfp.VBR == VbrMode.vbr_mtrh || gfp.VBR == VbrMode.vbr_mt) ? false 13181 : true; 13182 break; 13183 case 2: 13184 useOldS3 = false; 13185 break; 13186 case 3: 13187 bvl_a = 8; 13188 snr_l_a = -1.75; 13189 snr_l_b = -0.0125; 13190 snr_s_a = -8.25; 13191 snr_s_b = -2.25; 13192 break; 13193 } 13194 gfc.ms_ener_ratio_old = .25; 13195 gfc.blocktype_old[0] = gfc.blocktype_old[1] = Encoder.NORM_TYPE; 13196 // the vbr header is long blocks 13197 13198 for (i = 0; i < 4; ++i) { 13199 for (var j = 0; j < Encoder.CBANDS; ++j) { 13200 gfc.nb_1[i][j] = 1e20; 13201 gfc.nb_2[i][j] = 1e20; 13202 gfc.nb_s1[i][j] = gfc.nb_s2[i][j] = 1.0; 13203 } 13204 for (var sb = 0; sb < Encoder.SBMAX_l; sb++) { 13205 gfc.en[i].l[sb] = 1e20; 13206 gfc.thm[i].l[sb] = 1e20; 13207 } 13208 for (var j = 0; j < 3; ++j) { 13209 for (var sb = 0; sb < Encoder.SBMAX_s; sb++) { 13210 gfc.en[i].s[sb][j] = 1e20; 13211 gfc.thm[i].s[sb][j] = 1e20; 13212 } 13213 gfc.nsPsy.lastAttacks[i] = 0; 13214 } 13215 for (var j = 0; j < 9; j++) 13216 gfc.nsPsy.last_en_subshort[i][j] = 10.; 13217 } 13218 13219 /* init. for loudness approx. -jd 2001 mar 27 */ 13220 gfc.loudness_sq_save[0] = gfc.loudness_sq_save[1] = 0.0; 13221 13222 /************************************************************************* 13223 * now compute the psychoacoustic model specific constants 13224 ************************************************************************/ 13225 /* compute numlines, bo, bm, bval, bval_width, mld */ 13226 13227 gfc.npart_l = init_numline(gfc.numlines_l, gfc.bo_l, gfc.bm_l, bval, 13228 bval_width, gfc.mld_l, gfc.PSY.bo_l_weight, sfreq, 13229 Encoder.BLKSIZE, gfc.scalefac_band.l, Encoder.BLKSIZE 13230 / (2.0 * 576), Encoder.SBMAX_l); 13231 /* compute the spreading function */ 13232 for (i = 0; i < gfc.npart_l; i++) { 13233 var snr = snr_l_a; 13234 if (bval[i] >= bvl_a) { 13235 snr = snr_l_b * (bval[i] - bvl_a) / (bvl_b - bvl_a) + snr_l_a 13236 * (bvl_b - bval[i]) / (bvl_b - bvl_a); 13237 } 13238 norm[i] = Math.pow(10.0, snr / 10.0); 13239 if (gfc.numlines_l[i] > 0) { 13240 gfc.rnumlines_l[i] = 1.0 / gfc.numlines_l[i]; 13241 } else { 13242 gfc.rnumlines_l[i] = 0; 13243 } 13244 } 13245 gfc.s3_ll = init_s3_values(gfc.s3ind, gfc.npart_l, bval, bval_width, 13246 norm, useOldS3); 13247 13248 /* compute long block specific values, ATH and MINVAL */ 13249 var j = 0; 13250 for (i = 0; i < gfc.npart_l; i++) { 13251 var x; 13252 13253 /* ATH */ 13254 x = Float.MAX_VALUE; 13255 for (var k = 0; k < gfc.numlines_l[i]; k++, j++) { 13256 var freq = sfreq * j / (1000.0 * Encoder.BLKSIZE); 13257 var level; 13258 /* 13259 * ATH below 100 Hz constant, not further climbing 13260 */ 13261 level = this.ATHformula(freq * 1000, gfp) - 20; 13262 // scale to FFT units; returned value is in dB 13263 level = Math.pow(10., 0.1 * level); 13264 // convert from dB . energy 13265 level *= gfc.numlines_l[i]; 13266 if (x > level) 13267 x = level; 13268 } 13269 gfc.ATH.cb_l[i] = x; 13270 13271 /* 13272 * MINVAL. For low freq, the strength of the masking is limited by 13273 * minval this is an ISO MPEG1 thing, dont know if it is really 13274 * needed 13275 */ 13276 /* 13277 * FIXME: it does work to reduce low-freq problems in S53-Wind-Sax 13278 * and lead-voice samples, but introduces some 3 kbps bit bloat too. 13279 * TODO: Further refinement of the shape of this hack. 13280 */ 13281 x = -20 + bval[i] * 20 / 10; 13282 if (x > 6) { 13283 x = 100; 13284 } 13285 if (x < -15) { 13286 x = -15; 13287 } 13288 x -= 8.; 13289 gfc.minval_l[i] = (Math.pow(10.0, x / 10.) * gfc.numlines_l[i]); 13290 } 13291 13292 /************************************************************************ 13293 * do the same things for short blocks 13294 ************************************************************************/ 13295 gfc.npart_s = init_numline(gfc.numlines_s, gfc.bo_s, gfc.bm_s, bval, 13296 bval_width, gfc.mld_s, gfc.PSY.bo_s_weight, sfreq, 13297 Encoder.BLKSIZE_s, gfc.scalefac_band.s, Encoder.BLKSIZE_s 13298 / (2.0 * 192), Encoder.SBMAX_s); 13299 13300 /* SNR formula. short block is normalized by SNR. is it still right ? */ 13301 j = 0; 13302 for (i = 0; i < gfc.npart_s; i++) { 13303 var x; 13304 var snr = snr_s_a; 13305 if (bval[i] >= bvl_a) { 13306 snr = snr_s_b * (bval[i] - bvl_a) / (bvl_b - bvl_a) + snr_s_a 13307 * (bvl_b - bval[i]) / (bvl_b - bvl_a); 13308 } 13309 norm[i] = Math.pow(10.0, snr / 10.0); 13310 13311 /* ATH */ 13312 x = Float.MAX_VALUE; 13313 for (var k = 0; k < gfc.numlines_s[i]; k++, j++) { 13314 var freq = sfreq * j / (1000.0 * Encoder.BLKSIZE_s); 13315 var level; 13316 /* freq = Min(.1,freq); */ 13317 /* 13318 * ATH below 100 Hz constant, not 13319 * further climbing 13320 */ 13321 level = this.ATHformula(freq * 1000, gfp) - 20; 13322 // scale to FFT units; returned value is in dB 13323 level = Math.pow(10., 0.1 * level); 13324 // convert from dB . energy 13325 level *= gfc.numlines_s[i]; 13326 if (x > level) 13327 x = level; 13328 } 13329 gfc.ATH.cb_s[i] = x; 13330 13331 /* 13332 * MINVAL. For low freq, the strength of the masking is limited by 13333 * minval this is an ISO MPEG1 thing, dont know if it is really 13334 * needed 13335 */ 13336 x = (-7.0 + bval[i] * 7.0 / 12.0); 13337 if (bval[i] > 12) { 13338 x *= 1 + Math.log(1 + x) * 3.1; 13339 } 13340 if (bval[i] < 12) { 13341 x *= 1 + Math.log(1 - x) * 2.3; 13342 } 13343 if (x < -15) { 13344 x = -15; 13345 } 13346 x -= 8; 13347 gfc.minval_s[i] = Math.pow(10.0, x / 10) 13348 * gfc.numlines_s[i]; 13349 } 13350 13351 gfc.s3_ss = init_s3_values(gfc.s3ind_s, gfc.npart_s, bval, bval_width, 13352 norm, useOldS3); 13353 13354 init_mask_add_max_values(); 13355 fft.init_fft(gfc); 13356 13357 /* setup temporal masking */ 13358 gfc.decay = Math.exp(-1.0 * LOG10 13359 / (temporalmask_sustain_sec * sfreq / 192.0)); 13360 13361 { 13362 var msfix; 13363 msfix = NS_MSFIX; 13364 if ((gfp.exp_nspsytune & 2) != 0) 13365 msfix = 1.0; 13366 if (Math.abs(gfp.msfix) > 0.0) 13367 msfix = gfp.msfix; 13368 gfp.msfix = msfix; 13369 13370 /* 13371 * spread only from npart_l bands. Normally, we use the spreading 13372 * function to convolve from npart_l down to npart_l bands 13373 */ 13374 for (var b = 0; b < gfc.npart_l; b++) 13375 if (gfc.s3ind[b][1] > gfc.npart_l - 1) 13376 gfc.s3ind[b][1] = gfc.npart_l - 1; 13377 } 13378 13379 /* 13380 * prepare for ATH auto adjustment: we want to decrease the ATH by 12 dB 13381 * per second 13382 */ 13383 var frame_duration = (576. * gfc.mode_gr / sfreq); 13384 gfc.ATH.decay = Math.pow(10., -12. / 10. * frame_duration); 13385 gfc.ATH.adjust = 0.01; 13386 /* minimum, for leading low loudness */ 13387 gfc.ATH.adjustLimit = 1.0; 13388 /* on lead, allow adjust up to maximum */ 13389 13390 13391 if (gfp.ATHtype != -1) { 13392 /* compute equal loudness weights (eql_w) */ 13393 var freq; 13394 var freq_inc = gfp.out_samplerate 13395 / (Encoder.BLKSIZE); 13396 var eql_balance = 0.0; 13397 freq = 0.0; 13398 for (i = 0; i < Encoder.BLKSIZE / 2; ++i) { 13399 /* convert ATH dB to relative power (not dB) */ 13400 /* to determine eql_w */ 13401 freq += freq_inc; 13402 gfc.ATH.eql_w[i] = 1. / Math.pow(10, this.ATHformula(freq, gfp) / 10); 13403 eql_balance += gfc.ATH.eql_w[i]; 13404 } 13405 eql_balance = 1.0 / eql_balance; 13406 for (i = Encoder.BLKSIZE / 2; --i >= 0;) { /* scale weights */ 13407 gfc.ATH.eql_w[i] *= eql_balance; 13408 } 13409 } 13410 { 13411 for (var b = j = 0; b < gfc.npart_s; ++b) { 13412 for (i = 0; i < gfc.numlines_s[b]; ++i) { 13413 ++j; 13414 } 13415 } 13416 for (var b = j = 0; b < gfc.npart_l; ++b) { 13417 for (i = 0; i < gfc.numlines_l[b]; ++i) { 13418 ++j; 13419 } 13420 } 13421 } 13422 j = 0; 13423 for (i = 0; i < gfc.npart_l; i++) { 13424 var freq = sfreq * (j + gfc.numlines_l[i] / 2) / (1.0 * Encoder.BLKSIZE); 13425 gfc.mld_cb_l[i] = stereo_demask(freq); 13426 j += gfc.numlines_l[i]; 13427 } 13428 for (; i < Encoder.CBANDS; ++i) { 13429 gfc.mld_cb_l[i] = 1; 13430 } 13431 j = 0; 13432 for (i = 0; i < gfc.npart_s; i++) { 13433 var freq = sfreq * (j + gfc.numlines_s[i] / 2) / (1.0 * Encoder.BLKSIZE_s); 13434 gfc.mld_cb_s[i] = stereo_demask(freq); 13435 j += gfc.numlines_s[i]; 13436 } 13437 for (; i < Encoder.CBANDS; ++i) { 13438 gfc.mld_cb_s[i] = 1; 13439 } 13440 return 0; 13441 } 13442 13443 /** 13444 * Those ATH formulas are returning their minimum value for input = -1 13445 */ 13446 function ATHformula_GB(f, value) { 13447 /** 13448 * <PRE> 13449 * from Painter & Spanias 13450 * modified by Gabriel Bouvigne to better fit the reality 13451 * ath = 3.640 * pow(f,-0.8) 13452 * - 6.800 * exp(-0.6*pow(f-3.4,2.0)) 13453 * + 6.000 * exp(-0.15*pow(f-8.7,2.0)) 13454 * + 0.6* 0.001 * pow(f,4.0); 13455 * 13456 * 13457 * In the past LAME was using the Painter &Spanias formula. 13458 * But we had some recurrent problems with HF content. 13459 * We measured real ATH values, and found the older formula 13460 * to be inaccurate in the higher part. So we made this new 13461 * formula and this solved most of HF problematic test cases. 13462 * The tradeoff is that in VBR mode it increases a lot the 13463 * bitrate. 13464 * </PRE> 13465 */ 13466 13467 /* 13468 * This curve can be adjusted according to the VBR scale: it adjusts 13469 * from something close to Painter & Spanias on V9 up to Bouvigne's 13470 * formula for V0. This way the VBR bitrate is more balanced according 13471 * to the -V value. 13472 */ 13473 13474 // the following Hack allows to ask for the lowest value 13475 if (f < -.3) 13476 f = 3410; 13477 13478 // convert to khz 13479 f /= 1000; 13480 f = Math.max(0.1, f); 13481 var ath = 3.640 * Math.pow(f, -0.8) - 6.800 13482 * Math.exp(-0.6 * Math.pow(f - 3.4, 2.0)) + 6.000 13483 * Math.exp(-0.15 * Math.pow(f - 8.7, 2.0)) 13484 + (0.6 + 0.04 * value) * 0.001 * Math.pow(f, 4.0); 13485 return ath; 13486 } 13487 13488 this.ATHformula = function (f, gfp) { 13489 var ath; 13490 switch (gfp.ATHtype) { 13491 case 0: 13492 ath = ATHformula_GB(f, 9); 13493 break; 13494 case 1: 13495 // over sensitive, should probably be removed 13496 ath = ATHformula_GB(f, -1); 13497 break; 13498 case 2: 13499 ath = ATHformula_GB(f, 0); 13500 break; 13501 case 3: 13502 // modification of GB formula by Roel 13503 ath = ATHformula_GB(f, 1) + 6; 13504 break; 13505 case 4: 13506 ath = ATHformula_GB(f, gfp.ATHcurve); 13507 break; 13508 default: 13509 ath = ATHformula_GB(f, 0); 13510 break; 13511 } 13512 return ath; 13513 } 13514 13515} 13516 13517 13518 13519function Lame() { 13520 var self = this; 13521 var LAME_MAXALBUMART = (128 * 1024); 13522 13523 Lame.V9 = 410; 13524 Lame.V8 = 420; 13525 Lame.V7 = 430; 13526 Lame.V6 = 440; 13527 Lame.V5 = 450; 13528 Lame.V4 = 460; 13529 Lame.V3 = 470; 13530 Lame.V2 = 480; 13531 Lame.V1 = 490; 13532 Lame.V0 = 500; 13533 13534 /* still there for compatibility */ 13535 13536 Lame.R3MIX = 1000; 13537 Lame.STANDARD = 1001; 13538 Lame.EXTREME = 1002; 13539 Lame.INSANE = 1003; 13540 Lame.STANDARD_FAST = 1004; 13541 Lame.EXTREME_FAST = 1005; 13542 Lame.MEDIUM = 1006; 13543 Lame.MEDIUM_FAST = 1007; 13544 13545 /** 13546 * maximum size of mp3buffer needed if you encode at most 1152 samples for 13547 * each call to lame_encode_buffer. see lame_encode_buffer() below 13548 * (LAME_MAXMP3BUFFER is now obsolete) 13549 */ 13550 var LAME_MAXMP3BUFFER = (16384 + LAME_MAXALBUMART); 13551 Lame.LAME_MAXMP3BUFFER = LAME_MAXMP3BUFFER; 13552 13553 var ga; 13554 var bs; 13555 var p; 13556 var qupvt; 13557 var qu; 13558 var psy = new PsyModel(); 13559 var vbr; 13560 var ver; 13561 var id3; 13562 var mpglib; 13563 this.enc = new Encoder(); 13564 13565 this.setModules = function (_ga, _bs, _p, _qupvt, _qu, _vbr, _ver, _id3, _mpglib) { 13566 ga = _ga; 13567 bs = _bs; 13568 p = _p; 13569 qupvt = _qupvt; 13570 qu = _qu; 13571 vbr = _vbr; 13572 ver = _ver; 13573 id3 = _id3; 13574 mpglib = _mpglib; 13575 this.enc.setModules(bs, psy, qupvt, vbr); 13576 } 13577 13578 /** 13579 * PSY Model related stuff 13580 */ 13581 function PSY() { 13582 /** 13583 * The dbQ stuff. 13584 */ 13585 this.mask_adjust = 0.; 13586 /** 13587 * The dbQ stuff. 13588 */ 13589 this.mask_adjust_short = 0.; 13590 /* at transition from one scalefactor band to next */ 13591 /** 13592 * Band weight long scalefactor bands. 13593 */ 13594 this.bo_l_weight = new_float(Encoder.SBMAX_l); 13595 /** 13596 * Band weight short scalefactor bands. 13597 */ 13598 this.bo_s_weight = new_float(Encoder.SBMAX_s); 13599 } 13600 13601 function LowPassHighPass() { 13602 this.lowerlimit = 0.; 13603 } 13604 13605 function BandPass(bitrate, lPass) { 13606 this.lowpass = lPass; 13607 } 13608 13609 var LAME_ID = 0xFFF88E3B; 13610 13611 function lame_init_old(gfp) { 13612 var gfc; 13613 13614 gfp.class_id = LAME_ID; 13615 13616 gfc = gfp.internal_flags = new LameInternalFlags(); 13617 13618 /* Global flags. set defaults here for non-zero values */ 13619 /* see lame.h for description */ 13620 /* 13621 * set integer values to -1 to mean that LAME will compute the best 13622 * value, UNLESS the calling program as set it (and the value is no 13623 * longer -1) 13624 */ 13625 13626 gfp.mode = MPEGMode.NOT_SET; 13627 gfp.original = 1; 13628 gfp.in_samplerate = 44100; 13629 gfp.num_channels = 2; 13630 gfp.num_samples = -1; 13631 13632 gfp.bWriteVbrTag = true; 13633 gfp.quality = -1; 13634 gfp.short_blocks = null; 13635 gfc.subblock_gain = -1; 13636 13637 gfp.lowpassfreq = 0; 13638 gfp.highpassfreq = 0; 13639 gfp.lowpasswidth = -1; 13640 gfp.highpasswidth = -1; 13641 13642 gfp.VBR = VbrMode.vbr_off; 13643 gfp.VBR_q = 4; 13644 gfp.ATHcurve = -1; 13645 gfp.VBR_mean_bitrate_kbps = 128; 13646 gfp.VBR_min_bitrate_kbps = 0; 13647 gfp.VBR_max_bitrate_kbps = 0; 13648 gfp.VBR_hard_min = 0; 13649 gfc.VBR_min_bitrate = 1; 13650 /* not 0 ????? */ 13651 gfc.VBR_max_bitrate = 13; 13652 /* not 14 ????? */ 13653 13654 gfp.quant_comp = -1; 13655 gfp.quant_comp_short = -1; 13656 13657 gfp.msfix = -1; 13658 13659 gfc.resample_ratio = 1; 13660 13661 gfc.OldValue[0] = 180; 13662 gfc.OldValue[1] = 180; 13663 gfc.CurrentStep[0] = 4; 13664 gfc.CurrentStep[1] = 4; 13665 gfc.masking_lower = 1; 13666 gfc.nsPsy.attackthre = -1; 13667 gfc.nsPsy.attackthre_s = -1; 13668 13669 gfp.scale = -1; 13670 13671 gfp.athaa_type = -1; 13672 gfp.ATHtype = -1; 13673 /* default = -1 = set in lame_init_params */ 13674 gfp.athaa_loudapprox = -1; 13675 /* 1 = flat loudness approx. (total energy) */ 13676 /* 2 = equal loudness curve */ 13677 gfp.athaa_sensitivity = 0.0; 13678 /* no offset */ 13679 gfp.useTemporal = null; 13680 gfp.interChRatio = -1; 13681 13682 /* 13683 * The reason for int mf_samples_to_encode = ENCDELAY + POSTDELAY; 13684 * ENCDELAY = internal encoder delay. And then we have to add 13685 * POSTDELAY=288 because of the 50% MDCT overlap. A 576 MDCT granule 13686 * decodes to 1152 samples. To synthesize the 576 samples centered under 13687 * this granule we need the previous granule for the first 288 samples 13688 * (no problem), and the next granule for the next 288 samples (not 13689 * possible if this is last granule). So we need to pad with 288 samples 13690 * to make sure we can encode the 576 samples we are interested in. 13691 */ 13692 gfc.mf_samples_to_encode = Encoder.ENCDELAY + Encoder.POSTDELAY; 13693 gfp.encoder_padding = 0; 13694 gfc.mf_size = Encoder.ENCDELAY - Encoder.MDCTDELAY; 13695 /* 13696 * we pad input with this many 0's 13697 */ 13698 13699 gfp.findReplayGain = false; 13700 gfp.decode_on_the_fly = false; 13701 13702 gfc.decode_on_the_fly = false; 13703 gfc.findReplayGain = false; 13704 gfc.findPeakSample = false; 13705 13706 gfc.RadioGain = 0; 13707 gfc.AudiophileGain = 0; 13708 gfc.noclipGainChange = 0; 13709 gfc.noclipScale = -1.0; 13710 13711 gfp.preset = 0; 13712 13713 gfp.write_id3tag_automatic = true; 13714 return 0; 13715 } 13716 13717 this.lame_init = function () { 13718 var gfp = new LameGlobalFlags(); 13719 13720 var ret = lame_init_old(gfp); 13721 if (ret != 0) { 13722 return null; 13723 } 13724 13725 gfp.lame_allocated_gfp = 1; 13726 return gfp; 13727 } 13728 13729 function filter_coef(x) { 13730 if (x > 1.0) 13731 return 0.0; 13732 if (x <= 0.0) 13733 return 1.0; 13734 13735 return Math.cos(Math.PI / 2 * x); 13736 } 13737 13738 this.nearestBitrateFullIndex = function (bitrate) { 13739 /* borrowed from DM abr presets */ 13740 13741 var full_bitrate_table = [8, 16, 24, 32, 40, 48, 56, 64, 80, 13742 96, 112, 128, 160, 192, 224, 256, 320]; 13743 13744 var lower_range = 0, lower_range_kbps = 0, upper_range = 0, upper_range_kbps = 0; 13745 13746 /* We assume specified bitrate will be 320kbps */ 13747 upper_range_kbps = full_bitrate_table[16]; 13748 upper_range = 16; 13749 lower_range_kbps = full_bitrate_table[16]; 13750 lower_range = 16; 13751 13752 /* 13753 * Determine which significant bitrates the value specified falls 13754 * between, if loop ends without breaking then we were correct above 13755 * that the value was 320 13756 */ 13757 for (var b = 0; b < 16; b++) { 13758 if ((Math.max(bitrate, full_bitrate_table[b + 1])) != bitrate) { 13759 upper_range_kbps = full_bitrate_table[b + 1]; 13760 upper_range = b + 1; 13761 lower_range_kbps = full_bitrate_table[b]; 13762 lower_range = (b); 13763 break; 13764 /* We found upper range */ 13765 } 13766 } 13767 13768 /* Determine which range the value specified is closer to */ 13769 if ((upper_range_kbps - bitrate) > (bitrate - lower_range_kbps)) { 13770 return lower_range; 13771 } 13772 return upper_range; 13773 } 13774 13775 function optimum_samplefreq(lowpassfreq, input_samplefreq) { 13776 /* 13777 * Rules: 13778 * 13779 * - if possible, sfb21 should NOT be used 13780 */ 13781 var suggested_samplefreq = 44100; 13782 13783 if (input_samplefreq >= 48000) 13784 suggested_samplefreq = 48000; 13785 else if (input_samplefreq >= 44100) 13786 suggested_samplefreq = 44100; 13787 else if (input_samplefreq >= 32000) 13788 suggested_samplefreq = 32000; 13789 else if (input_samplefreq >= 24000) 13790 suggested_samplefreq = 24000; 13791 else if (input_samplefreq >= 22050) 13792 suggested_samplefreq = 22050; 13793 else if (input_samplefreq >= 16000) 13794 suggested_samplefreq = 16000; 13795 else if (input_samplefreq >= 12000) 13796 suggested_samplefreq = 12000; 13797 else if (input_samplefreq >= 11025) 13798 suggested_samplefreq = 11025; 13799 else if (input_samplefreq >= 8000) 13800 suggested_samplefreq = 8000; 13801 13802 if (lowpassfreq == -1) 13803 return suggested_samplefreq; 13804 13805 if (lowpassfreq <= 15960) 13806 suggested_samplefreq = 44100; 13807 if (lowpassfreq <= 15250) 13808 suggested_samplefreq = 32000; 13809 if (lowpassfreq <= 11220) 13810 suggested_samplefreq = 24000; 13811 if (lowpassfreq <= 9970) 13812 suggested_samplefreq = 22050; 13813 if (lowpassfreq <= 7230) 13814 suggested_samplefreq = 16000; 13815 if (lowpassfreq <= 5420) 13816 suggested_samplefreq = 12000; 13817 if (lowpassfreq <= 4510) 13818 suggested_samplefreq = 11025; 13819 if (lowpassfreq <= 3970) 13820 suggested_samplefreq = 8000; 13821 13822 if (input_samplefreq < suggested_samplefreq) { 13823 /* 13824 * choose a valid MPEG sample frequency above the input sample 13825 * frequency to avoid SFB21/12 bitrate bloat rh 061115 13826 */ 13827 if (input_samplefreq > 44100) { 13828 return 48000; 13829 } 13830 if (input_samplefreq > 32000) { 13831 return 44100; 13832 } 13833 if (input_samplefreq > 24000) { 13834 return 32000; 13835 } 13836 if (input_samplefreq > 22050) { 13837 return 24000; 13838 } 13839 if (input_samplefreq > 16000) { 13840 return 22050; 13841 } 13842 if (input_samplefreq > 12000) { 13843 return 16000; 13844 } 13845 if (input_samplefreq > 11025) { 13846 return 12000; 13847 } 13848 if (input_samplefreq > 8000) { 13849 return 11025; 13850 } 13851 return 8000; 13852 } 13853 return suggested_samplefreq; 13854 } 13855 13856 /** 13857 * convert samp freq in Hz to index 13858 */ 13859 function SmpFrqIndex(sample_freq, gpf) { 13860 switch (sample_freq) { 13861 case 44100: 13862 gpf.version = 1; 13863 return 0; 13864 case 48000: 13865 gpf.version = 1; 13866 return 1; 13867 case 32000: 13868 gpf.version = 1; 13869 return 2; 13870 case 22050: 13871 gpf.version = 0; 13872 return 0; 13873 case 24000: 13874 gpf.version = 0; 13875 return 1; 13876 case 16000: 13877 gpf.version = 0; 13878 return 2; 13879 case 11025: 13880 gpf.version = 0; 13881 return 0; 13882 case 12000: 13883 gpf.version = 0; 13884 return 1; 13885 case 8000: 13886 gpf.version = 0; 13887 return 2; 13888 default: 13889 gpf.version = 0; 13890 return -1; 13891 } 13892 } 13893 13894 /** 13895 * @param bRate 13896 * legal rates from 8 to 320 13897 */ 13898 function FindNearestBitrate(bRate, version, samplerate) { 13899 /* MPEG-1 or MPEG-2 LSF */ 13900 if (samplerate < 16000) 13901 version = 2; 13902 13903 var bitrate = Tables.bitrate_table[version][1]; 13904 13905 for (var i = 2; i <= 14; i++) { 13906 if (Tables.bitrate_table[version][i] > 0) { 13907 if (Math.abs(Tables.bitrate_table[version][i] - bRate) < Math 13908 .abs(bitrate - bRate)) 13909 bitrate = Tables.bitrate_table[version][i]; 13910 } 13911 } 13912 return bitrate; 13913 } 13914 13915 /** 13916 * @param bRate 13917 * legal rates from 32 to 448 kbps 13918 * @param version 13919 * MPEG-1 or MPEG-2/2.5 LSF 13920 */ 13921 function BitrateIndex(bRate, version, samplerate) { 13922 /* convert bitrate in kbps to index */ 13923 if (samplerate < 16000) 13924 version = 2; 13925 for (var i = 0; i <= 14; i++) { 13926 if (Tables.bitrate_table[version][i] > 0) { 13927 if (Tables.bitrate_table[version][i] == bRate) { 13928 return i; 13929 } 13930 } 13931 } 13932 return -1; 13933 } 13934 13935 function optimum_bandwidth(lh, bitrate) { 13936 /** 13937 * <PRE> 13938 * Input: 13939 * bitrate total bitrate in kbps 13940 * 13941 * Output: 13942 * lowerlimit: best lowpass frequency limit for input filter in Hz 13943 * upperlimit: best highpass frequency limit for input filter in Hz 13944 * </PRE> 13945 */ 13946 var freq_map = [new BandPass(8, 2000), 13947 new BandPass(16, 3700), new BandPass(24, 3900), 13948 new BandPass(32, 5500), new BandPass(40, 7000), 13949 new BandPass(48, 7500), new BandPass(56, 10000), 13950 new BandPass(64, 11000), new BandPass(80, 13500), 13951 new BandPass(96, 15100), new BandPass(112, 15600), 13952 new BandPass(128, 17000), new BandPass(160, 17500), 13953 new BandPass(192, 18600), new BandPass(224, 19400), 13954 new BandPass(256, 19700), new BandPass(320, 20500)]; 13955 13956 var table_index = self.nearestBitrateFullIndex(bitrate); 13957 lh.lowerlimit = freq_map[table_index].lowpass; 13958 } 13959 13960 function lame_init_params_ppflt(gfp) { 13961 var gfc = gfp.internal_flags; 13962 /***************************************************************/ 13963 /* compute info needed for polyphase filter (filter type==0, default) */ 13964 /***************************************************************/ 13965 13966 var lowpass_band = 32; 13967 var highpass_band = -1; 13968 13969 if (gfc.lowpass1 > 0) { 13970 var minband = 999; 13971 for (var band = 0; band <= 31; band++) { 13972 var freq = (band / 31.0); 13973 /* this band and above will be zeroed: */ 13974 if (freq >= gfc.lowpass2) { 13975 lowpass_band = Math.min(lowpass_band, band); 13976 } 13977 if (gfc.lowpass1 < freq && freq < gfc.lowpass2) { 13978 minband = Math.min(minband, band); 13979 } 13980 } 13981 13982 /* 13983 * compute the *actual* transition band implemented by the polyphase 13984 * filter 13985 */ 13986 if (minband == 999) { 13987 gfc.lowpass1 = (lowpass_band - .75) / 31.0; 13988 } else { 13989 gfc.lowpass1 = (minband - .75) / 31.0; 13990 } 13991 gfc.lowpass2 = lowpass_band / 31.0; 13992 } 13993 13994 /* 13995 * make sure highpass filter is within 90% of what the effective 13996 * highpass frequency will be 13997 */ 13998 if (gfc.highpass2 > 0) { 13999 if (gfc.highpass2 < .9 * (.75 / 31.0)) { 14000 gfc.highpass1 = 0; 14001 gfc.highpass2 = 0; 14002 System.err.println("Warning: highpass filter disabled. " 14003 + "highpass frequency too small\n"); 14004 } 14005 } 14006 14007 if (gfc.highpass2 > 0) { 14008 var maxband = -1; 14009 for (var band = 0; band <= 31; band++) { 14010 var freq = band / 31.0; 14011 /* this band and below will be zereod */ 14012 if (freq <= gfc.highpass1) { 14013 highpass_band = Math.max(highpass_band, band); 14014 } 14015 if (gfc.highpass1 < freq && freq < gfc.highpass2) { 14016 maxband = Math.max(maxband, band); 14017 } 14018 } 14019 /* 14020 * compute the *actual* transition band implemented by the polyphase 14021 * filter 14022 */ 14023 gfc.highpass1 = highpass_band / 31.0; 14024 if (maxband == -1) { 14025 gfc.highpass2 = (highpass_band + .75) / 31.0; 14026 } else { 14027 gfc.highpass2 = (maxband + .75) / 31.0; 14028 } 14029 } 14030 14031 for (var band = 0; band < 32; band++) { 14032 var fc1, fc2; 14033 var freq = band / 31.0; 14034 if (gfc.highpass2 > gfc.highpass1) { 14035 fc1 = filter_coef((gfc.highpass2 - freq) 14036 / (gfc.highpass2 - gfc.highpass1 + 1e-20)); 14037 } else { 14038 fc1 = 1.0; 14039 } 14040 if (gfc.lowpass2 > gfc.lowpass1) { 14041 fc2 = filter_coef((freq - gfc.lowpass1) 14042 / (gfc.lowpass2 - gfc.lowpass1 + 1e-20)); 14043 } else { 14044 fc2 = 1.0; 14045 } 14046 gfc.amp_filter[band] = (fc1 * fc2); 14047 } 14048 } 14049 14050 function lame_init_qval(gfp) { 14051 var gfc = gfp.internal_flags; 14052 14053 switch (gfp.quality) { 14054 default: 14055 case 9: /* no psymodel, no noise shaping */ 14056 gfc.psymodel = 0; 14057 gfc.noise_shaping = 0; 14058 gfc.noise_shaping_amp = 0; 14059 gfc.noise_shaping_stop = 0; 14060 gfc.use_best_huffman = 0; 14061 gfc.full_outer_loop = 0; 14062 break; 14063 14064 case 8: 14065 gfp.quality = 7; 14066 //$FALL-THROUGH$ 14067 case 7: 14068 /* 14069 * use psymodel (for short block and m/s switching), but no noise 14070 * shapping 14071 */ 14072 gfc.psymodel = 1; 14073 gfc.noise_shaping = 0; 14074 gfc.noise_shaping_amp = 0; 14075 gfc.noise_shaping_stop = 0; 14076 gfc.use_best_huffman = 0; 14077 gfc.full_outer_loop = 0; 14078 break; 14079 14080 case 6: 14081 gfc.psymodel = 1; 14082 if (gfc.noise_shaping == 0) 14083 gfc.noise_shaping = 1; 14084 gfc.noise_shaping_amp = 0; 14085 gfc.noise_shaping_stop = 0; 14086 if (gfc.subblock_gain == -1) 14087 gfc.subblock_gain = 1; 14088 gfc.use_best_huffman = 0; 14089 gfc.full_outer_loop = 0; 14090 break; 14091 14092 case 5: 14093 gfc.psymodel = 1; 14094 if (gfc.noise_shaping == 0) 14095 gfc.noise_shaping = 1; 14096 gfc.noise_shaping_amp = 0; 14097 gfc.noise_shaping_stop = 0; 14098 if (gfc.subblock_gain == -1) 14099 gfc.subblock_gain = 1; 14100 gfc.use_best_huffman = 0; 14101 gfc.full_outer_loop = 0; 14102 break; 14103 14104 case 4: 14105 gfc.psymodel = 1; 14106 if (gfc.noise_shaping == 0) 14107 gfc.noise_shaping = 1; 14108 gfc.noise_shaping_amp = 0; 14109 gfc.noise_shaping_stop = 0; 14110 if (gfc.subblock_gain == -1) 14111 gfc.subblock_gain = 1; 14112 gfc.use_best_huffman = 1; 14113 gfc.full_outer_loop = 0; 14114 break; 14115 14116 case 3: 14117 gfc.psymodel = 1; 14118 if (gfc.noise_shaping == 0) 14119 gfc.noise_shaping = 1; 14120 gfc.noise_shaping_amp = 1; 14121 gfc.noise_shaping_stop = 1; 14122 if (gfc.subblock_gain == -1) 14123 gfc.subblock_gain = 1; 14124 gfc.use_best_huffman = 1; 14125 gfc.full_outer_loop = 0; 14126 break; 14127 14128 case 2: 14129 gfc.psymodel = 1; 14130 if (gfc.noise_shaping == 0) 14131 gfc.noise_shaping = 1; 14132 if (gfc.substep_shaping == 0) 14133 gfc.substep_shaping = 2; 14134 gfc.noise_shaping_amp = 1; 14135 gfc.noise_shaping_stop = 1; 14136 if (gfc.subblock_gain == -1) 14137 gfc.subblock_gain = 1; 14138 gfc.use_best_huffman = 1; 14139 /* inner loop */ 14140 gfc.full_outer_loop = 0; 14141 break; 14142 14143 case 1: 14144 gfc.psymodel = 1; 14145 if (gfc.noise_shaping == 0) 14146 gfc.noise_shaping = 1; 14147 if (gfc.substep_shaping == 0) 14148 gfc.substep_shaping = 2; 14149 gfc.noise_shaping_amp = 2; 14150 gfc.noise_shaping_stop = 1; 14151 if (gfc.subblock_gain == -1) 14152 gfc.subblock_gain = 1; 14153 gfc.use_best_huffman = 1; 14154 gfc.full_outer_loop = 0; 14155 break; 14156 14157 case 0: 14158 gfc.psymodel = 1; 14159 if (gfc.noise_shaping == 0) 14160 gfc.noise_shaping = 1; 14161 if (gfc.substep_shaping == 0) 14162 gfc.substep_shaping = 2; 14163 gfc.noise_shaping_amp = 2; 14164 gfc.noise_shaping_stop = 1; 14165 if (gfc.subblock_gain == -1) 14166 gfc.subblock_gain = 1; 14167 gfc.use_best_huffman = 1; 14168 /* 14169 * type 2 disabled because of it slowness, in favor of full outer 14170 * loop search 14171 */ 14172 gfc.full_outer_loop = 0; 14173 /* 14174 * full outer loop search disabled because of audible distortions it 14175 * may generate rh 060629 14176 */ 14177 break; 14178 } 14179 14180 } 14181 14182 function lame_init_bitstream(gfp) { 14183 var gfc = gfp.internal_flags; 14184 gfp.frameNum = 0; 14185 14186 if (gfp.write_id3tag_automatic) { 14187 id3.id3tag_write_v2(gfp); 14188 } 14189 /* initialize histogram data optionally used by frontend */ 14190 14191 gfc.bitrate_stereoMode_Hist = new_int_n([16, 4 + 1]); 14192 gfc.bitrate_blockType_Hist = new_int_n([16, 4 + 1 + 1]); 14193 14194 gfc.PeakSample = 0.0; 14195 14196 /* Write initial VBR Header to bitstream and init VBR data */ 14197 if (gfp.bWriteVbrTag) 14198 vbr.InitVbrTag(gfp); 14199 } 14200 14201 /******************************************************************** 14202 * initialize internal params based on data in gf (globalflags struct filled 14203 * in by calling program) 14204 * 14205 * OUTLINE: 14206 * 14207 * We first have some complex code to determine bitrate, output samplerate 14208 * and mode. It is complicated by the fact that we allow the user to set 14209 * some or all of these parameters, and need to determine best possible 14210 * values for the rest of them: 14211 * 14212 * 1. set some CPU related flags 2. check if we are mono.mono, stereo.mono 14213 * or stereo.stereo 3. compute bitrate and output samplerate: user may have 14214 * set compression ratio user may have set a bitrate user may have set a 14215 * output samplerate 4. set some options which depend on output samplerate 14216 * 5. compute the actual compression ratio 6. set mode based on compression 14217 * ratio 14218 * 14219 * The remaining code is much simpler - it just sets options based on the 14220 * mode & compression ratio: 14221 * 14222 * set allow_diff_short based on mode select lowpass filter based on 14223 * compression ratio & mode set the bitrate index, and min/max bitrates for 14224 * VBR modes disable VBR tag if it is not appropriate initialize the 14225 * bitstream initialize scalefac_band data set sideinfo_len (based on 14226 * channels, CRC, out_samplerate) write an id3v2 tag into the bitstream 14227 * write VBR tag into the bitstream set mpeg1/2 flag estimate the number of 14228 * frames (based on a lot of data) 14229 * 14230 * now we set more flags: nspsytune: see code VBR modes see code CBR/ABR see 14231 * code 14232 * 14233 * Finally, we set the algorithm flags based on the gfp.quality value 14234 * lame_init_qval(gfp); 14235 * 14236 ********************************************************************/ 14237 this.lame_init_params = function (gfp) { 14238 var gfc = gfp.internal_flags; 14239 14240 gfc.Class_ID = 0; 14241 if (gfc.ATH == null) 14242 gfc.ATH = new ATH(); 14243 if (gfc.PSY == null) 14244 gfc.PSY = new PSY(); 14245 if (gfc.rgdata == null) 14246 gfc.rgdata = new ReplayGain(); 14247 14248 gfc.channels_in = gfp.num_channels; 14249 if (gfc.channels_in == 1) 14250 gfp.mode = MPEGMode.MONO; 14251 gfc.channels_out = (gfp.mode == MPEGMode.MONO) ? 1 : 2; 14252 gfc.mode_ext = Encoder.MPG_MD_MS_LR; 14253 if (gfp.mode == MPEGMode.MONO) 14254 gfp.force_ms = false; 14255 /* 14256 * don't allow forced mid/side stereo for mono output 14257 */ 14258 14259 if (gfp.VBR == VbrMode.vbr_off && gfp.VBR_mean_bitrate_kbps != 128 14260 && gfp.brate == 0) 14261 gfp.brate = gfp.VBR_mean_bitrate_kbps; 14262 14263 if (gfp.VBR == VbrMode.vbr_off || gfp.VBR == VbrMode.vbr_mtrh 14264 || gfp.VBR == VbrMode.vbr_mt) { 14265 /* these modes can handle free format condition */ 14266 } else { 14267 gfp.free_format = false; 14268 /* mode can't be mixed with free format */ 14269 } 14270 14271 if (gfp.VBR == VbrMode.vbr_off && gfp.brate == 0) { 14272 /* no bitrate or compression ratio specified, use 11.025 */ 14273 if (BitStream.EQ(gfp.compression_ratio, 0)) 14274 gfp.compression_ratio = 11.025; 14275 /* 14276 * rate to compress a CD down to exactly 128000 bps 14277 */ 14278 } 14279 14280 /* find bitrate if user specify a compression ratio */ 14281 if (gfp.VBR == VbrMode.vbr_off && gfp.compression_ratio > 0) { 14282 14283 if (gfp.out_samplerate == 0) 14284 gfp.out_samplerate = map2MP3Frequency((int)(0.97 * gfp.in_samplerate)); 14285 /* 14286 * round up with a margin of 3 % 14287 */ 14288 14289 /* 14290 * choose a bitrate for the output samplerate which achieves 14291 * specified compression ratio 14292 */ 14293 gfp.brate = 0 | (gfp.out_samplerate * 16 * gfc.channels_out / (1.e3 * gfp.compression_ratio)); 14294 14295 /* we need the version for the bitrate table look up */ 14296 gfc.samplerate_index = SmpFrqIndex(gfp.out_samplerate, gfp); 14297 14298 if (!gfp.free_format) /* 14299 * for non Free Format find the nearest allowed 14300 * bitrate 14301 */ 14302 gfp.brate = FindNearestBitrate(gfp.brate, gfp.version, 14303 gfp.out_samplerate); 14304 } 14305 14306 if (gfp.out_samplerate != 0) { 14307 if (gfp.out_samplerate < 16000) { 14308 gfp.VBR_mean_bitrate_kbps = Math.max(gfp.VBR_mean_bitrate_kbps, 14309 8); 14310 gfp.VBR_mean_bitrate_kbps = Math.min(gfp.VBR_mean_bitrate_kbps, 14311 64); 14312 } else if (gfp.out_samplerate < 32000) { 14313 gfp.VBR_mean_bitrate_kbps = Math.max(gfp.VBR_mean_bitrate_kbps, 14314 8); 14315 gfp.VBR_mean_bitrate_kbps = Math.min(gfp.VBR_mean_bitrate_kbps, 14316 160); 14317 } else { 14318 gfp.VBR_mean_bitrate_kbps = Math.max(gfp.VBR_mean_bitrate_kbps, 14319 32); 14320 gfp.VBR_mean_bitrate_kbps = Math.min(gfp.VBR_mean_bitrate_kbps, 14321 320); 14322 } 14323 } 14324 14325 /****************************************************************/ 14326 /* if a filter has not been enabled, see if we should add one: */ 14327 /****************************************************************/ 14328 if (gfp.lowpassfreq == 0) { 14329 var lowpass = 16000.; 14330 14331 switch (gfp.VBR) { 14332 case VbrMode.vbr_off: 14333 { 14334 var lh = new LowPassHighPass(); 14335 optimum_bandwidth(lh, gfp.brate); 14336 lowpass = lh.lowerlimit; 14337 break; 14338 } 14339 case VbrMode.vbr_abr: 14340 { 14341 var lh = new LowPassHighPass(); 14342 optimum_bandwidth(lh, gfp.VBR_mean_bitrate_kbps); 14343 lowpass = lh.lowerlimit; 14344 break; 14345 } 14346 case VbrMode.vbr_rh: 14347 { 14348 var x = [19500, 19000, 18600, 18000, 17500, 16000, 14349 15600, 14900, 12500, 10000, 3950]; 14350 if (0 <= gfp.VBR_q && gfp.VBR_q <= 9) { 14351 var a = x[gfp.VBR_q], b = x[gfp.VBR_q + 1], m = gfp.VBR_q_frac; 14352 lowpass = linear_int(a, b, m); 14353 } else { 14354 lowpass = 19500; 14355 } 14356 break; 14357 } 14358 default: 14359 { 14360 var x = [19500, 19000, 18500, 18000, 17500, 16500, 14361 15500, 14500, 12500, 9500, 3950]; 14362 if (0 <= gfp.VBR_q && gfp.VBR_q <= 9) { 14363 var a = x[gfp.VBR_q], b = x[gfp.VBR_q + 1], m = gfp.VBR_q_frac; 14364 lowpass = linear_int(a, b, m); 14365 } else { 14366 lowpass = 19500; 14367 } 14368 } 14369 } 14370 if (gfp.mode == MPEGMode.MONO 14371 && (gfp.VBR == VbrMode.vbr_off || gfp.VBR == VbrMode.vbr_abr)) 14372 lowpass *= 1.5; 14373 14374 gfp.lowpassfreq = lowpass | 0; 14375 } 14376 14377 if (gfp.out_samplerate == 0) { 14378 if (2 * gfp.lowpassfreq > gfp.in_samplerate) { 14379 gfp.lowpassfreq = gfp.in_samplerate / 2; 14380 } 14381 gfp.out_samplerate = optimum_samplefreq(gfp.lowpassfreq | 0, 14382 gfp.in_samplerate); 14383 } 14384 14385 gfp.lowpassfreq = Math.min(20500, gfp.lowpassfreq); 14386 gfp.lowpassfreq = Math.min(gfp.out_samplerate / 2, gfp.lowpassfreq); 14387 14388 if (gfp.VBR == VbrMode.vbr_off) { 14389 gfp.compression_ratio = gfp.out_samplerate * 16 * gfc.channels_out 14390 / (1.e3 * gfp.brate); 14391 } 14392 if (gfp.VBR == VbrMode.vbr_abr) { 14393 gfp.compression_ratio = gfp.out_samplerate * 16 * gfc.channels_out 14394 / (1.e3 * gfp.VBR_mean_bitrate_kbps); 14395 } 14396 14397 /* 14398 * do not compute ReplayGain values and do not find the peak sample if 14399 * we can't store them 14400 */ 14401 if (!gfp.bWriteVbrTag) { 14402 gfp.findReplayGain = false; 14403 gfp.decode_on_the_fly = false; 14404 gfc.findPeakSample = false; 14405 } 14406 gfc.findReplayGain = gfp.findReplayGain; 14407 gfc.decode_on_the_fly = gfp.decode_on_the_fly; 14408 14409 if (gfc.decode_on_the_fly) 14410 gfc.findPeakSample = true; 14411 14412 if (gfc.findReplayGain) { 14413 if (ga.InitGainAnalysis(gfc.rgdata, gfp.out_samplerate) == GainAnalysis.INIT_GAIN_ANALYSIS_ERROR) { 14414 gfp.internal_flags = null; 14415 return -6; 14416 } 14417 } 14418 14419 if (gfc.decode_on_the_fly && !gfp.decode_only) { 14420 if (gfc.hip != null) { 14421 mpglib.hip_decode_exit(gfc.hip); 14422 } 14423 gfc.hip = mpglib.hip_decode_init(); 14424 } 14425 14426 gfc.mode_gr = gfp.out_samplerate <= 24000 ? 1 : 2; 14427 /* 14428 * Number of granules per frame 14429 */ 14430 gfp.framesize = 576 * gfc.mode_gr; 14431 gfp.encoder_delay = Encoder.ENCDELAY; 14432 14433 gfc.resample_ratio = gfp.in_samplerate / gfp.out_samplerate; 14434 14435 /** 14436 * <PRE> 14437 * sample freq bitrate compression ratio 14438 * [kHz] [kbps/channel] for 16 bit input 14439 * 44.1 56 12.6 14440 * 44.1 64 11.025 14441 * 44.1 80 8.82 14442 * 22.05 24 14.7 14443 * 22.05 32 11.025 14444 * 22.05 40 8.82 14445 * 16 16 16.0 14446 * 16 24 10.667 14447 * </PRE> 14448 */ 14449 /** 14450 * <PRE> 14451 * For VBR, take a guess at the compression_ratio. 14452 * For example: 14453 * 14454 * VBR_q compression like 14455 * - 4.4 320 kbps/44 kHz 14456 * 0...1 5.5 256 kbps/44 kHz 14457 * 2 7.3 192 kbps/44 kHz 14458 * 4 8.8 160 kbps/44 kHz 14459 * 6 11 128 kbps/44 kHz 14460 * 9 14.7 96 kbps 14461 * 14462 * for lower bitrates, downsample with --resample 14463 * </PRE> 14464 */ 14465 switch (gfp.VBR) { 14466 case VbrMode.vbr_mt: 14467 case VbrMode.vbr_rh: 14468 case VbrMode.vbr_mtrh: 14469 { 14470 /* numbers are a bit strange, but they determine the lowpass value */ 14471 var cmp = [5.7, 6.5, 7.3, 8.2, 10, 11.9, 13, 14, 14472 15, 16.5]; 14473 gfp.compression_ratio = cmp[gfp.VBR_q]; 14474 } 14475 break; 14476 case VbrMode.vbr_abr: 14477 gfp.compression_ratio = gfp.out_samplerate * 16 * gfc.channels_out 14478 / (1.e3 * gfp.VBR_mean_bitrate_kbps); 14479 break; 14480 default: 14481 gfp.compression_ratio = gfp.out_samplerate * 16 * gfc.channels_out 14482 / (1.e3 * gfp.brate); 14483 break; 14484 } 14485 14486 /* 14487 * mode = -1 (not set by user) or mode = MONO (because of only 1 input 14488 * channel). If mode has not been set, then select J-STEREO 14489 */ 14490 if (gfp.mode == MPEGMode.NOT_SET) { 14491 gfp.mode = MPEGMode.JOINT_STEREO; 14492 } 14493 14494 /* apply user driven high pass filter */ 14495 if (gfp.highpassfreq > 0) { 14496 gfc.highpass1 = 2. * gfp.highpassfreq; 14497 14498 if (gfp.highpasswidth >= 0) 14499 gfc.highpass2 = 2. * (gfp.highpassfreq + gfp.highpasswidth); 14500 else 14501 /* 0% above on default */ 14502 gfc.highpass2 = (1 + 0.00) * 2. * gfp.highpassfreq; 14503 14504 gfc.highpass1 /= gfp.out_samplerate; 14505 gfc.highpass2 /= gfp.out_samplerate; 14506 } else { 14507 gfc.highpass1 = 0; 14508 gfc.highpass2 = 0; 14509 } 14510 /* apply user driven low pass filter */ 14511 if (gfp.lowpassfreq > 0) { 14512 gfc.lowpass2 = 2. * gfp.lowpassfreq; 14513 if (gfp.lowpasswidth >= 0) { 14514 gfc.lowpass1 = 2. * (gfp.lowpassfreq - gfp.lowpasswidth); 14515 if (gfc.lowpass1 < 0) /* has to be >= 0 */ 14516 gfc.lowpass1 = 0; 14517 } else { /* 0% below on default */ 14518 gfc.lowpass1 = (1 - 0.00) * 2. * gfp.lowpassfreq; 14519 } 14520 gfc.lowpass1 /= gfp.out_samplerate; 14521 gfc.lowpass2 /= gfp.out_samplerate; 14522 } else { 14523 gfc.lowpass1 = 0; 14524 gfc.lowpass2 = 0; 14525 } 14526 14527 /**********************************************************************/ 14528 /* compute info needed for polyphase filter (filter type==0, default) */ 14529 /**********************************************************************/ 14530 lame_init_params_ppflt(gfp); 14531 /******************************************************* 14532 * samplerate and bitrate index 14533 *******************************************************/ 14534 gfc.samplerate_index = SmpFrqIndex(gfp.out_samplerate, gfp); 14535 if (gfc.samplerate_index < 0) { 14536 gfp.internal_flags = null; 14537 return -1; 14538 } 14539 14540 if (gfp.VBR == VbrMode.vbr_off) { 14541 if (gfp.free_format) { 14542 gfc.bitrate_index = 0; 14543 } else { 14544 gfp.brate = FindNearestBitrate(gfp.brate, gfp.version, 14545 gfp.out_samplerate); 14546 gfc.bitrate_index = BitrateIndex(gfp.brate, gfp.version, 14547 gfp.out_samplerate); 14548 if (gfc.bitrate_index <= 0) { 14549 gfp.internal_flags = null; 14550 return -1; 14551 } 14552 } 14553 } else { 14554 gfc.bitrate_index = 1; 14555 } 14556 14557 /* for CBR, we will write an "info" tag. */ 14558 14559 if (gfp.analysis) 14560 gfp.bWriteVbrTag = false; 14561 14562 /* some file options not allowed if output is: not specified or stdout */ 14563 if (gfc.pinfo != null) 14564 gfp.bWriteVbrTag = false; 14565 /* disable Xing VBR tag */ 14566 14567 bs.init_bit_stream_w(gfc); 14568 14569 var j = gfc.samplerate_index + (3 * gfp.version) + 6 14570 * (gfp.out_samplerate < 16000 ? 1 : 0); 14571 for (var i = 0; i < Encoder.SBMAX_l + 1; i++) 14572 gfc.scalefac_band.l[i] = qupvt.sfBandIndex[j].l[i]; 14573 14574 for (var i = 0; i < Encoder.PSFB21 + 1; i++) { 14575 var size = (gfc.scalefac_band.l[22] - gfc.scalefac_band.l[21]) 14576 / Encoder.PSFB21; 14577 var start = gfc.scalefac_band.l[21] + i * size; 14578 gfc.scalefac_band.psfb21[i] = start; 14579 } 14580 gfc.scalefac_band.psfb21[Encoder.PSFB21] = 576; 14581 14582 for (var i = 0; i < Encoder.SBMAX_s + 1; i++) 14583 gfc.scalefac_band.s[i] = qupvt.sfBandIndex[j].s[i]; 14584 14585 for (var i = 0; i < Encoder.PSFB12 + 1; i++) { 14586 var size = (gfc.scalefac_band.s[13] - gfc.scalefac_band.s[12]) 14587 / Encoder.PSFB12; 14588 var start = gfc.scalefac_band.s[12] + i * size; 14589 gfc.scalefac_band.psfb12[i] = start; 14590 } 14591 gfc.scalefac_band.psfb12[Encoder.PSFB12] = 192; 14592 /* determine the mean bitrate for main data */ 14593 if (gfp.version == 1) /* MPEG 1 */ 14594 gfc.sideinfo_len = (gfc.channels_out == 1) ? 4 + 17 : 4 + 32; 14595 else 14596 /* MPEG 2 */ 14597 gfc.sideinfo_len = (gfc.channels_out == 1) ? 4 + 9 : 4 + 17; 14598 14599 if (gfp.error_protection) 14600 gfc.sideinfo_len += 2; 14601 14602 lame_init_bitstream(gfp); 14603 14604 gfc.Class_ID = LAME_ID; 14605 14606 { 14607 var k; 14608 14609 for (k = 0; k < 19; k++) 14610 gfc.nsPsy.pefirbuf[k] = 700 * gfc.mode_gr * gfc.channels_out; 14611 14612 if (gfp.ATHtype == -1) 14613 gfp.ATHtype = 4; 14614 } 14615 14616 switch (gfp.VBR) { 14617 14618 case VbrMode.vbr_mt: 14619 gfp.VBR = VbrMode.vbr_mtrh; 14620 //$FALL-THROUGH$ 14621 case VbrMode.vbr_mtrh: 14622 { 14623 if (gfp.useTemporal == null) { 14624 gfp.useTemporal = false; 14625 /* off by default for this VBR mode */ 14626 } 14627 14628 p.apply_preset(gfp, 500 - (gfp.VBR_q * 10), 0); 14629 /** 14630 * <PRE> 14631 * The newer VBR code supports only a limited 14632 * subset of quality levels: 14633 * 9-5=5 are the same, uses x^3/4 quantization 14634 * 4-0=0 are the same 5 plus best huffman divide code 14635 * </PRE> 14636 */ 14637 if (gfp.quality < 0) 14638 gfp.quality = LAME_DEFAULT_QUALITY; 14639 if (gfp.quality < 5) 14640 gfp.quality = 0; 14641 if (gfp.quality > 5) 14642 gfp.quality = 5; 14643 14644 gfc.PSY.mask_adjust = gfp.maskingadjust; 14645 gfc.PSY.mask_adjust_short = gfp.maskingadjust_short; 14646 14647 /* 14648 * sfb21 extra only with MPEG-1 at higher sampling rates 14649 */ 14650 if (gfp.experimentalY) 14651 gfc.sfb21_extra = false; 14652 else 14653 gfc.sfb21_extra = (gfp.out_samplerate > 44000); 14654 14655 gfc.iteration_loop = new VBRNewIterationLoop(qu); 14656 break; 14657 14658 } 14659 case VbrMode.vbr_rh: 14660 { 14661 14662 p.apply_preset(gfp, 500 - (gfp.VBR_q * 10), 0); 14663 14664 gfc.PSY.mask_adjust = gfp.maskingadjust; 14665 gfc.PSY.mask_adjust_short = gfp.maskingadjust_short; 14666 14667 /* 14668 * sfb21 extra only with MPEG-1 at higher sampling rates 14669 */ 14670 if (gfp.experimentalY) 14671 gfc.sfb21_extra = false; 14672 else 14673 gfc.sfb21_extra = (gfp.out_samplerate > 44000); 14674 14675 /* 14676 * VBR needs at least the output of GPSYCHO, so we have to garantee 14677 * that by setting a minimum quality level, actually level 6 does 14678 * it. down to level 6 14679 */ 14680 if (gfp.quality > 6) 14681 gfp.quality = 6; 14682 14683 if (gfp.quality < 0) 14684 gfp.quality = LAME_DEFAULT_QUALITY; 14685 14686 gfc.iteration_loop = new VBROldIterationLoop(qu); 14687 break; 14688 } 14689 14690 default: /* cbr/abr */ 14691 { 14692 var vbrmode; 14693 14694 /* 14695 * no sfb21 extra with CBR code 14696 */ 14697 gfc.sfb21_extra = false; 14698 14699 if (gfp.quality < 0) 14700 gfp.quality = LAME_DEFAULT_QUALITY; 14701 14702 vbrmode = gfp.VBR; 14703 if (vbrmode == VbrMode.vbr_off) 14704 gfp.VBR_mean_bitrate_kbps = gfp.brate; 14705 /* second, set parameters depending on bitrate */ 14706 p.apply_preset(gfp, gfp.VBR_mean_bitrate_kbps, 0); 14707 gfp.VBR = vbrmode; 14708 14709 gfc.PSY.mask_adjust = gfp.maskingadjust; 14710 gfc.PSY.mask_adjust_short = gfp.maskingadjust_short; 14711 14712 if (vbrmode == VbrMode.vbr_off) { 14713 gfc.iteration_loop = new CBRNewIterationLoop(qu); 14714 } else { 14715 gfc.iteration_loop = new ABRIterationLoop(qu); 14716 } 14717 break; 14718 } 14719 } 14720 /* initialize default values common for all modes */ 14721 14722 if (gfp.VBR != VbrMode.vbr_off) { /* choose a min/max bitrate for VBR */ 14723 /* if the user didn't specify VBR_max_bitrate: */ 14724 gfc.VBR_min_bitrate = 1; 14725 /* 14726 * default: allow 8 kbps (MPEG-2) or 32 kbps (MPEG-1) 14727 */ 14728 gfc.VBR_max_bitrate = 14; 14729 /* 14730 * default: allow 160 kbps (MPEG-2) or 320 kbps (MPEG-1) 14731 */ 14732 if (gfp.out_samplerate < 16000) 14733 gfc.VBR_max_bitrate = 8; 14734 /* default: allow 64 kbps (MPEG-2.5) */ 14735 if (gfp.VBR_min_bitrate_kbps != 0) { 14736 gfp.VBR_min_bitrate_kbps = FindNearestBitrate( 14737 gfp.VBR_min_bitrate_kbps, gfp.version, 14738 gfp.out_samplerate); 14739 gfc.VBR_min_bitrate = BitrateIndex(gfp.VBR_min_bitrate_kbps, 14740 gfp.version, gfp.out_samplerate); 14741 if (gfc.VBR_min_bitrate < 0) 14742 return -1; 14743 } 14744 if (gfp.VBR_max_bitrate_kbps != 0) { 14745 gfp.VBR_max_bitrate_kbps = FindNearestBitrate( 14746 gfp.VBR_max_bitrate_kbps, gfp.version, 14747 gfp.out_samplerate); 14748 gfc.VBR_max_bitrate = BitrateIndex(gfp.VBR_max_bitrate_kbps, 14749 gfp.version, gfp.out_samplerate); 14750 if (gfc.VBR_max_bitrate < 0) 14751 return -1; 14752 } 14753 gfp.VBR_min_bitrate_kbps = Tables.bitrate_table[gfp.version][gfc.VBR_min_bitrate]; 14754 gfp.VBR_max_bitrate_kbps = Tables.bitrate_table[gfp.version][gfc.VBR_max_bitrate]; 14755 gfp.VBR_mean_bitrate_kbps = Math.min( 14756 Tables.bitrate_table[gfp.version][gfc.VBR_max_bitrate], 14757 gfp.VBR_mean_bitrate_kbps); 14758 gfp.VBR_mean_bitrate_kbps = Math.max( 14759 Tables.bitrate_table[gfp.version][gfc.VBR_min_bitrate], 14760 gfp.VBR_mean_bitrate_kbps); 14761 } 14762 14763 /* just another daily changing developer switch */ 14764 if (gfp.tune) { 14765 gfc.PSY.mask_adjust += gfp.tune_value_a; 14766 gfc.PSY.mask_adjust_short += gfp.tune_value_a; 14767 } 14768 14769 /* initialize internal qval settings */ 14770 lame_init_qval(gfp); 14771 /* 14772 * automatic ATH adjustment on 14773 */ 14774 if (gfp.athaa_type < 0) 14775 gfc.ATH.useAdjust = 3; 14776 else 14777 gfc.ATH.useAdjust = gfp.athaa_type; 14778 14779 /* initialize internal adaptive ATH settings -jd */ 14780 gfc.ATH.aaSensitivityP = Math.pow(10.0, gfp.athaa_sensitivity 14781 / -10.0); 14782 14783 if (gfp.short_blocks == null) { 14784 gfp.short_blocks = ShortBlock.short_block_allowed; 14785 } 14786 14787 /* 14788 * Note Jan/2003: Many hardware decoders cannot handle short blocks in 14789 * regular stereo mode unless they are coupled (same type in both 14790 * channels) it is a rare event (1 frame per min. or so) that LAME would 14791 * use uncoupled short blocks, so lets turn them off until we decide how 14792 * to handle this. No other encoders allow uncoupled short blocks, even 14793 * though it is in the standard. 14794 */ 14795 /* 14796 * rh 20040217: coupling makes no sense for mono and dual-mono streams 14797 */ 14798 if (gfp.short_blocks == ShortBlock.short_block_allowed 14799 && (gfp.mode == MPEGMode.JOINT_STEREO || gfp.mode == MPEGMode.STEREO)) { 14800 gfp.short_blocks = ShortBlock.short_block_coupled; 14801 } 14802 14803 if (gfp.quant_comp < 0) 14804 gfp.quant_comp = 1; 14805 if (gfp.quant_comp_short < 0) 14806 gfp.quant_comp_short = 0; 14807 14808 if (gfp.msfix < 0) 14809 gfp.msfix = 0; 14810 14811 /* select psychoacoustic model */ 14812 gfp.exp_nspsytune = gfp.exp_nspsytune | 1; 14813 14814 if (gfp.internal_flags.nsPsy.attackthre < 0) 14815 gfp.internal_flags.nsPsy.attackthre = PsyModel.NSATTACKTHRE; 14816 if (gfp.internal_flags.nsPsy.attackthre_s < 0) 14817 gfp.internal_flags.nsPsy.attackthre_s = PsyModel.NSATTACKTHRE_S; 14818 14819 14820 if (gfp.scale < 0) 14821 gfp.scale = 1; 14822 14823 if (gfp.ATHtype < 0) 14824 gfp.ATHtype = 4; 14825 14826 if (gfp.ATHcurve < 0) 14827 gfp.ATHcurve = 4; 14828 14829 if (gfp.athaa_loudapprox < 0) 14830 gfp.athaa_loudapprox = 2; 14831 14832 if (gfp.interChRatio < 0) 14833 gfp.interChRatio = 0; 14834 14835 if (gfp.useTemporal == null) 14836 gfp.useTemporal = true; 14837 /* on by default */ 14838 14839 /* 14840 * padding method as described in 14841 * "MPEG-Layer3 / Bitstream Syntax and Decoding" by Martin Sieler, Ralph 14842 * Sperschneider 14843 * 14844 * note: there is no padding for the very first frame 14845 * 14846 * Robert Hegemann 2000-06-22 14847 */ 14848 gfc.slot_lag = gfc.frac_SpF = 0; 14849 if (gfp.VBR == VbrMode.vbr_off) 14850 gfc.slot_lag = gfc.frac_SpF = (((gfp.version + 1) * 72000 * gfp.brate) % gfp.out_samplerate) | 0; 14851 14852 qupvt.iteration_init(gfp); 14853 psy.psymodel_init(gfp); 14854 return 0; 14855 } 14856 14857 function update_inbuffer_size(gfc, nsamples) { 14858 if (gfc.in_buffer_0 == null || gfc.in_buffer_nsamples < nsamples) { 14859 gfc.in_buffer_0 = new_float(nsamples); 14860 gfc.in_buffer_1 = new_float(nsamples); 14861 gfc.in_buffer_nsamples = nsamples; 14862 } 14863 } 14864 14865 this.lame_encode_flush = function (gfp, mp3buffer, mp3bufferPos, mp3buffer_size) { 14866 var gfc = gfp.internal_flags; 14867 var buffer = new_short_n([2, 1152]); 14868 var imp3 = 0, mp3count, mp3buffer_size_remaining; 14869 14870 /* 14871 * we always add POSTDELAY=288 padding to make sure granule with real 14872 * data can be complety decoded (because of 50% overlap with next 14873 * granule 14874 */ 14875 var end_padding; 14876 var frames_left; 14877 var samples_to_encode = gfc.mf_samples_to_encode - Encoder.POSTDELAY; 14878 var mf_needed = calcNeeded(gfp); 14879 14880 /* Was flush already called? */ 14881 if (gfc.mf_samples_to_encode < 1) { 14882 return 0; 14883 } 14884 mp3count = 0; 14885 14886 if (gfp.in_samplerate != gfp.out_samplerate) { 14887 /* 14888 * delay due to resampling; needs to be fixed, if resampling code 14889 * gets changed 14890 */ 14891 samples_to_encode += 16. * gfp.out_samplerate / gfp.in_samplerate; 14892 } 14893 end_padding = gfp.framesize - (samples_to_encode % gfp.framesize); 14894 if (end_padding < 576) 14895 end_padding += gfp.framesize; 14896 gfp.encoder_padding = end_padding; 14897 14898 frames_left = (samples_to_encode + end_padding) / gfp.framesize; 14899 14900 /* 14901 * send in a frame of 0 padding until all internal sample buffers are 14902 * flushed 14903 */ 14904 while (frames_left > 0 && imp3 >= 0) { 14905 var bunch = mf_needed - gfc.mf_size; 14906 var frame_num = gfp.frameNum; 14907 14908 bunch *= gfp.in_samplerate; 14909 bunch /= gfp.out_samplerate; 14910 if (bunch > 1152) 14911 bunch = 1152; 14912 if (bunch < 1) 14913 bunch = 1; 14914 14915 mp3buffer_size_remaining = mp3buffer_size - mp3count; 14916 14917 /* if user specifed buffer size = 0, dont check size */ 14918 if (mp3buffer_size == 0) 14919 mp3buffer_size_remaining = 0; 14920 14921 imp3 = this.lame_encode_buffer(gfp, buffer[0], buffer[1], bunch, 14922 mp3buffer, mp3bufferPos, mp3buffer_size_remaining); 14923 14924 mp3bufferPos += imp3; 14925 mp3count += imp3; 14926 frames_left -= (frame_num != gfp.frameNum) ? 1 : 0; 14927 } 14928 /* 14929 * Set gfc.mf_samples_to_encode to 0, so we may detect and break loops 14930 * calling it more than once in a row. 14931 */ 14932 gfc.mf_samples_to_encode = 0; 14933 14934 if (imp3 < 0) { 14935 /* some type of fatal error */ 14936 return imp3; 14937 } 14938 14939 mp3buffer_size_remaining = mp3buffer_size - mp3count; 14940 /* if user specifed buffer size = 0, dont check size */ 14941 if (mp3buffer_size == 0) 14942 mp3buffer_size_remaining = 0; 14943 14944 /* mp3 related stuff. bit buffer might still contain some mp3 data */ 14945 bs.flush_bitstream(gfp); 14946 imp3 = bs.copy_buffer(gfc, mp3buffer, mp3bufferPos, 14947 mp3buffer_size_remaining, 1); 14948 if (imp3 < 0) { 14949 /* some type of fatal error */ 14950 return imp3; 14951 } 14952 mp3bufferPos += imp3; 14953 mp3count += imp3; 14954 mp3buffer_size_remaining = mp3buffer_size - mp3count; 14955 /* if user specifed buffer size = 0, dont check size */ 14956 if (mp3buffer_size == 0) 14957 mp3buffer_size_remaining = 0; 14958 14959 if (gfp.write_id3tag_automatic) { 14960 /* write a id3 tag to the bitstream */ 14961 id3.id3tag_write_v1(gfp); 14962 14963 imp3 = bs.copy_buffer(gfc, mp3buffer, mp3bufferPos, 14964 mp3buffer_size_remaining, 0); 14965 14966 if (imp3 < 0) { 14967 return imp3; 14968 } 14969 mp3count += imp3; 14970 } 14971 return mp3count; 14972 }; 14973 14974 this.lame_encode_buffer = function (gfp, buffer_l, buffer_r, nsamples, mp3buf, mp3bufPos, mp3buf_size) { 14975 var gfc = gfp.internal_flags; 14976 var in_buffer = [null, null]; 14977 14978 if (gfc.Class_ID != LAME_ID) 14979 return -3; 14980 14981 if (nsamples == 0) 14982 return 0; 14983 14984 update_inbuffer_size(gfc, nsamples); 14985 14986 in_buffer[0] = gfc.in_buffer_0; 14987 in_buffer[1] = gfc.in_buffer_1; 14988 14989 /* make a copy of input buffer, changing type to sample_t */ 14990 for (var i = 0; i < nsamples; i++) { 14991 in_buffer[0][i] = buffer_l[i]; 14992 if (gfc.channels_in > 1) 14993 in_buffer[1][i] = buffer_r[i]; 14994 } 14995 14996 return lame_encode_buffer_sample(gfp, in_buffer[0], in_buffer[1], 14997 nsamples, mp3buf, mp3bufPos, mp3buf_size); 14998 } 14999 15000 function calcNeeded(gfp) { 15001 var mf_needed = Encoder.BLKSIZE + gfp.framesize - Encoder.FFTOFFSET; 15002 /* 15003 * amount needed for FFT 15004 */ 15005 mf_needed = Math.max(mf_needed, 512 + gfp.framesize - 32); 15006 15007 return mf_needed; 15008 } 15009 15010 function lame_encode_buffer_sample(gfp, buffer_l, buffer_r, nsamples, mp3buf, mp3bufPos, mp3buf_size) { 15011 var gfc = gfp.internal_flags; 15012 var mp3size = 0, ret, i, ch, mf_needed; 15013 var mp3out; 15014 var mfbuf = [null, null]; 15015 var in_buffer = [null, null]; 15016 15017 if (gfc.Class_ID != LAME_ID) 15018 return -3; 15019 15020 if (nsamples == 0) 15021 return 0; 15022 15023 /* copy out any tags that may have been written into bitstream */ 15024 mp3out = bs.copy_buffer(gfc, mp3buf, mp3bufPos, mp3buf_size, 0); 15025 if (mp3out < 0) 15026 return mp3out; 15027 /* not enough buffer space */ 15028 mp3bufPos += mp3out; 15029 mp3size += mp3out; 15030 15031 in_buffer[0] = buffer_l; 15032 in_buffer[1] = buffer_r; 15033 15034 /* Apply user defined re-scaling */ 15035 15036 /* user selected scaling of the samples */ 15037 if (BitStream.NEQ(gfp.scale, 0) && BitStream.NEQ(gfp.scale, 1.0)) { 15038 for (i = 0; i < nsamples; ++i) { 15039 in_buffer[0][i] *= gfp.scale; 15040 if (gfc.channels_out == 2) 15041 in_buffer[1][i] *= gfp.scale; 15042 } 15043 } 15044 15045 /* user selected scaling of the channel 0 (left) samples */ 15046 if (BitStream.NEQ(gfp.scale_left, 0) 15047 && BitStream.NEQ(gfp.scale_left, 1.0)) { 15048 for (i = 0; i < nsamples; ++i) { 15049 in_buffer[0][i] *= gfp.scale_left; 15050 } 15051 } 15052 15053 /* user selected scaling of the channel 1 (right) samples */ 15054 if (BitStream.NEQ(gfp.scale_right, 0) 15055 && BitStream.NEQ(gfp.scale_right, 1.0)) { 15056 for (i = 0; i < nsamples; ++i) { 15057 in_buffer[1][i] *= gfp.scale_right; 15058 } 15059 } 15060 15061 /* Downsample to Mono if 2 channels in and 1 channel out */ 15062 if (gfp.num_channels == 2 && gfc.channels_out == 1) { 15063 for (i = 0; i < nsamples; ++i) { 15064 in_buffer[0][i] = 0.5 * ( in_buffer[0][i] + in_buffer[1][i]); 15065 in_buffer[1][i] = 0.0; 15066 } 15067 } 15068 15069 mf_needed = calcNeeded(gfp); 15070 15071 mfbuf[0] = gfc.mfbuf[0]; 15072 mfbuf[1] = gfc.mfbuf[1]; 15073 15074 var in_bufferPos = 0; 15075 while (nsamples > 0) { 15076 var in_buffer_ptr = [null, null]; 15077 var n_in = 0; 15078 /* number of input samples processed with fill_buffer */ 15079 var n_out = 0; 15080 /* number of samples output with fill_buffer */ 15081 /* n_in <> n_out if we are resampling */ 15082 15083 in_buffer_ptr[0] = in_buffer[0]; 15084 in_buffer_ptr[1] = in_buffer[1]; 15085 /* copy in new samples into mfbuf, with resampling */ 15086 var inOut = new InOut(); 15087 fill_buffer(gfp, mfbuf, in_buffer_ptr, in_bufferPos, nsamples, 15088 inOut); 15089 n_in = inOut.n_in; 15090 n_out = inOut.n_out; 15091 15092 /* compute ReplayGain of resampled input if requested */ 15093 if (gfc.findReplayGain && !gfc.decode_on_the_fly) 15094 if (ga.AnalyzeSamples(gfc.rgdata, mfbuf[0], gfc.mf_size, 15095 mfbuf[1], gfc.mf_size, n_out, gfc.channels_out) == GainAnalysis.GAIN_ANALYSIS_ERROR) 15096 return -6; 15097 15098 /* update in_buffer counters */ 15099 nsamples -= n_in; 15100 in_bufferPos += n_in; 15101 if (gfc.channels_out == 2) 15102 ;// in_bufferPos += n_in; 15103 15104 /* update mfbuf[] counters */ 15105 gfc.mf_size += n_out; 15106 15107 /* 15108 * lame_encode_flush may have set gfc.mf_sample_to_encode to 0 so we 15109 * have to reinitialize it here when that happened. 15110 */ 15111 if (gfc.mf_samples_to_encode < 1) { 15112 gfc.mf_samples_to_encode = Encoder.ENCDELAY + Encoder.POSTDELAY; 15113 } 15114 gfc.mf_samples_to_encode += n_out; 15115 15116 if (gfc.mf_size >= mf_needed) { 15117 /* encode the frame. */ 15118 /* mp3buf = pointer to current location in buffer */ 15119 /* mp3buf_size = size of original mp3 output buffer */ 15120 /* = 0 if we should not worry about the */ 15121 /* buffer size because calling program is */ 15122 /* to lazy to compute it */ 15123 /* mp3size = size of data written to buffer so far */ 15124 /* mp3buf_size-mp3size = amount of space avalable */ 15125 15126 var buf_size = mp3buf_size - mp3size; 15127 if (mp3buf_size == 0) 15128 buf_size = 0; 15129 15130 ret = lame_encode_frame(gfp, mfbuf[0], mfbuf[1], mp3buf, 15131 mp3bufPos, buf_size); 15132 15133 if (ret < 0) 15134 return ret; 15135 mp3bufPos += ret; 15136 mp3size += ret; 15137 15138 /* shift out old samples */ 15139 gfc.mf_size -= gfp.framesize; 15140 gfc.mf_samples_to_encode -= gfp.framesize; 15141 for (ch = 0; ch < gfc.channels_out; ch++) 15142 for (i = 0; i < gfc.mf_size; i++) 15143 mfbuf[ch][i] = mfbuf[ch][i + gfp.framesize]; 15144 } 15145 } 15146 15147 return mp3size; 15148 } 15149 15150 function lame_encode_frame(gfp, inbuf_l, inbuf_r, mp3buf, mp3bufPos, mp3buf_size) { 15151 var ret = self.enc.lame_encode_mp3_frame(gfp, inbuf_l, inbuf_r, mp3buf, 15152 mp3bufPos, mp3buf_size); 15153 gfp.frameNum++; 15154 return ret; 15155 } 15156 15157 function InOut() { 15158 this.n_in = 0; 15159 this.n_out = 0; 15160 } 15161 15162 15163 function NumUsed() { 15164 this.num_used = 0; 15165 } 15166 15167 /** 15168 * Greatest common divisor. 15169 * <p> 15170 * Joint work of Euclid and M. Hendry 15171 */ 15172 function gcd(i, j) { 15173 return j != 0 ? gcd(j, i % j) : i; 15174 } 15175 15176 /** 15177 * Resampling via FIR filter, blackman window. 15178 */ 15179 function blackman(x, fcn, l) { 15180 /* 15181 * This algorithm from: SIGNAL PROCESSING ALGORITHMS IN FORTRAN AND C 15182 * S.D. Stearns and R.A. David, Prentice-Hall, 1992 15183 */ 15184 var wcn = (Math.PI * fcn); 15185 15186 x /= l; 15187 if (x < 0) 15188 x = 0; 15189 if (x > 1) 15190 x = 1; 15191 var x2 = x - .5; 15192 15193 var bkwn = 0.42 - 0.5 * Math.cos(2 * x * Math.PI) + 0.08 * Math.cos(4 * x * Math.PI); 15194 if (Math.abs(x2) < 1e-9) 15195 return (wcn / Math.PI); 15196 else 15197 return (bkwn * Math.sin(l * wcn * x2) / (Math.PI * l * x2)); 15198 } 15199 15200 function fill_buffer_resample(gfp, outbuf, outbufPos, desired_len, inbuf, in_bufferPos, len, num_used, ch) { 15201 var gfc = gfp.internal_flags; 15202 var i, j = 0, k; 15203 /* number of convolution functions to pre-compute */ 15204 var bpc = gfp.out_samplerate 15205 / gcd(gfp.out_samplerate, gfp.in_samplerate); 15206 if (bpc > LameInternalFlags.BPC) 15207 bpc = LameInternalFlags.BPC; 15208 15209 var intratio = (Math.abs(gfc.resample_ratio 15210 - Math.floor(.5 + gfc.resample_ratio)) < .0001) ? 1 : 0; 15211 var fcn = 1.00 / gfc.resample_ratio; 15212 if (fcn > 1.00) 15213 fcn = 1.00; 15214 var filter_l = 31; 15215 if (0 == filter_l % 2) 15216 --filter_l; 15217 /* must be odd */ 15218 filter_l += intratio; 15219 /* unless resample_ratio=int, it must be even */ 15220 15221 var BLACKSIZE = filter_l + 1; 15222 /* size of data needed for FIR */ 15223 15224 if (gfc.fill_buffer_resample_init == 0) { 15225 gfc.inbuf_old[0] = new_float(BLACKSIZE); 15226 gfc.inbuf_old[1] = new_float(BLACKSIZE); 15227 for (i = 0; i <= 2 * bpc; ++i) 15228 gfc.blackfilt[i] = new_float(BLACKSIZE); 15229 15230 gfc.itime[0] = 0; 15231 gfc.itime[1] = 0; 15232 15233 /* precompute blackman filter coefficients */ 15234 for (j = 0; j <= 2 * bpc; j++) { 15235 var sum = 0.; 15236 var offset = (j - bpc) / (2. * bpc); 15237 for (i = 0; i <= filter_l; i++) 15238 sum += gfc.blackfilt[j][i] = blackman(i - offset, fcn, 15239 filter_l); 15240 for (i = 0; i <= filter_l; i++) 15241 gfc.blackfilt[j][i] /= sum; 15242 } 15243 gfc.fill_buffer_resample_init = 1; 15244 } 15245 15246 var inbuf_old = gfc.inbuf_old[ch]; 15247 15248 /* time of j'th element in inbuf = itime + j/ifreq; */ 15249 /* time of k'th element in outbuf = j/ofreq */ 15250 for (k = 0; k < desired_len; k++) { 15251 var time0; 15252 var joff; 15253 15254 time0 = k * gfc.resample_ratio; 15255 /* time of k'th output sample */ 15256 j = 0 | Math.floor(time0 - gfc.itime[ch]); 15257 15258 /* check if we need more input data */ 15259 if ((filter_l + j - filter_l / 2) >= len) 15260 break; 15261 15262 /* blackman filter. by default, window centered at j+.5(filter_l%2) */ 15263 /* but we want a window centered at time0. */ 15264 var offset = (time0 - gfc.itime[ch] - (j + .5 * (filter_l % 2))); 15265 15266 /* find the closest precomputed window for this offset: */ 15267 joff = 0 | Math.floor((offset * 2 * bpc) + bpc + .5); 15268 var xvalue = 0.; 15269 for (i = 0; i <= filter_l; ++i) { 15270 /* force integer index */ 15271 var j2 = 0 | (i + j - filter_l / 2); 15272 var y; 15273 y = (j2 < 0) ? inbuf_old[BLACKSIZE + j2] : inbuf[in_bufferPos 15274 + j2]; 15275 xvalue += y * gfc.blackfilt[joff][i]; 15276 } 15277 outbuf[outbufPos + k] = xvalue; 15278 } 15279 15280 /* k = number of samples added to outbuf */ 15281 /* last k sample used data from [j-filter_l/2,j+filter_l-filter_l/2] */ 15282 15283 /* how many samples of input data were used: */ 15284 num_used.num_used = Math.min(len, filter_l + j - filter_l / 2); 15285 15286 /* 15287 * adjust our input time counter. Incriment by the number of samples 15288 * used, then normalize so that next output sample is at time 0, next 15289 * input buffer is at time itime[ch] 15290 */ 15291 gfc.itime[ch] += num_used.num_used - k * gfc.resample_ratio; 15292 15293 /* save the last BLACKSIZE samples into the inbuf_old buffer */ 15294 if (num_used.num_used >= BLACKSIZE) { 15295 for (i = 0; i < BLACKSIZE; i++) 15296 inbuf_old[i] = inbuf[in_bufferPos + num_used.num_used + i 15297 - BLACKSIZE]; 15298 } else { 15299 /* shift in num_used.num_used samples into inbuf_old */ 15300 var n_shift = BLACKSIZE - num_used.num_used; 15301 /* 15302 * number of samples to 15303 * shift 15304 */ 15305 15306 /* 15307 * shift n_shift samples by num_used.num_used, to make room for the 15308 * num_used new samples 15309 */ 15310 for (i = 0; i < n_shift; ++i) 15311 inbuf_old[i] = inbuf_old[i + num_used.num_used]; 15312 15313 /* shift in the num_used.num_used samples */ 15314 for (j = 0; i < BLACKSIZE; ++i, ++j) 15315 inbuf_old[i] = inbuf[in_bufferPos + j]; 15316 15317 } 15318 return k; 15319 /* return the number samples created at the new samplerate */ 15320 } 15321 15322 function fill_buffer(gfp, mfbuf, in_buffer, in_bufferPos, nsamples, io) { 15323 var gfc = gfp.internal_flags; 15324 15325 /* copy in new samples into mfbuf, with resampling if necessary */ 15326 if ((gfc.resample_ratio < .9999) || (gfc.resample_ratio > 1.0001)) { 15327 for (var ch = 0; ch < gfc.channels_out; ch++) { 15328 var numUsed = new NumUsed(); 15329 io.n_out = fill_buffer_resample(gfp, mfbuf[ch], gfc.mf_size, 15330 gfp.framesize, in_buffer[ch], in_bufferPos, nsamples, 15331 numUsed, ch); 15332 io.n_in = numUsed.num_used; 15333 } 15334 } else { 15335 io.n_out = Math.min(gfp.framesize, nsamples); 15336 io.n_in = io.n_out; 15337 for (var i = 0; i < io.n_out; ++i) { 15338 mfbuf[0][gfc.mf_size + i] = in_buffer[0][in_bufferPos + i]; 15339 if (gfc.channels_out == 2) 15340 mfbuf[1][gfc.mf_size + i] = in_buffer[1][in_bufferPos + i]; 15341 } 15342 } 15343 } 15344 15345} 15346 15347 15348 15349function GetAudio() { 15350 var parse; 15351 var mpg; 15352 15353 this.setModules = function (parse2, mpg2) { 15354 parse = parse2; 15355 mpg = mpg2; 15356 } 15357} 15358 15359 15360function Parse() { 15361 var ver; 15362 var id3; 15363 var pre; 15364 15365 this.setModules = function (ver2, id32, pre2) { 15366 ver = ver2; 15367 id3 = id32; 15368 pre = pre2; 15369 } 15370} 15371 15372function MPGLib() { 15373} 15374 15375function ID3Tag() { 15376 var bits; 15377 var ver; 15378 15379 this.setModules = function (_bits, _ver) { 15380 bits = _bits; 15381 ver = _ver; 15382 } 15383} 15384 15385function Mp3Encoder(channels, samplerate, kbps) { 15386 if (arguments.length != 3) { 15387 console.error('WARN: Mp3Encoder(channels, samplerate, kbps) not specified'); 15388 channels = 1; 15389 samplerate = 44100; 15390 kbps = 128; 15391 } 15392 var lame = new Lame(); 15393 var gaud = new GetAudio(); 15394 var ga = new GainAnalysis(); 15395 var bs = new BitStream(); 15396 var p = new Presets(); 15397 var qupvt = new QuantizePVT(); 15398 var qu = new Quantize(); 15399 var vbr = new VBRTag(); 15400 var ver = new Version(); 15401 var id3 = new ID3Tag(); 15402 var rv = new Reservoir(); 15403 var tak = new Takehiro(); 15404 var parse = new Parse(); 15405 var mpg = new MPGLib(); 15406 15407 lame.setModules(ga, bs, p, qupvt, qu, vbr, ver, id3, mpg); 15408 bs.setModules(ga, mpg, ver, vbr); 15409 id3.setModules(bs, ver); 15410 p.setModules(lame); 15411 qu.setModules(bs, rv, qupvt, tak); 15412 qupvt.setModules(tak, rv, lame.enc.psy); 15413 rv.setModules(bs); 15414 tak.setModules(qupvt); 15415 vbr.setModules(lame, bs, ver); 15416 gaud.setModules(parse, mpg); 15417 parse.setModules(ver, id3, p); 15418 15419 var gfp = lame.lame_init(); 15420 15421 gfp.num_channels = channels; 15422 gfp.in_samplerate = samplerate; 15423 gfp.brate = kbps; 15424 gfp.mode = MPEGMode.STEREO; 15425 gfp.quality = 3; 15426 gfp.bWriteVbrTag = false; 15427 gfp.disable_reservoir = true; 15428 gfp.write_id3tag_automatic = false; 15429 15430 var retcode = lame.lame_init_params(gfp); 15431 var maxSamples = 1152; 15432 var mp3buf_size = 0 | (1.25 * maxSamples + 7200); 15433 var mp3buf = new_byte(mp3buf_size); 15434 15435 this.encodeBuffer = function (left, right) { 15436 if (channels == 1) { 15437 right = left; 15438 } 15439 if (left.length > maxSamples) { 15440 maxSamples = left.length; 15441 mp3buf_size = 0 | (1.25 * maxSamples + 7200); 15442 mp3buf = new_byte(mp3buf_size); 15443 } 15444 15445 var _sz = lame.lame_encode_buffer(gfp, left, right, left.length, mp3buf, 0, mp3buf_size); 15446 return new Int8Array(mp3buf.subarray(0, _sz)); 15447 }; 15448 15449 this.flush = function () { 15450 var _sz = lame.lame_encode_flush(gfp, mp3buf, 0, mp3buf_size); 15451 return new Int8Array(mp3buf.subarray(0, _sz)); 15452 }; 15453} 15454 15455function WavHeader() { 15456 this.dataOffset = 0; 15457 this.dataLen = 0; 15458 this.channels = 0; 15459 this.sampleRate = 0; 15460} 15461 15462function fourccToInt(fourcc) { 15463 return fourcc.charCodeAt(0) << 24 | fourcc.charCodeAt(1) << 16 | fourcc.charCodeAt(2) << 8 | fourcc.charCodeAt(3); 15464} 15465 15466WavHeader.RIFF = fourccToInt("RIFF"); 15467WavHeader.WAVE = fourccToInt("WAVE"); 15468WavHeader.fmt_ = fourccToInt("fmt "); 15469WavHeader.data = fourccToInt("data"); 15470 15471WavHeader.readHeader = function (dataView) { 15472 var w = new WavHeader(); 15473 15474 var header = dataView.getUint32(0, false); 15475 if (WavHeader.RIFF != header) { 15476 return; 15477 } 15478 var fileLen = dataView.getUint32(4, true); 15479 if (WavHeader.WAVE != dataView.getUint32(8, false)) { 15480 return; 15481 } 15482 if (WavHeader.fmt_ != dataView.getUint32(12, false)) { 15483 return; 15484 } 15485 var fmtLen = dataView.getUint32(16, true); 15486 var pos = 16 + 4; 15487 switch (fmtLen) { 15488 case 16: 15489 case 18: 15490 w.channels = dataView.getUint16(pos + 2, true); 15491 w.sampleRate = dataView.getUint32(pos + 4, true); 15492 break; 15493 default: 15494 throw 'extended fmt chunk not implemented'; 15495 } 15496 pos += fmtLen; 15497 var data = WavHeader.data; 15498 var len = 0; 15499 while (data != header) { 15500 header = dataView.getUint32(pos, false); 15501 len = dataView.getUint32(pos + 4, true); 15502 if (data == header) { 15503 break; 15504 } 15505 pos += (len + 8); 15506 } 15507 w.dataLen = len; 15508 w.dataOffset = pos + 8; 15509 return w; 15510}; 15511 15512L3Side.SFBMAX = (Encoder.SBMAX_s * 3); 15513//testFullLength(); 15514lamejs.Mp3Encoder = Mp3Encoder; 15515lamejs.WavHeader = WavHeader; 15516} 15517//fs=require('fs'); 15518lamejs();
Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.