1 /* ResidualVM - A 3D game interpreter
2 *
3 * ResidualVM is the legal property of its developers, whose names
4 * are too numerous to list here. Please refer to the AUTHORS
5 * file distributed with this source distribution.
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version 2
10 * of the License, or (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
20 *
21 */
22
23 // Based on xoreos' WMA code which is in turn
24 // Largely based on the WMA implementation found in FFmpeg.
25
26 #include "common/util.h"
27 #include "common/math.h"
28 #include "common/sinewindows.h"
29 #include "common/error.h"
30 #include "common/memstream.h"
31 #include "common/mdct.h"
32 #include "common/huffman.h"
33
34 #include "audio/audiostream.h"
35
36 #include "audio/decoders/util.h"
37 #include "audio/decoders/raw.h"
38 #include "audio/decoders/wma.h"
39 #include "audio/decoders/wmadata.h"
40
41 namespace Audio {
42
butterflyFloats(float * v1,float * v2,int len)43 static inline void butterflyFloats(float *v1, float *v2, int len) {
44 while (len-- > 0) {
45 float t = *v1 - *v2;
46
47 *v1++ += *v2;
48 *v2++ = t;
49 }
50 }
51
vectorFMulAdd(float * dst,const float * src0,const float * src1,const float * src2,int len)52 static inline void vectorFMulAdd(float *dst, const float *src0,
53 const float *src1, const float *src2, int len) {
54 while (len-- > 0)
55 *dst++ = *src0++ * *src1++ + *src2++;
56 }
57
vectorFMulReverse(float * dst,const float * src0,const float * src1,int len)58 static inline void vectorFMulReverse(float *dst, const float *src0,
59 const float *src1, int len) {
60 src1 += len - 1;
61
62 while (len-- > 0)
63 *dst++ = *src0++ * *src1--;
64 }
65
66
WMACodec(int version,uint32 sampleRate,uint8 channels,uint32 bitRate,uint32 blockAlign,Common::SeekableReadStream * extraData)67 WMACodec::WMACodec(int version, uint32 sampleRate, uint8 channels,
68 uint32 bitRate, uint32 blockAlign, Common::SeekableReadStream *extraData) :
69 _version(version), _sampleRate(sampleRate), _channels(channels),
70 _bitRate(bitRate), _blockAlign(blockAlign), _audioFlags(0),
71 _resetBlockLengths(true), _curFrame(0), _frameLen(0), _frameLenBits(0),
72 _blockSizeCount(0), _framePos(0), _curBlock(0), _blockLen(0), _blockLenBits(0),
73 _nextBlockLenBits(0), _prevBlockLenBits(0), _byteOffsetBits(0),
74 _hgainHuffman(0), _expHuffman(0), _lastSuperframeLen(0), _lastBitoffset(0) {
75
76 for (int i = 0; i < 2; i++) {
77 _coefHuffman[i] = 0;
78
79 _coefHuffmanRunTable [i] = 0;
80 _coefHuffmanLevelTable[i] = 0;
81 _coefHuffmanIntTable [i] = 0;
82 }
83
84 if ((_version != 1) && (_version != 2))
85 error("WMACodec::init(): Unsupported WMA version %d", _version);
86
87 if ((_sampleRate == 0) || (_sampleRate > 50000))
88 error("WMACodec::init(): Invalid sample rate %d", _sampleRate);
89 if ((_channels == 0) || (_channels > kChannelsMax))
90 error("WMACodec::init(): Unsupported number of channels %d",
91 _channels);
92
93 _audioFlags = FLAG_16BITS;
94
95 #ifdef SCUMM_LITTLE_ENDIAN
96 _audioFlags |= FLAG_LITTLE_ENDIAN;
97 #endif
98
99 if (_channels == 2) {
100 _audioFlags |= FLAG_STEREO;
101 }
102
103 init(extraData);
104 }
105
~WMACodec()106 WMACodec::~WMACodec() {
107 delete _expHuffman;
108 delete _hgainHuffman;
109
110 for (int i = 0; i < 2; i++) {
111 delete[] _coefHuffmanRunTable [i];
112 delete[] _coefHuffmanLevelTable[i];
113 delete[] _coefHuffmanIntTable [i];
114
115 delete _coefHuffman[i];
116 }
117
118 for (Common::Array<Common::MDCT *>::iterator m = _mdct.begin(); m != _mdct.end(); ++m)
119 delete *m;
120 }
121
init(Common::SeekableReadStream * extraData)122 void WMACodec::init(Common::SeekableReadStream *extraData) {
123 // Flags
124 uint16 flags = getFlags(extraData);
125 evalFlags(flags, extraData);
126
127 // Frame length
128 _frameLenBits = getFrameBitLength();
129 _frameLen = 1 << _frameLenBits;
130
131 // Number of MDCT block sizes
132 _blockSizeCount = getBlockSizeCount(flags);
133
134 float bps = ((float) _bitRate) / ((float) (_channels * _sampleRate));
135
136 _byteOffsetBits = Common::intLog2((int) (bps * _frameLen / 8.0 + 0.05)) + 2;
137
138 // Compute high frequency value and choose if noise coding should be activated
139 float highFreq;
140 _useNoiseCoding = useNoiseCoding(highFreq, bps);
141
142 // Compute the scale factor band sizes for each MDCT block size
143 evalMDCTScales(highFreq);
144
145 // Init the noise generator
146 initNoise();
147
148 // Init the coefficient huffman codes
149 initCoefHuffman(bps);
150
151 // Init MDCTs
152 initMDCT();
153
154 // Init exponent codes
155 initExponents();
156
157 // Clear the sample output buffers
158 memset(_output , 0, sizeof(_output));
159 memset(_frameOut, 0, sizeof(_frameOut));
160 }
161
getFlags(Common::SeekableReadStream * extraData)162 uint16 WMACodec::getFlags(Common::SeekableReadStream *extraData) {
163 if ((_version == 1) && extraData && (extraData->size() >= 4)) {
164 extraData->seek(2);
165 return extraData->readUint16LE();
166 }
167
168 if ((_version == 2) && extraData && (extraData->size() >= 6)) {
169 extraData->seek(4);
170 return extraData->readUint16LE();
171 }
172
173 return 0;
174 }
175
evalFlags(uint16 flags,Common::SeekableReadStream * extraData)176 void WMACodec::evalFlags(uint16 flags, Common::SeekableReadStream *extraData) {
177 _useExpHuffman = (flags & 0x0001) != 0;
178 _useBitReservoir = (flags & 0x0002) != 0;
179 _useVariableBlockLen = (flags & 0x0004) != 0;
180
181 if ((_version == 2) && extraData && (extraData->size() >= 8)) {
182 extraData->seek(4);
183 if ((extraData->readUint16LE() == 0x000D) && _useVariableBlockLen) {
184 // Apparently, this fixes ffmpeg "issue1503"
185
186 _useVariableBlockLen = false;
187 }
188 }
189 }
190
getFrameBitLength()191 int WMACodec::getFrameBitLength() {
192 if (_sampleRate <= 16000)
193 return 9;
194
195 if ((_sampleRate <= 22050) || (_sampleRate <= 32000 && _version == 1))
196 return 10;
197
198 if (_sampleRate <= 48000)
199 return 11;
200
201 if (_sampleRate <= 96000)
202 return 12;
203
204 return 13;
205 }
206
getBlockSizeCount(uint16 flags)207 int WMACodec::getBlockSizeCount(uint16 flags) {
208 if (!_useVariableBlockLen)
209 return 1;
210
211 int count = ((flags >> 3) & 3) + 1;
212
213 if ((_bitRate / _channels) >= 32000)
214 count += 2;
215
216 const int maxCount = _frameLenBits - kBlockBitsMin;
217
218 return MIN(count, maxCount) + 1;
219 }
220
getNormalizedSampleRate()221 uint32 WMACodec::getNormalizedSampleRate() {
222 // Sample rates are only normalized in WMAv2
223 if (_version != 2)
224 return _sampleRate;
225
226 if (_sampleRate>= 44100)
227 return 44100;
228
229 if (_sampleRate >= 22050)
230 return 22050;
231
232 if (_sampleRate >= 16000)
233 return 16000;
234
235 if (_sampleRate >= 11025)
236 return 11025;
237
238 if (_sampleRate >= 8000)
239 return 8000;
240
241 return _sampleRate;
242 }
243
useNoiseCoding(float & highFreq,float & bps)244 bool WMACodec::useNoiseCoding(float &highFreq, float &bps) {
245 highFreq = _sampleRate * 0.5;
246
247 uint32 rateNormalized = getNormalizedSampleRate();
248
249 float bpsOrig = bps;
250 if (_channels == 2)
251 bps = bpsOrig * 1.6;
252
253 if (rateNormalized == 44100) {
254 if (bps >= 0.61)
255 return false;
256
257 highFreq = highFreq * 0.4;
258 return true;
259 }
260
261 if (rateNormalized == 22050) {
262 if (bps >= 1.16)
263 return false;
264
265 if (bps >= 0.72)
266 highFreq = highFreq * 0.7;
267 else
268 highFreq = highFreq * 0.6;
269
270 return true;
271 }
272
273 if (rateNormalized == 16000) {
274 if (bpsOrig > 0.5)
275 highFreq = highFreq * 0.5;
276 else
277 highFreq = highFreq * 0.3;
278
279 return true;
280 }
281
282 if (rateNormalized == 11025) {
283 highFreq = highFreq * 0.7;
284 return true;
285 }
286
287 if (rateNormalized == 8000) {
288 if (bpsOrig > 0.75)
289 return false;
290
291 if (bpsOrig <= 0.625)
292 highFreq = highFreq * 0.5;
293 else
294 highFreq = highFreq * 0.65;
295
296 return true;
297 }
298
299
300 if (bpsOrig >= 0.8)
301 highFreq = highFreq * 0.75;
302 else if (bpsOrig >= 0.6)
303 highFreq = highFreq * 0.6;
304 else
305 highFreq = highFreq * 0.5;
306
307 return true;
308 }
309
evalMDCTScales(float highFreq)310 void WMACodec::evalMDCTScales(float highFreq) {
311 if (_version == 1)
312 _coefsStart = 3;
313 else
314 _coefsStart = 0;
315
316 for (int k = 0; k < _blockSizeCount; k++) {
317 int blockLen = _frameLen >> k;
318
319 if (_version == 1) {
320 int i, lpos = 0;
321
322 for (i = 0; i < 25; i++) {
323 int a = wmaCriticalFreqs[i];
324 int b = _sampleRate;
325 int pos = ((blockLen * 2 * a) + (b >> 1)) / b;
326
327 if (pos > blockLen)
328 pos = blockLen;
329
330 _exponentBands[0][i] = pos - lpos;
331 if (pos >= blockLen) {
332 i++;
333 break;
334 }
335 lpos = pos;
336 }
337
338 _exponentSizes[0] = i;
339
340 } else {
341 // Hardcoded tables
342 const uint8 *table = 0;
343
344 int t = _frameLenBits - kBlockBitsMin - k;
345 if (t < 3) {
346 if (_sampleRate >= 44100)
347 table = exponentBand44100[t];
348 else if (_sampleRate >= 32000)
349 table = exponentBand32000[t];
350 else if (_sampleRate >= 22050)
351 table = exponentBand22050[t];
352 }
353
354 if (table) {
355 int n = *table++;
356
357 for (int i = 0; i < n; i++)
358 _exponentBands[k][i] = table[i];
359
360 _exponentSizes[k] = n;
361
362 } else {
363 int j = 0, lpos = 0;
364
365 for (int i = 0; i < 25; i++) {
366 int a = wmaCriticalFreqs[i];
367 int b = _sampleRate;
368 int pos = ((blockLen * 2 * a) + (b << 1)) / (4 * b);
369
370 pos <<= 2;
371 if (pos > blockLen)
372 pos = blockLen;
373
374 if (pos > lpos)
375 _exponentBands[k][j++] = pos - lpos;
376
377 if (pos >= blockLen)
378 break;
379
380 lpos = pos;
381 }
382
383 _exponentSizes[k] = j;
384 }
385
386 }
387
388 // Max number of coefs
389 _coefsEnd[k] = (_frameLen - ((_frameLen * 9) / 100)) >> k;
390
391 // High freq computation
392 _highBandStart[k] = (int)((blockLen * 2 * highFreq) / _sampleRate + 0.5);
393
394 int n = _exponentSizes[k];
395 int j = 0;
396 int pos = 0;
397
398 for (int i = 0; i < n; i++) {
399 int start, end;
400
401 start = pos;
402 pos += _exponentBands[k][i];
403 end = pos;
404
405 if (start < _highBandStart[k])
406 start = _highBandStart[k];
407
408 if (end > _coefsEnd[k])
409 end = _coefsEnd[k];
410
411 if (end > start)
412 _exponentHighBands[k][j++] = end - start;
413
414 }
415
416 _exponentHighSizes[k] = j;
417 }
418 }
419
initNoise()420 void WMACodec::initNoise() {
421 if (!_useNoiseCoding)
422 return;
423
424 _noiseMult = _useExpHuffman ? 0.02 : 0.04;
425 _noiseIndex = 0;
426
427 uint seed = 1;
428 float norm = (1.0 / (float)(1LL << 31)) * sqrt(3.0f) * _noiseMult;
429
430 for (int i = 0; i < kNoiseTabSize; i++) {
431 seed = seed * 314159 + 1;
432
433 _noiseTable[i] = (float)((int)seed) * norm;
434 }
435
436 _hgainHuffman = new Common::Huffman(0, ARRAYSIZE(hgainHuffCodes),
437 hgainHuffCodes, hgainHuffBits);
438 }
439
initCoefHuffman(float bps)440 void WMACodec::initCoefHuffman(float bps) {
441 // Choose the parameter table
442 int coefHuffTable = 2;
443 if (_sampleRate >= 32000) {
444 if (bps < 0.72) {
445 coefHuffTable = 0;
446 } else if (bps < 1.16) {
447 coefHuffTable = 1;
448 }
449 }
450
451 _coefHuffmanParam[0] = &coefHuffmanParam[coefHuffTable * 2 ];
452 _coefHuffmanParam[1] = &coefHuffmanParam[coefHuffTable * 2 + 1];
453
454 _coefHuffman[0] = initCoefHuffman(_coefHuffmanRunTable[0], _coefHuffmanLevelTable[0],
455 _coefHuffmanIntTable[0], *_coefHuffmanParam[0]);
456 _coefHuffman[1] = initCoefHuffman(_coefHuffmanRunTable[1], _coefHuffmanLevelTable[1],
457 _coefHuffmanIntTable[1], *_coefHuffmanParam[1]);
458 }
459
initMDCT()460 void WMACodec::initMDCT() {
461 _mdct.reserve(_blockSizeCount);
462 for (int i = 0; i < _blockSizeCount; i++)
463 _mdct.push_back(new Common::MDCT(_frameLenBits - i + 1, true, 1.0));
464
465 // Init MDCT windows (simple sine window)
466 _mdctWindow.reserve(_blockSizeCount);
467 for (int i = 0; i < _blockSizeCount; i++)
468 _mdctWindow.push_back(Common::getSineWindow(_frameLenBits - i));
469 }
470
initExponents()471 void WMACodec::initExponents() {
472 if (_useExpHuffman)
473 _expHuffman = new Common::Huffman(0, ARRAYSIZE(scaleHuffCodes),
474 scaleHuffCodes, scaleHuffBits);
475 else
476 initLSPToCurve();
477 }
478
initCoefHuffman(uint16 * & runTable,float * & levelTable,uint16 * & intTable,const WMACoefHuffmanParam & params)479 Common::Huffman *WMACodec::initCoefHuffman(uint16 *&runTable, float *&levelTable,
480 uint16 *&intTable, const WMACoefHuffmanParam ¶ms) {
481
482 Common::Huffman *huffman =
483 new Common::Huffman(0, params.n, params.huffCodes, params.huffBits);
484
485 runTable = new uint16[params.n];
486 levelTable = new float[params.n];
487 intTable = new uint16[params.n];
488
489 uint16 *iLevelTable = new uint16[params.n];
490
491 int i = 2;
492 int level = 1;
493 int k = 0;
494
495 while (i < params.n) {
496 intTable[k] = i;
497
498 int l = params.levels[k++];
499
500 for (int j = 0; j < l; j++) {
501 runTable [i] = j;
502 iLevelTable[i] = level;
503 levelTable [i] = level;
504
505 i++;
506 }
507
508 level++;
509 }
510
511 delete[] iLevelTable;
512
513 return huffman;
514 }
515
initLSPToCurve()516 void WMACodec::initLSPToCurve() {
517 float wdel = M_PI / _frameLen;
518
519 for (int i = 0; i < _frameLen; i++)
520 _lspCosTable[i] = 2.0f * cosf(wdel * i);
521
522 // Tables for x^-0.25 computation
523 for (int i = 0; i < 256; i++) {
524 int e = i - 126;
525
526 _lspPowETable[i] = powf(2.0, e * -0.25);
527 }
528
529 // NOTE: These two tables are needed to avoid two operations in pow_m1_4
530 float b = 1.0;
531 for (int i = (1 << kLSPPowBits) - 1; i >= 0; i--) {
532 int m = (1 << kLSPPowBits) + i;
533 float a = (float) m * (0.5 / (1 << kLSPPowBits));
534
535 a = pow(a, -0.25f);
536
537 _lspPowMTable1[i] = 2 * a - b;
538 _lspPowMTable2[i] = b - a;
539
540 b = a;
541 }
542 }
543
decodeFrame(Common::SeekableReadStream & data)544 AudioStream *WMACodec::decodeFrame(Common::SeekableReadStream &data) {
545 Common::SeekableReadStream *stream = decodeSuperFrame(data);
546 if (!stream)
547 return 0;
548
549 return makeRawStream(stream, _sampleRate, _audioFlags, DisposeAfterUse::YES);
550 }
551
decodeSuperFrame(Common::SeekableReadStream & data)552 Common::SeekableReadStream *WMACodec::decodeSuperFrame(Common::SeekableReadStream &data) {
553 uint32 size = data.size();
554 if (size < _blockAlign) {
555 warning("WMACodec::decodeSuperFrame(): size < _blockAlign");
556 return 0;
557 }
558
559 if (_blockAlign)
560 size = _blockAlign;
561
562 Common::BitStream8MSB bits(data);
563
564 int outputDataSize = 0;
565 int16 *outputData = 0;
566
567 _curFrame = 0;
568
569 if (_useBitReservoir) {
570 // This superframe consists of more than just one frame
571
572 bits.skip(4); // Super frame index
573
574 // Number of frames in this superframe
575 int newFrameCount = bits.getBits(4) - 1;
576 if (newFrameCount < 0) {
577 warning("WMACodec::decodeSuperFrame(): newFrameCount == %d", newFrameCount);
578
579 _resetBlockLengths = true;
580 _lastSuperframeLen = 0;
581 _lastBitoffset = 0;
582
583 return 0;
584 }
585
586 // Number of frames in this superframe + overhang from the last superframe
587 int frameCount = newFrameCount;
588 if (_lastSuperframeLen > 0)
589 frameCount++;
590
591 // PCM output data
592 outputDataSize = frameCount * _channels * _frameLen;
593 outputData = new int16[outputDataSize];
594
595 memset(outputData, 0, outputDataSize * 2);
596
597 // Number of bits data that completes the last superframe's overhang.
598 int bitOffset = bits.getBits(_byteOffsetBits + 3);
599
600 if (_lastSuperframeLen > 0) {
601 // We have overhang data from the last superframe. Paste the
602 // complementary data from this superframe at the end and
603 // decode it as another frame.
604
605 byte *lastSuperframeEnd = _lastSuperframe + _lastSuperframeLen;
606
607 while (bitOffset > 7) { // Full bytes
608 *lastSuperframeEnd++ = bits.getBits(8);
609
610 bitOffset -= 8;
611 _lastSuperframeLen += 1;
612 }
613
614 if (bitOffset > 0) { // Remaining bits
615 *lastSuperframeEnd++ = bits.getBits(bitOffset) << (8 - bitOffset);
616
617 bitOffset = 0;
618 _lastSuperframeLen += 1;
619 }
620
621 Common::MemoryReadStream lastSuperframe(_lastSuperframe, _lastSuperframeLen);
622 Common::BitStream8MSB lastBits(lastSuperframe);
623
624 lastBits.skip(_lastBitoffset);
625
626 decodeFrame(lastBits, outputData);
627
628 _curFrame++;
629 }
630
631 // Skip any complementary data we haven't used
632 bits.skip(bitOffset);
633
634 // New superframe = New block lengths
635 _resetBlockLengths = true;
636
637 // Decode the frames
638 for (int i = 0; i < newFrameCount; i++, _curFrame++)
639 if (!decodeFrame(bits, outputData))
640 return 0;
641
642 // Check if we've got new overhang data
643 int remainingBits = bits.size() - bits.pos();
644 if (remainingBits > 0) {
645 // We do: Save it
646
647 _lastSuperframeLen = remainingBits >> 3;
648 _lastBitoffset = 8 - (remainingBits - (_lastSuperframeLen << 3));
649
650 if (_lastBitoffset > 0)
651 _lastSuperframeLen++;
652
653 data.seek(data.size() - _lastSuperframeLen);
654 data.read(_lastSuperframe, _lastSuperframeLen);
655 } else {
656 // We don't
657
658 _lastSuperframeLen = 0;
659 _lastBitoffset = 0;
660 }
661
662 } else {
663 // This superframe has only one frame
664
665 // PCM output data
666 outputDataSize = _channels * _frameLen;
667 outputData = new int16[outputDataSize];
668
669 memset(outputData, 0, outputDataSize * 2);
670
671 // Decode the frame
672 if (!decodeFrame(bits, outputData)) {
673 delete[] outputData;
674 return 0;
675 }
676 }
677
678 // And return our PCM output data as a stream, if available
679
680 if (!outputData)
681 return 0;
682
683 return new Common::MemoryReadStream((byte *) outputData, outputDataSize * 2, DisposeAfterUse::YES);
684 }
685
decodeFrame(Common::BitStream8MSB & bits,int16 * outputData)686 bool WMACodec::decodeFrame(Common::BitStream8MSB &bits, int16 *outputData) {
687 _framePos = 0;
688 _curBlock = 0;
689
690 // Decode all blocks
691 int finished = 0;
692 while (finished == 0)
693 finished = decodeBlock(bits);
694
695 // Check for error
696 if (finished < 0)
697 return false;
698
699 // Convert output into interleaved PCM data
700
701 const float *floatOut[kChannelsMax];
702 for (int i = 0; i < kChannelsMax; i++)
703 floatOut[i] = _frameOut[i];
704
705 int16 *pcmOut = outputData + _curFrame * _channels * _frameLen;
706
707 floatToInt16Interleave(pcmOut, floatOut, _frameLen, _channels);
708
709 // Prepare for the next frame
710 for (int i = 0; i < _channels; i++)
711 memmove(&_frameOut[i][0], &_frameOut[i][_frameLen], _frameLen * sizeof(float));
712
713 return true;
714 }
715
decodeBlock(Common::BitStream8MSB & bits)716 int WMACodec::decodeBlock(Common::BitStream8MSB &bits) {
717 // Computer new block length
718 if (!evalBlockLength(bits))
719 return -1;
720
721 // Block size
722
723 int bSize = _frameLenBits - _blockLenBits;
724 assert((bSize >= 0) && (bSize < _blockSizeCount));
725
726 // MS Stereo?
727
728 bool msStereo = false;
729 if (_channels == 2)
730 msStereo = bits.getBit();
731
732 // Which channels are encoded?
733
734 bool hasChannels = false;
735 bool hasChannel[kChannelsMax];
736 for (int i = 0; i < kChannelsMax; i++)
737 hasChannel[i] = false;
738
739 for (int i = 0; i < _channels; i++) {
740 hasChannel[i] = bits.getBit();
741 if (hasChannel[i])
742 hasChannels = true;
743 }
744
745 // Decode channels
746
747 if (hasChannels)
748 if (!decodeChannels(bits, bSize, msStereo, hasChannel))
749 return -1;
750
751 // Calculate IMDCTs
752
753 if (!calculateIMDCT(bSize, msStereo, hasChannel))
754 return -1;
755
756 // Update block number
757
758 _curBlock += 1;
759 _framePos += _blockLen;
760
761 // Finished
762 if (_framePos >= _frameLen)
763 return 1;
764
765 // Need more blocks
766 return 0;
767 }
768
decodeChannels(Common::BitStream8MSB & bits,int bSize,bool msStereo,bool * hasChannel)769 bool WMACodec::decodeChannels(Common::BitStream8MSB &bits, int bSize,
770 bool msStereo, bool *hasChannel) {
771
772 int totalGain = readTotalGain(bits);
773 int coefBitCount = totalGainToBits(totalGain);
774
775 int coefCount[kChannelsMax];
776 calculateCoefCount(coefCount, bSize);
777
778 if (!decodeNoise(bits, bSize, hasChannel, coefCount))
779 return false;
780
781 if (!decodeExponents(bits, bSize, hasChannel))
782 return false;
783
784 if (!decodeSpectralCoef(bits, msStereo, hasChannel, coefCount, coefBitCount))
785 return false;
786
787 float mdctNorm = getNormalizedMDCTLength();
788
789 calculateMDCTCoefficients(bSize, hasChannel, coefCount, totalGain, mdctNorm);
790
791 if (msStereo && hasChannel[1]) {
792 // Nominal case for ms stereo: we do it before MDCT
793 // No need to optimize this case because it should almost never happen
794
795 if (!hasChannel[0]) {
796 memset(_coefs[0], 0, sizeof(float) * _blockLen);
797 hasChannel[0] = true;
798 }
799
800 butterflyFloats(_coefs[0], _coefs[1], _blockLen);
801 }
802
803 return true;
804 }
805
calculateIMDCT(int bSize,bool msStereo,bool * hasChannel)806 bool WMACodec::calculateIMDCT(int bSize, bool msStereo, bool *hasChannel) {
807 Common::MDCT &mdct = *_mdct[bSize];
808
809 for (int i = 0; i < _channels; i++) {
810 int n4 = _blockLen / 2;
811
812 if (hasChannel[i])
813 mdct.calcIMDCT(_output, _coefs[i]);
814 else if (!(msStereo && (i == 1)))
815 memset(_output, 0, sizeof(_output));
816
817 // Multiply by the window and add in the frame
818 int index = (_frameLen / 2) + _framePos - n4;
819 window(&_frameOut[i][index]);
820 }
821
822 return true;
823 }
824
evalBlockLength(Common::BitStream8MSB & bits)825 bool WMACodec::evalBlockLength(Common::BitStream8MSB &bits) {
826 if (_useVariableBlockLen) {
827 // Variable block lengths
828
829 int n = Common::intLog2(_blockSizeCount - 1) + 1;
830
831 if (_resetBlockLengths) {
832 // Completely new block lengths
833
834 _resetBlockLengths = false;
835
836 const int prev = bits.getBits(n);
837 const int prevBits = _frameLenBits - prev;
838 if (prev >= _blockSizeCount) {
839 warning("WMACodec::evalBlockLength(): _prevBlockLenBits %d out of range", prevBits);
840 return false;
841 }
842
843 _prevBlockLenBits = prevBits;
844
845 const int cur = bits.getBits(n);
846 const int curBits = _frameLenBits - cur;
847 if (cur >= _blockSizeCount) {
848 warning("WMACodec::evalBlockLength(): _blockLenBits %d out of range", curBits);
849 return false;
850 }
851
852 _blockLenBits = curBits;
853
854 } else {
855 // Update block lengths
856
857 _prevBlockLenBits = _blockLenBits;
858 _blockLenBits = _nextBlockLenBits;
859 }
860
861 const int next = bits.getBits(n);
862 const int nextBits = _frameLenBits - next;
863 if (next >= _blockSizeCount) {
864 warning("WMACodec::evalBlockLength(): _nextBlockLenBits %d out of range", nextBits);
865 return false;
866 }
867
868 _nextBlockLenBits = nextBits;
869
870 } else {
871 // Fixed block length
872
873 _nextBlockLenBits = _frameLenBits;
874 _prevBlockLenBits = _frameLenBits;
875 _blockLenBits = _frameLenBits;
876 }
877
878 // Sanity checks
879
880 if (_frameLenBits - _blockLenBits >= _blockSizeCount) {
881 warning("WMACodec::evalBlockLength(): _blockLenBits not initialized to a valid value");
882 return false;
883 }
884
885 _blockLen = 1 << _blockLenBits;
886 if ((_framePos + _blockLen) > _frameLen) {
887 warning("WMACodec::evalBlockLength(): frame length overflow");
888 return false;
889 }
890
891 return true;
892 }
893
calculateCoefCount(int * coefCount,int bSize) const894 void WMACodec::calculateCoefCount(int *coefCount, int bSize) const {
895 const int coefN = _coefsEnd[bSize] - _coefsStart;
896
897 for (int i = 0; i < _channels; i++)
898 coefCount[i] = coefN;
899 }
900
decodeNoise(Common::BitStream8MSB & bits,int bSize,bool * hasChannel,int * coefCount)901 bool WMACodec::decodeNoise(Common::BitStream8MSB &bits, int bSize,
902 bool *hasChannel, int *coefCount) {
903 if (!_useNoiseCoding)
904 return true;
905
906 for (int i = 0; i < _channels; i++) {
907 if (!hasChannel[i])
908 continue;
909
910 const int n = _exponentHighSizes[bSize];
911 for (int j = 0; j < n; j++) {
912 bool a = bits.getBit() != 0;
913 _highBandCoded[i][j] = a;
914
915 // With noise coding, the coefficients are not transmitted
916 if (a)
917 coefCount[i] -= _exponentHighBands[bSize][j];
918 }
919 }
920
921 for (int i = 0; i < _channels; i++) {
922 if (!hasChannel[i])
923 continue;
924
925 const int n = _exponentHighSizes[bSize];
926 int val = (int) 0x80000000;
927
928 for (int j = 0; j < n; j++) {
929 if (!_highBandCoded[i][j])
930 continue;
931
932 if (val != (int) 0x80000000) {
933 int code = _hgainHuffman->getSymbol(bits);
934 if (code < 0) {
935 warning("WMACodec::decodeNoise(): HGain Huffman invalid");
936 return false;
937 }
938
939 val += code - 18;
940
941 } else
942 val = bits.getBits(7) - 19;
943
944 _highBandValues[i][j] = val;
945
946 }
947 }
948
949 return true;
950 }
951
decodeExponents(Common::BitStream8MSB & bits,int bSize,bool * hasChannel)952 bool WMACodec::decodeExponents(Common::BitStream8MSB &bits, int bSize, bool *hasChannel) {
953 // Exponents can be reused in short blocks
954 if (!((_blockLenBits == _frameLenBits) || bits.getBit()))
955 return true;
956
957 for (int i = 0; i < _channels; i++) {
958 if (!hasChannel[i])
959 continue;
960
961 if (_useExpHuffman) {
962 if (!decodeExpHuffman(bits, i))
963 return false;
964 } else {
965 if (!decodeExpLSP(bits, i))
966 return false;
967 }
968
969 _exponentsBSize[i] = bSize;
970 }
971
972 return true;
973 }
974
decodeSpectralCoef(Common::BitStream8MSB & bits,bool msStereo,bool * hasChannel,int * coefCount,int coefBitCount)975 bool WMACodec::decodeSpectralCoef(Common::BitStream8MSB &bits, bool msStereo, bool *hasChannel,
976 int *coefCount, int coefBitCount) {
977 // Simple RLE encoding
978
979 for (int i = 0; i < _channels; i++) {
980 if (hasChannel[i]) {
981 // Special Huffman tables are used for MS stereo
982 // because there is potentially less energy there.
983 const int tindex = ((i == 1) && msStereo);
984
985 float *ptr = &_coefs1[i][0];
986 memset(ptr, 0, _blockLen * sizeof(float));
987
988 if (!decodeRunLevel(bits, *_coefHuffman[tindex],
989 _coefHuffmanLevelTable[tindex], _coefHuffmanRunTable[tindex],
990 0, ptr, 0, coefCount[i], _blockLen, _frameLenBits, coefBitCount))
991 return false;
992 }
993
994 if ((_version == 1) && (_channels >= 2))
995 bits.skip(-bits.pos() & 7);
996 }
997
998 return true;
999 }
1000
getNormalizedMDCTLength() const1001 float WMACodec::getNormalizedMDCTLength() const {
1002 const int n4 = _blockLen / 2;
1003
1004 float mdctNorm = 1.0 / (float) n4;
1005 if (_version == 1)
1006 mdctNorm *= sqrt((float) n4);
1007
1008 return mdctNorm;
1009 }
1010
calculateMDCTCoefficients(int bSize,bool * hasChannel,int * coefCount,int totalGain,float mdctNorm)1011 void WMACodec::calculateMDCTCoefficients(int bSize, bool *hasChannel,
1012 int *coefCount, int totalGain, float mdctNorm) {
1013
1014 for (int i = 0; i < _channels; i++) {
1015 if (!hasChannel[i])
1016 continue;
1017
1018 float *coefs = _coefs[i];
1019 const float *coefs1 = _coefs1[i];
1020 const float *exponents = _exponents[i];
1021
1022 const int eSize = _exponentsBSize[i];
1023
1024 const float mult = (pow(10, totalGain * 0.05) / _maxExponent[i]) * mdctNorm;
1025
1026 if (_useNoiseCoding) {
1027
1028 // Very low freqs: noise
1029 for (int j = 0; j < _coefsStart; j++) {
1030 *coefs++ = _noiseTable[_noiseIndex] * exponents[(j << bSize) >> eSize] * mult;
1031
1032 _noiseIndex = (_noiseIndex + 1) & (kNoiseTabSize - 1);
1033 }
1034
1035 // Compute power of high bands
1036 float expPower[kHighBandSizeMax];
1037
1038 const int n1 = _exponentHighSizes[bSize];
1039 exponents = _exponents[i] + ((_highBandStart[bSize] << bSize) >> eSize);
1040
1041 int lastHighBand = 0;
1042 for (int k = 0; k < n1; k++) {
1043 const int n = _exponentHighBands[_frameLenBits - _blockLenBits][k];
1044
1045 if (_highBandCoded[i][k]) {
1046 float e2 = 0;
1047
1048 for (int j = 0; j < n; j++) {
1049 const float v = exponents[(j << bSize) >> eSize];
1050
1051 e2 += v * v;
1052 }
1053
1054 expPower[k] = e2 / n;
1055 lastHighBand = k;
1056 }
1057
1058 exponents += (n << bSize) >> eSize;
1059 }
1060
1061 // Main freqs and high freqs
1062 exponents = _exponents[i] + ((_coefsStart << bSize) >> eSize);
1063
1064 for (int k = -1; k < n1; k++) {
1065
1066 int n;
1067 if (k < 0)
1068 n = _highBandStart[bSize] - _coefsStart;
1069 else
1070 n = _exponentHighBands[_frameLenBits - _blockLenBits][k];
1071
1072 if (k >= 0 && _highBandCoded[i][k]) {
1073 // Use noise with specified power
1074
1075 float mult1 = sqrt(expPower[k] / expPower[lastHighBand]);
1076
1077 mult1 *= pow(10, _highBandValues[i][k] * 0.05);
1078 mult1 /= _maxExponent[i] * _noiseMult;
1079 mult1 *= mdctNorm;
1080
1081 for (int j = 0; j < n; j++) {
1082 float noise = _noiseTable[_noiseIndex];
1083
1084 _noiseIndex = (_noiseIndex + 1) & (kNoiseTabSize - 1);
1085 *coefs++ = noise * exponents[(j << bSize) >> eSize] * mult1;
1086 }
1087
1088 exponents += (n << bSize) >> eSize;
1089
1090 } else {
1091 // Coded values + small noise
1092
1093 for (int j = 0; j < n; j++) {
1094 float noise = _noiseTable[_noiseIndex];
1095
1096 _noiseIndex = (_noiseIndex + 1) & (kNoiseTabSize - 1);
1097 *coefs++ = ((*coefs1++) + noise) * exponents[(j << bSize) >> eSize] * mult;
1098 }
1099
1100 exponents += (n << bSize) >> eSize;
1101 }
1102
1103 }
1104
1105 // Very high freqs: Noise
1106 const int n = _blockLen - _coefsEnd[bSize];
1107 const float mult1 = mult * exponents[(-(1 << bSize)) >> eSize];
1108
1109 for (int j = 0; j < n; j++) {
1110 *coefs++ = _noiseTable[_noiseIndex] * mult1;
1111 _noiseIndex = (_noiseIndex + 1) & (kNoiseTabSize - 1);
1112 }
1113
1114 } else {
1115
1116 for (int j = 0; j < _coefsStart; j++)
1117 *coefs++ = 0.0;
1118
1119 for (int j = 0;j < coefCount[i]; j++) {
1120 *coefs = coefs1[j] * exponents[(j << bSize) >> eSize] * mult;
1121 coefs++;
1122 }
1123
1124 int n = _blockLen - _coefsEnd[bSize];
1125 for (int j = 0; j < n; j++)
1126 *coefs++ = 0.0;
1127
1128 }
1129
1130 }
1131
1132 }
1133
1134 static const float powTab[] = {
1135 1.7782794100389e-04, 2.0535250264571e-04,
1136 2.3713737056617e-04, 2.7384196342644e-04,
1137 3.1622776601684e-04, 3.6517412725484e-04,
1138 4.2169650342858e-04, 4.8696752516586e-04,
1139 5.6234132519035e-04, 6.4938163157621e-04,
1140 7.4989420933246e-04, 8.6596432336006e-04,
1141 1.0000000000000e-03, 1.1547819846895e-03,
1142 1.3335214321633e-03, 1.5399265260595e-03,
1143 1.7782794100389e-03, 2.0535250264571e-03,
1144 2.3713737056617e-03, 2.7384196342644e-03,
1145 3.1622776601684e-03, 3.6517412725484e-03,
1146 4.2169650342858e-03, 4.8696752516586e-03,
1147 5.6234132519035e-03, 6.4938163157621e-03,
1148 7.4989420933246e-03, 8.6596432336006e-03,
1149 1.0000000000000e-02, 1.1547819846895e-02,
1150 1.3335214321633e-02, 1.5399265260595e-02,
1151 1.7782794100389e-02, 2.0535250264571e-02,
1152 2.3713737056617e-02, 2.7384196342644e-02,
1153 3.1622776601684e-02, 3.6517412725484e-02,
1154 4.2169650342858e-02, 4.8696752516586e-02,
1155 5.6234132519035e-02, 6.4938163157621e-02,
1156 7.4989420933246e-02, 8.6596432336007e-02,
1157 1.0000000000000e-01, 1.1547819846895e-01,
1158 1.3335214321633e-01, 1.5399265260595e-01,
1159 1.7782794100389e-01, 2.0535250264571e-01,
1160 2.3713737056617e-01, 2.7384196342644e-01,
1161 3.1622776601684e-01, 3.6517412725484e-01,
1162 4.2169650342858e-01, 4.8696752516586e-01,
1163 5.6234132519035e-01, 6.4938163157621e-01,
1164 7.4989420933246e-01, 8.6596432336007e-01,
1165 1.0000000000000e+00, 1.1547819846895e+00,
1166 1.3335214321633e+00, 1.5399265260595e+00,
1167 1.7782794100389e+00, 2.0535250264571e+00,
1168 2.3713737056617e+00, 2.7384196342644e+00,
1169 3.1622776601684e+00, 3.6517412725484e+00,
1170 4.2169650342858e+00, 4.8696752516586e+00,
1171 5.6234132519035e+00, 6.4938163157621e+00,
1172 7.4989420933246e+00, 8.6596432336007e+00,
1173 1.0000000000000e+01, 1.1547819846895e+01,
1174 1.3335214321633e+01, 1.5399265260595e+01,
1175 1.7782794100389e+01, 2.0535250264571e+01,
1176 2.3713737056617e+01, 2.7384196342644e+01,
1177 3.1622776601684e+01, 3.6517412725484e+01,
1178 4.2169650342858e+01, 4.8696752516586e+01,
1179 5.6234132519035e+01, 6.4938163157621e+01,
1180 7.4989420933246e+01, 8.6596432336007e+01,
1181 1.0000000000000e+02, 1.1547819846895e+02,
1182 1.3335214321633e+02, 1.5399265260595e+02,
1183 1.7782794100389e+02, 2.0535250264571e+02,
1184 2.3713737056617e+02, 2.7384196342644e+02,
1185 3.1622776601684e+02, 3.6517412725484e+02,
1186 4.2169650342858e+02, 4.8696752516586e+02,
1187 5.6234132519035e+02, 6.4938163157621e+02,
1188 7.4989420933246e+02, 8.6596432336007e+02,
1189 1.0000000000000e+03, 1.1547819846895e+03,
1190 1.3335214321633e+03, 1.5399265260595e+03,
1191 1.7782794100389e+03, 2.0535250264571e+03,
1192 2.3713737056617e+03, 2.7384196342644e+03,
1193 3.1622776601684e+03, 3.6517412725484e+03,
1194 4.2169650342858e+03, 4.8696752516586e+03,
1195 5.6234132519035e+03, 6.4938163157621e+03,
1196 7.4989420933246e+03, 8.6596432336007e+03,
1197 1.0000000000000e+04, 1.1547819846895e+04,
1198 1.3335214321633e+04, 1.5399265260595e+04,
1199 1.7782794100389e+04, 2.0535250264571e+04,
1200 2.3713737056617e+04, 2.7384196342644e+04,
1201 3.1622776601684e+04, 3.6517412725484e+04,
1202 4.2169650342858e+04, 4.8696752516586e+04,
1203 5.6234132519035e+04, 6.4938163157621e+04,
1204 7.4989420933246e+04, 8.6596432336007e+04,
1205 1.0000000000000e+05, 1.1547819846895e+05,
1206 1.3335214321633e+05, 1.5399265260595e+05,
1207 1.7782794100389e+05, 2.0535250264571e+05,
1208 2.3713737056617e+05, 2.7384196342644e+05,
1209 3.1622776601684e+05, 3.6517412725484e+05,
1210 4.2169650342858e+05, 4.8696752516586e+05,
1211 5.6234132519035e+05, 6.4938163157621e+05,
1212 7.4989420933246e+05, 8.6596432336007e+05,
1213 };
1214
decodeExpHuffman(Common::BitStream8MSB & bits,int ch)1215 bool WMACodec::decodeExpHuffman(Common::BitStream8MSB &bits, int ch) {
1216 const float *ptab = powTab + 60;
1217 const uint32 *iptab = (const uint32 *) ptab;
1218
1219 const uint16 *ptr = _exponentBands[_frameLenBits - _blockLenBits];
1220
1221 uint32 *q = (uint32 *) _exponents[ch];
1222 uint32 *qEnd = q + _blockLen;
1223
1224 float maxScale = 0;
1225
1226 int lastExp;
1227 if (_version == 1) {
1228
1229 lastExp = bits.getBits(5) + 10;
1230
1231 float v = ptab[lastExp];
1232 uint32 iv = iptab[lastExp];
1233
1234 maxScale = v;
1235
1236 int n = *ptr++;
1237
1238 switch (n & 3) do {
1239 case 0: *q++ = iv; // fall through
1240 case 3: *q++ = iv; // fall through
1241 case 2: *q++ = iv; // fall through
1242 case 1: *q++ = iv;
1243 } while ((n -= 4) > 0);
1244
1245 } else
1246 lastExp = 36;
1247
1248 while (q < qEnd) {
1249 int code = _expHuffman->getSymbol(bits);
1250 if (code < 0) {
1251 warning("WMACodec::decodeExpHuffman(): Exponent invalid");
1252 return false;
1253 }
1254
1255 // NOTE: This offset is the same as MPEG4 AAC!
1256 lastExp += code - 60;
1257 if ((unsigned) lastExp + 60 >= ARRAYSIZE(powTab)) {
1258 warning("WMACodec::decodeExpHuffman(): Exponent out of range: %d", lastExp);
1259 return false;
1260 }
1261
1262 float v = ptab[lastExp];
1263 uint32 iv = iptab[lastExp];
1264
1265 if (v > maxScale)
1266 maxScale = v;
1267
1268 int n = *ptr++;
1269
1270 switch (n & 3) do {
1271 case 0: *q++ = iv; // fall through
1272 case 3: *q++ = iv; // fall through
1273 case 2: *q++ = iv; // fall through
1274 case 1: *q++ = iv;
1275 } while ((n -= 4) > 0);
1276
1277 }
1278
1279 _maxExponent[ch] = maxScale;
1280
1281 return true;
1282 }
1283
lspToCurve(float * out,float * val_max_ptr,int n,float * lsp)1284 void WMACodec::lspToCurve(float *out, float *val_max_ptr, int n, float *lsp) {
1285 float val_max = 0;
1286
1287 for (int i = 0; i < n; i++) {
1288 float p = 0.5f;
1289 float q = 0.5f;
1290 float w = _lspCosTable[i];
1291
1292 for (int j = 1; j < kLSPCoefCount; j += 2) {
1293 q *= w - lsp[j - 1];
1294 p *= w - lsp[j];
1295 }
1296
1297 p *= p * (2.0f - w);
1298 q *= q * (2.0f + w);
1299
1300 float v = p + q;
1301 v = pow_m1_4(v);
1302
1303 if (v > val_max)
1304 val_max = v;
1305
1306 out[i] = v;
1307 }
1308
1309 *val_max_ptr = val_max;
1310 }
1311
1312 // Decode exponents coded with LSP coefficients (same idea as Vorbis)
decodeExpLSP(Common::BitStream8MSB & bits,int ch)1313 bool WMACodec::decodeExpLSP(Common::BitStream8MSB &bits, int ch) {
1314 float lspCoefs[kLSPCoefCount];
1315
1316 for (int i = 0; i < kLSPCoefCount; i++) {
1317 int val;
1318
1319 if (i == 0 || i >= 8)
1320 val = bits.getBits(3);
1321 else
1322 val = bits.getBits(4);
1323
1324 lspCoefs[i] = lspCodebook[i][val];
1325 }
1326
1327 lspToCurve(_exponents[ch], &_maxExponent[ch], _blockLen, lspCoefs);
1328 return true;
1329 }
1330
decodeRunLevel(Common::BitStream8MSB & bits,const Common::Huffman & huffman,const float * levelTable,const uint16 * runTable,int version,float * ptr,int offset,int numCoefs,int blockLen,int frameLenBits,int coefNbBits)1331 bool WMACodec::decodeRunLevel(Common::BitStream8MSB &bits, const Common::Huffman &huffman,
1332 const float *levelTable, const uint16 *runTable, int version, float *ptr,
1333 int offset, int numCoefs, int blockLen, int frameLenBits, int coefNbBits) {
1334
1335 const uint32 *ilvl = (const uint32*) levelTable;
1336 uint32 *iptr = (uint32 *) ptr;
1337
1338 const unsigned int coefMask = blockLen - 1;
1339
1340 for (; offset < numCoefs; offset++) {
1341 const int code = huffman.getSymbol(bits);
1342
1343 if (code > 1) {
1344 // Normal code
1345
1346 const int sign = bits.getBit() - 1;
1347
1348 offset += runTable[code];
1349
1350 iptr[offset & coefMask] = ilvl[code] ^ (sign << 31);
1351
1352 } else if (code == 1) {
1353 // EOB
1354
1355 break;
1356
1357 } else {
1358 // Escape
1359
1360 int level;
1361
1362 if (!version) {
1363
1364 level = bits.getBits(coefNbBits);
1365 // NOTE: This is rather suboptimal. reading blockLenBits would be better
1366 offset += bits.getBits(frameLenBits);
1367
1368 } else {
1369 level = getLargeVal(bits);
1370
1371 // Escape decode
1372 if (bits.getBit()) {
1373 if (bits.getBit()) {
1374 if (bits.getBit()) {
1375 warning("WMACodec::decodeRunLevel(): Broken escape sequence");
1376 return false;
1377 } else
1378 offset += bits.getBits(frameLenBits) + 4;
1379 } else
1380 offset += bits.getBits(2) + 1;
1381 }
1382
1383 }
1384
1385 const int sign = bits.getBit() - 1;
1386
1387 ptr[offset & coefMask] = (level ^ sign) - sign;
1388
1389 }
1390 }
1391
1392 // NOTE: EOB can be omitted
1393 if (offset > numCoefs) {
1394 warning("WMACodec::decodeRunLevel(): Overflow in spectral RLE, ignoring");
1395 return true;
1396 }
1397
1398 return true;
1399 }
1400
1401 /** Apply MDCT window and add into output.
1402 *
1403 * We ensure that when the windows overlap their squared sum
1404 * is always 1 (MDCT reconstruction rule).
1405 */
window(float * out) const1406 void WMACodec::window(float *out) const {
1407 const float *in = _output;
1408
1409 // Left part
1410 if (_blockLenBits <= _prevBlockLenBits) {
1411
1412 const int bSize = _frameLenBits - _blockLenBits;
1413
1414 vectorFMulAdd(out, in, _mdctWindow[bSize], out, _blockLen);
1415
1416 } else {
1417
1418 const int blockLen = 1 << _prevBlockLenBits;
1419 const int n = (_blockLen - blockLen) / 2;
1420
1421 const int bSize = _frameLenBits - _prevBlockLenBits;
1422
1423 vectorFMulAdd(out + n, in + n, _mdctWindow[bSize], out + n, blockLen);
1424
1425 memcpy(out + n + blockLen, in + n + blockLen, n * sizeof(float));
1426 }
1427
1428 out += _blockLen;
1429 in += _blockLen;
1430
1431 // Right part
1432 if (_blockLenBits <= _nextBlockLenBits) {
1433
1434 const int bSize = _frameLenBits - _blockLenBits;
1435
1436 vectorFMulReverse(out, in, _mdctWindow[bSize], _blockLen);
1437
1438 } else {
1439
1440 const int blockLen = 1 << _nextBlockLenBits;
1441 const int n = (_blockLen - blockLen) / 2;
1442
1443 const int bSize = _frameLenBits - _nextBlockLenBits;
1444
1445 memcpy(out, in, n*sizeof(float));
1446
1447 vectorFMulReverse(out + n, in + n, _mdctWindow[bSize], blockLen);
1448
1449 memset(out + n + blockLen, 0, n * sizeof(float));
1450 }
1451 }
1452
pow_m1_4(float x) const1453 float WMACodec::pow_m1_4(float x) const {
1454 union {
1455 float f;
1456 unsigned int v;
1457 } u, t;
1458
1459 u.f = x;
1460
1461 const unsigned int e = u.v >> 23;
1462 const unsigned int m = (u.v >> (23 - kLSPPowBits)) & ((1 << kLSPPowBits) - 1);
1463
1464 // Build interpolation scale: 1 <= t < 2
1465 t.v = ((u.v << kLSPPowBits) & ((1 << 23) - 1)) | (127 << 23);
1466
1467 const float a = _lspPowMTable1[m];
1468 const float b = _lspPowMTable2[m];
1469
1470 return _lspPowETable[e] * (a + b * t.f);
1471 }
1472
readTotalGain(Common::BitStream8MSB & bits)1473 int WMACodec::readTotalGain(Common::BitStream8MSB &bits) {
1474 int totalGain = 1;
1475
1476 int v = 127;
1477 while (v == 127) {
1478 v = bits.getBits(7);
1479
1480 totalGain += v;
1481 }
1482
1483 return totalGain;
1484 }
1485
totalGainToBits(int totalGain)1486 int WMACodec::totalGainToBits(int totalGain) {
1487 if (totalGain < 15) return 13;
1488 else if (totalGain < 32) return 12;
1489 else if (totalGain < 40) return 11;
1490 else if (totalGain < 45) return 10;
1491 else return 9;
1492 }
1493
getLargeVal(Common::BitStream8MSB & bits)1494 uint32 WMACodec::getLargeVal(Common::BitStream8MSB &bits) {
1495 // Consumes up to 34 bits
1496
1497 int count = 8;
1498 if (bits.getBit()) {
1499 count += 8;
1500
1501 if (bits.getBit()) {
1502 count += 8;
1503
1504 if (bits.getBit())
1505 count += 7;
1506 }
1507 }
1508
1509 return bits.getBits(count);
1510 }
1511
1512 } // End of namespace Audio
1513