• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 
2 /* -----------------------------------------------------------------------------------------------------------
3 Software License for The Fraunhofer FDK AAC Codec Library for Android
4 
5 � Copyright  1995 - 2012 Fraunhofer-Gesellschaft zur F�rderung der angewandten Forschung e.V.
6   All rights reserved.
7 
8  1.    INTRODUCTION
9 The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software that implements
10 the MPEG Advanced Audio Coding ("AAC") encoding and decoding scheme for digital audio.
11 This FDK AAC Codec software is intended to be used on a wide variety of Android devices.
12 
13 AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient general perceptual
14 audio codecs. AAC-ELD is considered the best-performing full-bandwidth communications codec by
15 independent studies and is widely deployed. AAC has been standardized by ISO and IEC as part
16 of the MPEG specifications.
17 
18 Patent licenses for necessary patent claims for the FDK AAC Codec (including those of Fraunhofer)
19 may be obtained through Via Licensing (www.vialicensing.com) or through the respective patent owners
20 individually for the purpose of encoding or decoding bit streams in products that are compliant with
21 the ISO/IEC MPEG audio standards. Please note that most manufacturers of Android devices already license
22 these patent claims through Via Licensing or directly from the patent owners, and therefore FDK AAC Codec
23 software may already be covered under those patent licenses when it is used for those licensed purposes only.
24 
25 Commercially-licensed AAC software libraries, including floating-point versions with enhanced sound quality,
26 are also available from Fraunhofer. Users are encouraged to check the Fraunhofer website for additional
27 applications information and documentation.
28 
29 2.    COPYRIGHT LICENSE
30 
31 Redistribution and use in source and binary forms, with or without modification, are permitted without
32 payment of copyright license fees provided that you satisfy the following conditions:
33 
34 You must retain the complete text of this software license in redistributions of the FDK AAC Codec or
35 your modifications thereto in source code form.
36 
37 You must retain the complete text of this software license in the documentation and/or other materials
38 provided with redistributions of the FDK AAC Codec or your modifications thereto in binary form.
39 You must make available free of charge copies of the complete source code of the FDK AAC Codec and your
40 modifications thereto to recipients of copies in binary form.
41 
42 The name of Fraunhofer may not be used to endorse or promote products derived from this library without
43 prior written permission.
44 
45 You may not charge copyright license fees for anyone to use, copy or distribute the FDK AAC Codec
46 software or your modifications thereto.
47 
48 Your modified versions of the FDK AAC Codec must carry prominent notices stating that you changed the software
49 and the date of any change. For modified versions of the FDK AAC Codec, the term
50 "Fraunhofer FDK AAC Codec Library for Android" must be replaced by the term
51 "Third-Party Modified Version of the Fraunhofer FDK AAC Codec Library for Android."
52 
53 3.    NO PATENT LICENSE
54 
55 NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without limitation the patents of Fraunhofer,
56 ARE GRANTED BY THIS SOFTWARE LICENSE. Fraunhofer provides no warranty of patent non-infringement with
57 respect to this software.
58 
59 You may use this FDK AAC Codec software or modifications thereto only for purposes that are authorized
60 by appropriate patent licenses.
61 
62 4.    DISCLAIMER
63 
64 This FDK AAC Codec software is provided by Fraunhofer on behalf of the copyright holders and contributors
65 "AS IS" and WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, including but not limited to the implied warranties
66 of merchantability and fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
67 CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary, or consequential damages,
68 including but not limited to procurement of substitute goods or services; loss of use, data, or profits,
69 or business interruption, however caused and on any theory of liability, whether in contract, strict
70 liability, or tort (including negligence), arising in any way out of the use of this software, even if
71 advised of the possibility of such damage.
72 
73 5.    CONTACT INFORMATION
74 
75 Fraunhofer Institute for Integrated Circuits IIS
76 Attention: Audio and Multimedia Departments - FDK AAC LL
77 Am Wolfsmantel 33
78 91058 Erlangen, Germany
79 
80 www.iis.fraunhofer.de/amm
81 amm-info@iis.fraunhofer.de
82 ----------------------------------------------------------------------------------------------------------- */
83 
84 #include "mh_det.h"
85 
86 #include "sbr_ram.h"
87 #include "sbr_misc.h"
88 
89 
90 #include "genericStds.h"
91 
92 #define SFM_SHIFT 2     /* Attention: SFM_SCALE depends on SFM_SHIFT */
93 #define SFM_SCALE (MAXVAL_DBL >> SFM_SHIFT)   /* 1.0 >> SFM_SHIFT */
94 
95 
96 /*!< Detector Parameters for AAC core codec. */
97 static const DETECTOR_PARAMETERS_MH paramsAac = {
98 9,                                             /*!< deltaTime */
99 {
100 FL2FXCONST_DBL(20.0f*RELAXATION_FLOAT),        /*!< thresHoldDiff */
101 FL2FXCONST_DBL(1.26f*RELAXATION_FLOAT),        /*!< thresHoldDiffGuide */
102 FL2FXCONST_DBL(15.0f*RELAXATION_FLOAT),        /*!< thresHoldTone */
103 FL2FXCONST_DBL((1.0f/15.0f)*RELAXATION_FLOAT), /*!< invThresHoldTone */
104 FL2FXCONST_DBL(1.26f*RELAXATION_FLOAT),        /*!< thresHoldToneGuide */
105 FL2FXCONST_DBL(0.3f)>>SFM_SHIFT,               /*!< sfmThresSbr */
106 FL2FXCONST_DBL(0.1f)>>SFM_SHIFT,               /*!< sfmThresOrig */
107 FL2FXCONST_DBL(0.3f),                          /*!< decayGuideOrig */
108 FL2FXCONST_DBL(0.5f),                          /*!< decayGuideDiff */
109 FL2FXCONST_DBL(-0.000112993269),  /* LD64(FL2FXCONST_DBL(0.995f)) */ /*!< derivThresMaxLD64 */
110 FL2FXCONST_DBL(-0.000112993269),  /* LD64(FL2FXCONST_DBL(0.995f)) */ /*!< derivThresBelowLD64 */
111 FL2FXCONST_DBL(-0.005030126483f) /* LD64(FL2FXCONST_DBL(0.8f)) */    /*!< derivThresAboveLD64 */
112 },
113 50                                             /*!< maxComp */
114 };
115 
116 /*!< Detector Parameters for AAC LD core codec. */
117 static const DETECTOR_PARAMETERS_MH paramsAacLd = {
118 16,                                            /*!< Delta time. */
119 {
120 FL2FXCONST_DBL(25.0f*RELAXATION_FLOAT),        /*!< thresHoldDiff */
121 FL2FXCONST_DBL(1.26f*RELAXATION_FLOAT),        /*!< tresHoldDiffGuide */
122 FL2FXCONST_DBL(15.0f*RELAXATION_FLOAT),        /*!< thresHoldTone */
123 FL2FXCONST_DBL((1.0f/15.0f)*RELAXATION_FLOAT), /*!< invThresHoldTone */
124 FL2FXCONST_DBL(1.26f*RELAXATION_FLOAT),        /*!< thresHoldToneGuide */
125 FL2FXCONST_DBL(0.3f)>>SFM_SHIFT,               /*!< sfmThresSbr */
126 FL2FXCONST_DBL(0.1f)>>SFM_SHIFT,               /*!< sfmThresOrig */
127 FL2FXCONST_DBL(0.3f),                          /*!< decayGuideOrig */
128 FL2FXCONST_DBL(0.2f),                          /*!< decayGuideDiff */
129 FL2FXCONST_DBL(-0.000112993269),  /* LD64(FL2FXCONST_DBL(0.995f)) */  /*!< derivThresMaxLD64 */
130 FL2FXCONST_DBL(-0.000112993269),  /* LD64(FL2FXCONST_DBL(0.995f)) */  /*!< derivThresBelowLD64 */
131 FL2FXCONST_DBL(-0.005030126483f) /* LD64(FL2FXCONST_DBL(0.8f)) */     /*!< derivThresAboveLD64 */
132 },
133 50                                             /*!< maxComp */
134 };
135 
136 
137 /**************************************************************************/
138 /*!
139   \brief     Calculates the difference in tonality between original and SBR
140              for a given time and frequency region.
141 
142              The values for pDiffMapped2Scfb are scaled by RELAXATION
143 
144   \return    none.
145 
146 */
147 /**************************************************************************/
diff(FIXP_DBL * RESTRICT pTonalityOrig,FIXP_DBL * pDiffMapped2Scfb,const UCHAR * RESTRICT pFreqBandTable,INT nScfb,SCHAR * indexVector)148 static void diff(FIXP_DBL *RESTRICT pTonalityOrig,
149                  FIXP_DBL *pDiffMapped2Scfb,
150                  const UCHAR *RESTRICT pFreqBandTable,
151                  INT       nScfb,
152                  SCHAR    *indexVector)
153 {
154   UCHAR i, ll, lu, k;
155   FIXP_DBL maxValOrig, maxValSbr, tmp;
156   INT scale;
157 
158   for(i=0; i < nScfb; i++){
159     ll = pFreqBandTable[i];
160     lu = pFreqBandTable[i+1];
161 
162     maxValOrig = FL2FXCONST_DBL(0.0f);
163     maxValSbr = FL2FXCONST_DBL(0.0f);
164 
165     for(k=ll;k<lu;k++){
166       maxValOrig = fixMax(maxValOrig, pTonalityOrig[k]);
167       maxValSbr = fixMax(maxValSbr, pTonalityOrig[indexVector[k]]);
168     }
169 
170     if ((maxValSbr >= RELAXATION)) {
171         tmp = fDivNorm(maxValOrig, maxValSbr, &scale);
172         pDiffMapped2Scfb[i] = scaleValue(fMult(tmp,RELAXATION_FRACT), fixMax(-(DFRACT_BITS-1),(scale-RELAXATION_SHIFT)));
173     }
174     else {
175         pDiffMapped2Scfb[i] = maxValOrig;
176     }
177   }
178 }
179 
180 
181 /**************************************************************************/
182 /*!
183   \brief     Calculates a flatness measure of the tonality measures.
184 
185   Calculation of the power function and using scalefactor for basis:
186     Using log2:
187     z  = (2^k * x)^y;
188     z' = CalcLd(z) = y*CalcLd(x) + y*k;
189     z  = CalcInvLd(z');
190 
191     Using ld64:
192     z  = (2^k * x)^y;
193     z' = CalcLd64(z) = y*CalcLd64(x)/64 + y*k/64;
194     z  = CalcInvLd64(z');
195 
196   The values pSfmOrigVec and pSfmSbrVec are scaled by the factor 1/4.0
197 
198   \return    none.
199 
200 */
201 /**************************************************************************/
calculateFlatnessMeasure(FIXP_DBL * pQuotaBuffer,SCHAR * indexVector,FIXP_DBL * pSfmOrigVec,FIXP_DBL * pSfmSbrVec,const UCHAR * pFreqBandTable,INT nSfb)202 static void calculateFlatnessMeasure(FIXP_DBL *pQuotaBuffer,
203                                      SCHAR    *indexVector,
204                                      FIXP_DBL *pSfmOrigVec,
205                                      FIXP_DBL *pSfmSbrVec,
206                                      const UCHAR *pFreqBandTable,
207                                      INT       nSfb)
208 {
209   INT i,j;
210   FIXP_DBL invBands,tmp1,tmp2;
211   INT shiftFac0,shiftFacSum0;
212   INT shiftFac1,shiftFacSum1;
213   FIXP_DBL accu;
214 
215   for(i=0;i<nSfb;i++)
216   {
217     INT ll = pFreqBandTable[i];
218     INT lu = pFreqBandTable[i+1];
219     pSfmOrigVec[i] = (FIXP_DBL)(MAXVAL_DBL>>2);
220     pSfmSbrVec[i]  = (FIXP_DBL)(MAXVAL_DBL>>2);
221 
222     if(lu - ll > 1){
223       FIXP_DBL amOrig,amTransp,gmOrig,gmTransp,sfmOrig,sfmTransp;
224       invBands = GetInvInt(lu-ll);
225       shiftFacSum0 = 0;
226       shiftFacSum1 = 0;
227       amOrig = amTransp = FL2FXCONST_DBL(0.0f);
228       gmOrig = gmTransp = (FIXP_DBL)MAXVAL_DBL;
229 
230       for(j= ll; j<lu; j++) {
231         sfmOrig   = pQuotaBuffer[j];
232         sfmTransp = pQuotaBuffer[indexVector[j]];
233 
234         amOrig   += fMult(sfmOrig, invBands);
235         amTransp += fMult(sfmTransp, invBands);
236 
237         shiftFac0 = CountLeadingBits(sfmOrig);
238         shiftFac1 = CountLeadingBits(sfmTransp);
239 
240         gmOrig   = fMult(gmOrig, sfmOrig<<shiftFac0);
241         gmTransp = fMult(gmTransp, sfmTransp<<shiftFac1);
242 
243         shiftFacSum0 += shiftFac0;
244         shiftFacSum1 += shiftFac1;
245       }
246 
247       if (gmOrig > FL2FXCONST_DBL(0.0f)) {
248 
249         tmp1 = CalcLdData(gmOrig);      /* CalcLd64(x)/64 */
250         tmp1 = fMult(invBands, tmp1);   /* y*CalcLd64(x)/64 */
251 
252         /* y*k/64 */
253         accu = (FIXP_DBL)-shiftFacSum0 << (DFRACT_BITS-1-8);
254         tmp2 = fMultDiv2(invBands, accu) << (2+1);
255 
256         tmp2 = tmp1 + tmp2;             /* y*CalcLd64(x)/64 + y*k/64 */
257         gmOrig = CalcInvLdData(tmp2);   /* CalcInvLd64(z'); */
258       }
259       else {
260         gmOrig = FL2FXCONST_DBL(0.0f);
261       }
262 
263       if (gmTransp > FL2FXCONST_DBL(0.0f)) {
264 
265         tmp1 = CalcLdData(gmTransp);    /* CalcLd64(x)/64 */
266         tmp1 = fMult(invBands, tmp1);   /* y*CalcLd64(x)/64 */
267 
268         /* y*k/64 */
269         accu = (FIXP_DBL)-shiftFacSum1 << (DFRACT_BITS-1-8);
270         tmp2 = fMultDiv2(invBands, accu) << (2+1);
271 
272         tmp2 = tmp1 + tmp2;             /* y*CalcLd64(x)/64 + y*k/64 */
273         gmTransp = CalcInvLdData(tmp2); /* CalcInvLd64(z'); */
274       }
275       else {
276         gmTransp = FL2FXCONST_DBL(0.0f);
277       }
278       if ( amOrig != FL2FXCONST_DBL(0.0f) )
279         pSfmOrigVec[i] = FDKsbrEnc_LSI_divide_scale_fract(gmOrig,amOrig,SFM_SCALE);
280 
281       if ( amTransp != FL2FXCONST_DBL(0.0f) )
282         pSfmSbrVec[i] = FDKsbrEnc_LSI_divide_scale_fract(gmTransp,amTransp,SFM_SCALE);
283     }
284   }
285 }
286 
287 /**************************************************************************/
288 /*!
289   \brief     Calculates the input to the missing harmonics detection.
290 
291 
292   \return    none.
293 
294 */
295 /**************************************************************************/
calculateDetectorInput(FIXP_DBL ** RESTRICT pQuotaBuffer,SCHAR * RESTRICT indexVector,FIXP_DBL ** RESTRICT tonalityDiff,FIXP_DBL ** RESTRICT pSfmOrig,FIXP_DBL ** RESTRICT pSfmSbr,const UCHAR * freqBandTable,INT nSfb,INT noEstPerFrame,INT move)296 static void calculateDetectorInput(FIXP_DBL **RESTRICT pQuotaBuffer,  /*!< Pointer to tonality matrix. */
297                                    SCHAR     *RESTRICT indexVector,
298                                    FIXP_DBL **RESTRICT tonalityDiff,
299                                    FIXP_DBL **RESTRICT pSfmOrig,
300                                    FIXP_DBL **RESTRICT pSfmSbr,
301                                    const UCHAR *freqBandTable,
302                                    INT nSfb,
303                                    INT noEstPerFrame,
304                                    INT move)
305 {
306   INT est;
307 
308   /*
309   New estimate.
310   */
311   for (est=0; est < noEstPerFrame; est++) {
312 
313     diff(pQuotaBuffer[est+move],
314          tonalityDiff[est+move],
315          freqBandTable,
316          nSfb,
317          indexVector);
318 
319     calculateFlatnessMeasure(pQuotaBuffer[est+ move],
320                              indexVector,
321                              pSfmOrig[est + move],
322                              pSfmSbr[est + move],
323                              freqBandTable,
324                              nSfb);
325   }
326 }
327 
328 
329 /**************************************************************************/
330 /*!
331   \brief     Checks that the detection is not due to a LP filter
332 
333   This function determines if a newly detected missing harmonics is not
334   in fact just a low-pass filtere input signal. If so, the detection is
335   removed.
336 
337   \return    none.
338 
339 */
340 /**************************************************************************/
removeLowPassDetection(UCHAR * RESTRICT pAddHarmSfb,UCHAR ** RESTRICT pDetectionVectors,INT start,INT stop,INT nSfb,const UCHAR * RESTRICT pFreqBandTable,FIXP_DBL * RESTRICT pNrgVector,THRES_HOLDS mhThresh)341 static void removeLowPassDetection(UCHAR *RESTRICT pAddHarmSfb,
342                                    UCHAR **RESTRICT pDetectionVectors,
343                                    INT start,
344                                    INT stop,
345                                    INT nSfb,
346                                    const UCHAR *RESTRICT pFreqBandTable,
347                                    FIXP_DBL *RESTRICT pNrgVector,
348                                    THRES_HOLDS mhThresh)
349 
350 {
351   INT i,est;
352   INT maxDerivPos = pFreqBandTable[nSfb];
353   INT numBands = pFreqBandTable[nSfb];
354   FIXP_DBL nrgLow,nrgHigh;
355   FIXP_DBL nrgLD64,nrgLowLD64,nrgHighLD64,nrgDiffLD64;
356   FIXP_DBL valLD64,maxValLD64,maxValAboveLD64;
357   INT bLPsignal = 0;
358 
359   maxValLD64 = FL2FXCONST_DBL(-1.0f);
360   for(i = numBands - 1 - 2; i > pFreqBandTable[0];i--){
361     nrgLow  = pNrgVector[i];
362     nrgHigh = pNrgVector[i + 2];
363 
364     if(nrgLow != FL2FXCONST_DBL(0.0f) && nrgLow > nrgHigh){
365       nrgLowLD64 = CalcLdData(nrgLow>>1);
366       nrgDiffLD64 = CalcLdData((nrgLow>>1)-(nrgHigh>>1));
367       valLD64 = nrgDiffLD64-nrgLowLD64;
368       if(valLD64 > maxValLD64){
369         maxDerivPos = i;
370         maxValLD64 = valLD64;
371       }
372       if(maxValLD64 > mhThresh.derivThresMaxLD64) {
373         break;
374       }
375     }
376   }
377 
378   /* Find the largest "gradient" above. (should be relatively flat, hence we expect a low value
379      if the signal is LP.*/
380   maxValAboveLD64 = FL2FXCONST_DBL(-1.0f);
381   for(i = numBands - 1 - 2; i > maxDerivPos + 2;i--){
382     nrgLow  = pNrgVector[i];
383     nrgHigh = pNrgVector[i + 2];
384 
385     if(nrgLow != FL2FXCONST_DBL(0.0f) && nrgLow > nrgHigh){
386 		   nrgLowLD64 = CalcLdData(nrgLow>>1);
387 		   nrgDiffLD64 = CalcLdData((nrgLow>>1)-(nrgHigh>>1));
388 			 valLD64 = nrgDiffLD64-nrgLowLD64;
389       if(valLD64 > maxValAboveLD64){
390         maxValAboveLD64 = valLD64;
391       }
392     }
393 		 else {
394       if(nrgHigh != FL2FXCONST_DBL(0.0f) && nrgHigh > nrgLow){
395 		     nrgHighLD64 = CalcLdData(nrgHigh>>1);
396 		     nrgDiffLD64 = CalcLdData((nrgHigh>>1)-(nrgLow>>1));
397 			   valLD64 = nrgDiffLD64-nrgHighLD64;
398         if(valLD64 > maxValAboveLD64){
399           maxValAboveLD64 = valLD64;
400         }
401       }
402 		 }
403   }
404 
405   if(maxValLD64 > mhThresh.derivThresMaxLD64 && maxValAboveLD64 < mhThresh.derivThresAboveLD64){
406     bLPsignal = 1;
407 
408     for(i = maxDerivPos - 1; i > maxDerivPos - 5 && i >= 0 ; i--){
409       if(pNrgVector[i] != FL2FXCONST_DBL(0.0f) && pNrgVector[i] > pNrgVector[maxDerivPos + 2]){
410 		     nrgDiffLD64 = CalcLdData((pNrgVector[i]>>1)-(pNrgVector[maxDerivPos + 2]>>1));
411 				 nrgLD64 = CalcLdData(pNrgVector[i]>>1);
412   			 valLD64 = nrgDiffLD64-nrgLD64;
413         if(valLD64 < mhThresh.derivThresBelowLD64) {
414           bLPsignal = 0;
415           break;
416         }
417       }
418       else{
419         bLPsignal = 0;
420         break;
421       }
422     }
423   }
424 
425   if(bLPsignal){
426     for(i=0;i<nSfb;i++){
427       if(maxDerivPos >= pFreqBandTable[i] && maxDerivPos < pFreqBandTable[i+1])
428         break;
429     }
430 
431     if(pAddHarmSfb[i]){
432       pAddHarmSfb[i] = 0;
433       for(est = start; est < stop ; est++){
434         pDetectionVectors[est][i] = 0;
435       }
436     }
437   }
438 }
439 
440 /**************************************************************************/
441 /*!
442   \brief     Checks if it is allowed to detect a missing tone, that wasn't
443              detected previously.
444 
445 
446   \return    newDetectionAllowed flag.
447 
448 */
449 /**************************************************************************/
isDetectionOfNewToneAllowed(const SBR_FRAME_INFO * pFrameInfo,INT * pDetectionStartPos,INT noEstPerFrame,INT prevTransientFrame,INT prevTransientPos,INT prevTransientFlag,INT transientPosOffset,INT transientFlag,INT transientPos,INT deltaTime,HANDLE_SBR_MISSING_HARMONICS_DETECTOR h_sbrMissingHarmonicsDetector)450 static INT isDetectionOfNewToneAllowed(const SBR_FRAME_INFO *pFrameInfo,
451                                        INT *pDetectionStartPos,
452                                        INT noEstPerFrame,
453                                        INT prevTransientFrame,
454                                        INT prevTransientPos,
455                                        INT prevTransientFlag,
456                                        INT transientPosOffset,
457                                        INT transientFlag,
458                                        INT transientPos,
459                                        INT deltaTime,
460                                        HANDLE_SBR_MISSING_HARMONICS_DETECTOR h_sbrMissingHarmonicsDetector)
461 {
462   INT transientFrame, newDetectionAllowed;
463 
464 
465   /* Determine if this is a frame where a transient starts...
466    * If the transient flag was set the previous frame but not the
467    * transient frame flag, the transient frame flag is set in the current frame.
468    *****************************************************************************/
469   transientFrame = 0;
470   if(transientFlag){
471     if(transientPos + transientPosOffset < pFrameInfo->borders[pFrameInfo->nEnvelopes])
472       transientFrame = 1;
473       if(noEstPerFrame > 1){
474         if(transientPos + transientPosOffset > h_sbrMissingHarmonicsDetector->timeSlots >> 1){
475           *pDetectionStartPos = noEstPerFrame;
476         }
477         else{
478           *pDetectionStartPos = noEstPerFrame >> 1;
479         }
480 
481       }
482       else{
483         *pDetectionStartPos = noEstPerFrame;
484       }
485   }
486   else{
487     if(prevTransientFlag && !prevTransientFrame){
488       transientFrame = 1;
489       *pDetectionStartPos = 0;
490     }
491   }
492 
493   /*
494    * Determine if detection of new missing harmonics are allowed.
495    * If the frame contains a transient it's ok. If the previous
496    * frame contained a transient it needs to be sufficiently close
497    * to the start of the current frame.
498    ****************************************************************/
499   newDetectionAllowed = 0;
500   if(transientFrame){
501     newDetectionAllowed = 1;
502   }
503   else {
504     if(prevTransientFrame &&
505        fixp_abs(pFrameInfo->borders[0] - (prevTransientPos + transientPosOffset -
506                                      h_sbrMissingHarmonicsDetector->timeSlots)) < deltaTime)
507       newDetectionAllowed = 1;
508       *pDetectionStartPos = 0;
509   }
510 
511   h_sbrMissingHarmonicsDetector->previousTransientFlag  = transientFlag;
512   h_sbrMissingHarmonicsDetector->previousTransientFrame = transientFrame;
513   h_sbrMissingHarmonicsDetector->previousTransientPos   = transientPos;
514 
515   return (newDetectionAllowed);
516 }
517 
518 
519 /**************************************************************************/
520 /*!
521   \brief     Cleans up the detection after a transient.
522 
523 
524   \return    none.
525 
526 */
527 /**************************************************************************/
transientCleanUp(FIXP_DBL ** quotaBuffer,INT nSfb,UCHAR ** detectionVectors,UCHAR * pAddHarmSfb,UCHAR * pPrevAddHarmSfb,INT ** signBuffer,const UCHAR * pFreqBandTable,INT start,INT stop,INT newDetectionAllowed,FIXP_DBL * pNrgVector,THRES_HOLDS mhThresh)528 static void transientCleanUp(FIXP_DBL **quotaBuffer,
529                              INT nSfb,
530                              UCHAR **detectionVectors,
531                              UCHAR *pAddHarmSfb,
532                              UCHAR *pPrevAddHarmSfb,
533                              INT ** signBuffer,
534                              const UCHAR *pFreqBandTable,
535                              INT start,
536                              INT stop,
537                              INT newDetectionAllowed,
538                              FIXP_DBL *pNrgVector,
539                              THRES_HOLDS mhThresh)
540 {
541   INT i,j,li, ui,est;
542 
543   for(est=start; est < stop; est++) {
544     for(i=0; i<nSfb; i++) {
545       pAddHarmSfb[i] = pAddHarmSfb[i] || detectionVectors[est][i];
546     }
547   }
548 
549   if(newDetectionAllowed == 1){
550     /*
551      * Check for duplication of sines located
552      * on the border of two scf-bands.
553      *************************************************/
554     for(i=0;i<nSfb-1;i++) {
555       li = pFreqBandTable[i];
556       ui = pFreqBandTable[i+1];
557 
558       /* detection in adjacent channels.*/
559       if(pAddHarmSfb[i] && pAddHarmSfb[i+1]) {
560         FIXP_DBL maxVal1, maxVal2;
561         INT maxPos1, maxPos2, maxPosTime1, maxPosTime2;
562 
563         li = pFreqBandTable[i];
564         ui = pFreqBandTable[i+1];
565 
566         /* Find maximum tonality in the the two scf bands.*/
567         maxPosTime1 = start;
568         maxPos1 = li;
569         maxVal1 = quotaBuffer[start][li];
570         for(est = start; est < stop; est++){
571           for(j = li; j<ui; j++){
572             if(quotaBuffer[est][j] > maxVal1){
573               maxVal1 = quotaBuffer[est][j];
574               maxPos1 = j;
575               maxPosTime1 = est;
576             }
577           }
578         }
579 
580         li = pFreqBandTable[i+1];
581         ui = pFreqBandTable[i+2];
582 
583         /* Find maximum tonality in the the two scf bands.*/
584         maxPosTime2 = start;
585         maxPos2 = li;
586         maxVal2 = quotaBuffer[start][li];
587         for(est = start; est < stop; est++){
588           for(j = li; j<ui; j++){
589             if(quotaBuffer[est][j] > maxVal2){
590               maxVal2 = quotaBuffer[est][j];
591               maxPos2 = j;
592               maxPosTime2 = est;
593             }
594           }
595         }
596 
597         /* If the maximum values are in adjacent QMF-channels, we need to remove
598            the lowest of the two.*/
599         if(maxPos2-maxPos1 < 2){
600 
601           if(pPrevAddHarmSfb[i] == 1 && pPrevAddHarmSfb[i+1] == 0){
602             /* Keep the lower, remove the upper.*/
603             pAddHarmSfb[i+1] = 0;
604             for(est=start; est<stop; est++){
605               detectionVectors[est][i+1] = 0;
606             }
607           }
608           else{
609             if(pPrevAddHarmSfb[i] == 0 && pPrevAddHarmSfb[i+1] == 1){
610               /* Keep the upper, remove the lower.*/
611               pAddHarmSfb[i] = 0;
612               for(est=start; est<stop; est++){
613                 detectionVectors[est][i] = 0;
614               }
615             }
616             else{
617              /* If the maximum values are in adjacent QMF-channels, and if the signs indicate that it is the same sine,
618                 we need to remove the lowest of the two.*/
619               if(maxVal1 > maxVal2){
620                 if(signBuffer[maxPosTime1][maxPos2] < 0 && signBuffer[maxPosTime1][maxPos1] > 0){
621                   /* Keep the lower, remove the upper.*/
622                   pAddHarmSfb[i+1] = 0;
623                   for(est=start; est<stop; est++){
624                     detectionVectors[est][i+1] = 0;
625                   }
626                 }
627               }
628               else{
629                 if(signBuffer[maxPosTime2][maxPos2] < 0 && signBuffer[maxPosTime2][maxPos1] > 0){
630                   /* Keep the upper, remove the lower.*/
631                   pAddHarmSfb[i] = 0;
632                   for(est=start; est<stop; est++){
633                     detectionVectors[est][i] = 0;
634                   }
635                 }
636               }
637             }
638           }
639         }
640       }
641     }
642 
643     /* Make sure that the detection is not the cut-off of a low pass filter. */
644     removeLowPassDetection(pAddHarmSfb,
645                            detectionVectors,
646                            start,
647                            stop,
648                            nSfb,
649                            pFreqBandTable,
650                            pNrgVector,
651                            mhThresh);
652   }
653   else {
654    /*
655     * If a missing harmonic wasn't missing the previous frame
656     * the transient-flag needs to be set in order to be allowed to detect it.
657     *************************************************************************/
658     for(i=0;i<nSfb;i++){
659       if(pAddHarmSfb[i] - pPrevAddHarmSfb[i] > 0)
660         pAddHarmSfb[i] = 0;
661     }
662   }
663 }
664 
665 
666 /**************************************************************************/
667 /*!
668   \brief     Do detection for one tonality estimate.
669 
670 
671   \return    none.
672 
673 */
674 /**************************************************************************/
detection(FIXP_DBL * quotaBuffer,FIXP_DBL * pDiffVecScfb,INT nSfb,UCHAR * pHarmVec,const UCHAR * pFreqBandTable,FIXP_DBL * sfmOrig,FIXP_DBL * sfmSbr,GUIDE_VECTORS guideVectors,GUIDE_VECTORS newGuideVectors,THRES_HOLDS mhThresh)675 static void detection(FIXP_DBL *quotaBuffer,
676                       FIXP_DBL *pDiffVecScfb,
677                       INT nSfb,
678                       UCHAR *pHarmVec,
679                       const UCHAR *pFreqBandTable,
680                       FIXP_DBL *sfmOrig,
681                       FIXP_DBL *sfmSbr,
682                       GUIDE_VECTORS guideVectors,
683                       GUIDE_VECTORS newGuideVectors,
684                       THRES_HOLDS mhThresh)
685 {
686 
687   INT i,j,ll, lu;
688   FIXP_DBL thresTemp,thresOrig;
689 
690   /*
691    * Do detection on the difference vector, i.e. the difference between
692    * the original and the transposed.
693    *********************************************************************/
694   for(i=0;i<nSfb;i++){
695 
696     thresTemp = (guideVectors.guideVectorDiff[i] != FL2FXCONST_DBL(0.0f))
697                   ? fixMax(fMult(mhThresh.decayGuideDiff,guideVectors.guideVectorDiff[i]), mhThresh.thresHoldDiffGuide)
698                   : mhThresh.thresHoldDiff;
699 
700     thresTemp = fixMin(thresTemp, mhThresh.thresHoldDiff);
701 
702     if(pDiffVecScfb[i] > thresTemp){
703       pHarmVec[i] = 1;
704       newGuideVectors.guideVectorDiff[i] = pDiffVecScfb[i];
705     }
706     else{
707       /* If the guide wasn't zero, but the current level is to low,
708          start tracking the decay on the tone in the original rather
709          than the difference.*/
710       if(guideVectors.guideVectorDiff[i] != FL2FXCONST_DBL(0.0f)){
711         guideVectors.guideVectorOrig[i] = mhThresh.thresHoldToneGuide;
712       }
713     }
714   }
715 
716   /*
717    * Trace tones in the original signal that at one point
718    * have been detected because they will be replaced by
719    * multiple tones in the sbr signal.
720    ****************************************************/
721 
722   for(i=0;i<nSfb;i++){
723     ll = pFreqBandTable[i];
724     lu = pFreqBandTable[i+1];
725 
726     thresOrig = fixMax(fMult(guideVectors.guideVectorOrig[i], mhThresh.decayGuideOrig), mhThresh.thresHoldToneGuide);
727     thresOrig = fixMin(thresOrig, mhThresh.thresHoldTone);
728 
729     if(guideVectors.guideVectorOrig[i] != FL2FXCONST_DBL(0.0f)){
730       for(j= ll;j<lu;j++){
731         if(quotaBuffer[j] > thresOrig){
732           pHarmVec[i] = 1;
733           newGuideVectors.guideVectorOrig[i] = quotaBuffer[j];
734         }
735       }
736     }
737   }
738 
739   /*
740    * Check for multiple sines in the transposed signal,
741    * where there is only one in the original.
742    ****************************************************/
743   thresOrig = mhThresh.thresHoldTone;
744 
745   for(i=0;i<nSfb;i++){
746     ll = pFreqBandTable[i];
747     lu = pFreqBandTable[i+1];
748 
749     if(pHarmVec[i] == 0){
750       if(lu -ll > 1){
751         for(j= ll;j<lu;j++){
752           if(quotaBuffer[j] > thresOrig && (sfmSbr[i] > mhThresh.sfmThresSbr && sfmOrig[i] < mhThresh.sfmThresOrig)){
753             pHarmVec[i] = 1;
754             newGuideVectors.guideVectorOrig[i] = quotaBuffer[j];
755           }
756         }
757       }
758       else{
759         if(i < nSfb -1){
760           ll = pFreqBandTable[i];
761 
762           if(i>0){
763             if(quotaBuffer[ll] > mhThresh.thresHoldTone && (pDiffVecScfb[i+1] < mhThresh.invThresHoldTone || pDiffVecScfb[i-1] < mhThresh.invThresHoldTone)){
764                 pHarmVec[i] = 1;
765                 newGuideVectors.guideVectorOrig[i] = quotaBuffer[ll];
766             }
767           }
768           else{
769             if(quotaBuffer[ll] > mhThresh.thresHoldTone && pDiffVecScfb[i+1] < mhThresh.invThresHoldTone){
770                 pHarmVec[i] = 1;
771                 newGuideVectors.guideVectorOrig[i] = quotaBuffer[ll];
772             }
773           }
774         }
775       }
776     }
777   }
778 }
779 
780 
781 /**************************************************************************/
782 /*!
783   \brief     Do detection for every tonality estimate, using forward prediction.
784 
785 
786   \return    none.
787 
788 */
789 /**************************************************************************/
detectionWithPrediction(FIXP_DBL ** quotaBuffer,FIXP_DBL ** pDiffVecScfb,INT ** signBuffer,INT nSfb,const UCHAR * pFreqBandTable,FIXP_DBL ** sfmOrig,FIXP_DBL ** sfmSbr,UCHAR ** detectionVectors,UCHAR * pPrevAddHarmSfb,GUIDE_VECTORS * guideVectors,INT noEstPerFrame,INT detectionStart,INT totNoEst,INT newDetectionAllowed,INT * pAddHarmFlag,UCHAR * pAddHarmSfb,FIXP_DBL * pNrgVector,const DETECTOR_PARAMETERS_MH * mhParams)790 static void detectionWithPrediction(FIXP_DBL **quotaBuffer,
791                                     FIXP_DBL **pDiffVecScfb,
792                                     INT ** signBuffer,
793                                     INT nSfb,
794                                     const UCHAR* pFreqBandTable,
795                                     FIXP_DBL **sfmOrig,
796                                     FIXP_DBL **sfmSbr,
797                                     UCHAR **detectionVectors,
798                                     UCHAR *pPrevAddHarmSfb,
799                                     GUIDE_VECTORS *guideVectors,
800                                     INT noEstPerFrame,
801                                     INT detectionStart,
802                                     INT totNoEst,
803                                     INT newDetectionAllowed,
804                                     INT *pAddHarmFlag,
805                                     UCHAR *pAddHarmSfb,
806                                     FIXP_DBL *pNrgVector,
807                                     const DETECTOR_PARAMETERS_MH *mhParams)
808 {
809   INT est = 0,i;
810   INT start;
811 
812   FDKmemclear(pAddHarmSfb,nSfb*sizeof(UCHAR));
813 
814   if(newDetectionAllowed){
815 
816     if(totNoEst > 1){
817       start = detectionStart;
818 
819       if (start != 0) {
820         FDKmemcpy(guideVectors[start].guideVectorDiff,guideVectors[0].guideVectorDiff,nSfb*sizeof(FIXP_DBL));
821         FDKmemcpy(guideVectors[start].guideVectorOrig,guideVectors[0].guideVectorOrig,nSfb*sizeof(FIXP_DBL));
822         FDKmemclear(guideVectors[start-1].guideVectorDetected,nSfb*sizeof(UCHAR));
823       }
824     }
825     else{
826       start = 0;
827     }
828   }
829   else{
830     start = 0;
831   }
832 
833 
834   for(est = start; est < totNoEst; est++){
835 
836     /*
837     * Do detection on the current frame using
838     * guide-info from the previous.
839     *******************************************/
840     if(est > 0){
841       FDKmemcpy(guideVectors[est].guideVectorDetected,detectionVectors[est-1],nSfb*sizeof(UCHAR));
842     }
843 
844     FDKmemclear(detectionVectors[est], nSfb*sizeof(UCHAR));
845 
846     if(est < totNoEst-1){
847       FDKmemclear(guideVectors[est+1].guideVectorDiff,nSfb*sizeof(FIXP_DBL));
848       FDKmemclear(guideVectors[est+1].guideVectorOrig,nSfb*sizeof(FIXP_DBL));
849       FDKmemclear(guideVectors[est+1].guideVectorDetected,nSfb*sizeof(UCHAR));
850 
851       detection(quotaBuffer[est],
852                 pDiffVecScfb[est],
853                 nSfb,
854                 detectionVectors[est],
855                 pFreqBandTable,
856                 sfmOrig[est],
857                 sfmSbr[est],
858                 guideVectors[est],
859                 guideVectors[est+1],
860                 mhParams->thresHolds);
861     }
862     else{
863       FDKmemclear(guideVectors[est].guideVectorDiff,nSfb*sizeof(FIXP_DBL));
864       FDKmemclear(guideVectors[est].guideVectorOrig,nSfb*sizeof(FIXP_DBL));
865       FDKmemclear(guideVectors[est].guideVectorDetected,nSfb*sizeof(UCHAR));
866 
867       detection(quotaBuffer[est],
868                 pDiffVecScfb[est],
869                 nSfb,
870                 detectionVectors[est],
871                 pFreqBandTable,
872                 sfmOrig[est],
873                 sfmSbr[est],
874                 guideVectors[est],
875                 guideVectors[est],
876                 mhParams->thresHolds);
877     }
878   }
879 
880 
881   /* Clean up the detection.*/
882   transientCleanUp(quotaBuffer,
883                    nSfb,
884                    detectionVectors,
885                    pAddHarmSfb,
886                    pPrevAddHarmSfb,
887                    signBuffer,
888                    pFreqBandTable,
889                    start,
890                    totNoEst,
891                    newDetectionAllowed,
892                    pNrgVector,
893                    mhParams->thresHolds);
894 
895 
896   /* Set flag... */
897   *pAddHarmFlag = 0;
898   for(i=0; i<nSfb; i++){
899     if(pAddHarmSfb[i]){
900       *pAddHarmFlag = 1;
901       break;
902     }
903   }
904 
905   FDKmemcpy(pPrevAddHarmSfb, pAddHarmSfb, nSfb*sizeof(UCHAR));
906   FDKmemcpy(guideVectors[0].guideVectorDetected,pAddHarmSfb,nSfb*sizeof(INT));
907 
908   for(i=0; i<nSfb ; i++){
909 
910     guideVectors[0].guideVectorDiff[i] = FL2FXCONST_DBL(0.0f);
911     guideVectors[0].guideVectorOrig[i] = FL2FXCONST_DBL(0.0f);
912 
913     if(pAddHarmSfb[i] == 1){
914       /* If we had a detection use the guide-value in the next frame from the last estimate were the detection
915       was done.*/
916       for(est=start; est < totNoEst; est++){
917         if(guideVectors[est].guideVectorDiff[i] != FL2FXCONST_DBL(0.0f)){
918           guideVectors[0].guideVectorDiff[i] = guideVectors[est].guideVectorDiff[i];
919         }
920         if(guideVectors[est].guideVectorOrig[i] != FL2FXCONST_DBL(0.0f)){
921           guideVectors[0].guideVectorOrig[i] = guideVectors[est].guideVectorOrig[i];
922         }
923       }
924     }
925   }
926 
927 }
928 
929 
930 /**************************************************************************/
931 /*!
932   \brief     Calculates a compensation vector for the energy data.
933 
934   This function calculates a compensation vector for the energy data (i.e.
935   envelope data) that is calculated elsewhere. This is since, one sine on
936   the border of two scalefactor bands, will be replace by one sine in the
937   middle of either scalefactor band. However, since the sine that is replaced
938   will influence the energy estimate in both scalefactor bands (in the envelops
939   calculation function) a compensation value is required in order to avoid
940   noise substitution in the decoder next to the synthetic sine.
941 
942   \return    none.
943 
944 */
945 /**************************************************************************/
calculateCompVector(UCHAR * pAddHarmSfb,FIXP_DBL ** pTonalityMatrix,INT ** pSignMatrix,UCHAR * pEnvComp,INT nSfb,const UCHAR * freqBandTable,INT totNoEst,INT maxComp,UCHAR * pPrevEnvComp,INT newDetectionAllowed)946 static void calculateCompVector(UCHAR *pAddHarmSfb,
947                                 FIXP_DBL **pTonalityMatrix,
948                                 INT ** pSignMatrix,
949                                 UCHAR *pEnvComp,
950                                 INT nSfb,
951                                 const UCHAR *freqBandTable,
952                                 INT totNoEst,
953                                 INT maxComp,
954                                 UCHAR *pPrevEnvComp,
955                                 INT newDetectionAllowed)
956 {
957 
958   INT scfBand,est,l,ll,lu,maxPosF,maxPosT;
959   FIXP_DBL maxVal;
960   INT compValue;
961   FIXP_DBL tmp;
962 
963   FDKmemclear(pEnvComp,nSfb*sizeof(UCHAR));
964 
965   for(scfBand=0; scfBand < nSfb; scfBand++){
966 
967     if(pAddHarmSfb[scfBand]){ /* A missing sine was detected */
968       ll = freqBandTable[scfBand];
969       lu = freqBandTable[scfBand+1];
970 
971       maxPosF = 0;                        /* First find the maximum*/
972       maxPosT = 0;
973       maxVal = FL2FXCONST_DBL(0.0f);
974 
975       for(est=0;est<totNoEst;est++){
976         for(l=ll; l<lu; l++){
977           if(pTonalityMatrix[est][l] > maxVal){
978             maxVal = pTonalityMatrix[est][l];
979             maxPosF = l;
980             maxPosT = est;
981           }
982         }
983       }
984 
985       /*
986        * If the maximum tonality is at the lower border of the
987        * scalefactor band, we check the sign of the adjacent channels
988        * to see if this sine is shared by the lower channel. If so, the
989        * energy of the single sine will be present in two scalefactor bands
990        * in the SBR data, which will cause problems in the decoder, when we
991        * add a sine to just one of the channels.
992        *********************************************************************/
993       if(maxPosF == ll && scfBand){
994         if(!pAddHarmSfb[scfBand - 1]) {     /* No detection below*/
995           if (pSignMatrix[maxPosT][maxPosF - 1] > 0 && pSignMatrix[maxPosT][maxPosF] < 0) {
996             /* The comp value is calulated as the tonallity value, i.e we want to
997                reduce the envelope data for this channel with as much as the tonality
998                that is spread from the channel above. (ld64(RELAXATION) = 0.31143075889) */
999             tmp = fixp_abs((FIXP_DBL)CalcLdData(pTonalityMatrix[maxPosT][maxPosF - 1]) + RELAXATION_LD64);
1000             tmp = (tmp >> (DFRACT_BITS-1-LD_DATA_SHIFT-1)) + (FIXP_DBL)1;  /* shift one bit less for rounding */
1001             compValue = ((INT)(LONG)tmp) >> 1;
1002 
1003 						      /* limit the comp-value*/
1004             if (compValue > maxComp)
1005               compValue = maxComp;
1006 
1007             pEnvComp[scfBand-1] = compValue;
1008 					     }
1009 				    }
1010       }
1011 
1012       /*
1013        * Same as above, but for the upper end of the scalefactor-band.
1014        ***************************************************************/
1015       if(maxPosF == lu-1 && scfBand+1 < nSfb){        /* Upper border*/
1016         if(!pAddHarmSfb[scfBand + 1]) {
1017           if (pSignMatrix[maxPosT][maxPosF] > 0 && pSignMatrix[maxPosT][maxPosF + 1] < 0) {
1018             tmp = fixp_abs((FIXP_DBL)CalcLdData(pTonalityMatrix[maxPosT][maxPosF + 1]) + RELAXATION_LD64);
1019             tmp = (tmp >> (DFRACT_BITS-1-LD_DATA_SHIFT-1)) + (FIXP_DBL)1;  /* shift one bit less for rounding */
1020             compValue = ((INT)(LONG)tmp) >> 1;
1021 
1022             if (compValue > maxComp)
1023               compValue = maxComp;
1024 
1025             pEnvComp[scfBand+1] = compValue;
1026 					 }
1027 				 }
1028       }
1029 		 }
1030 	 }
1031 
1032   if(newDetectionAllowed == 0){
1033     for(scfBand=0;scfBand<nSfb;scfBand++){
1034       if(pEnvComp[scfBand] != 0 && pPrevEnvComp[scfBand] == 0)
1035         pEnvComp[scfBand] = 0;
1036     }
1037   }
1038 
1039   /* remember the value for the next frame.*/
1040   FDKmemcpy(pPrevEnvComp,pEnvComp,nSfb*sizeof(UCHAR));
1041 }
1042 
1043 
1044 /**************************************************************************/
1045 /*!
1046   \brief     Detects where strong tonal components will be missing after
1047              HFR in the decoder.
1048 
1049 
1050   \return    none.
1051 
1052 */
1053 /**************************************************************************/
1054 void
FDKsbrEnc_SbrMissingHarmonicsDetectorQmf(HANDLE_SBR_MISSING_HARMONICS_DETECTOR h_sbrMHDet,FIXP_DBL ** pQuotaBuffer,INT ** pSignBuffer,SCHAR * indexVector,const SBR_FRAME_INFO * pFrameInfo,const UCHAR * pTranInfo,INT * pAddHarmonicsFlag,UCHAR * pAddHarmonicsScaleFactorBands,const UCHAR * freqBandTable,INT nSfb,UCHAR * envelopeCompensation,FIXP_DBL * pNrgVector)1055 FDKsbrEnc_SbrMissingHarmonicsDetectorQmf(HANDLE_SBR_MISSING_HARMONICS_DETECTOR h_sbrMHDet,
1056                                FIXP_DBL ** pQuotaBuffer,
1057                                INT ** pSignBuffer,
1058                                SCHAR* indexVector,
1059                                const SBR_FRAME_INFO *pFrameInfo,
1060                                const UCHAR* pTranInfo,
1061                                INT* pAddHarmonicsFlag,
1062                                UCHAR* pAddHarmonicsScaleFactorBands,
1063                                const UCHAR* freqBandTable,
1064                                INT nSfb,
1065                                UCHAR* envelopeCompensation,
1066                                FIXP_DBL *pNrgVector)
1067 {
1068   INT transientFlag = pTranInfo[1];
1069   INT transientPos  = pTranInfo[0];
1070   INT newDetectionAllowed;
1071   INT transientDetStart = 0;
1072 
1073   UCHAR ** detectionVectors  = h_sbrMHDet->detectionVectors;
1074   INT move                = h_sbrMHDet->move;
1075   INT noEstPerFrame       = h_sbrMHDet->noEstPerFrame;
1076   INT totNoEst            = h_sbrMHDet->totNoEst;
1077   INT prevTransientFlag   = h_sbrMHDet->previousTransientFlag;
1078   INT prevTransientFrame  = h_sbrMHDet->previousTransientFrame;
1079   INT transientPosOffset  = h_sbrMHDet->transientPosOffset;
1080   INT prevTransientPos    = h_sbrMHDet->previousTransientPos;
1081   GUIDE_VECTORS* guideVectors = h_sbrMHDet->guideVectors;
1082   INT deltaTime = h_sbrMHDet->mhParams->deltaTime;
1083   INT maxComp = h_sbrMHDet->mhParams->maxComp;
1084 
1085   int est;
1086 
1087   /*
1088   Buffer values.
1089   */
1090   FDK_ASSERT(move<=(MAX_NO_OF_ESTIMATES>>1));
1091   FDK_ASSERT(noEstPerFrame<=(MAX_NO_OF_ESTIMATES>>1));
1092 
1093   FIXP_DBL *sfmSbr[MAX_NO_OF_ESTIMATES];
1094   FIXP_DBL *sfmOrig[MAX_NO_OF_ESTIMATES];
1095   FIXP_DBL *tonalityDiff[MAX_NO_OF_ESTIMATES];
1096 
1097   for (est=0; est < MAX_NO_OF_ESTIMATES/2; est++) {
1098     sfmSbr[est]       = h_sbrMHDet->sfmSbr[est];
1099     sfmOrig[est]      = h_sbrMHDet->sfmOrig[est];
1100     tonalityDiff[est] = h_sbrMHDet->tonalityDiff[est];
1101   }
1102 
1103   C_ALLOC_SCRATCH_START(scratch_mem, FIXP_DBL, (3*MAX_NO_OF_ESTIMATES/2*MAX_FREQ_COEFFS));
1104   FIXP_DBL *scratch = scratch_mem;
1105   for (; est < MAX_NO_OF_ESTIMATES; est++) {
1106     sfmSbr[est]       = scratch; scratch+=MAX_FREQ_COEFFS;
1107     sfmOrig[est]      = scratch; scratch+=MAX_FREQ_COEFFS;
1108     tonalityDiff[est] = scratch; scratch+=MAX_FREQ_COEFFS;
1109   }
1110 
1111 
1112 
1113   /* Determine if we're allowed to detect "missing harmonics" that wasn't detected before.
1114      In order to be allowed to do new detection, there must be a transient in the current
1115      frame, or a transient in the previous frame sufficiently close to the current frame. */
1116   newDetectionAllowed = isDetectionOfNewToneAllowed(pFrameInfo,
1117                                                     &transientDetStart,
1118                                                     noEstPerFrame,
1119                                                     prevTransientFrame,
1120                                                     prevTransientPos,
1121                                                     prevTransientFlag,
1122                                                     transientPosOffset,
1123                                                     transientFlag,
1124                                                     transientPos,
1125                                                     deltaTime,
1126                                                     h_sbrMHDet);
1127 
1128   /* Calulate the variables that will be used subsequently for the actual detection */
1129   calculateDetectorInput(pQuotaBuffer,
1130                          indexVector,
1131                          tonalityDiff,
1132                          sfmOrig,
1133                          sfmSbr,
1134                          freqBandTable,
1135                          nSfb,
1136                          noEstPerFrame,
1137                          move);
1138 
1139   /* Do the actual detection using information from previous detections */
1140   detectionWithPrediction(pQuotaBuffer,
1141                           tonalityDiff,
1142                           pSignBuffer,
1143                           nSfb,
1144                           freqBandTable,
1145                           sfmOrig,
1146                           sfmSbr,
1147                           detectionVectors,
1148                           h_sbrMHDet->guideScfb,
1149                           guideVectors,
1150                           noEstPerFrame,
1151                           transientDetStart,
1152                           totNoEst,
1153                           newDetectionAllowed,
1154                           pAddHarmonicsFlag,
1155                           pAddHarmonicsScaleFactorBands,
1156                           pNrgVector,
1157                           h_sbrMHDet->mhParams);
1158 
1159   /* Calculate the comp vector, so that the energy can be
1160      compensated for a sine between two QMF-bands. */
1161   calculateCompVector(pAddHarmonicsScaleFactorBands,
1162                       pQuotaBuffer,
1163                       pSignBuffer,
1164                       envelopeCompensation,
1165                       nSfb,
1166                       freqBandTable,
1167                       totNoEst,
1168                       maxComp,
1169                       h_sbrMHDet->prevEnvelopeCompensation,
1170                       newDetectionAllowed);
1171 
1172   for (est=0; est < move; est++) {
1173     FDKmemcpy(tonalityDiff[est], tonalityDiff[est + noEstPerFrame], sizeof(FIXP_DBL)*MAX_FREQ_COEFFS);
1174     FDKmemcpy(sfmOrig[est], sfmOrig[est + noEstPerFrame], sizeof(FIXP_DBL)*MAX_FREQ_COEFFS);
1175     FDKmemcpy(sfmSbr[est], sfmSbr[est + noEstPerFrame], sizeof(FIXP_DBL)*MAX_FREQ_COEFFS);
1176   }
1177   C_ALLOC_SCRATCH_END(scratch, FIXP_DBL, (3*MAX_NO_OF_ESTIMATES/2*MAX_FREQ_COEFFS));
1178 
1179 
1180 }
1181 
1182 /**************************************************************************/
1183 /*!
1184   \brief     Initialize an instance of the missing harmonics detector.
1185 
1186 
1187   \return    errorCode, noError if OK.
1188 
1189 */
1190 /**************************************************************************/
1191 INT
FDKsbrEnc_CreateSbrMissingHarmonicsDetector(HANDLE_SBR_MISSING_HARMONICS_DETECTOR hSbrMHDet,INT chan)1192 FDKsbrEnc_CreateSbrMissingHarmonicsDetector (
1193                                    HANDLE_SBR_MISSING_HARMONICS_DETECTOR hSbrMHDet,
1194                                    INT chan)
1195 {
1196   HANDLE_SBR_MISSING_HARMONICS_DETECTOR hs = hSbrMHDet;
1197   INT i;
1198 
1199   UCHAR* detectionVectors    = GetRam_Sbr_detectionVectors(chan);
1200   UCHAR* guideVectorDetected = GetRam_Sbr_guideVectorDetected(chan);
1201   FIXP_DBL* guideVectorDiff  = GetRam_Sbr_guideVectorDiff(chan);
1202   FIXP_DBL* guideVectorOrig  = GetRam_Sbr_guideVectorOrig(chan);
1203 
1204   FDKmemclear (hs,sizeof(SBR_MISSING_HARMONICS_DETECTOR));
1205 
1206   hs->prevEnvelopeCompensation = GetRam_Sbr_prevEnvelopeCompensation(chan);
1207   hs->guideScfb                = GetRam_Sbr_guideScfb(chan);
1208 
1209   for(i=0; i<MAX_NO_OF_ESTIMATES; i++) {
1210     hs->guideVectors[i].guideVectorDiff = guideVectorDiff + (i*MAX_FREQ_COEFFS);
1211     hs->guideVectors[i].guideVectorOrig = guideVectorOrig + (i*MAX_FREQ_COEFFS);
1212     hs->detectionVectors[i] = detectionVectors + (i*MAX_FREQ_COEFFS);
1213     hs->guideVectors[i].guideVectorDetected = guideVectorDetected + (i*MAX_FREQ_COEFFS);
1214   }
1215 
1216   return 0;
1217 }
1218 
1219 
1220 /**************************************************************************/
1221 /*!
1222   \brief     Initialize an instance of the missing harmonics detector.
1223 
1224 
1225   \return    errorCode, noError if OK.
1226 
1227 */
1228 /**************************************************************************/
1229 INT
FDKsbrEnc_InitSbrMissingHarmonicsDetector(HANDLE_SBR_MISSING_HARMONICS_DETECTOR hSbrMHDet,INT sampleFreq,INT frameSize,INT nSfb,INT qmfNoChannels,INT totNoEst,INT move,INT noEstPerFrame,UINT sbrSyntaxFlags)1230 FDKsbrEnc_InitSbrMissingHarmonicsDetector (
1231                                    HANDLE_SBR_MISSING_HARMONICS_DETECTOR hSbrMHDet,
1232                                    INT sampleFreq,
1233                                    INT frameSize,
1234                                    INT nSfb,
1235                                    INT qmfNoChannels,
1236                                    INT totNoEst,
1237                                    INT move,
1238                                    INT noEstPerFrame,
1239                                    UINT sbrSyntaxFlags
1240                                   )
1241 {
1242   HANDLE_SBR_MISSING_HARMONICS_DETECTOR hs = hSbrMHDet;
1243   int i;
1244 
1245   FDK_ASSERT(totNoEst <= MAX_NO_OF_ESTIMATES);
1246 
1247   switch(frameSize){
1248   case 2048:
1249       hs->transientPosOffset = FRAME_MIDDLE_SLOT_2048;
1250       hs->timeSlots          = NUMBER_TIME_SLOTS_2048;
1251       break;
1252   case 1920:
1253       hs->transientPosOffset = FRAME_MIDDLE_SLOT_1920;
1254       hs->timeSlots          = NUMBER_TIME_SLOTS_1920;
1255       break;
1256   case 1024:
1257       hs->transientPosOffset = FRAME_MIDDLE_SLOT_512LD;
1258       hs->timeSlots          = 16;
1259       break;
1260   case 960:
1261       hs->transientPosOffset = FRAME_MIDDLE_SLOT_512LD;
1262       hs->timeSlots          = 15;
1263       break;
1264   default:
1265       return -1;
1266   }
1267 
1268   if (sbrSyntaxFlags & SBR_SYNTAX_LOW_DELAY) {
1269     hs->mhParams = &paramsAacLd;
1270   } else
1271   hs->mhParams = &paramsAac;
1272 
1273   hs->qmfNoChannels = qmfNoChannels;
1274   hs->sampleFreq = sampleFreq;
1275   hs->nSfb = nSfb;
1276 
1277   hs->totNoEst = totNoEst;
1278   hs->move = move;
1279   hs->noEstPerFrame = noEstPerFrame;
1280 
1281   for(i=0; i<totNoEst; i++) {
1282     FDKmemclear (hs->guideVectors[i].guideVectorDiff,sizeof(FIXP_DBL)*MAX_FREQ_COEFFS);
1283     FDKmemclear (hs->guideVectors[i].guideVectorOrig,sizeof(FIXP_DBL)*MAX_FREQ_COEFFS);
1284     FDKmemclear (hs->detectionVectors[i],sizeof(UCHAR)*MAX_FREQ_COEFFS);
1285     FDKmemclear (hs->guideVectors[i].guideVectorDetected,sizeof(UCHAR)*MAX_FREQ_COEFFS);
1286   }
1287 
1288   //for(i=0; i<totNoEst/2; i++) {
1289   for(i=0; i<MAX_NO_OF_ESTIMATES/2; i++) {
1290     FDKmemclear (hs->tonalityDiff[i],sizeof(FIXP_DBL)*MAX_FREQ_COEFFS);
1291     FDKmemclear (hs->sfmOrig[i],sizeof(FIXP_DBL)*MAX_FREQ_COEFFS);
1292     FDKmemclear (hs->sfmSbr[i],sizeof(FIXP_DBL)*MAX_FREQ_COEFFS);
1293   }
1294 
1295   FDKmemclear ( hs->prevEnvelopeCompensation, sizeof(UCHAR)*MAX_FREQ_COEFFS);
1296   FDKmemclear ( hs->guideScfb, sizeof(UCHAR)*MAX_FREQ_COEFFS);
1297 
1298   hs->previousTransientFlag = 0;
1299   hs->previousTransientFrame = 0;
1300   hs->previousTransientPos = 0;
1301 
1302   return (0);
1303 }
1304 
1305 /**************************************************************************/
1306 /*!
1307   \brief     Deletes an instance of the missing harmonics detector.
1308 
1309 
1310   \return    none.
1311 
1312 */
1313 /**************************************************************************/
1314 void
FDKsbrEnc_DeleteSbrMissingHarmonicsDetector(HANDLE_SBR_MISSING_HARMONICS_DETECTOR hSbrMHDet)1315 FDKsbrEnc_DeleteSbrMissingHarmonicsDetector(HANDLE_SBR_MISSING_HARMONICS_DETECTOR hSbrMHDet)
1316 {
1317   if (hSbrMHDet) {
1318     HANDLE_SBR_MISSING_HARMONICS_DETECTOR hs = hSbrMHDet;
1319 
1320     FreeRam_Sbr_detectionVectors(&hs->detectionVectors[0]);
1321     FreeRam_Sbr_guideVectorDetected(&hs->guideVectors[0].guideVectorDetected);
1322     FreeRam_Sbr_guideVectorDiff(&hs->guideVectors[0].guideVectorDiff);
1323     FreeRam_Sbr_guideVectorOrig(&hs->guideVectors[0].guideVectorOrig);
1324     FreeRam_Sbr_prevEnvelopeCompensation(&hs->prevEnvelopeCompensation);
1325     FreeRam_Sbr_guideScfb(&hs->guideScfb);
1326 
1327   }
1328 }
1329 
1330 /**************************************************************************/
1331 /*!
1332   \brief     Resets an instance of the missing harmonics detector.
1333 
1334 
1335   \return    error code, noError if OK.
1336 
1337 */
1338 /**************************************************************************/
1339 INT
FDKsbrEnc_ResetSbrMissingHarmonicsDetector(HANDLE_SBR_MISSING_HARMONICS_DETECTOR hSbrMissingHarmonicsDetector,INT nSfb)1340 FDKsbrEnc_ResetSbrMissingHarmonicsDetector (HANDLE_SBR_MISSING_HARMONICS_DETECTOR hSbrMissingHarmonicsDetector,
1341                                   INT nSfb)
1342 {
1343   int i;
1344   FIXP_DBL tempGuide[MAX_FREQ_COEFFS];
1345   UCHAR tempGuideInt[MAX_FREQ_COEFFS];
1346   INT nSfbPrev;
1347 
1348   nSfbPrev = hSbrMissingHarmonicsDetector->nSfb;
1349   hSbrMissingHarmonicsDetector->nSfb = nSfb;
1350 
1351   FDKmemcpy( tempGuideInt, hSbrMissingHarmonicsDetector->guideScfb, nSfbPrev * sizeof(UCHAR) );
1352 
1353   if ( nSfb > nSfbPrev ) {
1354     for ( i = 0; i < (nSfb - nSfbPrev); i++ ) {
1355       hSbrMissingHarmonicsDetector->guideScfb[i] = 0;
1356     }
1357 
1358     for ( i = 0; i < nSfbPrev; i++ ) {
1359       hSbrMissingHarmonicsDetector->guideScfb[i + (nSfb - nSfbPrev)] = tempGuideInt[i];
1360     }
1361   }
1362   else {
1363     for ( i = 0; i < nSfb; i++ ) {
1364       hSbrMissingHarmonicsDetector->guideScfb[i] = tempGuideInt[i + (nSfbPrev-nSfb)];
1365     }
1366   }
1367 
1368   FDKmemcpy ( tempGuide, hSbrMissingHarmonicsDetector->guideVectors[0].guideVectorDiff, nSfbPrev * sizeof(FIXP_DBL) );
1369 
1370   if (nSfb > nSfbPrev ) {
1371     for ( i = 0; i < (nSfb - nSfbPrev); i++ ) {
1372       hSbrMissingHarmonicsDetector->guideVectors[0].guideVectorDiff[i] = FL2FXCONST_DBL(0.0f);
1373     }
1374 
1375     for ( i = 0; i < nSfbPrev; i++ ) {
1376       hSbrMissingHarmonicsDetector->guideVectors[0].guideVectorDiff[i + (nSfb - nSfbPrev)] = tempGuide[i];
1377     }
1378   }
1379   else {
1380     for ( i = 0; i < nSfb; i++  ) {
1381       hSbrMissingHarmonicsDetector->guideVectors[0].guideVectorDiff[i] = tempGuide[i + (nSfbPrev-nSfb)];
1382     }
1383   }
1384 
1385   FDKmemcpy ( tempGuide, hSbrMissingHarmonicsDetector->guideVectors[0].guideVectorOrig, nSfbPrev * sizeof(FIXP_DBL) );
1386 
1387   if ( nSfb > nSfbPrev ) {
1388     for ( i = 0; i< (nSfb - nSfbPrev); i++ ) {
1389       hSbrMissingHarmonicsDetector->guideVectors[0].guideVectorOrig[i] = FL2FXCONST_DBL(0.0f);
1390     }
1391 
1392     for ( i = 0; i < nSfbPrev; i++ ) {
1393       hSbrMissingHarmonicsDetector->guideVectors[0].guideVectorOrig[i + (nSfb - nSfbPrev)] = tempGuide[i];
1394     }
1395   }
1396   else {
1397     for ( i = 0; i < nSfb; i++ ) {
1398       hSbrMissingHarmonicsDetector->guideVectors[0].guideVectorOrig[i] = tempGuide[i + (nSfbPrev-nSfb)];
1399     }
1400   }
1401 
1402   FDKmemcpy ( tempGuideInt, hSbrMissingHarmonicsDetector->guideVectors[0].guideVectorDetected, nSfbPrev * sizeof(UCHAR) );
1403 
1404   if ( nSfb > nSfbPrev ) {
1405     for ( i = 0; i < (nSfb - nSfbPrev); i++ ) {
1406       hSbrMissingHarmonicsDetector->guideVectors[0].guideVectorDetected[i] = 0;
1407     }
1408 
1409     for ( i = 0; i < nSfbPrev; i++ ) {
1410       hSbrMissingHarmonicsDetector->guideVectors[0].guideVectorDetected[i + (nSfb - nSfbPrev)] = tempGuideInt[i];
1411     }
1412   }
1413   else {
1414     for ( i = 0; i < nSfb; i++ ) {
1415       hSbrMissingHarmonicsDetector->guideVectors[0].guideVectorDetected[i] = tempGuideInt[i + (nSfbPrev-nSfb)];
1416     }
1417   }
1418 
1419   FDKmemcpy ( tempGuideInt, hSbrMissingHarmonicsDetector->prevEnvelopeCompensation, nSfbPrev * sizeof(UCHAR) );
1420 
1421   if ( nSfb > nSfbPrev ) {
1422     for ( i = 0; i < (nSfb - nSfbPrev); i++ ) {
1423       hSbrMissingHarmonicsDetector->prevEnvelopeCompensation[i] = 0;
1424     }
1425 
1426     for ( i = 0; i < nSfbPrev; i++ ) {
1427       hSbrMissingHarmonicsDetector->prevEnvelopeCompensation[i + (nSfb - nSfbPrev)] = tempGuideInt[i];
1428     }
1429   }
1430   else {
1431     for ( i = 0; i < nSfb; i++ ) {
1432       hSbrMissingHarmonicsDetector->prevEnvelopeCompensation[i] = tempGuideInt[i + (nSfbPrev-nSfb)];
1433     }
1434   }
1435 
1436   return 0;
1437 }
1438 
1439