1 /* -----------------------------------------------------------------------------
2 Software License for The Fraunhofer FDK AAC Codec Library for Android
3
4 © Copyright 1995 - 2018 Fraunhofer-Gesellschaft zur Förderung der angewandten
5 Forschung e.V. All rights reserved.
6
7 1. INTRODUCTION
8 The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software
9 that implements the MPEG Advanced Audio Coding ("AAC") encoding and decoding
10 scheme for digital audio. This FDK AAC Codec software is intended to be used on
11 a wide variety of Android devices.
12
13 AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient
14 general perceptual audio codecs. AAC-ELD is considered the best-performing
15 full-bandwidth communications codec by independent studies and is widely
16 deployed. AAC has been standardized by ISO and IEC as part of the MPEG
17 specifications.
18
19 Patent licenses for necessary patent claims for the FDK AAC Codec (including
20 those of Fraunhofer) may be obtained through Via Licensing
21 (www.vialicensing.com) or through the respective patent owners individually for
22 the purpose of encoding or decoding bit streams in products that are compliant
23 with the ISO/IEC MPEG audio standards. Please note that most manufacturers of
24 Android devices already license these patent claims through Via Licensing or
25 directly from the patent owners, and therefore FDK AAC Codec software may
26 already be covered under those patent licenses when it is used for those
27 licensed purposes only.
28
29 Commercially-licensed AAC software libraries, including floating-point versions
30 with enhanced sound quality, are also available from Fraunhofer. Users are
31 encouraged to check the Fraunhofer website for additional applications
32 information and documentation.
33
34 2. COPYRIGHT LICENSE
35
36 Redistribution and use in source and binary forms, with or without modification,
37 are permitted without payment of copyright license fees provided that you
38 satisfy the following conditions:
39
40 You must retain the complete text of this software license in redistributions of
41 the FDK AAC Codec or your modifications thereto in source code form.
42
43 You must retain the complete text of this software license in the documentation
44 and/or other materials provided with redistributions of the FDK AAC Codec or
45 your modifications thereto in binary form. You must make available free of
46 charge copies of the complete source code of the FDK AAC Codec and your
47 modifications thereto to recipients of copies in binary form.
48
49 The name of Fraunhofer may not be used to endorse or promote products derived
50 from this library without prior written permission.
51
52 You may not charge copyright license fees for anyone to use, copy or distribute
53 the FDK AAC Codec software or your modifications thereto.
54
55 Your modified versions of the FDK AAC Codec must carry prominent notices stating
56 that you changed the software and the date of any change. For modified versions
57 of the FDK AAC Codec, the term "Fraunhofer FDK AAC Codec Library for Android"
58 must be replaced by the term "Third-Party Modified Version of the Fraunhofer FDK
59 AAC Codec Library for Android."
60
61 3. NO PATENT LICENSE
62
63 NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without
64 limitation the patents of Fraunhofer, ARE GRANTED BY THIS SOFTWARE LICENSE.
65 Fraunhofer provides no warranty of patent non-infringement with respect to this
66 software.
67
68 You may use this FDK AAC Codec software or modifications thereto only for
69 purposes that are authorized by appropriate patent licenses.
70
71 4. DISCLAIMER
72
73 This FDK AAC Codec software is provided by Fraunhofer on behalf of the copyright
74 holders and contributors "AS IS" and WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES,
75 including but not limited to the implied warranties of merchantability and
76 fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
77 CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary,
78 or consequential damages, including but not limited to procurement of substitute
79 goods or services; loss of use, data, or profits, or business interruption,
80 however caused and on any theory of liability, whether in contract, strict
81 liability, or tort (including negligence), arising in any way out of the use of
82 this software, even if advised of the possibility of such damage.
83
84 5. CONTACT INFORMATION
85
86 Fraunhofer Institute for Integrated Circuits IIS
87 Attention: Audio and Multimedia Departments - FDK AAC LL
88 Am Wolfsmantel 33
89 91058 Erlangen, Germany
90
91 www.iis.fraunhofer.de/amm
92 amm-info@iis.fraunhofer.de
93 ----------------------------------------------------------------------------- */
94
95 /************************* MPEG-D DRC decoder library **************************
96
97 Author(s):
98
99 Description:
100
101 *******************************************************************************/
102
103 #include "fixpoint_math.h"
104 #include "drcDec_reader.h"
105 #include "drcDec_tools.h"
106 #include "drcDec_rom.h"
107 #include "drcDecoder.h"
108
109 /* MPEG-D DRC AMD 1 */
110
111 #define UNIDRCCONFEXT_PARAM_DRC 0x1
112 #define UNIDRCCONFEXT_V1 0x2
113 #define UNIDRCLOUDEXT_EQ 0x1
114
115 #define UNIDRCGAINEXT_TERM 0x0
116 #define UNIDRCLOUDEXT_TERM 0x0
117 #define UNIDRCCONFEXT_TERM 0x0
118
_getZ(const int nNodesMax)119 static int _getZ(const int nNodesMax) {
120 /* Z is the minimum codeword length that is needed to encode all possible
121 * timeDelta values */
122 /* Z = ceil(log2(2*nNodesMax)) */
123 int Z = 1;
124 while ((1 << Z) < (2 * nNodesMax)) {
125 Z++;
126 }
127 return Z;
128 }
129
_getTimeDeltaMin(const GAIN_SET * pGset,const int deltaTminDefault)130 static int _getTimeDeltaMin(const GAIN_SET* pGset, const int deltaTminDefault) {
131 if (pGset->timeDeltaMinPresent) {
132 return pGset->timeDeltaMin;
133 } else {
134 return deltaTminDefault;
135 }
136 }
137
138 /* compare and assign */
_compAssign(UCHAR * dest,const UCHAR src)139 static inline int _compAssign(UCHAR* dest, const UCHAR src) {
140 int diff = 0;
141 if (*dest != src) diff = 1;
142 *dest = src;
143 return diff;
144 }
145
_compAssign(ULONG * dest,const ULONG src)146 static inline int _compAssign(ULONG* dest, const ULONG src) {
147 int diff = 0;
148 if (*dest != src) diff = 1;
149 *dest = src;
150 return diff;
151 }
152
153 typedef const SCHAR (*Huffman)[2];
154
_decodeHuffmanCW(Huffman h,HANDLE_FDK_BITSTREAM hBs)155 int _decodeHuffmanCW(Huffman h, /*!< pointer to huffman codebook table */
156 HANDLE_FDK_BITSTREAM hBs) /*!< Handle to bitbuffer */
157 {
158 SCHAR index = 0;
159 int value, bit;
160
161 while (index >= 0) {
162 bit = FDKreadBits(hBs, 1);
163 index = h[index][bit];
164 }
165
166 value = index + 64; /* Add offset */
167
168 return value;
169 }
170
171 /**********/
172 /* uniDrc */
173 /**********/
174
175 DRC_ERROR
drcDec_readUniDrc(HANDLE_FDK_BITSTREAM hBs,HANDLE_UNI_DRC_CONFIG hUniDrcConfig,HANDLE_LOUDNESS_INFO_SET hLoudnessInfoSet,const int frameSize,const int deltaTminDefault,HANDLE_UNI_DRC_GAIN hUniDrcGain)176 drcDec_readUniDrc(HANDLE_FDK_BITSTREAM hBs, HANDLE_UNI_DRC_CONFIG hUniDrcConfig,
177 HANDLE_LOUDNESS_INFO_SET hLoudnessInfoSet,
178 const int frameSize, const int deltaTminDefault,
179 HANDLE_UNI_DRC_GAIN hUniDrcGain) {
180 DRC_ERROR err = DE_OK;
181 int loudnessInfoSetPresent, uniDrcConfigPresent;
182
183 loudnessInfoSetPresent = FDKreadBits(hBs, 1);
184 if (loudnessInfoSetPresent) {
185 uniDrcConfigPresent = FDKreadBits(hBs, 1);
186 if (uniDrcConfigPresent) {
187 err = drcDec_readUniDrcConfig(hBs, hUniDrcConfig);
188 if (err) {
189 /* clear config, if parsing error occured */
190 FDKmemclear(hUniDrcConfig, sizeof(UNI_DRC_CONFIG));
191 hUniDrcConfig->diff = 1;
192 }
193 }
194 err = drcDec_readLoudnessInfoSet(hBs, hLoudnessInfoSet);
195 if (err) {
196 /* clear config, if parsing error occured */
197 FDKmemclear(hLoudnessInfoSet, sizeof(LOUDNESS_INFO_SET));
198 hLoudnessInfoSet->diff = 1;
199 }
200 }
201
202 if (hUniDrcGain != NULL) {
203 err = drcDec_readUniDrcGain(hBs, hUniDrcConfig, frameSize, deltaTminDefault,
204 hUniDrcGain);
205 if (err) return err;
206 }
207
208 return err;
209 }
210
211 /**************/
212 /* uniDrcGain */
213 /**************/
214
_decodeGainInitial(HANDLE_FDK_BITSTREAM hBs,const GAIN_CODING_PROFILE gainCodingProfile)215 static FIXP_SGL _decodeGainInitial(
216 HANDLE_FDK_BITSTREAM hBs, const GAIN_CODING_PROFILE gainCodingProfile) {
217 int sign, magn;
218 FIXP_SGL gainInitial = (FIXP_SGL)0;
219 switch (gainCodingProfile) {
220 case GCP_REGULAR:
221 sign = FDKreadBits(hBs, 1);
222 magn = FDKreadBits(hBs, 8);
223
224 gainInitial =
225 (FIXP_SGL)(magn << (FRACT_BITS - 1 - 3 - 7)); /* magn * 0.125; */
226 if (sign) gainInitial = -gainInitial;
227 break;
228 case GCP_FADING:
229 sign = FDKreadBits(hBs, 1);
230 if (sign == 0)
231 gainInitial = (FIXP_SGL)0;
232 else {
233 magn = FDKreadBits(hBs, 10);
234 gainInitial = -(FIXP_SGL)(
235 (magn + 1) << (FRACT_BITS - 1 - 3 - 7)); /* - (magn + 1) * 0.125; */
236 }
237 break;
238 case GCP_CLIPPING_DUCKING:
239 sign = FDKreadBits(hBs, 1);
240 if (sign == 0)
241 gainInitial = (FIXP_SGL)0;
242 else {
243 magn = FDKreadBits(hBs, 8);
244 gainInitial = -(FIXP_SGL)(
245 (magn + 1) << (FRACT_BITS - 1 - 3 - 7)); /* - (magn + 1) * 0.125; */
246 }
247 break;
248 case GCP_CONSTANT:
249 break;
250 }
251 return gainInitial;
252 }
253
_decodeNNodes(HANDLE_FDK_BITSTREAM hBs)254 static int _decodeNNodes(HANDLE_FDK_BITSTREAM hBs) {
255 int nNodes = 0, endMarker = 0;
256
257 /* decode number of nodes */
258 while (endMarker != 1) {
259 nNodes++;
260 if (nNodes >= 128) break;
261 endMarker = FDKreadBits(hBs, 1);
262 }
263 return nNodes;
264 }
265
_decodeGains(HANDLE_FDK_BITSTREAM hBs,const GAIN_CODING_PROFILE gainCodingProfile,const int nNodes,GAIN_NODE * pNodes)266 static void _decodeGains(HANDLE_FDK_BITSTREAM hBs,
267 const GAIN_CODING_PROFILE gainCodingProfile,
268 const int nNodes, GAIN_NODE* pNodes) {
269 int k, deltaGain;
270 Huffman deltaGainCodebook;
271
272 pNodes[0].gainDb = _decodeGainInitial(hBs, gainCodingProfile);
273
274 if (gainCodingProfile == GCP_CLIPPING_DUCKING) {
275 deltaGainCodebook = (Huffman)&deltaGain_codingProfile_2_huffman;
276 } else {
277 deltaGainCodebook = (Huffman)&deltaGain_codingProfile_0_1_huffman;
278 }
279
280 for (k = 1; k < nNodes; k++) {
281 deltaGain = _decodeHuffmanCW(deltaGainCodebook, hBs);
282 if (k >= 16) continue;
283 /* gain_dB_e = 7 */
284 pNodes[k].gainDb =
285 pNodes[k - 1].gainDb +
286 (FIXP_SGL)(deltaGain << (FRACT_BITS - 1 - 7 -
287 3)); /* pNodes[k-1].gainDb + 0.125*deltaGain */
288 }
289 }
290
_decodeSlopes(HANDLE_FDK_BITSTREAM hBs,const GAIN_INTERPOLATION_TYPE gainInterpolationType,const int nNodes,GAIN_NODE * pNodes)291 static void _decodeSlopes(HANDLE_FDK_BITSTREAM hBs,
292 const GAIN_INTERPOLATION_TYPE gainInterpolationType,
293 const int nNodes, GAIN_NODE* pNodes) {
294 int k = 0;
295
296 if (gainInterpolationType == GIT_SPLINE) {
297 /* decode slope steepness */
298 for (k = 0; k < nNodes; k++) {
299 _decodeHuffmanCW((Huffman)&slopeSteepness_huffman, hBs);
300 }
301 }
302 }
303
_decodeTimeDelta(HANDLE_FDK_BITSTREAM hBs,const int Z)304 static int _decodeTimeDelta(HANDLE_FDK_BITSTREAM hBs, const int Z) {
305 int prefix, mu;
306
307 prefix = FDKreadBits(hBs, 2);
308 switch (prefix) {
309 case 0x0:
310 return 1;
311 case 0x1:
312 mu = FDKreadBits(hBs, 2);
313 return mu + 2;
314 case 0x2:
315 mu = FDKreadBits(hBs, 3);
316 return mu + 6;
317 case 0x3:
318 mu = FDKreadBits(hBs, Z);
319 return mu + 14;
320 default:
321 return 0;
322 }
323 }
324
_decodeTimes(HANDLE_FDK_BITSTREAM hBs,const int deltaTmin,const int frameSize,const int fullFrame,const int timeOffset,const int Z,const int nNodes,GAIN_NODE * pNodes)325 static void _decodeTimes(HANDLE_FDK_BITSTREAM hBs, const int deltaTmin,
326 const int frameSize, const int fullFrame,
327 const int timeOffset, const int Z, const int nNodes,
328 GAIN_NODE* pNodes) {
329 int timeDelta, k;
330 int timeOffs = timeOffset;
331 int frameEndFlag, nodeTimeTmp, nodeResFlag;
332
333 if (fullFrame == 0) {
334 frameEndFlag = FDKreadBits(hBs, 1);
335 } else {
336 frameEndFlag = 1;
337 }
338
339 if (frameEndFlag ==
340 1) { /* frameEndFlag == 1 signals that the last node is at the end of the
341 DRC frame */
342 nodeResFlag = 0;
343 for (k = 0; k < nNodes - 1; k++) {
344 /* decode a delta time value */
345 timeDelta = _decodeTimeDelta(hBs, Z);
346 if (k >= (16 - 1)) continue;
347 /* frameEndFlag == 1 needs special handling for last node with node
348 * reservoir */
349 nodeTimeTmp = timeOffs + timeDelta * deltaTmin;
350 if (nodeTimeTmp > frameSize + timeOffset) {
351 if (nodeResFlag == 0) {
352 pNodes[k].time = frameSize + timeOffset;
353 nodeResFlag = 1;
354 }
355 pNodes[k + 1].time = nodeTimeTmp;
356 } else {
357 pNodes[k].time = nodeTimeTmp;
358 }
359 timeOffs = nodeTimeTmp;
360 }
361 if (nodeResFlag == 0) {
362 k = fMin(k, 16 - 1);
363 pNodes[k].time = frameSize + timeOffset;
364 }
365 } else {
366 for (k = 0; k < nNodes; k++) {
367 /* decode a delta time value */
368 timeDelta = _decodeTimeDelta(hBs, Z);
369 if (k >= 16) continue;
370 pNodes[k].time = timeOffs + timeDelta * deltaTmin;
371 timeOffs = pNodes[k].time;
372 }
373 }
374 }
375
_readNodes(HANDLE_FDK_BITSTREAM hBs,GAIN_SET * gainSet,const int frameSize,const int timeDeltaMin,UCHAR * pNNodes,GAIN_NODE * pNodes)376 static void _readNodes(HANDLE_FDK_BITSTREAM hBs, GAIN_SET* gainSet,
377 const int frameSize, const int timeDeltaMin,
378 UCHAR* pNNodes, GAIN_NODE* pNodes) {
379 int timeOffset, drcGainCodingMode, nNodes;
380 int Z = _getZ(frameSize / timeDeltaMin);
381 if (gainSet->timeAlignment == 0) {
382 timeOffset = -1;
383 } else {
384 timeOffset = -timeDeltaMin +
385 (timeDeltaMin - 1) /
386 2; /* timeOffset = - deltaTmin + floor((deltaTmin-1)/2); */
387 }
388
389 drcGainCodingMode = FDKreadBits(hBs, 1);
390 if (drcGainCodingMode == 0) {
391 /* "simple" mode: only one node at the end of the frame with slope = 0 */
392 nNodes = 1;
393 pNodes[0].gainDb = _decodeGainInitial(
394 hBs, (GAIN_CODING_PROFILE)gainSet->gainCodingProfile);
395 pNodes[0].time = frameSize + timeOffset;
396 } else {
397 nNodes = _decodeNNodes(hBs);
398
399 _decodeSlopes(hBs, (GAIN_INTERPOLATION_TYPE)gainSet->gainInterpolationType,
400 nNodes, pNodes);
401
402 _decodeTimes(hBs, timeDeltaMin, frameSize, gainSet->fullFrame, timeOffset,
403 Z, nNodes, pNodes);
404
405 _decodeGains(hBs, (GAIN_CODING_PROFILE)gainSet->gainCodingProfile, nNodes,
406 pNodes);
407 }
408 *pNNodes = (UCHAR)nNodes;
409 }
410
_readDrcGainSequence(HANDLE_FDK_BITSTREAM hBs,GAIN_SET * gainSet,const int frameSize,const int timeDeltaMin,UCHAR * pNNodes,GAIN_NODE pNodes[16])411 static void _readDrcGainSequence(HANDLE_FDK_BITSTREAM hBs, GAIN_SET* gainSet,
412 const int frameSize, const int timeDeltaMin,
413 UCHAR* pNNodes, GAIN_NODE pNodes[16]) {
414 SHORT timeBufPrevFrame[16], timeBufCurFrame[16];
415 int nNodesNodeRes, nNodesCur, k, m;
416
417 if (gainSet->gainCodingProfile == GCP_CONSTANT) {
418 *pNNodes = 1;
419 pNodes[0].time = frameSize - 1;
420 pNodes[0].gainDb = (FIXP_SGL)0;
421 } else {
422 _readNodes(hBs, gainSet, frameSize, timeDeltaMin, pNNodes, pNodes);
423
424 /* count number of nodes in node reservoir */
425 nNodesNodeRes = 0;
426 nNodesCur = 0;
427 /* count and buffer nodes from node reservoir */
428 for (k = 0; k < *pNNodes; k++) {
429 if (k >= 16) continue;
430 if (pNodes[k].time >= frameSize) {
431 /* write node reservoir times into buffer */
432 timeBufPrevFrame[nNodesNodeRes] = pNodes[k].time;
433 nNodesNodeRes++;
434 } else { /* times from current frame */
435 timeBufCurFrame[nNodesCur] = pNodes[k].time;
436 nNodesCur++;
437 }
438 }
439 /* compose right time order (bit reservoir first) */
440 for (k = 0; k < nNodesNodeRes; k++) {
441 /* subtract two time frameSize: one to remove node reservoir offset and
442 * one to get the negative index relative to the current frame
443 */
444 pNodes[k].time = timeBufPrevFrame[k] - 2 * frameSize;
445 }
446 /* ...and times from current frame */
447 for (m = 0; m < nNodesCur; m++, k++) {
448 pNodes[k].time = timeBufCurFrame[m];
449 }
450 }
451 }
452
_readUniDrcGainExtension(HANDLE_FDK_BITSTREAM hBs,UNI_DRC_GAIN_EXTENSION * pExt)453 static DRC_ERROR _readUniDrcGainExtension(HANDLE_FDK_BITSTREAM hBs,
454 UNI_DRC_GAIN_EXTENSION* pExt) {
455 DRC_ERROR err = DE_OK;
456 int k, bitSizeLen, extSizeBits, bitSize;
457
458 k = 0;
459 pExt->uniDrcGainExtType[k] = FDKreadBits(hBs, 4);
460 while (pExt->uniDrcGainExtType[k] != UNIDRCGAINEXT_TERM) {
461 if (k >= (8 - 1)) return DE_MEMORY_ERROR;
462 bitSizeLen = FDKreadBits(hBs, 3);
463 extSizeBits = bitSizeLen + 4;
464
465 bitSize = FDKreadBits(hBs, extSizeBits);
466 pExt->extBitSize[k] = bitSize + 1;
467
468 switch (pExt->uniDrcGainExtType[k]) {
469 /* add future extensions here */
470 default:
471 FDKpushFor(hBs, pExt->extBitSize[k]);
472 break;
473 }
474 k++;
475 pExt->uniDrcGainExtType[k] = FDKreadBits(hBs, 4);
476 }
477
478 return err;
479 }
480
481 DRC_ERROR
drcDec_readUniDrcGain(HANDLE_FDK_BITSTREAM hBs,HANDLE_UNI_DRC_CONFIG hUniDrcConfig,const int frameSize,const int deltaTminDefault,HANDLE_UNI_DRC_GAIN hUniDrcGain)482 drcDec_readUniDrcGain(HANDLE_FDK_BITSTREAM hBs,
483 HANDLE_UNI_DRC_CONFIG hUniDrcConfig, const int frameSize,
484 const int deltaTminDefault,
485 HANDLE_UNI_DRC_GAIN hUniDrcGain) {
486 DRC_ERROR err = DE_OK;
487 int seq, gainSequenceCount;
488 DRC_COEFFICIENTS_UNI_DRC* pCoef =
489 selectDrcCoefficients(hUniDrcConfig, LOCATION_SELECTED);
490 if (pCoef == NULL) return DE_OK;
491 if (hUniDrcGain == NULL) return DE_OK; /* hUniDrcGain not initialized yet */
492
493 gainSequenceCount = fMin(pCoef->gainSequenceCount, (UCHAR)12);
494
495 for (seq = 0; seq < gainSequenceCount; seq++) {
496 UCHAR index = pCoef->gainSetIndexForGainSequence[seq];
497 GAIN_SET* gainSet;
498 int timeDeltaMin;
499 UCHAR tmpNNodes = 0;
500 GAIN_NODE tmpNodes[16];
501
502 if ((index >= pCoef->gainSetCount) || (index >= 12)) return DE_NOT_OK;
503 gainSet = &(pCoef->gainSet[index]);
504
505 timeDeltaMin = _getTimeDeltaMin(gainSet, deltaTminDefault);
506
507 _readDrcGainSequence(hBs, gainSet, frameSize, timeDeltaMin, &tmpNNodes,
508 tmpNodes);
509
510 hUniDrcGain->nNodes[seq] = tmpNNodes;
511 FDKmemcpy(hUniDrcGain->gainNode[seq], tmpNodes,
512 fMin(tmpNNodes, (UCHAR)16) * sizeof(GAIN_NODE));
513 }
514
515 hUniDrcGain->uniDrcGainExtPresent = FDKreadBits(hBs, 1);
516 if (hUniDrcGain->uniDrcGainExtPresent == 1) {
517 err = _readUniDrcGainExtension(hBs, &(hUniDrcGain->uniDrcGainExtension));
518 if (err) return err;
519 }
520
521 return err;
522 }
523
524 /****************/
525 /* uniDrcConfig */
526 /****************/
527
_decodeDuckingModification(HANDLE_FDK_BITSTREAM hBs,DUCKING_MODIFICATION * pDMod,int isBox)528 static void _decodeDuckingModification(HANDLE_FDK_BITSTREAM hBs,
529 DUCKING_MODIFICATION* pDMod, int isBox) {
530 int bsDuckingScaling, sigma, mu;
531
532 if (isBox) FDKpushFor(hBs, 7); /* reserved */
533 pDMod->duckingScalingPresent = FDKreadBits(hBs, 1);
534
535 if (pDMod->duckingScalingPresent) {
536 if (isBox) FDKpushFor(hBs, 4); /* reserved */
537 bsDuckingScaling = FDKreadBits(hBs, 4);
538 sigma = bsDuckingScaling >> 3;
539 mu = bsDuckingScaling & 0x7;
540
541 if (sigma) {
542 pDMod->duckingScaling = (FIXP_SGL)(
543 (7 - mu) << (FRACT_BITS - 1 - 3 - 2)); /* 1.0 - 0.125 * (1 + mu); */
544 } else {
545 pDMod->duckingScaling = (FIXP_SGL)(
546 (9 + mu) << (FRACT_BITS - 1 - 3 - 2)); /* 1.0 + 0.125 * (1 + mu); */
547 }
548 } else {
549 pDMod->duckingScaling = (FIXP_SGL)(1 << (FRACT_BITS - 1 - 2)); /* 1.0 */
550 }
551 }
552
_decodeGainModification(HANDLE_FDK_BITSTREAM hBs,const int version,int bandCount,GAIN_MODIFICATION * pGMod,int isBox)553 static void _decodeGainModification(HANDLE_FDK_BITSTREAM hBs, const int version,
554 int bandCount, GAIN_MODIFICATION* pGMod,
555 int isBox) {
556 int sign, bsGainOffset, bsAttenuationScaling, bsAmplificationScaling;
557
558 if (version > 0) {
559 int b, shapeFilterPresent;
560
561 if (isBox) {
562 FDKpushFor(hBs, 4); /* reserved */
563 bandCount = FDKreadBits(hBs, 4);
564 }
565
566 for (b = 0; b < bandCount; b++) {
567 if (isBox) {
568 FDKpushFor(hBs, 4); /* reserved */
569 pGMod[b].targetCharacteristicLeftPresent = FDKreadBits(hBs, 1);
570 pGMod[b].targetCharacteristicRightPresent = FDKreadBits(hBs, 1);
571 pGMod[b].gainScalingPresent = FDKreadBits(hBs, 1);
572 pGMod[b].gainOffsetPresent = FDKreadBits(hBs, 1);
573 }
574
575 if (!isBox)
576 pGMod[b].targetCharacteristicLeftPresent = FDKreadBits(hBs, 1);
577 if (pGMod[b].targetCharacteristicLeftPresent) {
578 if (isBox) FDKpushFor(hBs, 4); /* reserved */
579 pGMod[b].targetCharacteristicLeftIndex = FDKreadBits(hBs, 4);
580 }
581 if (!isBox)
582 pGMod[b].targetCharacteristicRightPresent = FDKreadBits(hBs, 1);
583 if (pGMod[b].targetCharacteristicRightPresent) {
584 if (isBox) FDKpushFor(hBs, 4); /* reserved */
585 pGMod[b].targetCharacteristicRightIndex = FDKreadBits(hBs, 4);
586 }
587 if (!isBox) pGMod[b].gainScalingPresent = FDKreadBits(hBs, 1);
588 if (pGMod[b].gainScalingPresent) {
589 bsAttenuationScaling = FDKreadBits(hBs, 4);
590 pGMod[b].attenuationScaling = (FIXP_SGL)(
591 bsAttenuationScaling
592 << (FRACT_BITS - 1 - 3 - 2)); /* bsAttenuationScaling * 0.125; */
593 bsAmplificationScaling = FDKreadBits(hBs, 4);
594 pGMod[b].amplificationScaling = (FIXP_SGL)(
595 bsAmplificationScaling
596 << (FRACT_BITS - 1 - 3 - 2)); /* bsAmplificationScaling * 0.125; */
597 }
598 if (!isBox) pGMod[b].gainOffsetPresent = FDKreadBits(hBs, 1);
599 if (pGMod[b].gainOffsetPresent) {
600 if (isBox) FDKpushFor(hBs, 2); /* reserved */
601 sign = FDKreadBits(hBs, 1);
602 bsGainOffset = FDKreadBits(hBs, 5);
603 pGMod[b].gainOffset = (FIXP_SGL)(
604 (1 + bsGainOffset)
605 << (FRACT_BITS - 1 - 2 - 4)); /* (1+bsGainOffset) * 0.25; */
606 if (sign) {
607 pGMod[b].gainOffset = -pGMod[b].gainOffset;
608 }
609 }
610 }
611 if (bandCount == 1) {
612 shapeFilterPresent = FDKreadBits(hBs, 1);
613 if (shapeFilterPresent) {
614 if (isBox) FDKpushFor(hBs, 3); /* reserved */
615 FDKpushFor(hBs, 4); /* pGMod->shapeFilterIndex */
616 } else {
617 if (isBox) FDKpushFor(hBs, 7); /* reserved */
618 }
619 }
620 } else {
621 int b, gainScalingPresent, gainOffsetPresent;
622 FIXP_SGL attenuationScaling = FL2FXCONST_SGL(1.0f / (float)(1 << 2)),
623 amplificationScaling = FL2FXCONST_SGL(1.0f / (float)(1 << 2)),
624 gainOffset = (FIXP_SGL)0;
625 if (isBox) FDKpushFor(hBs, 7); /* reserved */
626 gainScalingPresent = FDKreadBits(hBs, 1);
627 if (gainScalingPresent) {
628 bsAttenuationScaling = FDKreadBits(hBs, 4);
629 attenuationScaling = (FIXP_SGL)(
630 bsAttenuationScaling
631 << (FRACT_BITS - 1 - 3 - 2)); /* bsAttenuationScaling * 0.125; */
632 bsAmplificationScaling = FDKreadBits(hBs, 4);
633 amplificationScaling = (FIXP_SGL)(
634 bsAmplificationScaling
635 << (FRACT_BITS - 1 - 3 - 2)); /* bsAmplificationScaling * 0.125; */
636 }
637 if (isBox) FDKpushFor(hBs, 7); /* reserved */
638 gainOffsetPresent = FDKreadBits(hBs, 1);
639 if (gainOffsetPresent) {
640 if (isBox) FDKpushFor(hBs, 2); /* reserved */
641 sign = FDKreadBits(hBs, 1);
642 bsGainOffset = FDKreadBits(hBs, 5);
643 gainOffset =
644 (FIXP_SGL)((1 + bsGainOffset) << (FRACT_BITS - 1 - 2 -
645 4)); /* (1+bsGainOffset) * 0.25; */
646 if (sign) {
647 gainOffset = -gainOffset;
648 }
649 }
650 for (b = 0; b < 4; b++) {
651 pGMod[b].targetCharacteristicLeftPresent = 0;
652 pGMod[b].targetCharacteristicRightPresent = 0;
653 pGMod[b].gainScalingPresent = gainScalingPresent;
654 pGMod[b].attenuationScaling = attenuationScaling;
655 pGMod[b].amplificationScaling = amplificationScaling;
656 pGMod[b].gainOffsetPresent = gainOffsetPresent;
657 pGMod[b].gainOffset = gainOffset;
658 }
659 }
660 }
661
_readDrcCharacteristic(HANDLE_FDK_BITSTREAM hBs,const int version,DRC_CHARACTERISTIC * pDChar,int isBox)662 static void _readDrcCharacteristic(HANDLE_FDK_BITSTREAM hBs, const int version,
663 DRC_CHARACTERISTIC* pDChar, int isBox) {
664 if (version == 0) {
665 if (isBox) FDKpushFor(hBs, 1); /* reserved */
666 pDChar->cicpIndex = FDKreadBits(hBs, 7);
667 if (pDChar->cicpIndex > 0) {
668 pDChar->present = 1;
669 pDChar->isCICP = 1;
670 } else {
671 pDChar->present = 0;
672 }
673 } else {
674 pDChar->present = FDKreadBits(hBs, 1);
675 if (isBox) pDChar->isCICP = FDKreadBits(hBs, 1);
676 if (pDChar->present) {
677 if (!isBox) pDChar->isCICP = FDKreadBits(hBs, 1);
678 if (pDChar->isCICP) {
679 if (isBox) FDKpushFor(hBs, 1); /* reserved */
680 pDChar->cicpIndex = FDKreadBits(hBs, 7);
681 } else {
682 pDChar->custom.left = FDKreadBits(hBs, 4);
683 pDChar->custom.right = FDKreadBits(hBs, 4);
684 }
685 }
686 }
687 }
688
_readBandBorder(HANDLE_FDK_BITSTREAM hBs,BAND_BORDER * pBBord,int drcBandType,int isBox)689 static void _readBandBorder(HANDLE_FDK_BITSTREAM hBs, BAND_BORDER* pBBord,
690 int drcBandType, int isBox) {
691 if (drcBandType) {
692 if (isBox) FDKpushFor(hBs, 4); /* reserved */
693 pBBord->crossoverFreqIndex = FDKreadBits(hBs, 4);
694 } else {
695 if (isBox) FDKpushFor(hBs, 6); /* reserved */
696 pBBord->startSubBandIndex = FDKreadBits(hBs, 10);
697 }
698 }
699
_readGainSet(HANDLE_FDK_BITSTREAM hBs,const int version,int * gainSequenceIndex,GAIN_SET * pGSet,int isBox)700 static DRC_ERROR _readGainSet(HANDLE_FDK_BITSTREAM hBs, const int version,
701 int* gainSequenceIndex, GAIN_SET* pGSet,
702 int isBox) {
703 if (isBox) FDKpushFor(hBs, 2); /* reserved */
704 pGSet->gainCodingProfile = FDKreadBits(hBs, 2);
705 pGSet->gainInterpolationType = FDKreadBits(hBs, 1);
706 pGSet->fullFrame = FDKreadBits(hBs, 1);
707 pGSet->timeAlignment = FDKreadBits(hBs, 1);
708 pGSet->timeDeltaMinPresent = FDKreadBits(hBs, 1);
709
710 if (pGSet->timeDeltaMinPresent) {
711 int bsTimeDeltaMin;
712 if (isBox) FDKpushFor(hBs, 5); /* reserved */
713 bsTimeDeltaMin = FDKreadBits(hBs, 11);
714 pGSet->timeDeltaMin = bsTimeDeltaMin + 1;
715 }
716
717 if (pGSet->gainCodingProfile != GCP_CONSTANT) {
718 int i;
719 if (isBox) FDKpushFor(hBs, 3); /* reserved */
720 pGSet->bandCount = FDKreadBits(hBs, 4);
721 if (pGSet->bandCount > 4) return DE_MEMORY_ERROR;
722
723 if ((pGSet->bandCount > 1) || isBox) {
724 pGSet->drcBandType = FDKreadBits(hBs, 1);
725 }
726
727 for (i = 0; i < pGSet->bandCount; i++) {
728 if (version == 0) {
729 *gainSequenceIndex = (*gainSequenceIndex) + 1;
730 } else {
731 int indexPresent;
732 indexPresent = (isBox) ? 1 : FDKreadBits(hBs, 1);
733 if (indexPresent) {
734 int bsIndex;
735 bsIndex = FDKreadBits(hBs, 6);
736 *gainSequenceIndex = bsIndex;
737 } else {
738 *gainSequenceIndex = (*gainSequenceIndex) + 1;
739 }
740 }
741 pGSet->gainSequenceIndex[i] = *gainSequenceIndex;
742 _readDrcCharacteristic(hBs, version, &(pGSet->drcCharacteristic[i]),
743 isBox);
744 }
745 for (i = 1; i < pGSet->bandCount; i++) {
746 _readBandBorder(hBs, &(pGSet->bandBorder[i]), pGSet->drcBandType, isBox);
747 }
748 } else {
749 pGSet->bandCount = 1;
750 *gainSequenceIndex = (*gainSequenceIndex) + 1;
751 pGSet->gainSequenceIndex[0] = *gainSequenceIndex;
752 }
753
754 return DE_OK;
755 }
756
_readCustomDrcCharacteristic(HANDLE_FDK_BITSTREAM hBs,const CHARACTERISTIC_SIDE side,UCHAR * pCharacteristicFormat,CUSTOM_DRC_CHAR * pCChar,int isBox)757 static DRC_ERROR _readCustomDrcCharacteristic(HANDLE_FDK_BITSTREAM hBs,
758 const CHARACTERISTIC_SIDE side,
759 UCHAR* pCharacteristicFormat,
760 CUSTOM_DRC_CHAR* pCChar,
761 int isBox) {
762 if (isBox) FDKpushFor(hBs, 7); /* reserved */
763 *pCharacteristicFormat = FDKreadBits(hBs, 1);
764 if (*pCharacteristicFormat == CF_SIGMOID) {
765 int bsGain, bsIoRatio, bsExp;
766 if (isBox) FDKpushFor(hBs, 1); /* reserved */
767 bsGain = FDKreadBits(hBs, 6);
768 if (side == CS_LEFT) {
769 pCChar->sigmoid.gain = (FIXP_SGL)(bsGain << (FRACT_BITS - 1 - 6));
770 } else {
771 pCChar->sigmoid.gain = (FIXP_SGL)(-bsGain << (FRACT_BITS - 1 - 6));
772 }
773 bsIoRatio = FDKreadBits(hBs, 4);
774 /* pCChar->sigmoid.ioRatio = 0.05 + 0.15 * bsIoRatio; */
775 pCChar->sigmoid.ioRatio =
776 FL2FXCONST_SGL(0.05f / (float)(1 << 2)) +
777 (FIXP_SGL)((((3 * bsIoRatio) << (FRACT_BITS - 1)) / 5) >> 4);
778 bsExp = FDKreadBits(hBs, 4);
779 if (bsExp < 15) {
780 pCChar->sigmoid.exp = (FIXP_SGL)((1 + 2 * bsExp) << (FRACT_BITS - 1 - 5));
781 } else {
782 pCChar->sigmoid.exp = (FIXP_SGL)MAXVAL_SGL; /* represents infinity */
783 }
784 pCChar->sigmoid.flipSign = FDKreadBits(hBs, 1);
785 } else { /* CF_NODES */
786 int i, bsCharacteristicNodeCount, bsNodeLevelDelta, bsNodeGain;
787 if (isBox) FDKpushFor(hBs, 6); /* reserved */
788 bsCharacteristicNodeCount = FDKreadBits(hBs, 2);
789 pCChar->nodes.characteristicNodeCount = bsCharacteristicNodeCount + 1;
790 if (pCChar->nodes.characteristicNodeCount > 4) return DE_MEMORY_ERROR;
791 pCChar->nodes.nodeLevel[0] = DRC_INPUT_LOUDNESS_TARGET_SGL;
792 pCChar->nodes.nodeGain[0] = (FIXP_SGL)0;
793 for (i = 0; i < pCChar->nodes.characteristicNodeCount; i++) {
794 if (isBox) FDKpushFor(hBs, 3); /* reserved */
795 bsNodeLevelDelta = FDKreadBits(hBs, 5);
796 if (side == CS_LEFT) {
797 pCChar->nodes.nodeLevel[i + 1] =
798 pCChar->nodes.nodeLevel[i] -
799 (FIXP_SGL)((1 + bsNodeLevelDelta) << (FRACT_BITS - 1 - 7));
800 } else {
801 pCChar->nodes.nodeLevel[i + 1] =
802 pCChar->nodes.nodeLevel[i] +
803 (FIXP_SGL)((1 + bsNodeLevelDelta) << (FRACT_BITS - 1 - 7));
804 }
805 bsNodeGain = FDKreadBits(hBs, 8);
806 pCChar->nodes.nodeGain[i + 1] = (FIXP_SGL)(
807 (bsNodeGain - 128)
808 << (FRACT_BITS - 1 - 1 - 7)); /* 0.5f * bsNodeGain - 64.0f; */
809 }
810 }
811 return DE_OK;
812 }
813
_skipLoudEqInstructions(HANDLE_FDK_BITSTREAM hBs)814 static void _skipLoudEqInstructions(HANDLE_FDK_BITSTREAM hBs) {
815 int i;
816 int downmixIdPresent, additionalDownmixIdPresent,
817 additionalDownmixIdCount = 0;
818 int drcSetIdPresent, additionalDrcSetIdPresent, additionalDrcSetIdCount = 0;
819 int eqSetIdPresent, additionalEqSetIdPresent, additionalEqSetIdCount = 0;
820 int loudEqGainSequenceCount, drcCharacteristicFormatIsCICP;
821
822 FDKpushFor(hBs, 4); /* loudEqSetId */
823 FDKpushFor(hBs, 4); /* drcLocation */
824 downmixIdPresent = FDKreadBits(hBs, 1);
825 if (downmixIdPresent) {
826 FDKpushFor(hBs, 7); /* downmixId */
827 additionalDownmixIdPresent = FDKreadBits(hBs, 1);
828 if (additionalDownmixIdPresent) {
829 additionalDownmixIdCount = FDKreadBits(hBs, 7);
830 for (i = 0; i < additionalDownmixIdCount; i++) {
831 FDKpushFor(hBs, 7); /* additionalDownmixId */
832 }
833 }
834 }
835
836 drcSetIdPresent = FDKreadBits(hBs, 1);
837 if (drcSetIdPresent) {
838 FDKpushFor(hBs, 6); /* drcSetId */
839 additionalDrcSetIdPresent = FDKreadBits(hBs, 1);
840 if (additionalDrcSetIdPresent) {
841 additionalDrcSetIdCount = FDKreadBits(hBs, 6);
842 for (i = 0; i < additionalDrcSetIdCount; i++) {
843 FDKpushFor(hBs, 6); /* additionalDrcSetId; */
844 }
845 }
846 }
847
848 eqSetIdPresent = FDKreadBits(hBs, 1);
849 if (eqSetIdPresent) {
850 FDKpushFor(hBs, 6); /* eqSetId */
851 additionalEqSetIdPresent = FDKreadBits(hBs, 1);
852 if (additionalEqSetIdPresent) {
853 additionalEqSetIdCount = FDKreadBits(hBs, 6);
854 for (i = 0; i < additionalEqSetIdCount; i++) {
855 FDKpushFor(hBs, 6); /* additionalEqSetId; */
856 }
857 }
858 }
859
860 FDKpushFor(hBs, 1); /* loudnessAfterDrc */
861 FDKpushFor(hBs, 1); /* loudnessAfterEq */
862 loudEqGainSequenceCount = FDKreadBits(hBs, 6);
863 for (i = 0; i < loudEqGainSequenceCount; i++) {
864 FDKpushFor(hBs, 6); /* gainSequenceIndex */
865 drcCharacteristicFormatIsCICP = FDKreadBits(hBs, 1);
866 if (drcCharacteristicFormatIsCICP) {
867 FDKpushFor(hBs, 7); /* drcCharacteristic */
868 } else {
869 FDKpushFor(hBs, 4); /* drcCharacteristicLeftIndex */
870 FDKpushFor(hBs, 4); /* drcCharacteristicRightIndex */
871 }
872 FDKpushFor(hBs, 6); /* frequencyRangeIndex */
873 FDKpushFor(hBs, 3); /* bsLoudEqScaling */
874 FDKpushFor(hBs, 5); /* bsLoudEqOffset */
875 }
876 }
877
_skipEqSubbandGainSpline(HANDLE_FDK_BITSTREAM hBs)878 static void _skipEqSubbandGainSpline(HANDLE_FDK_BITSTREAM hBs) {
879 int nEqNodes, k, bits;
880 nEqNodes = FDKreadBits(hBs, 5);
881 nEqNodes += 2;
882 for (k = 0; k < nEqNodes; k++) {
883 bits = FDKreadBits(hBs, 1);
884 if (!bits) {
885 FDKpushFor(hBs, 4);
886 }
887 }
888 FDKpushFor(hBs, 4 * (nEqNodes - 1));
889 bits = FDKreadBits(hBs, 2);
890 switch (bits) {
891 case 0:
892 FDKpushFor(hBs, 5);
893 break;
894 case 1:
895 case 2:
896 FDKpushFor(hBs, 4);
897 break;
898 case 3:
899 FDKpushFor(hBs, 3);
900 break;
901 }
902 FDKpushFor(hBs, 5 * (nEqNodes - 1));
903 }
904
_skipEqCoefficients(HANDLE_FDK_BITSTREAM hBs)905 static void _skipEqCoefficients(HANDLE_FDK_BITSTREAM hBs) {
906 int j, k;
907 int eqDelayMaxPresent;
908 int uniqueFilterBlockCount, filterElementCount, filterElementGainPresent;
909 int uniqueTdFilterElementCount, eqFilterFormat, bsRealZeroRadiusOneCount,
910 realZeroCount, genericZeroCount, realPoleCount, complexPoleCount,
911 firFilterOrder;
912 int uniqueEqSubbandGainsCount, eqSubbandGainRepresentation,
913 eqSubbandGainCount;
914 EQ_SUBBAND_GAIN_FORMAT eqSubbandGainFormat;
915
916 eqDelayMaxPresent = FDKreadBits(hBs, 1);
917 if (eqDelayMaxPresent) {
918 FDKpushFor(hBs, 8); /* bsEqDelayMax */
919 }
920
921 uniqueFilterBlockCount = FDKreadBits(hBs, 6);
922 for (j = 0; j < uniqueFilterBlockCount; j++) {
923 filterElementCount = FDKreadBits(hBs, 6);
924 for (k = 0; k < filterElementCount; k++) {
925 FDKpushFor(hBs, 6); /* filterElementIndex */
926 filterElementGainPresent = FDKreadBits(hBs, 1);
927 if (filterElementGainPresent) {
928 FDKpushFor(hBs, 10); /* bsFilterElementGain */
929 }
930 }
931 }
932 uniqueTdFilterElementCount = FDKreadBits(hBs, 6);
933 for (j = 0; j < uniqueTdFilterElementCount; j++) {
934 eqFilterFormat = FDKreadBits(hBs, 1);
935 if (eqFilterFormat == 0) { /* pole/zero */
936 bsRealZeroRadiusOneCount = FDKreadBits(hBs, 3);
937 realZeroCount = FDKreadBits(hBs, 6);
938 genericZeroCount = FDKreadBits(hBs, 6);
939 realPoleCount = FDKreadBits(hBs, 4);
940 complexPoleCount = FDKreadBits(hBs, 4);
941 FDKpushFor(hBs, 2 * bsRealZeroRadiusOneCount * 1);
942 FDKpushFor(hBs, realZeroCount * 8);
943 FDKpushFor(hBs, genericZeroCount * 14);
944 FDKpushFor(hBs, realPoleCount * 8);
945 FDKpushFor(hBs, complexPoleCount * 14);
946 } else { /* FIR coefficients */
947 firFilterOrder = FDKreadBits(hBs, 7);
948 FDKpushFor(hBs, 1);
949 FDKpushFor(hBs, (firFilterOrder / 2 + 1) * 11);
950 }
951 }
952 uniqueEqSubbandGainsCount = FDKreadBits(hBs, 6);
953 if (uniqueEqSubbandGainsCount > 0) {
954 eqSubbandGainRepresentation = FDKreadBits(hBs, 1);
955 eqSubbandGainFormat = (EQ_SUBBAND_GAIN_FORMAT)FDKreadBits(hBs, 4);
956 switch (eqSubbandGainFormat) {
957 case GF_QMF32:
958 eqSubbandGainCount = 32;
959 break;
960 case GF_QMFHYBRID39:
961 eqSubbandGainCount = 39;
962 break;
963 case GF_QMF64:
964 eqSubbandGainCount = 64;
965 break;
966 case GF_QMFHYBRID71:
967 eqSubbandGainCount = 71;
968 break;
969 case GF_QMF128:
970 eqSubbandGainCount = 128;
971 break;
972 case GF_QMFHYBRID135:
973 eqSubbandGainCount = 135;
974 break;
975 case GF_UNIFORM:
976 default:
977 eqSubbandGainCount = FDKreadBits(hBs, 8);
978 eqSubbandGainCount++;
979 break;
980 }
981 for (k = 0; k < uniqueEqSubbandGainsCount; k++) {
982 if (eqSubbandGainRepresentation == 1) {
983 _skipEqSubbandGainSpline(hBs);
984 } else {
985 FDKpushFor(hBs, eqSubbandGainCount * 9);
986 }
987 }
988 }
989 }
990
_skipTdFilterCascade(HANDLE_FDK_BITSTREAM hBs,const int eqChannelGroupCount)991 static void _skipTdFilterCascade(HANDLE_FDK_BITSTREAM hBs,
992 const int eqChannelGroupCount) {
993 int i, eqCascadeGainPresent, filterBlockCount, eqPhaseAlignmentPresent;
994 for (i = 0; i < eqChannelGroupCount; i++) {
995 eqCascadeGainPresent = FDKreadBits(hBs, 1);
996 if (eqCascadeGainPresent) {
997 FDKpushFor(hBs, 10); /* bsEqCascadeGain */
998 }
999 filterBlockCount = FDKreadBits(hBs, 4);
1000 FDKpushFor(hBs, filterBlockCount * 7); /* filterBlockIndex */
1001 }
1002 eqPhaseAlignmentPresent = FDKreadBits(hBs, 1);
1003 {
1004 if (eqPhaseAlignmentPresent) {
1005 for (i = 0; i < eqChannelGroupCount; i++) {
1006 FDKpushFor(hBs, (eqChannelGroupCount - i - 1) * 1);
1007 }
1008 }
1009 }
1010 }
1011
_skipEqInstructions(HANDLE_FDK_BITSTREAM hBs,HANDLE_UNI_DRC_CONFIG hUniDrcConfig)1012 static DRC_ERROR _skipEqInstructions(HANDLE_FDK_BITSTREAM hBs,
1013 HANDLE_UNI_DRC_CONFIG hUniDrcConfig) {
1014 DRC_ERROR err = DE_OK;
1015 int c, i, k, channelCount;
1016 int downmixIdPresent, downmixId, eqApplyToDownmix, additionalDownmixIdPresent,
1017 additionalDownmixIdCount = 0;
1018 int additionalDrcSetIdPresent, additionalDrcSetIdCount;
1019 int dependsOnEqSetPresent, eqChannelGroupCount, tdFilterCascadePresent,
1020 subbandGainsPresent, eqTransitionDurationPresent;
1021
1022 FDKpushFor(hBs, 6); /* eqSetId */
1023 FDKpushFor(hBs, 4); /* eqSetComplexityLevel */
1024 downmixIdPresent = FDKreadBits(hBs, 1);
1025 if (downmixIdPresent) {
1026 downmixId = FDKreadBits(hBs, 7);
1027 eqApplyToDownmix = FDKreadBits(hBs, 1);
1028 additionalDownmixIdPresent = FDKreadBits(hBs, 1);
1029 if (additionalDownmixIdPresent) {
1030 additionalDownmixIdCount = FDKreadBits(hBs, 7);
1031 FDKpushFor(hBs, additionalDownmixIdCount * 7); /* additionalDownmixId */
1032 }
1033 } else {
1034 downmixId = 0;
1035 eqApplyToDownmix = 0;
1036 }
1037 FDKpushFor(hBs, 6); /* drcSetId */
1038 additionalDrcSetIdPresent = FDKreadBits(hBs, 1);
1039 if (additionalDrcSetIdPresent) {
1040 additionalDrcSetIdCount = FDKreadBits(hBs, 6);
1041 for (i = 0; i < additionalDrcSetIdCount; i++) {
1042 FDKpushFor(hBs, 6); /* additionalDrcSetId */
1043 }
1044 }
1045 FDKpushFor(hBs, 16); /* eqSetPurpose */
1046 dependsOnEqSetPresent = FDKreadBits(hBs, 1);
1047 if (dependsOnEqSetPresent) {
1048 FDKpushFor(hBs, 6); /* dependsOnEqSet */
1049 } else {
1050 FDKpushFor(hBs, 1); /* noIndependentEqUse */
1051 }
1052
1053 channelCount = hUniDrcConfig->channelLayout.baseChannelCount;
1054 if ((downmixIdPresent == 1) && (eqApplyToDownmix == 1) && (downmixId != 0) &&
1055 (downmixId != DOWNMIX_ID_ANY_DOWNMIX) &&
1056 (additionalDownmixIdCount == 0)) {
1057 DOWNMIX_INSTRUCTIONS* pDown =
1058 selectDownmixInstructions(hUniDrcConfig, downmixId);
1059 if (pDown == NULL) return DE_NOT_OK;
1060
1061 channelCount =
1062 pDown->targetChannelCount; /* targetChannelCountFromDownmixId*/
1063 } else if ((downmixId == DOWNMIX_ID_ANY_DOWNMIX) ||
1064 (additionalDownmixIdCount > 1)) {
1065 channelCount = 1;
1066 }
1067
1068 eqChannelGroupCount = 0;
1069 for (c = 0; c < channelCount; c++) {
1070 UCHAR eqChannelGroupForChannel[8];
1071 int newGroup = 1;
1072 if (c >= 8) return DE_MEMORY_ERROR;
1073 eqChannelGroupForChannel[c] = FDKreadBits(hBs, 7);
1074 for (k = 0; k < c; k++) {
1075 if (eqChannelGroupForChannel[c] == eqChannelGroupForChannel[k]) {
1076 newGroup = 0;
1077 }
1078 }
1079 if (newGroup == 1) {
1080 eqChannelGroupCount += 1;
1081 }
1082 }
1083 tdFilterCascadePresent = FDKreadBits(hBs, 1);
1084 if (tdFilterCascadePresent) {
1085 _skipTdFilterCascade(hBs, eqChannelGroupCount);
1086 }
1087 subbandGainsPresent = FDKreadBits(hBs, 1);
1088 if (subbandGainsPresent) {
1089 FDKpushFor(hBs, eqChannelGroupCount * 6); /* subbandGainsIndex */
1090 }
1091 eqTransitionDurationPresent = FDKreadBits(hBs, 1);
1092 if (eqTransitionDurationPresent) {
1093 FDKpushFor(hBs, 5); /* bsEqTransitionDuration */
1094 }
1095 return err;
1096 }
1097
_skipDrcCoefficientsBasic(HANDLE_FDK_BITSTREAM hBs)1098 static void _skipDrcCoefficientsBasic(HANDLE_FDK_BITSTREAM hBs) {
1099 FDKpushFor(hBs, 4); /* drcLocation */
1100 FDKpushFor(hBs, 7); /* drcCharacteristic */
1101 }
1102
_readDrcCoefficientsUniDrc(HANDLE_FDK_BITSTREAM hBs,const int version,DRC_COEFFICIENTS_UNI_DRC * pCoef)1103 static DRC_ERROR _readDrcCoefficientsUniDrc(HANDLE_FDK_BITSTREAM hBs,
1104 const int version,
1105 DRC_COEFFICIENTS_UNI_DRC* pCoef) {
1106 DRC_ERROR err = DE_OK;
1107 int i, bsDrcFrameSize;
1108 int gainSequenceIndex = -1;
1109
1110 pCoef->drcLocation = FDKreadBits(hBs, 4);
1111 pCoef->drcFrameSizePresent = FDKreadBits(hBs, 1);
1112
1113 if (pCoef->drcFrameSizePresent == 1) {
1114 bsDrcFrameSize = FDKreadBits(hBs, 15);
1115 pCoef->drcFrameSize = bsDrcFrameSize + 1;
1116 }
1117 if (version == 0) {
1118 int gainSequenceCount = 0, gainSetCount;
1119 pCoef->characteristicLeftCount = 0;
1120 pCoef->characteristicRightCount = 0;
1121 gainSetCount = FDKreadBits(hBs, 6);
1122 pCoef->gainSetCount = fMin(gainSetCount, 12);
1123 for (i = 0; i < gainSetCount; i++) {
1124 GAIN_SET tmpGset;
1125 FDKmemclear(&tmpGset, sizeof(GAIN_SET));
1126 err = _readGainSet(hBs, version, &gainSequenceIndex, &tmpGset, 0);
1127 if (err) return err;
1128 gainSequenceCount += tmpGset.bandCount;
1129
1130 if (i >= 12) continue;
1131 pCoef->gainSet[i] = tmpGset;
1132 }
1133 pCoef->gainSequenceCount = gainSequenceCount;
1134 } else { /* (version == 1) */
1135 UCHAR drcCharacteristicLeftPresent, drcCharacteristicRightPresent;
1136 UCHAR shapeFiltersPresent, shapeFilterCount, tmpPresent;
1137 int gainSetCount;
1138 drcCharacteristicLeftPresent = FDKreadBits(hBs, 1);
1139 if (drcCharacteristicLeftPresent) {
1140 pCoef->characteristicLeftCount = FDKreadBits(hBs, 4);
1141 if ((pCoef->characteristicLeftCount + 1) > 16) return DE_MEMORY_ERROR;
1142 for (i = 0; i < pCoef->characteristicLeftCount; i++) {
1143 err = _readCustomDrcCharacteristic(
1144 hBs, CS_LEFT, &(pCoef->characteristicLeftFormat[i + 1]),
1145 &(pCoef->customCharacteristicLeft[i + 1]), 0);
1146 if (err) return err;
1147 }
1148 }
1149 drcCharacteristicRightPresent = FDKreadBits(hBs, 1);
1150 if (drcCharacteristicRightPresent) {
1151 pCoef->characteristicRightCount = FDKreadBits(hBs, 4);
1152 if ((pCoef->characteristicRightCount + 1) > 16) return DE_MEMORY_ERROR;
1153 for (i = 0; i < pCoef->characteristicRightCount; i++) {
1154 err = _readCustomDrcCharacteristic(
1155 hBs, CS_RIGHT, &(pCoef->characteristicRightFormat[i + 1]),
1156 &(pCoef->customCharacteristicRight[i + 1]), 0);
1157 if (err) return err;
1158 }
1159 }
1160 shapeFiltersPresent = FDKreadBits(hBs, 1);
1161 if (shapeFiltersPresent) {
1162 shapeFilterCount = FDKreadBits(hBs, 4);
1163 for (i = 0; i < shapeFilterCount; i++) {
1164 tmpPresent = FDKreadBits(hBs, 1);
1165 if (tmpPresent) /* lfCutParams */
1166 FDKpushFor(hBs, 5);
1167
1168 tmpPresent = FDKreadBits(hBs, 1);
1169 if (tmpPresent) /* lfBoostParams */
1170 FDKpushFor(hBs, 5);
1171
1172 tmpPresent = FDKreadBits(hBs, 1);
1173 if (tmpPresent) /* hfCutParams */
1174 FDKpushFor(hBs, 5);
1175
1176 tmpPresent = FDKreadBits(hBs, 1);
1177 if (tmpPresent) /* hfBoostParams */
1178 FDKpushFor(hBs, 5);
1179 }
1180 }
1181 pCoef->gainSequenceCount = FDKreadBits(hBs, 6);
1182 gainSetCount = FDKreadBits(hBs, 6);
1183 pCoef->gainSetCount = fMin(gainSetCount, 12);
1184 for (i = 0; i < gainSetCount; i++) {
1185 GAIN_SET tmpGset;
1186 FDKmemclear(&tmpGset, sizeof(GAIN_SET));
1187 err = _readGainSet(hBs, version, &gainSequenceIndex, &tmpGset, 0);
1188 if (err) return err;
1189
1190 if (i >= 12) continue;
1191 pCoef->gainSet[i] = tmpGset;
1192 }
1193 }
1194 for (i = 0; i < 12; i++) {
1195 pCoef->gainSetIndexForGainSequence[i] = 255;
1196 }
1197 for (i = 0; i < pCoef->gainSetCount; i++) {
1198 int b;
1199 for (b = 0; b < pCoef->gainSet[i].bandCount; b++) {
1200 if (pCoef->gainSet[i].gainSequenceIndex[b] >= 12) continue;
1201 pCoef->gainSetIndexForGainSequence[pCoef->gainSet[i]
1202 .gainSequenceIndex[b]] = i;
1203 }
1204 }
1205
1206 return err;
1207 }
1208
_skipDrcInstructionsBasic(HANDLE_FDK_BITSTREAM hBs)1209 static void _skipDrcInstructionsBasic(HANDLE_FDK_BITSTREAM hBs) {
1210 int drcSetEffect;
1211 int additionalDownmixIdPresent, additionalDownmixIdCount,
1212 limiterPeakTargetPresent;
1213 int drcSetTargetLoudnessPresent, drcSetTargetLoudnessValueLowerPresent;
1214
1215 FDKpushFor(hBs, 6); /* drcSetId */
1216 FDKpushFor(hBs, 4); /* drcLocation */
1217 FDKpushFor(hBs, 7); /* downmixId */
1218 additionalDownmixIdPresent = FDKreadBits(hBs, 1);
1219 if (additionalDownmixIdPresent) {
1220 additionalDownmixIdCount = FDKreadBits(hBs, 3);
1221 FDKpushFor(hBs, 7 * additionalDownmixIdCount); /* additionalDownmixId */
1222 }
1223
1224 drcSetEffect = FDKreadBits(hBs, 16);
1225 if (!(drcSetEffect & (EB_DUCK_OTHER | EB_DUCK_SELF))) {
1226 limiterPeakTargetPresent = FDKreadBits(hBs, 1);
1227 if (limiterPeakTargetPresent) {
1228 FDKpushFor(hBs, 8); /* bsLimiterPeakTarget */
1229 }
1230 }
1231
1232 drcSetTargetLoudnessPresent = FDKreadBits(hBs, 1);
1233 if (drcSetTargetLoudnessPresent) {
1234 FDKpushFor(hBs, 6); /* bsDrcSetTargetLoudnessValueUpper */
1235 drcSetTargetLoudnessValueLowerPresent = FDKreadBits(hBs, 1);
1236 if (drcSetTargetLoudnessValueLowerPresent) {
1237 FDKpushFor(hBs, 6); /* bsDrcSetTargetLoudnessValueLower */
1238 }
1239 }
1240 }
1241
_readDrcInstructionsUniDrc(HANDLE_FDK_BITSTREAM hBs,const int version,HANDLE_UNI_DRC_CONFIG hUniDrcConfig,DRC_INSTRUCTIONS_UNI_DRC * pInst)1242 static DRC_ERROR _readDrcInstructionsUniDrc(HANDLE_FDK_BITSTREAM hBs,
1243 const int version,
1244 HANDLE_UNI_DRC_CONFIG hUniDrcConfig,
1245 DRC_INSTRUCTIONS_UNI_DRC* pInst) {
1246 DRC_ERROR err = DE_OK;
1247 int i, g, c;
1248 int downmixIdPresent, additionalDownmixIdPresent, additionalDownmixIdCount;
1249 int bsLimiterPeakTarget, channelCount;
1250 DRC_COEFFICIENTS_UNI_DRC* pCoef = NULL;
1251 int repeatParameters, bsRepeatParametersCount;
1252 int repeatSequenceIndex, bsRepeatSequenceCount;
1253 SCHAR* gainSetIndex = pInst->gainSetIndex;
1254 SCHAR channelGroupForChannel[8];
1255 DUCKING_MODIFICATION duckingModificationForChannelGroup[8];
1256
1257 pInst->drcSetId = FDKreadBits(hBs, 6);
1258 if (version == 0) {
1259 /* Assume all v0 DRC sets to be manageable in terms of complexity */
1260 pInst->drcSetComplexityLevel = 2;
1261 } else {
1262 pInst->drcSetComplexityLevel = FDKreadBits(hBs, 4);
1263 }
1264 pInst->drcLocation = FDKreadBits(hBs, 4);
1265 if (version == 0) {
1266 downmixIdPresent = 1;
1267 } else {
1268 downmixIdPresent = FDKreadBits(hBs, 1);
1269 }
1270 if (downmixIdPresent) {
1271 pInst->downmixId[0] = FDKreadBits(hBs, 7);
1272 if (version == 0) {
1273 if (pInst->downmixId[0] == 0)
1274 pInst->drcApplyToDownmix = 0;
1275 else
1276 pInst->drcApplyToDownmix = 1;
1277 } else {
1278 pInst->drcApplyToDownmix = FDKreadBits(hBs, 1);
1279 }
1280
1281 additionalDownmixIdPresent = FDKreadBits(hBs, 1);
1282 if (additionalDownmixIdPresent) {
1283 additionalDownmixIdCount = FDKreadBits(hBs, 3);
1284 if ((1 + additionalDownmixIdCount) > 8) return DE_MEMORY_ERROR;
1285 for (i = 0; i < additionalDownmixIdCount; i++) {
1286 pInst->downmixId[i + 1] = FDKreadBits(hBs, 7);
1287 }
1288 pInst->downmixIdCount = 1 + additionalDownmixIdCount;
1289 } else {
1290 pInst->downmixIdCount = 1;
1291 }
1292 } else {
1293 pInst->downmixId[0] = 0;
1294 pInst->downmixIdCount = 1;
1295 }
1296
1297 pInst->drcSetEffect = FDKreadBits(hBs, 16);
1298
1299 if ((pInst->drcSetEffect & (EB_DUCK_OTHER | EB_DUCK_SELF)) == 0) {
1300 pInst->limiterPeakTargetPresent = FDKreadBits(hBs, 1);
1301 if (pInst->limiterPeakTargetPresent) {
1302 bsLimiterPeakTarget = FDKreadBits(hBs, 8);
1303 pInst->limiterPeakTarget = -(FIXP_SGL)(
1304 bsLimiterPeakTarget
1305 << (FRACT_BITS - 1 - 3 - 5)); /* - bsLimiterPeakTarget * 0.125; */
1306 }
1307 }
1308
1309 pInst->drcSetTargetLoudnessPresent = FDKreadBits(hBs, 1);
1310
1311 /* set default values */
1312 pInst->drcSetTargetLoudnessValueUpper = 0;
1313 pInst->drcSetTargetLoudnessValueLower = -63;
1314
1315 if (pInst->drcSetTargetLoudnessPresent == 1) {
1316 int bsDrcSetTargetLoudnessValueUpper, bsDrcSetTargetLoudnessValueLower;
1317 int drcSetTargetLoudnessValueLowerPresent;
1318 bsDrcSetTargetLoudnessValueUpper = FDKreadBits(hBs, 6);
1319 pInst->drcSetTargetLoudnessValueUpper =
1320 bsDrcSetTargetLoudnessValueUpper - 63;
1321 drcSetTargetLoudnessValueLowerPresent = FDKreadBits(hBs, 1);
1322 if (drcSetTargetLoudnessValueLowerPresent == 1) {
1323 bsDrcSetTargetLoudnessValueLower = FDKreadBits(hBs, 6);
1324 pInst->drcSetTargetLoudnessValueLower =
1325 bsDrcSetTargetLoudnessValueLower - 63;
1326 }
1327 }
1328
1329 pInst->dependsOnDrcSetPresent = FDKreadBits(hBs, 1);
1330
1331 pInst->noIndependentUse = 0;
1332 if (pInst->dependsOnDrcSetPresent) {
1333 pInst->dependsOnDrcSet = FDKreadBits(hBs, 6);
1334 } else {
1335 pInst->noIndependentUse = FDKreadBits(hBs, 1);
1336 }
1337
1338 if (version == 0) {
1339 pInst->requiresEq = 0;
1340 } else {
1341 pInst->requiresEq = FDKreadBits(hBs, 1);
1342 }
1343
1344 pCoef = selectDrcCoefficients(hUniDrcConfig, pInst->drcLocation);
1345
1346 pInst->drcChannelCount = channelCount =
1347 hUniDrcConfig->channelLayout.baseChannelCount;
1348
1349 if (pInst->drcSetEffect & (EB_DUCK_OTHER | EB_DUCK_SELF)) {
1350 DUCKING_MODIFICATION* pDModForChannel =
1351 pInst->duckingModificationForChannel;
1352 c = 0;
1353 while (c < channelCount) {
1354 int bsGainSetIndex;
1355 bsGainSetIndex = FDKreadBits(hBs, 6);
1356 if (c >= 8) return DE_MEMORY_ERROR;
1357 gainSetIndex[c] = bsGainSetIndex - 1;
1358 _decodeDuckingModification(hBs, &(pDModForChannel[c]), 0);
1359
1360 c++;
1361 repeatParameters = FDKreadBits(hBs, 1);
1362 if (repeatParameters == 1) {
1363 bsRepeatParametersCount = FDKreadBits(hBs, 5);
1364 bsRepeatParametersCount += 1;
1365 for (i = 0; i < bsRepeatParametersCount; i++) {
1366 if (c >= 8) return DE_MEMORY_ERROR;
1367 gainSetIndex[c] = gainSetIndex[c - 1];
1368 pDModForChannel[c] = pDModForChannel[c - 1];
1369 c++;
1370 }
1371 }
1372 }
1373 if (c > channelCount) {
1374 return DE_NOT_OK;
1375 }
1376
1377 err = deriveDrcChannelGroups(
1378 pInst->drcSetEffect, pInst->drcChannelCount, gainSetIndex,
1379 pDModForChannel, &pInst->nDrcChannelGroups,
1380 pInst->gainSetIndexForChannelGroup, channelGroupForChannel,
1381 duckingModificationForChannelGroup);
1382 if (err) return (err);
1383 } else {
1384 int deriveChannelCount = 0;
1385 if (((version == 0) || (pInst->drcApplyToDownmix != 0)) &&
1386 (pInst->downmixId[0] != DOWNMIX_ID_BASE_LAYOUT) &&
1387 (pInst->downmixId[0] != DOWNMIX_ID_ANY_DOWNMIX) &&
1388 (pInst->downmixIdCount == 1)) {
1389 if (hUniDrcConfig->downmixInstructionsCount != 0) {
1390 DOWNMIX_INSTRUCTIONS* pDown =
1391 selectDownmixInstructions(hUniDrcConfig, pInst->downmixId[0]);
1392 if (pDown == NULL) return DE_NOT_OK;
1393 pInst->drcChannelCount = channelCount =
1394 pDown->targetChannelCount; /* targetChannelCountFromDownmixId*/
1395 } else {
1396 deriveChannelCount = 1;
1397 channelCount = 1;
1398 }
1399 } else if (((version == 0) || (pInst->drcApplyToDownmix != 0)) &&
1400 ((pInst->downmixId[0] == DOWNMIX_ID_ANY_DOWNMIX) ||
1401 (pInst->downmixIdCount > 1))) {
1402 /* Set maximum channel count as upper border. The effective channel count
1403 * is set at the process function. */
1404 pInst->drcChannelCount = 8;
1405 channelCount = 1;
1406 }
1407
1408 c = 0;
1409 while (c < channelCount) {
1410 int bsGainSetIndex;
1411 bsGainSetIndex = FDKreadBits(hBs, 6);
1412 if (c >= 8) return DE_MEMORY_ERROR;
1413 gainSetIndex[c] = bsGainSetIndex - 1;
1414 c++;
1415 repeatSequenceIndex = FDKreadBits(hBs, 1);
1416
1417 if (repeatSequenceIndex == 1) {
1418 bsRepeatSequenceCount = FDKreadBits(hBs, 5);
1419 bsRepeatSequenceCount += 1;
1420 if (deriveChannelCount) {
1421 channelCount = 1 + bsRepeatSequenceCount;
1422 }
1423 for (i = 0; i < bsRepeatSequenceCount; i++) {
1424 if (c >= 8) return DE_MEMORY_ERROR;
1425 gainSetIndex[c] = bsGainSetIndex - 1;
1426 c++;
1427 }
1428 }
1429 }
1430 if (c > channelCount) {
1431 return DE_NOT_OK;
1432 }
1433 if (deriveChannelCount) {
1434 pInst->drcChannelCount = channelCount;
1435 }
1436
1437 /* DOWNMIX_ID_ANY_DOWNMIX: channelCount is 1. Distribute gainSetIndex to all
1438 * channels. */
1439 if ((pInst->downmixId[0] == DOWNMIX_ID_ANY_DOWNMIX) ||
1440 (pInst->downmixIdCount > 1)) {
1441 for (c = 1; c < pInst->drcChannelCount; c++) {
1442 gainSetIndex[c] = gainSetIndex[0];
1443 }
1444 }
1445
1446 err = deriveDrcChannelGroups(pInst->drcSetEffect, pInst->drcChannelCount,
1447 gainSetIndex, NULL, &pInst->nDrcChannelGroups,
1448 pInst->gainSetIndexForChannelGroup,
1449 channelGroupForChannel, NULL);
1450 if (err) return (err);
1451
1452 for (g = 0; g < pInst->nDrcChannelGroups; g++) {
1453 int set, bandCount;
1454 set = pInst->gainSetIndexForChannelGroup[g];
1455
1456 /* get bandCount */
1457 if (pCoef != NULL && set < pCoef->gainSetCount) {
1458 bandCount = pCoef->gainSet[set].bandCount;
1459 } else {
1460 bandCount = 1;
1461 }
1462
1463 _decodeGainModification(hBs, version, bandCount,
1464 pInst->gainModificationForChannelGroup[g], 0);
1465 }
1466 }
1467
1468 return err;
1469 }
1470
_readChannelLayout(HANDLE_FDK_BITSTREAM hBs,CHANNEL_LAYOUT * pChan)1471 static DRC_ERROR _readChannelLayout(HANDLE_FDK_BITSTREAM hBs,
1472 CHANNEL_LAYOUT* pChan) {
1473 DRC_ERROR err = DE_OK;
1474
1475 pChan->baseChannelCount = FDKreadBits(hBs, 7);
1476
1477 if (pChan->baseChannelCount > 8) return DE_NOT_OK;
1478
1479 pChan->layoutSignalingPresent = FDKreadBits(hBs, 1);
1480
1481 if (pChan->layoutSignalingPresent) {
1482 pChan->definedLayout = FDKreadBits(hBs, 8);
1483
1484 if (pChan->definedLayout == 0) {
1485 int i;
1486 for (i = 0; i < pChan->baseChannelCount; i++) {
1487 if (i < 8) {
1488 pChan->speakerPosition[i] = FDKreadBits(hBs, 7);
1489 } else {
1490 FDKpushFor(hBs, 7);
1491 }
1492 }
1493 }
1494 }
1495 return err;
1496 }
1497
_readDownmixInstructions(HANDLE_FDK_BITSTREAM hBs,const int version,CHANNEL_LAYOUT * pChan,DOWNMIX_INSTRUCTIONS * pDown)1498 static DRC_ERROR _readDownmixInstructions(HANDLE_FDK_BITSTREAM hBs,
1499 const int version,
1500 CHANNEL_LAYOUT* pChan,
1501 DOWNMIX_INSTRUCTIONS* pDown) {
1502 DRC_ERROR err = DE_OK;
1503
1504 pDown->downmixId = FDKreadBits(hBs, 7);
1505 pDown->targetChannelCount = FDKreadBits(hBs, 7);
1506 pDown->targetLayout = FDKreadBits(hBs, 8);
1507 pDown->downmixCoefficientsPresent = FDKreadBits(hBs, 1);
1508
1509 if (pDown->downmixCoefficientsPresent) {
1510 int nDownmixCoeffs = pDown->targetChannelCount * pChan->baseChannelCount;
1511 int i;
1512 if (nDownmixCoeffs > 8 * 8) return DE_NOT_OK;
1513 if (version == 0) {
1514 pDown->bsDownmixOffset = 0;
1515 for (i = 0; i < nDownmixCoeffs; i++) {
1516 /* LFE downmix coefficients are not supported. */
1517 pDown->downmixCoefficient[i] = downmixCoeff[FDKreadBits(hBs, 4)];
1518 }
1519 } else {
1520 pDown->bsDownmixOffset = FDKreadBits(hBs, 4);
1521 for (i = 0; i < nDownmixCoeffs; i++) {
1522 pDown->downmixCoefficient[i] = downmixCoeffV1[FDKreadBits(hBs, 5)];
1523 }
1524 }
1525 }
1526 return err;
1527 }
1528
_readDrcExtensionV1(HANDLE_FDK_BITSTREAM hBs,HANDLE_UNI_DRC_CONFIG hUniDrcConfig)1529 static DRC_ERROR _readDrcExtensionV1(HANDLE_FDK_BITSTREAM hBs,
1530 HANDLE_UNI_DRC_CONFIG hUniDrcConfig) {
1531 DRC_ERROR err = DE_OK;
1532 int downmixInstructionsV1Present;
1533 int drcCoeffsAndInstructionsUniDrcV1Present;
1534 int loudEqInstructionsPresent, loudEqInstructionsCount;
1535 int eqPresent, eqInstructionsCount;
1536 int i, offset;
1537 int diff = hUniDrcConfig->diff;
1538
1539 downmixInstructionsV1Present = FDKreadBits(hBs, 1);
1540 if (downmixInstructionsV1Present == 1) {
1541 diff |= _compAssign(&hUniDrcConfig->downmixInstructionsCountV1,
1542 FDKreadBits(hBs, 7));
1543 offset = hUniDrcConfig->downmixInstructionsCountV0;
1544 hUniDrcConfig->downmixInstructionsCount = fMin(
1545 (UCHAR)(offset + hUniDrcConfig->downmixInstructionsCountV1), (UCHAR)6);
1546 for (i = 0; i < hUniDrcConfig->downmixInstructionsCountV1; i++) {
1547 DOWNMIX_INSTRUCTIONS tmpDown;
1548 FDKmemclear(&tmpDown, sizeof(DOWNMIX_INSTRUCTIONS));
1549 err = _readDownmixInstructions(hBs, 1, &hUniDrcConfig->channelLayout,
1550 &tmpDown);
1551 if (err) return err;
1552 if ((offset + i) >= 6) continue;
1553 if (!diff)
1554 diff |= (FDKmemcmp(&tmpDown,
1555 &(hUniDrcConfig->downmixInstructions[offset + i]),
1556 sizeof(DOWNMIX_INSTRUCTIONS)) != 0);
1557 hUniDrcConfig->downmixInstructions[offset + i] = tmpDown;
1558 }
1559 } else {
1560 diff |= _compAssign(&hUniDrcConfig->downmixInstructionsCountV1, 0);
1561 }
1562
1563 drcCoeffsAndInstructionsUniDrcV1Present = FDKreadBits(hBs, 1);
1564 if (drcCoeffsAndInstructionsUniDrcV1Present == 1) {
1565 diff |= _compAssign(&hUniDrcConfig->drcCoefficientsUniDrcCountV1,
1566 FDKreadBits(hBs, 3));
1567 offset = hUniDrcConfig->drcCoefficientsUniDrcCountV0;
1568 hUniDrcConfig->drcCoefficientsUniDrcCount =
1569 fMin((UCHAR)(offset + hUniDrcConfig->drcCoefficientsUniDrcCountV1),
1570 (UCHAR)2);
1571 for (i = 0; i < hUniDrcConfig->drcCoefficientsUniDrcCountV1; i++) {
1572 DRC_COEFFICIENTS_UNI_DRC tmpCoef;
1573 FDKmemclear(&tmpCoef, sizeof(DRC_COEFFICIENTS_UNI_DRC));
1574 err = _readDrcCoefficientsUniDrc(hBs, 1, &tmpCoef);
1575 if (err) return err;
1576 if ((offset + i) >= 2) continue;
1577 if (!diff)
1578 diff |= (FDKmemcmp(&tmpCoef,
1579 &(hUniDrcConfig->drcCoefficientsUniDrc[offset + i]),
1580 sizeof(DRC_COEFFICIENTS_UNI_DRC)) != 0);
1581 hUniDrcConfig->drcCoefficientsUniDrc[offset + i] = tmpCoef;
1582 }
1583
1584 diff |= _compAssign(&hUniDrcConfig->drcInstructionsUniDrcCountV1,
1585 FDKreadBits(hBs, 6));
1586 offset = hUniDrcConfig->drcInstructionsUniDrcCount;
1587 hUniDrcConfig->drcInstructionsUniDrcCount =
1588 fMin((UCHAR)(offset + hUniDrcConfig->drcInstructionsUniDrcCountV1),
1589 (UCHAR)12);
1590 for (i = 0; i < hUniDrcConfig->drcInstructionsUniDrcCount; i++) {
1591 DRC_INSTRUCTIONS_UNI_DRC tmpInst;
1592 FDKmemclear(&tmpInst, sizeof(DRC_INSTRUCTIONS_UNI_DRC));
1593 err = _readDrcInstructionsUniDrc(hBs, 1, hUniDrcConfig, &tmpInst);
1594 if (err) return err;
1595 if ((offset + i) >= 12) continue;
1596 if (!diff)
1597 diff |= (FDKmemcmp(&tmpInst,
1598 &(hUniDrcConfig->drcInstructionsUniDrc[offset + i]),
1599 sizeof(DRC_INSTRUCTIONS_UNI_DRC)) != 0);
1600 hUniDrcConfig->drcInstructionsUniDrc[offset + i] = tmpInst;
1601 }
1602 } else {
1603 diff |= _compAssign(&hUniDrcConfig->drcCoefficientsUniDrcCountV1, 0);
1604 diff |= _compAssign(&hUniDrcConfig->drcInstructionsUniDrcCountV1, 0);
1605 }
1606
1607 loudEqInstructionsPresent = FDKreadBits(hBs, 1);
1608 if (loudEqInstructionsPresent == 1) {
1609 loudEqInstructionsCount = FDKreadBits(hBs, 4);
1610 for (i = 0; i < loudEqInstructionsCount; i++) {
1611 _skipLoudEqInstructions(hBs);
1612 }
1613 }
1614
1615 eqPresent = FDKreadBits(hBs, 1);
1616 if (eqPresent == 1) {
1617 _skipEqCoefficients(hBs);
1618 eqInstructionsCount = FDKreadBits(hBs, 4);
1619 for (i = 0; i < eqInstructionsCount; i++) {
1620 _skipEqInstructions(hBs, hUniDrcConfig);
1621 }
1622 }
1623
1624 hUniDrcConfig->diff = diff;
1625
1626 return err;
1627 }
1628
_readUniDrcConfigExtension(HANDLE_FDK_BITSTREAM hBs,HANDLE_UNI_DRC_CONFIG hUniDrcConfig)1629 static DRC_ERROR _readUniDrcConfigExtension(
1630 HANDLE_FDK_BITSTREAM hBs, HANDLE_UNI_DRC_CONFIG hUniDrcConfig) {
1631 DRC_ERROR err = DE_OK;
1632 int k, bitSizeLen, extSizeBits, bitSize;
1633 INT nBitsRemaining;
1634 UNI_DRC_CONFIG_EXTENSION* pExt = &(hUniDrcConfig->uniDrcConfigExt);
1635
1636 k = 0;
1637 pExt->uniDrcConfigExtType[k] = FDKreadBits(hBs, 4);
1638 while (pExt->uniDrcConfigExtType[k] != UNIDRCCONFEXT_TERM) {
1639 if (k >= (8 - 1)) return DE_MEMORY_ERROR;
1640 bitSizeLen = FDKreadBits(hBs, 4);
1641 extSizeBits = bitSizeLen + 4;
1642
1643 bitSize = FDKreadBits(hBs, extSizeBits);
1644 pExt->extBitSize[k] = bitSize + 1;
1645 nBitsRemaining = (INT)FDKgetValidBits(hBs);
1646
1647 switch (pExt->uniDrcConfigExtType[k]) {
1648 case UNIDRCCONFEXT_V1:
1649 err = _readDrcExtensionV1(hBs, hUniDrcConfig);
1650 if (err) return err;
1651 if (nBitsRemaining !=
1652 ((INT)pExt->extBitSize[k] + (INT)FDKgetValidBits(hBs)))
1653 return DE_NOT_OK;
1654 break;
1655 case UNIDRCCONFEXT_PARAM_DRC:
1656 /* add future extensions here */
1657 default:
1658 FDKpushFor(hBs, pExt->extBitSize[k]);
1659 break;
1660 }
1661 k++;
1662 pExt->uniDrcConfigExtType[k] = FDKreadBits(hBs, 4);
1663 }
1664
1665 return err;
1666 }
1667
1668 DRC_ERROR
drcDec_readUniDrcConfig(HANDLE_FDK_BITSTREAM hBs,HANDLE_UNI_DRC_CONFIG hUniDrcConfig)1669 drcDec_readUniDrcConfig(HANDLE_FDK_BITSTREAM hBs,
1670 HANDLE_UNI_DRC_CONFIG hUniDrcConfig) {
1671 DRC_ERROR err = DE_OK;
1672 int i, diff = 0;
1673 int drcDescriptionBasicPresent, drcCoefficientsBasicCount,
1674 drcInstructionsBasicCount;
1675 CHANNEL_LAYOUT tmpChan;
1676 FDKmemclear(&tmpChan, sizeof(CHANNEL_LAYOUT));
1677 if (hUniDrcConfig == NULL) return DE_NOT_OK;
1678
1679 diff |= _compAssign(&hUniDrcConfig->sampleRatePresent, FDKreadBits(hBs, 1));
1680
1681 if (hUniDrcConfig->sampleRatePresent == 1) {
1682 diff |=
1683 _compAssign(&hUniDrcConfig->sampleRate, FDKreadBits(hBs, 18) + 1000);
1684 }
1685
1686 diff |= _compAssign(&hUniDrcConfig->downmixInstructionsCountV0,
1687 FDKreadBits(hBs, 7));
1688
1689 drcDescriptionBasicPresent = FDKreadBits(hBs, 1);
1690 if (drcDescriptionBasicPresent == 1) {
1691 drcCoefficientsBasicCount = FDKreadBits(hBs, 3);
1692 drcInstructionsBasicCount = FDKreadBits(hBs, 4);
1693 } else {
1694 drcCoefficientsBasicCount = 0;
1695 drcInstructionsBasicCount = 0;
1696 }
1697
1698 diff |= _compAssign(&hUniDrcConfig->drcCoefficientsUniDrcCountV0,
1699 FDKreadBits(hBs, 3));
1700 diff |= _compAssign(&hUniDrcConfig->drcInstructionsUniDrcCountV0,
1701 FDKreadBits(hBs, 6));
1702
1703 err = _readChannelLayout(hBs, &tmpChan);
1704 if (err) return err;
1705
1706 if (!diff)
1707 diff |= (FDKmemcmp(&tmpChan, &hUniDrcConfig->channelLayout,
1708 sizeof(CHANNEL_LAYOUT)) != 0);
1709 hUniDrcConfig->channelLayout = tmpChan;
1710
1711 hUniDrcConfig->downmixInstructionsCount =
1712 fMin(hUniDrcConfig->downmixInstructionsCountV0, (UCHAR)6);
1713 for (i = 0; i < hUniDrcConfig->downmixInstructionsCountV0; i++) {
1714 DOWNMIX_INSTRUCTIONS tmpDown;
1715 FDKmemclear(&tmpDown, sizeof(DOWNMIX_INSTRUCTIONS));
1716 err = _readDownmixInstructions(hBs, 0, &hUniDrcConfig->channelLayout,
1717 &tmpDown);
1718 if (err) return err;
1719 if (i >= 6) continue;
1720 if (!diff)
1721 diff |= (FDKmemcmp(&tmpDown, &(hUniDrcConfig->downmixInstructions[i]),
1722 sizeof(DOWNMIX_INSTRUCTIONS)) != 0);
1723 hUniDrcConfig->downmixInstructions[i] = tmpDown;
1724 }
1725
1726 for (i = 0; i < drcCoefficientsBasicCount; i++) {
1727 _skipDrcCoefficientsBasic(hBs);
1728 }
1729 for (i = 0; i < drcInstructionsBasicCount; i++) {
1730 _skipDrcInstructionsBasic(hBs);
1731 }
1732
1733 hUniDrcConfig->drcCoefficientsUniDrcCount =
1734 fMin(hUniDrcConfig->drcCoefficientsUniDrcCountV0, (UCHAR)2);
1735 for (i = 0; i < hUniDrcConfig->drcCoefficientsUniDrcCountV0; i++) {
1736 DRC_COEFFICIENTS_UNI_DRC tmpCoef;
1737 FDKmemclear(&tmpCoef, sizeof(DRC_COEFFICIENTS_UNI_DRC));
1738 err = _readDrcCoefficientsUniDrc(hBs, 0, &tmpCoef);
1739 if (err) return err;
1740 if (i >= 2) continue;
1741 if (!diff)
1742 diff |= (FDKmemcmp(&tmpCoef, &(hUniDrcConfig->drcCoefficientsUniDrc[i]),
1743 sizeof(DRC_COEFFICIENTS_UNI_DRC)) != 0);
1744 hUniDrcConfig->drcCoefficientsUniDrc[i] = tmpCoef;
1745 }
1746
1747 hUniDrcConfig->drcInstructionsUniDrcCount =
1748 fMin(hUniDrcConfig->drcInstructionsUniDrcCountV0, (UCHAR)12);
1749 for (i = 0; i < hUniDrcConfig->drcInstructionsUniDrcCountV0; i++) {
1750 DRC_INSTRUCTIONS_UNI_DRC tmpInst;
1751 FDKmemclear(&tmpInst, sizeof(DRC_INSTRUCTIONS_UNI_DRC));
1752 err = _readDrcInstructionsUniDrc(hBs, 0, hUniDrcConfig, &tmpInst);
1753 if (err) return err;
1754 if (i >= 12) continue;
1755 if (!diff)
1756 diff |= (FDKmemcmp(&tmpInst, &(hUniDrcConfig->drcInstructionsUniDrc[i]),
1757 sizeof(DRC_INSTRUCTIONS_UNI_DRC)) != 0);
1758 hUniDrcConfig->drcInstructionsUniDrc[i] = tmpInst;
1759 }
1760
1761 diff |=
1762 _compAssign(&hUniDrcConfig->uniDrcConfigExtPresent, FDKreadBits(hBs, 1));
1763 hUniDrcConfig->diff = diff;
1764
1765 if (hUniDrcConfig->uniDrcConfigExtPresent == 1) {
1766 err = _readUniDrcConfigExtension(hBs, hUniDrcConfig);
1767 if (err) return err;
1768 }
1769
1770 return err;
1771 }
1772
1773 /*******************/
1774 /* loudnessInfoSet */
1775 /*******************/
1776
_decodeMethodValue(HANDLE_FDK_BITSTREAM hBs,const UCHAR methodDefinition,FIXP_DBL * methodValue,INT isBox)1777 static DRC_ERROR _decodeMethodValue(HANDLE_FDK_BITSTREAM hBs,
1778 const UCHAR methodDefinition,
1779 FIXP_DBL* methodValue, INT isBox) {
1780 int tmp;
1781 FIXP_DBL val;
1782 switch (methodDefinition) {
1783 case MD_UNKNOWN_OTHER:
1784 case MD_PROGRAM_LOUDNESS:
1785 case MD_ANCHOR_LOUDNESS:
1786 case MD_MAX_OF_LOUDNESS_RANGE:
1787 case MD_MOMENTARY_LOUDNESS_MAX:
1788 case MD_SHORT_TERM_LOUDNESS_MAX:
1789 tmp = FDKreadBits(hBs, 8);
1790 val = FL2FXCONST_DBL(-57.75f / (float)(1 << 7)) +
1791 (FIXP_DBL)(
1792 tmp << (DFRACT_BITS - 1 - 2 - 7)); /* -57.75 + tmp * 0.25; */
1793 break;
1794 case MD_LOUDNESS_RANGE:
1795 tmp = FDKreadBits(hBs, 8);
1796 if (tmp == 0)
1797 val = (FIXP_DBL)0;
1798 else if (tmp <= 128)
1799 val = (FIXP_DBL)(tmp << (DFRACT_BITS - 1 - 2 - 7)); /* tmp * 0.25; */
1800 else if (tmp <= 204) {
1801 val = (FIXP_DBL)(tmp << (DFRACT_BITS - 1 - 1 - 7)) -
1802 FL2FXCONST_DBL(32.0f / (float)(1 << 7)); /* 0.5 * tmp - 32.0f; */
1803 } else {
1804 /* downscale by 1 more bit to prevent overflow at intermediate result */
1805 val = (FIXP_DBL)(tmp << (DFRACT_BITS - 1 - 8)) -
1806 FL2FXCONST_DBL(134.0f / (float)(1 << 8)); /* tmp - 134.0; */
1807 val <<= 1;
1808 }
1809 break;
1810 case MD_MIXING_LEVEL:
1811 tmp = FDKreadBits(hBs, isBox ? 8 : 5);
1812 val = (FIXP_DBL)(tmp << (DFRACT_BITS - 1 - 7)) +
1813 FL2FXCONST_DBL(80.0f / (float)(1 << 7)); /* tmp + 80.0; */
1814 break;
1815 case MD_ROOM_TYPE:
1816 tmp = FDKreadBits(hBs, isBox ? 8 : 2);
1817 val = (FIXP_DBL)(tmp << (DFRACT_BITS - 1 - 7)); /* tmp; */
1818 break;
1819 case MD_SHORT_TERM_LOUDNESS:
1820 tmp = FDKreadBits(hBs, 8);
1821 val = FL2FXCONST_DBL(-116.0f / (float)(1 << 7)) +
1822 (FIXP_DBL)(
1823 tmp << (DFRACT_BITS - 1 - 1 - 7)); /* -116.0 + tmp * 0.5; */
1824 break;
1825 default:
1826 return DE_NOT_OK; /* invalid methodDefinition value */
1827 }
1828 *methodValue = val;
1829 return DE_OK;
1830 }
1831
_readLoudnessMeasurement(HANDLE_FDK_BITSTREAM hBs,LOUDNESS_MEASUREMENT * pMeas)1832 static DRC_ERROR _readLoudnessMeasurement(HANDLE_FDK_BITSTREAM hBs,
1833 LOUDNESS_MEASUREMENT* pMeas) {
1834 DRC_ERROR err = DE_OK;
1835
1836 pMeas->methodDefinition = FDKreadBits(hBs, 4);
1837 err =
1838 _decodeMethodValue(hBs, pMeas->methodDefinition, &pMeas->methodValue, 0);
1839 if (err) return err;
1840 pMeas->measurementSystem = FDKreadBits(hBs, 4);
1841 pMeas->reliability = FDKreadBits(hBs, 2);
1842
1843 return err;
1844 }
1845
_readLoudnessInfo(HANDLE_FDK_BITSTREAM hBs,const int version,LOUDNESS_INFO * loudnessInfo)1846 static DRC_ERROR _readLoudnessInfo(HANDLE_FDK_BITSTREAM hBs, const int version,
1847 LOUDNESS_INFO* loudnessInfo) {
1848 DRC_ERROR err = DE_OK;
1849 int bsSamplePeakLevel, bsTruePeakLevel, i;
1850 int measurementCount;
1851
1852 loudnessInfo->drcSetId = FDKreadBits(hBs, 6);
1853 if (version >= 1) {
1854 loudnessInfo->eqSetId = FDKreadBits(hBs, 6);
1855 } else {
1856 loudnessInfo->eqSetId = 0;
1857 }
1858 loudnessInfo->downmixId = FDKreadBits(hBs, 7);
1859
1860 loudnessInfo->samplePeakLevelPresent = FDKreadBits(hBs, 1);
1861 if (loudnessInfo->samplePeakLevelPresent) {
1862 bsSamplePeakLevel = FDKreadBits(hBs, 12);
1863 if (bsSamplePeakLevel == 0) {
1864 loudnessInfo->samplePeakLevelPresent = 0;
1865 loudnessInfo->samplePeakLevel = (FIXP_DBL)0;
1866 } else { /* 20.0 - bsSamplePeakLevel * 0.03125; */
1867 loudnessInfo->samplePeakLevel =
1868 FL2FXCONST_DBL(20.0f / (float)(1 << 7)) -
1869 (FIXP_DBL)(bsSamplePeakLevel << (DFRACT_BITS - 1 - 5 - 7));
1870 }
1871 }
1872
1873 loudnessInfo->truePeakLevelPresent = FDKreadBits(hBs, 1);
1874 if (loudnessInfo->truePeakLevelPresent) {
1875 bsTruePeakLevel = FDKreadBits(hBs, 12);
1876 if (bsTruePeakLevel == 0) {
1877 loudnessInfo->truePeakLevelPresent = 0;
1878 loudnessInfo->truePeakLevel = (FIXP_DBL)0;
1879 } else {
1880 loudnessInfo->truePeakLevel =
1881 FL2FXCONST_DBL(20.0f / (float)(1 << 7)) -
1882 (FIXP_DBL)(bsTruePeakLevel << (DFRACT_BITS - 1 - 5 - 7));
1883 }
1884 loudnessInfo->truePeakLevelMeasurementSystem = FDKreadBits(hBs, 4);
1885 loudnessInfo->truePeakLevelReliability = FDKreadBits(hBs, 2);
1886 }
1887
1888 measurementCount = FDKreadBits(hBs, 4);
1889 loudnessInfo->measurementCount = fMin(measurementCount, 8);
1890 for (i = 0; i < measurementCount; i++) {
1891 LOUDNESS_MEASUREMENT tmpMeas;
1892 FDKmemclear(&tmpMeas, sizeof(LOUDNESS_MEASUREMENT));
1893 err = _readLoudnessMeasurement(hBs, &tmpMeas);
1894 if (err) return err;
1895 if (i >= 8) continue;
1896 loudnessInfo->loudnessMeasurement[i] = tmpMeas;
1897 }
1898
1899 return err;
1900 }
1901
_readLoudnessInfoSetExtEq(HANDLE_FDK_BITSTREAM hBs,HANDLE_LOUDNESS_INFO_SET hLoudnessInfoSet)1902 static DRC_ERROR _readLoudnessInfoSetExtEq(
1903 HANDLE_FDK_BITSTREAM hBs, HANDLE_LOUDNESS_INFO_SET hLoudnessInfoSet) {
1904 DRC_ERROR err = DE_OK;
1905 int i, offset;
1906 int diff = hLoudnessInfoSet->diff;
1907
1908 diff |= _compAssign(&hLoudnessInfoSet->loudnessInfoAlbumCountV1,
1909 FDKreadBits(hBs, 6));
1910 diff |=
1911 _compAssign(&hLoudnessInfoSet->loudnessInfoCountV1, FDKreadBits(hBs, 6));
1912
1913 offset = hLoudnessInfoSet->loudnessInfoAlbumCountV0;
1914 hLoudnessInfoSet->loudnessInfoAlbumCount = fMin(
1915 (UCHAR)(offset + hLoudnessInfoSet->loudnessInfoAlbumCountV1), (UCHAR)12);
1916 for (i = 0; i < hLoudnessInfoSet->loudnessInfoAlbumCountV1; i++) {
1917 LOUDNESS_INFO tmpLoud;
1918 FDKmemclear(&tmpLoud, sizeof(LOUDNESS_INFO));
1919 err = _readLoudnessInfo(hBs, 1, &tmpLoud);
1920 if (err) return err;
1921 if ((offset + i) >= 12) continue;
1922 if (!diff)
1923 diff |= (FDKmemcmp(&tmpLoud,
1924 &(hLoudnessInfoSet->loudnessInfoAlbum[offset + i]),
1925 sizeof(LOUDNESS_INFO)) != 0);
1926 hLoudnessInfoSet->loudnessInfoAlbum[offset + i] = tmpLoud;
1927 }
1928
1929 offset = hLoudnessInfoSet->loudnessInfoCountV0;
1930 hLoudnessInfoSet->loudnessInfoCount =
1931 fMin((UCHAR)(offset + hLoudnessInfoSet->loudnessInfoCountV1), (UCHAR)12);
1932 for (i = 0; i < hLoudnessInfoSet->loudnessInfoCountV1; i++) {
1933 LOUDNESS_INFO tmpLoud;
1934 FDKmemclear(&tmpLoud, sizeof(LOUDNESS_INFO));
1935 err = _readLoudnessInfo(hBs, 1, &tmpLoud);
1936 if (err) return err;
1937 if ((offset + i) >= 12) continue;
1938 if (!diff)
1939 diff |=
1940 (FDKmemcmp(&tmpLoud, &(hLoudnessInfoSet->loudnessInfo[offset + i]),
1941 sizeof(LOUDNESS_INFO)) != 0);
1942 hLoudnessInfoSet->loudnessInfo[offset + i] = tmpLoud;
1943 }
1944 hLoudnessInfoSet->diff = diff;
1945 return err;
1946 }
1947
_readLoudnessInfoSetExtension(HANDLE_FDK_BITSTREAM hBs,HANDLE_LOUDNESS_INFO_SET hLoudnessInfoSet)1948 static DRC_ERROR _readLoudnessInfoSetExtension(
1949 HANDLE_FDK_BITSTREAM hBs, HANDLE_LOUDNESS_INFO_SET hLoudnessInfoSet) {
1950 DRC_ERROR err = DE_OK;
1951 int k, bitSizeLen, extSizeBits, bitSize;
1952 INT nBitsRemaining;
1953 LOUDNESS_INFO_SET_EXTENSION* pExt = &(hLoudnessInfoSet->loudnessInfoSetExt);
1954
1955 k = 0;
1956 pExt->loudnessInfoSetExtType[k] = FDKreadBits(hBs, 4);
1957 while (pExt->loudnessInfoSetExtType[k] != UNIDRCLOUDEXT_TERM) {
1958 if (k >= (8 - 1)) return DE_MEMORY_ERROR;
1959 bitSizeLen = FDKreadBits(hBs, 4);
1960 extSizeBits = bitSizeLen + 4;
1961
1962 bitSize = FDKreadBits(hBs, extSizeBits);
1963 pExt->extBitSize[k] = bitSize + 1;
1964 nBitsRemaining = (INT)FDKgetValidBits(hBs);
1965
1966 switch (pExt->loudnessInfoSetExtType[k]) {
1967 case UNIDRCLOUDEXT_EQ:
1968 err = _readLoudnessInfoSetExtEq(hBs, hLoudnessInfoSet);
1969 if (err) return err;
1970 if (nBitsRemaining !=
1971 ((INT)pExt->extBitSize[k] + (INT)FDKgetValidBits(hBs)))
1972 return DE_NOT_OK;
1973 break;
1974 /* add future extensions here */
1975 default:
1976 FDKpushFor(hBs, pExt->extBitSize[k]);
1977 break;
1978 }
1979 k++;
1980 pExt->loudnessInfoSetExtType[k] = FDKreadBits(hBs, 4);
1981 }
1982
1983 return err;
1984 }
1985
1986 /* Parser for loundessInfoSet() */
1987 DRC_ERROR
drcDec_readLoudnessInfoSet(HANDLE_FDK_BITSTREAM hBs,HANDLE_LOUDNESS_INFO_SET hLoudnessInfoSet)1988 drcDec_readLoudnessInfoSet(HANDLE_FDK_BITSTREAM hBs,
1989 HANDLE_LOUDNESS_INFO_SET hLoudnessInfoSet) {
1990 DRC_ERROR err = DE_OK;
1991 int i, diff = 0;
1992 if (hLoudnessInfoSet == NULL) return DE_NOT_OK;
1993
1994 diff |= _compAssign(&hLoudnessInfoSet->loudnessInfoAlbumCountV0,
1995 FDKreadBits(hBs, 6));
1996 diff |=
1997 _compAssign(&hLoudnessInfoSet->loudnessInfoCountV0, FDKreadBits(hBs, 6));
1998
1999 hLoudnessInfoSet->loudnessInfoAlbumCount =
2000 fMin(hLoudnessInfoSet->loudnessInfoAlbumCountV0, (UCHAR)12);
2001 for (i = 0; i < hLoudnessInfoSet->loudnessInfoAlbumCountV0; i++) {
2002 LOUDNESS_INFO tmpLoud;
2003 FDKmemclear(&tmpLoud, sizeof(LOUDNESS_INFO));
2004 err = _readLoudnessInfo(hBs, 0, &tmpLoud);
2005 if (err) return err;
2006 if (i >= 12) continue;
2007 if (!diff)
2008 diff |= (FDKmemcmp(&tmpLoud, &(hLoudnessInfoSet->loudnessInfoAlbum[i]),
2009 sizeof(LOUDNESS_INFO)) != 0);
2010 hLoudnessInfoSet->loudnessInfoAlbum[i] = tmpLoud;
2011 }
2012
2013 hLoudnessInfoSet->loudnessInfoCount =
2014 fMin(hLoudnessInfoSet->loudnessInfoCountV0, (UCHAR)12);
2015 for (i = 0; i < hLoudnessInfoSet->loudnessInfoCountV0; i++) {
2016 LOUDNESS_INFO tmpLoud;
2017 FDKmemclear(&tmpLoud, sizeof(LOUDNESS_INFO));
2018 err = _readLoudnessInfo(hBs, 0, &tmpLoud);
2019 if (err) return err;
2020 if (i >= 12) continue;
2021 if (!diff)
2022 diff |= (FDKmemcmp(&tmpLoud, &(hLoudnessInfoSet->loudnessInfo[i]),
2023 sizeof(LOUDNESS_INFO)) != 0);
2024 hLoudnessInfoSet->loudnessInfo[i] = tmpLoud;
2025 }
2026
2027 diff |= _compAssign(&hLoudnessInfoSet->loudnessInfoSetExtPresent,
2028 FDKreadBits(hBs, 1));
2029 hLoudnessInfoSet->diff = diff;
2030
2031 if (hLoudnessInfoSet->loudnessInfoSetExtPresent) {
2032 err = _readLoudnessInfoSetExtension(hBs, hLoudnessInfoSet);
2033 if (err) return err;
2034 }
2035
2036 return err;
2037 }
2038