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(&degreeAlias[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