1 /* -----------------------------------------------------------------------------
2 Software License for The Fraunhofer FDK AAC Codec Library for Android
3
4 © Copyright 1995 - 2020 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 /**************************** SBR decoder library ******************************
96
97 Author(s):
98
99 Description:
100
101 *******************************************************************************/
102
103 /*!
104 \file
105 \brief Sbr decoder
106 This module provides the actual decoder implementation. The SBR data (side
107 information) is already decoded. Only three functions are provided:
108
109 \li 1.) createSbrDec(): One time initialization
110 \li 2.) resetSbrDec(): Called by sbr_Apply() when the information contained in
111 an SBR_HEADER_ELEMENT requires a reset and recalculation of important SBR
112 structures. \li 3.) sbr_dec(): The actual decoder. Calls the different tools
113 such as filterbanks, lppTransposer(), and calculateSbrEnvelope() [the envelope
114 adjuster].
115
116 \sa sbr_dec(), \ref documentationOverview
117 */
118
119 #include "sbr_dec.h"
120
121 #include "sbr_ram.h"
122 #include "env_extr.h"
123 #include "env_calc.h"
124 #include "scale.h"
125 #include "FDK_matrixCalloc.h"
126 #include "hbe.h"
127
128 #include "genericStds.h"
129
130 #include "sbrdec_drc.h"
131
copyHarmonicSpectrum(int * xOverQmf,FIXP_DBL ** qmfReal,FIXP_DBL ** qmfImag,int noCols,int overlap,KEEP_STATES_SYNCED_MODE keepStatesSynced)132 static void copyHarmonicSpectrum(int *xOverQmf, FIXP_DBL **qmfReal,
133 FIXP_DBL **qmfImag, int noCols, int overlap,
134 KEEP_STATES_SYNCED_MODE keepStatesSynced) {
135 int patchBands;
136 int patch, band, col, target, sourceBands, i;
137 int numPatches = 0;
138 int slotOffset = 0;
139
140 FIXP_DBL **ppqmfReal = qmfReal + overlap;
141 FIXP_DBL **ppqmfImag = qmfImag + overlap;
142
143 if (keepStatesSynced == KEEP_STATES_SYNCED_NORMAL) {
144 slotOffset = noCols - overlap - LPC_ORDER;
145 }
146
147 if (keepStatesSynced == KEEP_STATES_SYNCED_OUTDIFF) {
148 ppqmfReal = qmfReal;
149 ppqmfImag = qmfImag;
150 }
151
152 for (i = 1; i < MAX_NUM_PATCHES; i++) {
153 if (xOverQmf[i] != 0) {
154 numPatches++;
155 }
156 }
157
158 for (patch = (MAX_STRETCH_HBE - 1); patch < numPatches; patch++) {
159 patchBands = xOverQmf[patch + 1] - xOverQmf[patch];
160 target = xOverQmf[patch];
161 sourceBands = xOverQmf[MAX_STRETCH_HBE - 1] - xOverQmf[MAX_STRETCH_HBE - 2];
162
163 while (patchBands > 0) {
164 int numBands = sourceBands;
165 int startBand = xOverQmf[MAX_STRETCH_HBE - 1] - 1;
166 if (target + numBands >= xOverQmf[patch + 1]) {
167 numBands = xOverQmf[patch + 1] - target;
168 }
169 if ((((target + numBands - 1) % 2) +
170 ((xOverQmf[MAX_STRETCH_HBE - 1] - 1) % 2)) %
171 2) {
172 if (numBands == sourceBands) {
173 numBands--;
174 } else {
175 startBand--;
176 }
177 }
178 if (keepStatesSynced == KEEP_STATES_SYNCED_OUTDIFF) {
179 for (col = slotOffset; col < overlap + LPC_ORDER; col++) {
180 i = 0;
181 for (band = numBands; band > 0; band--) {
182 if ((target + band - 1 < 64) &&
183 (target + band - 1 < xOverQmf[patch + 1])) {
184 ppqmfReal[col][target + band - 1] = ppqmfReal[col][startBand - i];
185 ppqmfImag[col][target + band - 1] = ppqmfImag[col][startBand - i];
186 i++;
187 }
188 }
189 }
190 } else {
191 for (col = slotOffset; col < noCols; col++) {
192 i = 0;
193 for (band = numBands; band > 0; band--) {
194 if ((target + band - 1 < 64) &&
195 (target + band - 1 < xOverQmf[patch + 1])) {
196 ppqmfReal[col][target + band - 1] = ppqmfReal[col][startBand - i];
197 ppqmfImag[col][target + band - 1] = ppqmfImag[col][startBand - i];
198 i++;
199 }
200 }
201 }
202 }
203 target += numBands;
204 patchBands -= numBands;
205 }
206 }
207 }
208
209 /*!
210 \brief SBR decoder core function for one channel
211
212 \image html BufferMgmtDetailed-1632.png
213
214 Besides the filter states of the QMF filter bank and the LPC-states of
215 the LPP-Transposer, processing is mainly based on four buffers:
216 #timeIn, #timeOut, #WorkBuffer2 and #OverlapBuffer. The #WorkBuffer2
217 is reused for all channels and might be used by the core decoder, a
218 static overlap buffer is required for each channel. Due to in-place
219 processing, #timeIn and #timeOut point to identical locations.
220
221 The spectral data is organized in so-called slots. Each slot
222 contains 64 bands of complex data. The number of slots per frame
223 depends on the frame size. For mp3PRO, there are 18 slots per frame
224 and 6 slots per #OverlapBuffer. It is not necessary to have the slots
225 in located consecutive address ranges.
226
227 To optimize memory usage and to minimize the number of memory
228 accesses, the memory management is organized as follows (slot numbers
229 based on mp3PRO):
230
231 1.) Input time domain signal is located in #timeIn. The last slots
232 (0..5) of the spectral data of the previous frame are located in the
233 #OverlapBuffer. In addition, #frameData of the current frame resides
234 in the upper part of #timeIn.
235
236 2.) During the cplxAnalysisQmfFiltering(), 32 samples from #timeIn are
237 transformed into a slot of up to 32 complex spectral low band values at a
238 time. The first spectral slot -- nr. 6 -- is written at slot number
239 zero of #WorkBuffer2. #WorkBuffer2 will be completely filled with
240 spectral data.
241
242 3.) LPP-Transposition in lppTransposer() is processed on 24 slots. During the
243 transposition, the high band part of the spectral data is replicated
244 based on the low band data.
245
246 Envelope Adjustment is processed on the high band part of the spectral
247 data only by calculateSbrEnvelope().
248
249 4.) The cplxSynthesisQmfFiltering() creates 64 time domain samples out
250 of a slot of 64 complex spectral values at a time. The first 6 slots
251 in #timeOut are filled from the results of spectral slots 0..5 in the
252 #OverlapBuffer. The consecutive slots in timeOut are now filled with
253 the results of spectral slots 6..17.
254
255 5.) The preprocessed slots 18..23 have to be stored in the
256 #OverlapBuffer.
257
258 */
259
sbr_dec(HANDLE_SBR_DEC hSbrDec,LONG * timeIn,LONG * timeOut,HANDLE_SBR_DEC hSbrDecRight,LONG * timeOutRight,const int strideOut,HANDLE_SBR_HEADER_DATA hHeaderData,HANDLE_SBR_FRAME_DATA hFrameData,HANDLE_SBR_PREV_FRAME_DATA hPrevFrameData,const int applyProcessing,HANDLE_PS_DEC h_ps_d,const UINT flags,const int codecFrameSize,const INT sbrInDataHeadroom)260 void sbr_dec(
261 HANDLE_SBR_DEC hSbrDec, /*!< handle to Decoder channel */
262 LONG *timeIn, /*!< pointer to input time signal */
263 LONG *timeOut, /*!< pointer to output time signal */
264 HANDLE_SBR_DEC hSbrDecRight, /*!< handle to Decoder channel right */
265 LONG *timeOutRight, /*!< pointer to output time signal */
266 const int strideOut, /*!< Time data traversal strideOut */
267 HANDLE_SBR_HEADER_DATA hHeaderData, /*!< Static control data */
268 HANDLE_SBR_FRAME_DATA hFrameData, /*!< Control data of current frame */
269 HANDLE_SBR_PREV_FRAME_DATA
270 hPrevFrameData, /*!< Some control data of last frame */
271 const int applyProcessing, /*!< Flag for SBR operation */
272 HANDLE_PS_DEC h_ps_d, const UINT flags, const int codecFrameSize,
273 const INT sbrInDataHeadroom) {
274 int i, slot, reserve;
275 int saveLbScale;
276 int lastSlotOffs;
277 FIXP_DBL maxVal;
278
279 /* temporary pointer / variable for QMF;
280 required as we want to use temporary buffer
281 creating one frame delay for HBE in LP mode */
282 LONG *pTimeInQmf = timeIn;
283
284 /* Number of QMF timeslots in the overlap buffer: */
285 int ov_len = hSbrDec->LppTrans.pSettings->overlap;
286
287 /* Number of QMF slots per frame */
288 int noCols = hHeaderData->numberTimeSlots * hHeaderData->timeStep;
289
290 /* create pointer array for data to use for HBE and legacy sbr */
291 FIXP_DBL *pLowBandReal[(3 * 4) + 2 * ((1024) / (32) * (4) / 2)];
292 FIXP_DBL *pLowBandImag[(3 * 4) + 2 * ((1024) / (32) * (4) / 2)];
293
294 /* set pReal to where QMF analysis writes in case of legacy SBR */
295 FIXP_DBL **pReal = pLowBandReal + ov_len;
296 FIXP_DBL **pImag = pLowBandImag + ov_len;
297
298 /* map QMF buffer to pointer array (Overlap + Frame)*/
299 for (i = 0; i < noCols + ov_len; i++) {
300 pLowBandReal[i] = hSbrDec->qmfDomainInCh->hQmfSlotsReal[i];
301 pLowBandImag[i] = hSbrDec->qmfDomainInCh->hQmfSlotsImag[i];
302 }
303
304 if ((flags & SBRDEC_USAC_HARMONICSBR)) {
305 /* in case of harmonic SBR and no HBE_LP map additional buffer for
306 one more frame to pointer arry */
307 for (i = 0; i < noCols; i++) {
308 pLowBandReal[i + noCols + ov_len] = hSbrDec->hQmfHBESlotsReal[i];
309 pLowBandImag[i + noCols + ov_len] = hSbrDec->hQmfHBESlotsImag[i];
310 }
311
312 /* shift scale values according to buffer */
313 hSbrDec->scale_ov = hSbrDec->scale_lb;
314 hSbrDec->scale_lb = hSbrDec->scale_hbe;
315
316 /* set pReal to where QMF analysis writes in case of HBE */
317 pReal += noCols;
318 pImag += noCols;
319 if (flags & SBRDEC_SKIP_QMF_ANA) {
320 /* stereoCfgIndex3 with HBE */
321 FDK_QmfDomain_QmfData2HBE(hSbrDec->qmfDomainInCh,
322 hSbrDec->hQmfHBESlotsReal,
323 hSbrDec->hQmfHBESlotsImag);
324 } else {
325 /* We have to move old hbe frame data to lb area of buffer */
326 for (i = 0; i < noCols; i++) {
327 FDKmemcpy(pLowBandReal[ov_len + i], hSbrDec->hQmfHBESlotsReal[i],
328 hHeaderData->numberOfAnalysisBands * sizeof(FIXP_DBL));
329 FDKmemcpy(pLowBandImag[ov_len + i], hSbrDec->hQmfHBESlotsImag[i],
330 hHeaderData->numberOfAnalysisBands * sizeof(FIXP_DBL));
331 }
332 }
333 }
334
335 /*
336 low band codec signal subband filtering
337 */
338
339 if (flags & SBRDEC_SKIP_QMF_ANA) {
340 if (!(flags & SBRDEC_USAC_HARMONICSBR)) /* stereoCfgIndex3 w/o HBE */
341 FDK_QmfDomain_WorkBuffer2ProcChannel(hSbrDec->qmfDomainInCh);
342 } else {
343 C_AALLOC_SCRATCH_START(qmfTemp, FIXP_DBL, 2 * (64));
344 qmfAnalysisFiltering(&hSbrDec->qmfDomainInCh->fb, pReal, pImag,
345 &hSbrDec->qmfDomainInCh->scaling, pTimeInQmf,
346 0 + sbrInDataHeadroom, 1, qmfTemp);
347
348 C_AALLOC_SCRATCH_END(qmfTemp, FIXP_DBL, 2 * (64));
349 }
350
351 /*
352 Clear upper half of spectrum
353 */
354 if (!((flags & SBRDEC_USAC_HARMONICSBR) &&
355 (hFrameData->sbrPatchingMode == 0))) {
356 int nAnalysisBands = hHeaderData->numberOfAnalysisBands;
357
358 if (!(flags & SBRDEC_LOW_POWER)) {
359 for (slot = ov_len; slot < noCols + ov_len; slot++) {
360 FDKmemclear(&pLowBandReal[slot][nAnalysisBands],
361 ((64) - nAnalysisBands) * sizeof(FIXP_DBL));
362 FDKmemclear(&pLowBandImag[slot][nAnalysisBands],
363 ((64) - nAnalysisBands) * sizeof(FIXP_DBL));
364 }
365 } else {
366 for (slot = ov_len; slot < noCols + ov_len; slot++) {
367 FDKmemclear(&pLowBandReal[slot][nAnalysisBands],
368 ((64) - nAnalysisBands) * sizeof(FIXP_DBL));
369 }
370 }
371 }
372
373 /*
374 Shift spectral data left to gain accuracy in transposer and adjustor
375 */
376 /* Range was increased from lsb to no_channels because in some cases (e.g.
377 USAC conf eSbr_4_Pvc.mp4 and some HBE cases) it could be observed that the
378 signal between lsb and no_channels is used for the patching process.
379 */
380 maxVal = maxSubbandSample(pReal, (flags & SBRDEC_LOW_POWER) ? NULL : pImag, 0,
381 hSbrDec->qmfDomainInCh->fb.no_channels, 0, noCols);
382
383 reserve = fixMax(0, CntLeadingZeros(maxVal) - 1);
384 reserve = fixMin(reserve,
385 DFRACT_BITS - 1 - hSbrDec->qmfDomainInCh->scaling.lb_scale);
386
387 /* If all data is zero, lb_scale could become too large */
388 rescaleSubbandSamples(pReal, (flags & SBRDEC_LOW_POWER) ? NULL : pImag, 0,
389 hSbrDec->qmfDomainInCh->fb.no_channels, 0, noCols,
390 reserve);
391
392 hSbrDec->qmfDomainInCh->scaling.lb_scale += reserve;
393
394 if ((flags & SBRDEC_USAC_HARMONICSBR)) {
395 /* actually this is our hbe_scale */
396 hSbrDec->scale_hbe = hSbrDec->qmfDomainInCh->scaling.lb_scale;
397 /* the real lb_scale is stored in scale_lb from sbr */
398 hSbrDec->qmfDomainInCh->scaling.lb_scale = hSbrDec->scale_lb;
399 }
400 /*
401 save low band scale, wavecoding or parametric stereo may modify it
402 */
403 saveLbScale = hSbrDec->qmfDomainInCh->scaling.lb_scale;
404
405 if (applyProcessing) {
406 UCHAR *borders = hFrameData->frameInfo.borders;
407 lastSlotOffs = borders[hFrameData->frameInfo.nEnvelopes] -
408 hHeaderData->numberTimeSlots;
409
410 FIXP_DBL degreeAlias[(64)];
411 PVC_DYNAMIC_DATA pvcDynamicData;
412 pvcInitFrame(
413 &hSbrDec->PvcStaticData, &pvcDynamicData,
414 (hHeaderData->frameErrorFlag ? 0 : hHeaderData->bs_info.pvc_mode),
415 hFrameData->ns, hHeaderData->timeStep,
416 hHeaderData->freqBandData.lowSubband,
417 hFrameData->frameInfo.pvcBorders[0], hFrameData->pvcID);
418
419 if (!hHeaderData->frameErrorFlag && (hHeaderData->bs_info.pvc_mode > 0)) {
420 pvcDecodeFrame(&hSbrDec->PvcStaticData, &pvcDynamicData, pLowBandReal,
421 pLowBandImag, ov_len,
422 SCALE2EXP(hSbrDec->qmfDomainInCh->scaling.ov_lb_scale),
423 SCALE2EXP(hSbrDec->qmfDomainInCh->scaling.lb_scale));
424 }
425 pvcEndFrame(&hSbrDec->PvcStaticData, &pvcDynamicData);
426
427 /* The transposer will override most values in degreeAlias[].
428 The array needs to be cleared at least from lowSubband to highSubband
429 before. */
430 if (flags & SBRDEC_LOW_POWER)
431 FDKmemclear(°reeAlias[hHeaderData->freqBandData.lowSubband],
432 (hHeaderData->freqBandData.highSubband -
433 hHeaderData->freqBandData.lowSubband) *
434 sizeof(FIXP_DBL));
435
436 /*
437 Inverse filtering of lowband and transposition into the SBR-frequency
438 range
439 */
440
441 {
442 KEEP_STATES_SYNCED_MODE keepStatesSyncedMode =
443 ((flags & SBRDEC_USAC_HARMONICSBR) &&
444 (hFrameData->sbrPatchingMode != 0))
445 ? KEEP_STATES_SYNCED_NORMAL
446 : KEEP_STATES_SYNCED_OFF;
447
448 if (flags & SBRDEC_USAC_HARMONICSBR) {
449 if (flags & SBRDEC_QUAD_RATE) {
450 pReal -= 32;
451 pImag -= 32;
452 }
453
454 if ((hSbrDec->savedStates == 0) && (hFrameData->sbrPatchingMode == 1)) {
455 /* copy saved states from previous frame to legacy SBR lpc filterstate
456 * buffer */
457 for (i = 0; i < LPC_ORDER + ov_len; i++) {
458 FDKmemcpy(
459 hSbrDec->LppTrans.lpcFilterStatesRealLegSBR[i],
460 hSbrDec->codecQMFBufferReal[noCols - LPC_ORDER - ov_len + i],
461 hSbrDec->hHBE->noChannels * sizeof(FIXP_DBL));
462 FDKmemcpy(
463 hSbrDec->LppTrans.lpcFilterStatesImagLegSBR[i],
464 hSbrDec->codecQMFBufferImag[noCols - LPC_ORDER - ov_len + i],
465 hSbrDec->hHBE->noChannels * sizeof(FIXP_DBL));
466 }
467 }
468
469 /* saving unmodified QMF states in case we are switching from legacy SBR
470 * to HBE */
471 for (i = 0; i < hSbrDec->hHBE->noCols; i++) {
472 FDKmemcpy(hSbrDec->codecQMFBufferReal[i], pLowBandReal[ov_len + i],
473 hSbrDec->hHBE->noChannels * sizeof(FIXP_DBL));
474 FDKmemcpy(hSbrDec->codecQMFBufferImag[i], pLowBandImag[ov_len + i],
475 hSbrDec->hHBE->noChannels * sizeof(FIXP_DBL));
476 }
477
478 QmfTransposerApply(
479 hSbrDec->hHBE, pReal, pImag, noCols, pLowBandReal, pLowBandImag,
480 hSbrDec->LppTrans.lpcFilterStatesRealHBE,
481 hSbrDec->LppTrans.lpcFilterStatesImagHBE,
482 hFrameData->sbrPitchInBins, hSbrDec->scale_lb, hSbrDec->scale_hbe,
483 &hSbrDec->qmfDomainInCh->scaling.hb_scale, hHeaderData->timeStep,
484 borders[0], ov_len, keepStatesSyncedMode);
485
486 if (flags & SBRDEC_QUAD_RATE) {
487 int *xOverQmf = GetxOverBandQmfTransposer(hSbrDec->hHBE);
488
489 copyHarmonicSpectrum(xOverQmf, pLowBandReal, pLowBandImag, noCols,
490 ov_len, keepStatesSyncedMode);
491 }
492 }
493 }
494
495 if ((flags & SBRDEC_USAC_HARMONICSBR) &&
496 (hFrameData->sbrPatchingMode == 0)) {
497 hSbrDec->prev_frame_lSbr = 0;
498 hSbrDec->prev_frame_hbeSbr = 1;
499
500 lppTransposerHBE(
501 &hSbrDec->LppTrans, hSbrDec->hHBE, &hSbrDec->qmfDomainInCh->scaling,
502 pLowBandReal, pLowBandImag, hHeaderData->timeStep, borders[0],
503 lastSlotOffs, hHeaderData->freqBandData.nInvfBands,
504 hFrameData->sbr_invf_mode, hPrevFrameData->sbr_invf_mode);
505
506 } else {
507 if (flags & SBRDEC_USAC_HARMONICSBR) {
508 for (i = 0; i < LPC_ORDER + hSbrDec->LppTrans.pSettings->overlap; i++) {
509 /*
510 Store the unmodified qmf Slots values for upper part of spectrum
511 (required for LPC filtering) required if next frame is a HBE frame
512 */
513 FDKmemcpy(hSbrDec->LppTrans.lpcFilterStatesRealHBE[i],
514 hSbrDec->qmfDomainInCh
515 ->hQmfSlotsReal[hSbrDec->hHBE->noCols - LPC_ORDER + i],
516 (64) * sizeof(FIXP_DBL));
517 FDKmemcpy(hSbrDec->LppTrans.lpcFilterStatesImagHBE[i],
518 hSbrDec->qmfDomainInCh
519 ->hQmfSlotsImag[hSbrDec->hHBE->noCols - LPC_ORDER + i],
520 (64) * sizeof(FIXP_DBL));
521 }
522 }
523 {
524 hSbrDec->prev_frame_lSbr = 1;
525 hSbrDec->prev_frame_hbeSbr = 0;
526 }
527
528 lppTransposer(
529 &hSbrDec->LppTrans, &hSbrDec->qmfDomainInCh->scaling, pLowBandReal,
530 degreeAlias, // only used if useLP = 1
531 pLowBandImag, flags & SBRDEC_LOW_POWER,
532 hHeaderData->bs_info.sbr_preprocessing,
533 hHeaderData->freqBandData.v_k_master[0], hHeaderData->timeStep,
534 borders[0], lastSlotOffs, hHeaderData->freqBandData.nInvfBands,
535 hFrameData->sbr_invf_mode, hPrevFrameData->sbr_invf_mode);
536 }
537
538 /*
539 Adjust envelope of current frame.
540 */
541
542 if ((hFrameData->sbrPatchingMode !=
543 hSbrDec->SbrCalculateEnvelope.sbrPatchingMode)) {
544 ResetLimiterBands(hHeaderData->freqBandData.limiterBandTable,
545 &hHeaderData->freqBandData.noLimiterBands,
546 hHeaderData->freqBandData.freqBandTable[0],
547 hHeaderData->freqBandData.nSfb[0],
548 hSbrDec->LppTrans.pSettings->patchParam,
549 hSbrDec->LppTrans.pSettings->noOfPatches,
550 hHeaderData->bs_data.limiterBands,
551 hFrameData->sbrPatchingMode,
552 (flags & SBRDEC_USAC_HARMONICSBR) &&
553 (hFrameData->sbrPatchingMode == 0)
554 ? GetxOverBandQmfTransposer(hSbrDec->hHBE)
555 : NULL,
556 Get41SbrQmfTransposer(hSbrDec->hHBE));
557
558 hSbrDec->SbrCalculateEnvelope.sbrPatchingMode =
559 hFrameData->sbrPatchingMode;
560 }
561
562 calculateSbrEnvelope(
563 &hSbrDec->qmfDomainInCh->scaling, &hSbrDec->SbrCalculateEnvelope,
564 hHeaderData, hFrameData, &pvcDynamicData, pLowBandReal, pLowBandImag,
565 flags & SBRDEC_LOW_POWER,
566
567 degreeAlias, flags,
568 (hHeaderData->frameErrorFlag || hPrevFrameData->frameErrorFlag));
569
570 #if (SBRDEC_MAX_HB_FADE_FRAMES > 0)
571 /* Avoid hard onsets of high band */
572 if (hHeaderData->frameErrorFlag) {
573 if (hSbrDec->highBandFadeCnt < SBRDEC_MAX_HB_FADE_FRAMES) {
574 hSbrDec->highBandFadeCnt += 1;
575 }
576 } else {
577 if (hSbrDec->highBandFadeCnt >
578 0) { /* Manipulate high band scale factor to get a smooth fade-in */
579 hSbrDec->qmfDomainInCh->scaling.hb_scale += hSbrDec->highBandFadeCnt;
580 hSbrDec->qmfDomainInCh->scaling.hb_scale =
581 fMin(hSbrDec->qmfDomainInCh->scaling.hb_scale, DFRACT_BITS - 1);
582 hSbrDec->highBandFadeCnt -= 1;
583 }
584 }
585
586 #endif
587 /*
588 Update hPrevFrameData (to be used in the next frame)
589 */
590 for (i = 0; i < hHeaderData->freqBandData.nInvfBands; i++) {
591 hPrevFrameData->sbr_invf_mode[i] = hFrameData->sbr_invf_mode[i];
592 }
593 hPrevFrameData->coupling = hFrameData->coupling;
594 hPrevFrameData->stopPos = borders[hFrameData->frameInfo.nEnvelopes];
595 hPrevFrameData->ampRes = hFrameData->ampResolutionCurrentFrame;
596 hPrevFrameData->prevSbrPitchInBins = hFrameData->sbrPitchInBins;
597 /* could be done in extractFrameInfo_pvc() but hPrevFrameData is not
598 * available there */
599 FDKmemcpy(&hPrevFrameData->prevFrameInfo, &hFrameData->frameInfo,
600 sizeof(FRAME_INFO));
601 } else {
602 /* rescale from lsb to nAnalysisBands in order to compensate scaling with
603 * hb_scale in this area, done by synthesisFiltering*/
604 int rescale;
605 int lsb;
606 int length;
607
608 /* Reset hb_scale if no highband is present, because hb_scale is considered
609 * in the QMF-synthesis */
610 hSbrDec->qmfDomainInCh->scaling.hb_scale = saveLbScale;
611
612 rescale = hSbrDec->qmfDomainInCh->scaling.hb_scale -
613 hSbrDec->qmfDomainInCh->scaling.ov_lb_scale;
614 lsb = hSbrDec->qmfDomainOutCh->fb.lsb;
615 length = (hSbrDec->qmfDomainInCh->fb.no_channels - lsb);
616
617 if ((rescale < 0) && (length > 0)) {
618 if (!(flags & SBRDEC_LOW_POWER)) {
619 for (i = 0; i < ov_len; i++) {
620 scaleValues(&pLowBandReal[i][lsb], length, rescale);
621 scaleValues(&pLowBandImag[i][lsb], length, rescale);
622 }
623 } else {
624 for (i = 0; i < ov_len; i++) {
625 scaleValues(&pLowBandReal[i][lsb], length, rescale);
626 }
627 }
628 }
629 }
630
631 if (!(flags & SBRDEC_USAC_HARMONICSBR)) {
632 int length = hSbrDec->qmfDomainInCh->fb.lsb;
633 if (flags & SBRDEC_SYNTAX_USAC) {
634 length = hSbrDec->qmfDomainInCh->fb.no_channels;
635 }
636
637 /* in case of legacy sbr saving of filter states here */
638 for (i = 0; i < LPC_ORDER + ov_len; i++) {
639 /*
640 Store the unmodified qmf Slots values (required for LPC filtering)
641 */
642 if (!(flags & SBRDEC_LOW_POWER)) {
643 FDKmemcpy(hSbrDec->LppTrans.lpcFilterStatesRealLegSBR[i],
644 pLowBandReal[noCols - LPC_ORDER + i],
645 length * sizeof(FIXP_DBL));
646 FDKmemcpy(hSbrDec->LppTrans.lpcFilterStatesImagLegSBR[i],
647 pLowBandImag[noCols - LPC_ORDER + i],
648 length * sizeof(FIXP_DBL));
649 } else
650 FDKmemcpy(hSbrDec->LppTrans.lpcFilterStatesRealLegSBR[i],
651 pLowBandReal[noCols - LPC_ORDER + i],
652 length * sizeof(FIXP_DBL));
653 }
654 }
655
656 /*
657 Synthesis subband filtering.
658 */
659
660 if (!(flags & SBRDEC_PS_DECODED)) {
661 if (!(flags & SBRDEC_SKIP_QMF_SYN)) {
662 int outScalefactor = -(8);
663
664 if (h_ps_d != NULL) {
665 h_ps_d->procFrameBased = 1; /* we here do frame based processing */
666 }
667
668 sbrDecoder_drcApply(&hSbrDec->sbrDrcChannel, pLowBandReal,
669 (flags & SBRDEC_LOW_POWER) ? NULL : pLowBandImag,
670 hSbrDec->qmfDomainOutCh->fb.no_col, &outScalefactor);
671
672 qmfChangeOutScalefactor(&hSbrDec->qmfDomainOutCh->fb, outScalefactor);
673
674 {
675 HANDLE_FREQ_BAND_DATA hFreq = &hHeaderData->freqBandData;
676 int save_usb = hSbrDec->qmfDomainOutCh->fb.usb;
677
678 #if (QMF_MAX_SYNTHESIS_BANDS <= 64)
679 C_AALLOC_SCRATCH_START(qmfTemp, FIXP_DBL, 2 * QMF_MAX_SYNTHESIS_BANDS);
680 #else
681 C_AALLOC_STACK_START(qmfTemp, FIXP_DBL, 2 * QMF_MAX_SYNTHESIS_BANDS);
682 #endif
683 if (hSbrDec->qmfDomainOutCh->fb.usb < hFreq->ov_highSubband) {
684 /* we need to patch usb for this frame as overlap may contain higher
685 frequency range if headerchange occured; fb. usb is always limited
686 to maximum fb.no_channels; In case of wrongly decoded headers it
687 might be that ov_highSubband is higher than the number of synthesis
688 channels (fb.no_channels), which is forbidden, therefore we need to
689 limit ov_highSubband with fMin function to avoid not allowed usb in
690 synthesis filterbank. */
691 hSbrDec->qmfDomainOutCh->fb.usb =
692 fMin((UINT)hFreq->ov_highSubband,
693 (UINT)hSbrDec->qmfDomainOutCh->fb.no_channels);
694 }
695 {
696 qmfSynthesisFiltering(
697 &hSbrDec->qmfDomainOutCh->fb, pLowBandReal,
698 (flags & SBRDEC_LOW_POWER) ? NULL : pLowBandImag,
699 &hSbrDec->qmfDomainInCh->scaling,
700 hSbrDec->LppTrans.pSettings->overlap, timeOut, strideOut,
701 qmfTemp);
702 }
703 /* restore saved value */
704 hSbrDec->qmfDomainOutCh->fb.usb = save_usb;
705 hFreq->ov_highSubband = save_usb;
706 #if (QMF_MAX_SYNTHESIS_BANDS <= 64)
707 C_AALLOC_SCRATCH_END(qmfTemp, FIXP_DBL, 2 * QMF_MAX_SYNTHESIS_BANDS);
708 #else
709 C_AALLOC_STACK_END(qmfTemp, FIXP_DBL, 2 * QMF_MAX_SYNTHESIS_BANDS);
710 #endif
711 }
712 }
713
714 } else { /* (flags & SBRDEC_PS_DECODED) */
715 INT sdiff;
716 INT scaleFactorHighBand, scaleFactorLowBand_ov, scaleFactorLowBand_no_ov,
717 outScalefactor, outScalefactorR, outScalefactorL;
718
719 HANDLE_QMF_FILTER_BANK synQmf = &hSbrDec->qmfDomainOutCh->fb;
720 HANDLE_QMF_FILTER_BANK synQmfRight = &hSbrDecRight->qmfDomainOutCh->fb;
721
722 /* adapt scaling */
723 sdiff = hSbrDec->qmfDomainInCh->scaling.lb_scale -
724 reserve; /* Scaling difference */
725 scaleFactorHighBand = sdiff - hSbrDec->qmfDomainInCh->scaling.hb_scale;
726 scaleFactorLowBand_ov = sdiff - hSbrDec->qmfDomainInCh->scaling.ov_lb_scale;
727 scaleFactorLowBand_no_ov = sdiff - hSbrDec->qmfDomainInCh->scaling.lb_scale;
728
729 /* Scale of low band overlapping QMF data */
730 scaleFactorLowBand_ov =
731 fMin(DFRACT_BITS - 1, fMax(-(DFRACT_BITS - 1), scaleFactorLowBand_ov));
732 /* Scale of low band current QMF data */
733 scaleFactorLowBand_no_ov = fMin(
734 DFRACT_BITS - 1, fMax(-(DFRACT_BITS - 1), scaleFactorLowBand_no_ov));
735 /* Scale of current high band */
736 scaleFactorHighBand =
737 fMin(DFRACT_BITS - 1, fMax(-(DFRACT_BITS - 1), scaleFactorHighBand));
738
739 if (h_ps_d->procFrameBased == 1) /* If we have switched from frame to slot
740 based processing copy filter states */
741 { /* procFrameBased will be unset later */
742 /* copy filter states from left to right */
743 /* was ((640)-(64))*sizeof(FIXP_QSS)
744 flexible amount of synthesis bands needed for QMF based resampling
745 */
746 FDK_ASSERT(hSbrDec->qmfDomainInCh->pGlobalConf->nBandsSynthesis <=
747 QMF_MAX_SYNTHESIS_BANDS);
748 synQmfRight->outScalefactor = synQmf->outScalefactor;
749 FDKmemcpy(synQmfRight->FilterStates, synQmf->FilterStates,
750 9 * hSbrDec->qmfDomainInCh->pGlobalConf->nBandsSynthesis *
751 sizeof(FIXP_QSS));
752 }
753
754 /* Feed delaylines when parametric stereo is switched on. */
755 PreparePsProcessing(h_ps_d, pLowBandReal, pLowBandImag,
756 scaleFactorLowBand_ov);
757
758 /* use the same synthese qmf values for left and right channel */
759 synQmfRight->no_col = synQmf->no_col;
760 synQmfRight->lsb = synQmf->lsb;
761 synQmfRight->usb = synQmf->usb;
762
763 int env = 0;
764
765 {
766 #if (QMF_MAX_SYNTHESIS_BANDS <= 64)
767 C_AALLOC_SCRATCH_START(pWorkBuffer, FIXP_DBL,
768 2 * QMF_MAX_SYNTHESIS_BANDS);
769 #else
770 C_AALLOC_STACK_START(pWorkBuffer, FIXP_DBL, 2 * QMF_MAX_SYNTHESIS_BANDS);
771 #endif
772
773 int maxShift = 0;
774
775 if (hSbrDec->sbrDrcChannel.enable != 0) {
776 if (hSbrDec->sbrDrcChannel.prevFact_exp > maxShift) {
777 maxShift = hSbrDec->sbrDrcChannel.prevFact_exp;
778 }
779 if (hSbrDec->sbrDrcChannel.currFact_exp > maxShift) {
780 maxShift = hSbrDec->sbrDrcChannel.currFact_exp;
781 }
782 if (hSbrDec->sbrDrcChannel.nextFact_exp > maxShift) {
783 maxShift = hSbrDec->sbrDrcChannel.nextFact_exp;
784 }
785 }
786
787 /* copy DRC data to right channel (with PS both channels use the same DRC
788 * gains) */
789 FDKmemcpy(&hSbrDecRight->sbrDrcChannel, &hSbrDec->sbrDrcChannel,
790 sizeof(SBRDEC_DRC_CHANNEL));
791
792 outScalefactor = maxShift - (8);
793 outScalefactorL = outScalefactorR =
794 sbrInDataHeadroom + 1; /* +1: psDiffScale! (MPEG-PS) */
795
796 for (i = 0; i < synQmf->no_col; i++) { /* ----- no_col loop ----- */
797
798 /* qmf timeslot of right channel */
799 FIXP_DBL *rQmfReal = pWorkBuffer;
800 FIXP_DBL *rQmfImag = pWorkBuffer + synQmf->no_channels;
801
802 {
803 if (i ==
804 h_ps_d->bsData[h_ps_d->processSlot].mpeg.aEnvStartStop[env]) {
805 initSlotBasedRotation(h_ps_d, env,
806 hHeaderData->freqBandData.highSubband);
807 env++;
808 }
809
810 ApplyPsSlot(
811 h_ps_d, /* parametric stereo decoder handle */
812 (pLowBandReal + i), /* one timeslot of left/mono channel */
813 (pLowBandImag + i), /* one timeslot of left/mono channel */
814 rQmfReal, /* one timeslot or right channel */
815 rQmfImag, /* one timeslot or right channel */
816 scaleFactorLowBand_no_ov,
817 (i < hSbrDec->LppTrans.pSettings->overlap)
818 ? scaleFactorLowBand_ov
819 : scaleFactorLowBand_no_ov,
820 scaleFactorHighBand, synQmf->lsb, synQmf->usb);
821 }
822
823 sbrDecoder_drcApplySlot(/* right channel */
824 &hSbrDecRight->sbrDrcChannel, rQmfReal,
825 rQmfImag, i, synQmfRight->no_col, maxShift);
826
827 sbrDecoder_drcApplySlot(/* left channel */
828 &hSbrDec->sbrDrcChannel, *(pLowBandReal + i),
829 *(pLowBandImag + i), i, synQmf->no_col,
830 maxShift);
831
832 if (!(flags & SBRDEC_SKIP_QMF_SYN)) {
833 qmfChangeOutScalefactor(synQmf, outScalefactor);
834 qmfChangeOutScalefactor(synQmfRight, outScalefactor);
835
836 qmfSynthesisFilteringSlot(
837 synQmfRight, rQmfReal, /* QMF real buffer */
838 rQmfImag, /* QMF imag buffer */
839 outScalefactorL, outScalefactorL,
840 timeOutRight + (i * synQmf->no_channels * strideOut), strideOut,
841 pWorkBuffer);
842
843 qmfSynthesisFilteringSlot(
844 synQmf, *(pLowBandReal + i), /* QMF real buffer */
845 *(pLowBandImag + i), /* QMF imag buffer */
846 outScalefactorR, outScalefactorR,
847 timeOut + (i * synQmf->no_channels * strideOut), strideOut,
848 pWorkBuffer);
849 }
850 } /* no_col loop i */
851 #if (QMF_MAX_SYNTHESIS_BANDS <= 64)
852 C_AALLOC_SCRATCH_END(pWorkBuffer, FIXP_DBL, 2 * QMF_MAX_SYNTHESIS_BANDS);
853 #else
854 C_AALLOC_STACK_END(pWorkBuffer, FIXP_DBL, 2 * QMF_MAX_SYNTHESIS_BANDS);
855 #endif
856 }
857 }
858
859 sbrDecoder_drcUpdateChannel(&hSbrDec->sbrDrcChannel);
860
861 /*
862 Update overlap buffer
863 Even bands above usb are copied to avoid outdated spectral data in case
864 the stop frequency raises.
865 */
866
867 if (!(flags & SBRDEC_SKIP_QMF_SYN)) {
868 {
869 FDK_QmfDomain_SaveOverlap(hSbrDec->qmfDomainInCh, 0);
870 FDK_ASSERT(hSbrDec->qmfDomainInCh->scaling.ov_lb_scale == saveLbScale);
871 }
872 }
873
874 hSbrDec->savedStates = 0;
875
876 /* Save current frame status */
877 hPrevFrameData->frameErrorFlag = hHeaderData->frameErrorFlag;
878 hSbrDec->applySbrProc_old = applyProcessing;
879
880 } /* sbr_dec() */
881
882 /*!
883 \brief Creates sbr decoder structure
884 \return errorCode, 0 if successful
885 */
886 SBR_ERROR
createSbrDec(SBR_CHANNEL * hSbrChannel,HANDLE_SBR_HEADER_DATA hHeaderData,TRANSPOSER_SETTINGS * pSettings,const int downsampleFac,const UINT qmfFlags,const UINT flags,const int overlap,int chan,int codecFrameSize)887 createSbrDec(SBR_CHANNEL *hSbrChannel,
888 HANDLE_SBR_HEADER_DATA hHeaderData, /*!< Static control data */
889 TRANSPOSER_SETTINGS *pSettings,
890 const int downsampleFac, /*!< Downsampling factor */
891 const UINT qmfFlags, /*!< flags -> 1: HQ/LP selector, 2: CLDFB */
892 const UINT flags, const int overlap,
893 int chan, /*!< Channel for which to assign buffers etc. */
894 int codecFrameSize)
895
896 {
897 SBR_ERROR err = SBRDEC_OK;
898 int timeSlots =
899 hHeaderData->numberTimeSlots; /* Number of SBR slots per frame */
900 int noCols =
901 timeSlots * hHeaderData->timeStep; /* Number of QMF slots per frame */
902 HANDLE_SBR_DEC hs = &(hSbrChannel->SbrDec);
903
904 #if (SBRDEC_MAX_HB_FADE_FRAMES > 0)
905 hs->highBandFadeCnt = SBRDEC_MAX_HB_FADE_FRAMES;
906
907 #endif
908 hs->scale_hbe = 15;
909 hs->scale_lb = 15;
910 hs->scale_ov = 15;
911
912 hs->prev_frame_lSbr = 0;
913 hs->prev_frame_hbeSbr = 0;
914
915 hs->codecFrameSize = codecFrameSize;
916
917 /*
918 create envelope calculator
919 */
920 err = createSbrEnvelopeCalc(&hs->SbrCalculateEnvelope, hHeaderData, chan,
921 flags);
922 if (err != SBRDEC_OK) {
923 return err;
924 }
925
926 initSbrPrevFrameData(&hSbrChannel->prevFrameData, timeSlots);
927
928 /*
929 create transposer
930 */
931 err = createLppTransposer(
932 &hs->LppTrans, pSettings, hHeaderData->freqBandData.lowSubband,
933 hHeaderData->freqBandData.v_k_master, hHeaderData->freqBandData.numMaster,
934 hHeaderData->freqBandData.highSubband, timeSlots, noCols,
935 hHeaderData->freqBandData.freqBandTableNoise,
936 hHeaderData->freqBandData.nNfb, hHeaderData->sbrProcSmplRate, chan,
937 overlap);
938 if (err != SBRDEC_OK) {
939 return err;
940 }
941
942 if (flags & SBRDEC_USAC_HARMONICSBR) {
943 int noChannels, bSbr41 = flags & SBRDEC_QUAD_RATE ? 1 : 0;
944
945 noChannels =
946 QMF_SYNTH_CHANNELS /
947 ((bSbr41 + 1) * 2); /* 32 for (32:64 and 24:64) and 16 for 16:64 */
948
949 /* shared memory between hbeLightTimeDelayBuffer and hQmfHBESlotsReal if
950 * SBRDEC_HBE_ENABLE */
951 hSbrChannel->SbrDec.tmp_memory = (FIXP_DBL **)fdkCallocMatrix2D_aligned(
952 noCols, noChannels, sizeof(FIXP_DBL));
953 if (hSbrChannel->SbrDec.tmp_memory == NULL) {
954 return SBRDEC_MEM_ALLOC_FAILED;
955 }
956
957 hSbrChannel->SbrDec.hQmfHBESlotsReal = hSbrChannel->SbrDec.tmp_memory;
958 hSbrChannel->SbrDec.hQmfHBESlotsImag =
959 (FIXP_DBL **)fdkCallocMatrix2D_aligned(noCols, noChannels,
960 sizeof(FIXP_DBL));
961 if (hSbrChannel->SbrDec.hQmfHBESlotsImag == NULL) {
962 return SBRDEC_MEM_ALLOC_FAILED;
963 }
964
965 /* buffers containing unmodified qmf data; required when switching from
966 * legacy SBR to HBE */
967 /* buffer can be used as LPCFilterstates buffer because legacy SBR needs
968 * exactly these values for LPC filtering */
969 hSbrChannel->SbrDec.codecQMFBufferReal =
970 (FIXP_DBL **)fdkCallocMatrix2D_aligned(noCols, noChannels,
971 sizeof(FIXP_DBL));
972 if (hSbrChannel->SbrDec.codecQMFBufferReal == NULL) {
973 return SBRDEC_MEM_ALLOC_FAILED;
974 }
975
976 hSbrChannel->SbrDec.codecQMFBufferImag =
977 (FIXP_DBL **)fdkCallocMatrix2D_aligned(noCols, noChannels,
978 sizeof(FIXP_DBL));
979 if (hSbrChannel->SbrDec.codecQMFBufferImag == NULL) {
980 return SBRDEC_MEM_ALLOC_FAILED;
981 }
982
983 err = QmfTransposerCreate(&hs->hHBE, codecFrameSize, 0, bSbr41);
984 if (err != SBRDEC_OK) {
985 return err;
986 }
987 }
988
989 return err;
990 }
991
992 /*!
993 \brief Delete sbr decoder structure
994 \return errorCode, 0 if successful
995 */
deleteSbrDec(SBR_CHANNEL * hSbrChannel)996 int deleteSbrDec(SBR_CHANNEL *hSbrChannel) {
997 HANDLE_SBR_DEC hs = &hSbrChannel->SbrDec;
998
999 deleteSbrEnvelopeCalc(&hs->SbrCalculateEnvelope);
1000
1001 if (hs->tmp_memory != NULL) {
1002 FDK_FREE_MEMORY_2D_ALIGNED(hs->tmp_memory);
1003 }
1004
1005 /* modify here */
1006 FDK_FREE_MEMORY_2D_ALIGNED(hs->hQmfHBESlotsImag);
1007
1008 if (hs->hHBE != NULL) QmfTransposerClose(hs->hHBE);
1009
1010 if (hs->codecQMFBufferReal != NULL) {
1011 FDK_FREE_MEMORY_2D_ALIGNED(hs->codecQMFBufferReal);
1012 }
1013
1014 if (hs->codecQMFBufferImag != NULL) {
1015 FDK_FREE_MEMORY_2D_ALIGNED(hs->codecQMFBufferImag);
1016 }
1017
1018 return 0;
1019 }
1020
1021 /*!
1022 \brief resets sbr decoder structure
1023 \return errorCode, 0 if successful
1024 */
1025 SBR_ERROR
resetSbrDec(HANDLE_SBR_DEC hSbrDec,HANDLE_SBR_HEADER_DATA hHeaderData,HANDLE_SBR_PREV_FRAME_DATA hPrevFrameData,const int downsampleFac,const UINT flags,HANDLE_SBR_FRAME_DATA hFrameData)1026 resetSbrDec(HANDLE_SBR_DEC hSbrDec, HANDLE_SBR_HEADER_DATA hHeaderData,
1027 HANDLE_SBR_PREV_FRAME_DATA hPrevFrameData, const int downsampleFac,
1028 const UINT flags, HANDLE_SBR_FRAME_DATA hFrameData) {
1029 SBR_ERROR sbrError = SBRDEC_OK;
1030 int i;
1031 FIXP_DBL *pLowBandReal[128];
1032 FIXP_DBL *pLowBandImag[128];
1033 int useLP = flags & SBRDEC_LOW_POWER;
1034
1035 int old_lsb = hSbrDec->qmfDomainInCh->fb.lsb;
1036 int old_usb = hSbrDec->qmfDomainInCh->fb.usb;
1037 int new_lsb = hHeaderData->freqBandData.lowSubband;
1038 /* int new_usb = hHeaderData->freqBandData.highSubband; */
1039 int l, startBand, stopBand, startSlot, size;
1040
1041 FIXP_DBL **OverlapBufferReal = hSbrDec->qmfDomainInCh->hQmfSlotsReal;
1042 FIXP_DBL **OverlapBufferImag = hSbrDec->qmfDomainInCh->hQmfSlotsImag;
1043
1044 /* in case the previous frame was not active in terms of SBR processing, the
1045 full band from 0 to no_channels was rescaled and not overwritten. Thats why
1046 the scaling factor lb_scale can be seen as assigned to all bands from 0 to
1047 no_channels in the previous frame. The same states for the current frame if
1048 the current frame is not active in terms of SBR processing
1049 */
1050 int applySbrProc = (hHeaderData->syncState == SBR_ACTIVE ||
1051 (hHeaderData->frameErrorFlag == 0 &&
1052 hHeaderData->syncState == SBR_HEADER));
1053 int applySbrProc_old = hSbrDec->applySbrProc_old;
1054
1055 if (!applySbrProc) {
1056 new_lsb = (hSbrDec->qmfDomainInCh->fb).no_channels;
1057 }
1058 if (!applySbrProc_old) {
1059 old_lsb = (hSbrDec->qmfDomainInCh->fb).no_channels;
1060 old_usb = old_lsb;
1061 }
1062
1063 resetSbrEnvelopeCalc(&hSbrDec->SbrCalculateEnvelope);
1064
1065 /* Change lsb and usb */
1066 /* Synthesis */
1067 FDK_ASSERT(hSbrDec->qmfDomainOutCh != NULL);
1068 hSbrDec->qmfDomainOutCh->fb.lsb =
1069 fixMin((INT)hSbrDec->qmfDomainOutCh->fb.no_channels,
1070 (INT)hHeaderData->freqBandData.lowSubband);
1071 hSbrDec->qmfDomainOutCh->fb.usb =
1072 fixMin((INT)hSbrDec->qmfDomainOutCh->fb.no_channels,
1073 (INT)hHeaderData->freqBandData.highSubband);
1074 /* Analysis */
1075 FDK_ASSERT(hSbrDec->qmfDomainInCh != NULL);
1076 hSbrDec->qmfDomainInCh->fb.lsb = hSbrDec->qmfDomainOutCh->fb.lsb;
1077 hSbrDec->qmfDomainInCh->fb.usb = hSbrDec->qmfDomainOutCh->fb.usb;
1078
1079 /*
1080 The following initialization of spectral data in the overlap buffer
1081 is required for dynamic x-over or a change of the start-freq for 2 reasons:
1082
1083 1. If the lowband gets _wider_, unadjusted data would remain
1084
1085 2. If the lowband becomes _smaller_, the highest bands of the old lowband
1086 must be cleared because the whitening would be affected
1087 */
1088 startBand = old_lsb;
1089 stopBand = new_lsb;
1090 startSlot = fMax(0, hHeaderData->timeStep * (hPrevFrameData->stopPos -
1091 hHeaderData->numberTimeSlots));
1092 size = fMax(0, stopBand - startBand);
1093
1094 /* in case of USAC we don't want to zero out the memory, as this can lead to
1095 holes in the spectrum; fix shall only be applied for USAC not for MPEG-4
1096 SBR, in this case setting zero remains */
1097 if (!(flags & SBRDEC_SYNTAX_USAC)) {
1098 /* keep already adjusted data in the x-over-area */
1099 if (!useLP) {
1100 for (l = startSlot; l < hSbrDec->LppTrans.pSettings->overlap; l++) {
1101 FDKmemclear(&OverlapBufferReal[l][startBand], size * sizeof(FIXP_DBL));
1102 FDKmemclear(&OverlapBufferImag[l][startBand], size * sizeof(FIXP_DBL));
1103 }
1104 } else {
1105 for (l = startSlot; l < hSbrDec->LppTrans.pSettings->overlap; l++) {
1106 FDKmemclear(&OverlapBufferReal[l][startBand], size * sizeof(FIXP_DBL));
1107 }
1108 }
1109
1110 /*
1111 reset LPC filter states
1112 */
1113 startBand = fixMin(old_lsb, new_lsb);
1114 stopBand = fixMax(old_lsb, new_lsb);
1115 size = fixMax(0, stopBand - startBand);
1116
1117 FDKmemclear(&hSbrDec->LppTrans.lpcFilterStatesRealLegSBR[0][startBand],
1118 size * sizeof(FIXP_DBL));
1119 FDKmemclear(&hSbrDec->LppTrans.lpcFilterStatesRealLegSBR[1][startBand],
1120 size * sizeof(FIXP_DBL));
1121 if (!useLP) {
1122 FDKmemclear(&hSbrDec->LppTrans.lpcFilterStatesImagLegSBR[0][startBand],
1123 size * sizeof(FIXP_DBL));
1124 FDKmemclear(&hSbrDec->LppTrans.lpcFilterStatesImagLegSBR[1][startBand],
1125 size * sizeof(FIXP_DBL));
1126 }
1127 }
1128
1129 if (startSlot != 0) {
1130 int source_exp, target_exp, delta_exp, target_lsb, target_usb, reserve;
1131 FIXP_DBL maxVal;
1132
1133 /*
1134 Rescale already processed spectral data between old and new x-over
1135 frequency. This must be done because of the separate scalefactors for
1136 lowband and highband.
1137 */
1138
1139 /* We have four relevant transitions to cover:
1140 1. old_usb is lower than new_lsb; old SBR area is completely below new SBR
1141 area.
1142 -> entire old area was highband and belongs to lowband now
1143 and has to be rescaled.
1144 2. old_lsb is higher than new_usb; new SBR area is completely below old SBR
1145 area.
1146 -> old area between new_lsb and old_lsb was lowband and belongs to
1147 highband now and has to be rescaled to match new highband scale.
1148 3. old_lsb is lower and old_usb is higher than new_lsb; old and new SBR
1149 areas overlap.
1150 -> old area between old_lsb and new_lsb was highband and belongs to
1151 lowband now and has to be rescaled to match new lowband scale.
1152 4. new_lsb is lower and new_usb_is higher than old_lsb; old and new SBR
1153 areas overlap.
1154 -> old area between new_lsb and old_usb was lowband and belongs to
1155 highband now and has to be rescaled to match new highband scale.
1156 */
1157
1158 if (new_lsb > old_lsb) {
1159 /* case 1 and 3 */
1160 source_exp = SCALE2EXP(hSbrDec->qmfDomainInCh->scaling.ov_hb_scale);
1161 target_exp = SCALE2EXP(hSbrDec->qmfDomainInCh->scaling.ov_lb_scale);
1162
1163 startBand = old_lsb;
1164
1165 if (new_lsb >= old_usb) {
1166 /* case 1 */
1167 stopBand = old_usb;
1168 } else {
1169 /* case 3 */
1170 stopBand = new_lsb;
1171 }
1172
1173 target_lsb = 0;
1174 target_usb = old_lsb;
1175 } else {
1176 /* case 2 and 4 */
1177 source_exp = SCALE2EXP(hSbrDec->qmfDomainInCh->scaling.ov_lb_scale);
1178 target_exp = SCALE2EXP(hSbrDec->qmfDomainInCh->scaling.ov_hb_scale);
1179
1180 startBand = new_lsb;
1181 stopBand = old_lsb;
1182
1183 target_lsb = old_lsb;
1184 target_usb = old_usb;
1185 }
1186
1187 maxVal =
1188 maxSubbandSample(OverlapBufferReal, (useLP) ? NULL : OverlapBufferImag,
1189 startBand, stopBand, 0, startSlot);
1190
1191 reserve = ((LONG)maxVal != 0 ? CntLeadingZeros(maxVal) - 1 : 0);
1192 reserve = fixMin(
1193 reserve,
1194 DFRACT_BITS - 1 -
1195 EXP2SCALE(
1196 source_exp)); /* what is this line for, why do we need it? */
1197
1198 /* process only if x-over-area is not dominant after rescale;
1199 otherwise I'm not sure if all buffers are scaled correctly;
1200 */
1201 if (target_exp - (source_exp - reserve) >= 0) {
1202 rescaleSubbandSamples(OverlapBufferReal,
1203 (useLP) ? NULL : OverlapBufferImag, startBand,
1204 stopBand, 0, startSlot, reserve);
1205 source_exp -= reserve;
1206 }
1207
1208 delta_exp = target_exp - source_exp;
1209
1210 if (delta_exp < 0) { /* x-over-area is dominant */
1211 startBand = target_lsb;
1212 stopBand = target_usb;
1213 delta_exp = -delta_exp;
1214
1215 if (new_lsb > old_lsb) {
1216 /* The lowband has to be rescaled */
1217 hSbrDec->qmfDomainInCh->scaling.ov_lb_scale = EXP2SCALE(source_exp);
1218 } else {
1219 /* The highband has to be rescaled */
1220 hSbrDec->qmfDomainInCh->scaling.ov_hb_scale = EXP2SCALE(source_exp);
1221 }
1222 }
1223
1224 FDK_ASSERT(startBand <= stopBand);
1225
1226 if (!useLP) {
1227 for (l = 0; l < startSlot; l++) {
1228 scaleValues(OverlapBufferReal[l] + startBand, stopBand - startBand,
1229 -delta_exp);
1230 scaleValues(OverlapBufferImag[l] + startBand, stopBand - startBand,
1231 -delta_exp);
1232 }
1233 } else
1234 for (l = 0; l < startSlot; l++) {
1235 scaleValues(OverlapBufferReal[l] + startBand, stopBand - startBand,
1236 -delta_exp);
1237 }
1238 } /* startSlot != 0 */
1239
1240 /*
1241 Initialize transposer and limiter
1242 */
1243 sbrError = resetLppTransposer(
1244 &hSbrDec->LppTrans, hHeaderData->freqBandData.lowSubband,
1245 hHeaderData->freqBandData.v_k_master, hHeaderData->freqBandData.numMaster,
1246 hHeaderData->freqBandData.freqBandTableNoise,
1247 hHeaderData->freqBandData.nNfb, hHeaderData->freqBandData.highSubband,
1248 hHeaderData->sbrProcSmplRate);
1249 if (sbrError != SBRDEC_OK) return sbrError;
1250
1251 hSbrDec->savedStates = 0;
1252
1253 if ((flags & SBRDEC_USAC_HARMONICSBR) && applySbrProc) {
1254 sbrError = QmfTransposerReInit(hSbrDec->hHBE,
1255 hHeaderData->freqBandData.freqBandTable,
1256 hHeaderData->freqBandData.nSfb);
1257 if (sbrError != SBRDEC_OK) return sbrError;
1258
1259 /* copy saved states from previous frame to legacy SBR lpc filterstate
1260 * buffer */
1261 for (i = 0; i < LPC_ORDER + hSbrDec->LppTrans.pSettings->overlap; i++) {
1262 FDKmemcpy(
1263 hSbrDec->LppTrans.lpcFilterStatesRealLegSBR[i],
1264 hSbrDec->codecQMFBufferReal[hSbrDec->hHBE->noCols - LPC_ORDER -
1265 hSbrDec->LppTrans.pSettings->overlap + i],
1266 hSbrDec->hHBE->noChannels * sizeof(FIXP_DBL));
1267 FDKmemcpy(
1268 hSbrDec->LppTrans.lpcFilterStatesImagLegSBR[i],
1269 hSbrDec->codecQMFBufferImag[hSbrDec->hHBE->noCols - LPC_ORDER -
1270 hSbrDec->LppTrans.pSettings->overlap + i],
1271 hSbrDec->hHBE->noChannels * sizeof(FIXP_DBL));
1272 }
1273 hSbrDec->savedStates = 1;
1274
1275 {
1276 /* map QMF buffer to pointer array (Overlap + Frame)*/
1277 for (i = 0; i < hSbrDec->LppTrans.pSettings->overlap + LPC_ORDER; i++) {
1278 pLowBandReal[i] = hSbrDec->LppTrans.lpcFilterStatesRealHBE[i];
1279 pLowBandImag[i] = hSbrDec->LppTrans.lpcFilterStatesImagHBE[i];
1280 }
1281
1282 /* map QMF buffer to pointer array (Overlap + Frame)*/
1283 for (i = 0; i < hSbrDec->hHBE->noCols; i++) {
1284 pLowBandReal[i + hSbrDec->LppTrans.pSettings->overlap + LPC_ORDER] =
1285 hSbrDec->codecQMFBufferReal[i];
1286 pLowBandImag[i + hSbrDec->LppTrans.pSettings->overlap + LPC_ORDER] =
1287 hSbrDec->codecQMFBufferImag[i];
1288 }
1289
1290 if (flags & SBRDEC_QUAD_RATE) {
1291 if (hFrameData->sbrPatchingMode == 0) {
1292 int *xOverQmf = GetxOverBandQmfTransposer(hSbrDec->hHBE);
1293
1294 /* in case of harmonic SBR and no HBE_LP map additional buffer for
1295 one more frame to pointer arry */
1296 for (i = 0; i < hSbrDec->hHBE->noCols / 2; i++) {
1297 pLowBandReal[i + hSbrDec->hHBE->noCols +
1298 hSbrDec->LppTrans.pSettings->overlap + LPC_ORDER] =
1299 hSbrDec->hQmfHBESlotsReal[i];
1300 pLowBandImag[i + hSbrDec->hHBE->noCols +
1301 hSbrDec->LppTrans.pSettings->overlap + LPC_ORDER] =
1302 hSbrDec->hQmfHBESlotsImag[i];
1303 }
1304
1305 QmfTransposerApply(
1306 hSbrDec->hHBE,
1307 pLowBandReal + hSbrDec->LppTrans.pSettings->overlap +
1308 hSbrDec->hHBE->noCols / 2 + LPC_ORDER,
1309 pLowBandImag + hSbrDec->LppTrans.pSettings->overlap +
1310 hSbrDec->hHBE->noCols / 2 + LPC_ORDER,
1311 hSbrDec->hHBE->noCols, pLowBandReal, pLowBandImag,
1312 hSbrDec->LppTrans.lpcFilterStatesRealHBE,
1313 hSbrDec->LppTrans.lpcFilterStatesImagHBE,
1314 hPrevFrameData->prevSbrPitchInBins, hSbrDec->scale_lb,
1315 hSbrDec->scale_hbe, &hSbrDec->qmfDomainInCh->scaling.hb_scale,
1316 hHeaderData->timeStep, hFrameData->frameInfo.borders[0],
1317 hSbrDec->LppTrans.pSettings->overlap, KEEP_STATES_SYNCED_OUTDIFF);
1318
1319 copyHarmonicSpectrum(
1320 xOverQmf, pLowBandReal, pLowBandImag, hSbrDec->hHBE->noCols,
1321 hSbrDec->LppTrans.pSettings->overlap, KEEP_STATES_SYNCED_OUTDIFF);
1322 }
1323 } else {
1324 /* in case of harmonic SBR and no HBE_LP map additional buffer for
1325 one more frame to pointer arry */
1326 for (i = 0; i < hSbrDec->hHBE->noCols; i++) {
1327 pLowBandReal[i + hSbrDec->hHBE->noCols +
1328 hSbrDec->LppTrans.pSettings->overlap + LPC_ORDER] =
1329 hSbrDec->hQmfHBESlotsReal[i];
1330 pLowBandImag[i + hSbrDec->hHBE->noCols +
1331 hSbrDec->LppTrans.pSettings->overlap + LPC_ORDER] =
1332 hSbrDec->hQmfHBESlotsImag[i];
1333 }
1334
1335 if (hFrameData->sbrPatchingMode == 0) {
1336 QmfTransposerApply(
1337 hSbrDec->hHBE,
1338 pLowBandReal + hSbrDec->LppTrans.pSettings->overlap + LPC_ORDER,
1339 pLowBandImag + hSbrDec->LppTrans.pSettings->overlap + LPC_ORDER,
1340 hSbrDec->hHBE->noCols, pLowBandReal, pLowBandImag,
1341 hSbrDec->LppTrans.lpcFilterStatesRealHBE,
1342 hSbrDec->LppTrans.lpcFilterStatesImagHBE,
1343 0 /* not required for keeping states updated in this frame*/,
1344 hSbrDec->scale_lb, hSbrDec->scale_lb,
1345 &hSbrDec->qmfDomainInCh->scaling.hb_scale, hHeaderData->timeStep,
1346 hFrameData->frameInfo.borders[0],
1347 hSbrDec->LppTrans.pSettings->overlap, KEEP_STATES_SYNCED_NOOUT);
1348 }
1349
1350 QmfTransposerApply(
1351 hSbrDec->hHBE,
1352 pLowBandReal + hSbrDec->LppTrans.pSettings->overlap +
1353 hSbrDec->hHBE->noCols + LPC_ORDER,
1354 pLowBandImag + hSbrDec->LppTrans.pSettings->overlap +
1355 hSbrDec->hHBE->noCols + LPC_ORDER,
1356 hSbrDec->hHBE->noCols, pLowBandReal, pLowBandImag,
1357 hSbrDec->LppTrans.lpcFilterStatesRealHBE,
1358 hSbrDec->LppTrans.lpcFilterStatesImagHBE,
1359 hPrevFrameData->prevSbrPitchInBins, hSbrDec->scale_lb,
1360 hSbrDec->scale_hbe, &hSbrDec->qmfDomainInCh->scaling.hb_scale,
1361 hHeaderData->timeStep, hFrameData->frameInfo.borders[0],
1362 hSbrDec->LppTrans.pSettings->overlap, KEEP_STATES_SYNCED_OUTDIFF);
1363 }
1364
1365 if (hFrameData->sbrPatchingMode == 0) {
1366 for (i = startSlot; i < hSbrDec->LppTrans.pSettings->overlap; i++) {
1367 /*
1368 Store the unmodified qmf Slots values for upper part of spectrum
1369 (required for LPC filtering) required if next frame is a HBE frame
1370 */
1371 FDKmemcpy(hSbrDec->qmfDomainInCh->hQmfSlotsReal[i],
1372 hSbrDec->LppTrans.lpcFilterStatesRealHBE[i + LPC_ORDER],
1373 (64) * sizeof(FIXP_DBL));
1374 FDKmemcpy(hSbrDec->qmfDomainInCh->hQmfSlotsImag[i],
1375 hSbrDec->LppTrans.lpcFilterStatesImagHBE[i + LPC_ORDER],
1376 (64) * sizeof(FIXP_DBL));
1377 }
1378
1379 for (i = startSlot; i < hSbrDec->LppTrans.pSettings->overlap; i++) {
1380 /*
1381 Store the unmodified qmf Slots values for upper part of spectrum
1382 (required for LPC filtering) required if next frame is a HBE frame
1383 */
1384 FDKmemcpy(
1385 hSbrDec->qmfDomainInCh->hQmfSlotsReal[i],
1386 hSbrDec->codecQMFBufferReal[hSbrDec->hHBE->noCols -
1387 hSbrDec->LppTrans.pSettings->overlap +
1388 i],
1389 new_lsb * sizeof(FIXP_DBL));
1390 FDKmemcpy(
1391 hSbrDec->qmfDomainInCh->hQmfSlotsImag[i],
1392 hSbrDec->codecQMFBufferImag[hSbrDec->hHBE->noCols -
1393 hSbrDec->LppTrans.pSettings->overlap +
1394 i],
1395 new_lsb * sizeof(FIXP_DBL));
1396 }
1397 }
1398 }
1399 }
1400
1401 {
1402 int adapt_lb = 0, diff = 0,
1403 new_scale = hSbrDec->qmfDomainInCh->scaling.ov_lb_scale;
1404
1405 if ((hSbrDec->qmfDomainInCh->scaling.ov_lb_scale !=
1406 hSbrDec->qmfDomainInCh->scaling.lb_scale) &&
1407 startSlot != 0) {
1408 /* we need to adapt spectrum to have equal scale factor, always larger
1409 * than zero */
1410 diff = SCALE2EXP(hSbrDec->qmfDomainInCh->scaling.ov_lb_scale) -
1411 SCALE2EXP(hSbrDec->qmfDomainInCh->scaling.lb_scale);
1412
1413 if (diff > 0) {
1414 adapt_lb = 1;
1415 diff = -diff;
1416 new_scale = hSbrDec->qmfDomainInCh->scaling.ov_lb_scale;
1417 }
1418
1419 stopBand = new_lsb;
1420 }
1421
1422 if (hFrameData->sbrPatchingMode == 1) {
1423 /* scale states from LegSBR filterstates buffer */
1424 for (i = 0; i < hSbrDec->LppTrans.pSettings->overlap + LPC_ORDER; i++) {
1425 scaleValues(hSbrDec->LppTrans.lpcFilterStatesRealLegSBR[i], new_lsb,
1426 diff);
1427 if (!useLP) {
1428 scaleValues(hSbrDec->LppTrans.lpcFilterStatesImagLegSBR[i], new_lsb,
1429 diff);
1430 }
1431 }
1432
1433 if (flags & SBRDEC_SYNTAX_USAC) {
1434 /* get missing states between old and new x_over from LegSBR
1435 * filterstates buffer */
1436 /* in case of legacy SBR we leave these values zeroed out */
1437 for (i = startSlot; i < hSbrDec->LppTrans.pSettings->overlap; i++) {
1438 FDKmemcpy(&OverlapBufferReal[i][old_lsb],
1439 &hSbrDec->LppTrans
1440 .lpcFilterStatesRealLegSBR[LPC_ORDER + i][old_lsb],
1441 fMax(new_lsb - old_lsb, 0) * sizeof(FIXP_DBL));
1442 if (!useLP) {
1443 FDKmemcpy(&OverlapBufferImag[i][old_lsb],
1444 &hSbrDec->LppTrans
1445 .lpcFilterStatesImagLegSBR[LPC_ORDER + i][old_lsb],
1446 fMax(new_lsb - old_lsb, 0) * sizeof(FIXP_DBL));
1447 }
1448 }
1449 }
1450
1451 if (new_lsb > old_lsb) {
1452 stopBand = old_lsb;
1453 }
1454 }
1455 if ((adapt_lb == 1) && (stopBand > startBand)) {
1456 for (l = startSlot; l < hSbrDec->LppTrans.pSettings->overlap; l++) {
1457 scaleValues(OverlapBufferReal[l] + startBand, stopBand - startBand,
1458 diff);
1459 if (!useLP) {
1460 scaleValues(OverlapBufferImag[l] + startBand, stopBand - startBand,
1461 diff);
1462 }
1463 }
1464 }
1465 hSbrDec->qmfDomainInCh->scaling.ov_lb_scale = new_scale;
1466 }
1467
1468 sbrError = ResetLimiterBands(hHeaderData->freqBandData.limiterBandTable,
1469 &hHeaderData->freqBandData.noLimiterBands,
1470 hHeaderData->freqBandData.freqBandTable[0],
1471 hHeaderData->freqBandData.nSfb[0],
1472 hSbrDec->LppTrans.pSettings->patchParam,
1473 hSbrDec->LppTrans.pSettings->noOfPatches,
1474 hHeaderData->bs_data.limiterBands,
1475 hFrameData->sbrPatchingMode,
1476 GetxOverBandQmfTransposer(hSbrDec->hHBE),
1477 Get41SbrQmfTransposer(hSbrDec->hHBE));
1478
1479 hSbrDec->SbrCalculateEnvelope.sbrPatchingMode = hFrameData->sbrPatchingMode;
1480
1481 return sbrError;
1482 }
1483