Fraunhofer AAC codec.

License boilerplate update to follow.

Change-Id: I2810460c11a58b6d148d84673cc031f3685e79b5

1 files changed, 1381 insertions, 0 deletions

diff --git a/libSBRenc/src/mh_det.cpp b/libSBRenc/src/mh_det.cpp
new file mode 100644
index 0000000..8b6c1a0
--- /dev/null
+++ b/libSBRenc/src/mh_det.cpp
@@ -0,0 +1,1381 @@
+/****************************************************************************
+
+                     (C) Copyright Fraunhofer IIS (2004)
+                               All Rights Reserved
+
+    Please be advised that this software and/or program delivery is
+    Confidential Information of Fraunhofer and subject to and covered by the
+
+    Fraunhofer IIS Software Evaluation Agreement
+    between Google Inc. and  Fraunhofer
+    effective and in full force since March 1, 2012.
+
+    You may use this software and/or program only under the terms and
+    conditions described in the above mentioned Fraunhofer IIS Software
+    Evaluation Agreement. Any other and/or further use requires a separate agreement.
+
+
+   This software and/or program is protected by copyright law and international
+   treaties. Any reproduction or distribution of this software and/or program,
+   or any portion of it, may result in severe civil and criminal penalties, and
+   will be prosecuted to the maximum extent possible under law.
+
+ $Id$
+
+*******************************************************************************/
+
+#include "mh_det.h"
+
+#include "sbr_ram.h"
+#include "sbr_misc.h"
+
+
+#include "genericStds.h"
+
+#define SFM_SHIFT 2     /* Attention: SFM_SCALE depends on SFM_SHIFT */
+#define SFM_SCALE (MAXVAL_DBL >> SFM_SHIFT)   /* 1.0 >> SFM_SHIFT */
+
+
+/*!< Detector Parameters for AAC core codec. */
+static const DETECTOR_PARAMETERS_MH paramsAac = {
+9,                                             /*!< deltaTime */
+{
+FL2FXCONST_DBL(20.0f*RELAXATION_FLOAT),        /*!< thresHoldDiff */
+FL2FXCONST_DBL(1.26f*RELAXATION_FLOAT),        /*!< thresHoldDiffGuide */
+FL2FXCONST_DBL(15.0f*RELAXATION_FLOAT),        /*!< thresHoldTone */
+FL2FXCONST_DBL((1.0f/15.0f)*RELAXATION_FLOAT), /*!< invThresHoldTone */
+FL2FXCONST_DBL(1.26f*RELAXATION_FLOAT),        /*!< thresHoldToneGuide */
+FL2FXCONST_DBL(0.3f)>>SFM_SHIFT,               /*!< sfmThresSbr */
+FL2FXCONST_DBL(0.1f)>>SFM_SHIFT,               /*!< sfmThresOrig */
+FL2FXCONST_DBL(0.3f),                          /*!< decayGuideOrig */
+FL2FXCONST_DBL(0.5f),                          /*!< decayGuideDiff */
+FL2FXCONST_DBL(-0.000112993269),  /* LD64(FL2FXCONST_DBL(0.995f)) */ /*!< derivThresMaxLD64 */
+FL2FXCONST_DBL(-0.000112993269),  /* LD64(FL2FXCONST_DBL(0.995f)) */ /*!< derivThresBelowLD64 */
+FL2FXCONST_DBL(-0.005030126483f) /* LD64(FL2FXCONST_DBL(0.8f)) */    /*!< derivThresAboveLD64 */
+},
+50                                             /*!< maxComp */
+};
+
+/*!< Detector Parameters for AAC LD core codec. */
+static const DETECTOR_PARAMETERS_MH paramsAacLd = {
+16,                                            /*!< Delta time. */
+{
+FL2FXCONST_DBL(25.0f*RELAXATION_FLOAT),        /*!< thresHoldDiff */
+FL2FXCONST_DBL(1.26f*RELAXATION_FLOAT),        /*!< tresHoldDiffGuide */
+FL2FXCONST_DBL(15.0f*RELAXATION_FLOAT),        /*!< thresHoldTone */
+FL2FXCONST_DBL((1.0f/15.0f)*RELAXATION_FLOAT), /*!< invThresHoldTone */
+FL2FXCONST_DBL(1.26f*RELAXATION_FLOAT),        /*!< thresHoldToneGuide */
+FL2FXCONST_DBL(0.3f)>>SFM_SHIFT,               /*!< sfmThresSbr */
+FL2FXCONST_DBL(0.1f)>>SFM_SHIFT,               /*!< sfmThresOrig */
+FL2FXCONST_DBL(0.3f),                          /*!< decayGuideOrig */
+FL2FXCONST_DBL(0.2f),                          /*!< decayGuideDiff */
+FL2FXCONST_DBL(-0.000112993269),  /* LD64(FL2FXCONST_DBL(0.995f)) */  /*!< derivThresMaxLD64 */
+FL2FXCONST_DBL(-0.000112993269),  /* LD64(FL2FXCONST_DBL(0.995f)) */  /*!< derivThresBelowLD64 */
+FL2FXCONST_DBL(-0.005030126483f) /* LD64(FL2FXCONST_DBL(0.8f)) */     /*!< derivThresAboveLD64 */
+},
+50                                             /*!< maxComp */
+};
+
+
+/**************************************************************************/
+/*!
+  \brief     Calculates the difference in tonality between original and SBR
+             for a given time and frequency region.
+
+             The values for pDiffMapped2Scfb are scaled by RELAXATION
+
+  \return    none.
+
+*/
+/**************************************************************************/
+static void diff(FIXP_DBL *RESTRICT pTonalityOrig,
+                 FIXP_DBL *pDiffMapped2Scfb,
+                 const UCHAR *RESTRICT pFreqBandTable,
+                 INT       nScfb,
+                 SCHAR    *indexVector)
+{
+  UCHAR i, ll, lu, k;
+  FIXP_DBL maxValOrig, maxValSbr, tmp;
+  INT scale;
+
+  for(i=0; i < nScfb; i++){
+    ll = pFreqBandTable[i];
+    lu = pFreqBandTable[i+1];
+
+    maxValOrig = FL2FXCONST_DBL(0.0f);
+    maxValSbr = FL2FXCONST_DBL(0.0f);
+
+    for(k=ll;k<lu;k++){
+      maxValOrig = fixMax(maxValOrig, pTonalityOrig[k]);
+      maxValSbr = fixMax(maxValSbr, pTonalityOrig[indexVector[k]]);
+    }
+
+    if ((maxValSbr >= RELAXATION)) {
+        tmp = fDivNorm(maxValOrig, maxValSbr, &scale);
+        pDiffMapped2Scfb[i] = scaleValue(fMult(tmp,RELAXATION_FRACT), fixMax(-(DFRACT_BITS-1),(scale-RELAXATION_SHIFT)));
+    }
+    else {
+        pDiffMapped2Scfb[i] = maxValOrig;
+    }
+  }
+}
+
+
+/**************************************************************************/
+/*!
+  \brief     Calculates a flatness measure of the tonality measures.
+
+  Calculation of the power function and using scalefactor for basis:
+    Using log2:
+    z  = (2^k * x)^y;
+    z' = CalcLd(z) = y*CalcLd(x) + y*k;
+    z  = CalcInvLd(z');
+
+    Using ld64:
+    z  = (2^k * x)^y;
+    z' = CalcLd64(z) = y*CalcLd64(x)/64 + y*k/64;
+    z  = CalcInvLd64(z');
+
+  The values pSfmOrigVec and pSfmSbrVec are scaled by the factor 1/4.0
+
+  \return    none.
+
+*/
+/**************************************************************************/
+static void calculateFlatnessMeasure(FIXP_DBL *pQuotaBuffer,
+                                     SCHAR    *indexVector,
+                                     FIXP_DBL *pSfmOrigVec,
+                                     FIXP_DBL *pSfmSbrVec,
+                                     const UCHAR *pFreqBandTable,
+                                     INT       nSfb)
+{
+  INT i,j;
+  FIXP_DBL invBands,tmp1,tmp2;
+  INT shiftFac0,shiftFacSum0;
+  INT shiftFac1,shiftFacSum1;
+  FIXP_DBL accu;
+
+  for(i=0;i<nSfb;i++)
+  {
+    INT ll = pFreqBandTable[i];
+    INT lu = pFreqBandTable[i+1];
+    pSfmOrigVec[i] = (FIXP_DBL)(MAXVAL_DBL>>2);
+    pSfmSbrVec[i]  = (FIXP_DBL)(MAXVAL_DBL>>2);
+
+    if(lu - ll > 1){
+      FIXP_DBL amOrig,amTransp,gmOrig,gmTransp,sfmOrig,sfmTransp;
+      invBands = GetInvInt(lu-ll);
+      shiftFacSum0 = 0;
+      shiftFacSum1 = 0;
+      amOrig = amTransp = FL2FXCONST_DBL(0.0f);
+      gmOrig = gmTransp = (FIXP_DBL)MAXVAL_DBL;
+
+      for(j= ll; j<lu; j++) {
+        sfmOrig   = pQuotaBuffer[j];
+        sfmTransp = pQuotaBuffer[indexVector[j]];
+
+        amOrig   += fMult(sfmOrig, invBands);
+        amTransp += fMult(sfmTransp, invBands);
+
+        shiftFac0 = CountLeadingBits(sfmOrig);
+        shiftFac1 = CountLeadingBits(sfmTransp);
+
+        gmOrig   = fMult(gmOrig, sfmOrig<<shiftFac0);
+        gmTransp = fMult(gmTransp, sfmTransp<<shiftFac1);
+
+        shiftFacSum0 += shiftFac0;
+        shiftFacSum1 += shiftFac1;
+      }
+
+      if (gmOrig > FL2FXCONST_DBL(0.0f)) {
+
+        tmp1 = CalcLdData(gmOrig);      /* CalcLd64(x)/64 */
+        tmp1 = fMult(invBands, tmp1);   /* y*CalcLd64(x)/64 */
+
+        /* y*k/64 */
+        accu = (FIXP_DBL)-shiftFacSum0 << (DFRACT_BITS-1-8);
+        tmp2 = fMultDiv2(invBands, accu) << (2+1);
+
+        tmp2 = tmp1 + tmp2;             /* y*CalcLd64(x)/64 + y*k/64 */
+        gmOrig = CalcInvLdData(tmp2);   /* CalcInvLd64(z'); */
+      }
+      else {
+        gmOrig = FL2FXCONST_DBL(0.0f);
+      }
+
+      if (gmTransp > FL2FXCONST_DBL(0.0f)) {
+
+        tmp1 = CalcLdData(gmTransp);    /* CalcLd64(x)/64 */
+        tmp1 = fMult(invBands, tmp1);   /* y*CalcLd64(x)/64 */
+
+        /* y*k/64 */
+        accu = (FIXP_DBL)-shiftFacSum1 << (DFRACT_BITS-1-8);
+        tmp2 = fMultDiv2(invBands, accu) << (2+1);
+
+        tmp2 = tmp1 + tmp2;             /* y*CalcLd64(x)/64 + y*k/64 */
+        gmTransp = CalcInvLdData(tmp2); /* CalcInvLd64(z'); */
+      }
+      else {
+        gmTransp = FL2FXCONST_DBL(0.0f);
+      }
+      if ( amOrig != FL2FXCONST_DBL(0.0f) )
+        pSfmOrigVec[i] = FDKsbrEnc_LSI_divide_scale_fract(gmOrig,amOrig,SFM_SCALE);
+
+      if ( amTransp != FL2FXCONST_DBL(0.0f) )
+        pSfmSbrVec[i] = FDKsbrEnc_LSI_divide_scale_fract(gmTransp,amTransp,SFM_SCALE);
+    }
+  }
+}
+
+/**************************************************************************/
+/*!
+  \brief     Calculates the input to the missing harmonics detection.
+
+
+  \return    none.
+
+*/
+/**************************************************************************/
+static void calculateDetectorInput(FIXP_DBL **RESTRICT pQuotaBuffer,  /*!< Pointer to tonality matrix. */
+                                   SCHAR     *RESTRICT indexVector,
+                                   FIXP_DBL **RESTRICT tonalityDiff,
+                                   FIXP_DBL **RESTRICT pSfmOrig,
+                                   FIXP_DBL **RESTRICT pSfmSbr,
+                                   const UCHAR *freqBandTable,
+                                   INT nSfb,
+                                   INT noEstPerFrame,
+                                   INT move)
+{
+  INT est;
+
+  /*
+  New estimate.
+  */
+  for (est=0; est < noEstPerFrame; est++) {
+
+    diff(pQuotaBuffer[est+move],
+         tonalityDiff[est+move],
+         freqBandTable,
+         nSfb,
+         indexVector);
+
+    calculateFlatnessMeasure(pQuotaBuffer[est+ move],
+                             indexVector,
+                             pSfmOrig[est + move],
+                             pSfmSbr[est + move],
+                             freqBandTable,
+                             nSfb);
+  }
+}
+
+
+/**************************************************************************/
+/*!
+  \brief     Checks that the detection is not due to a LP filter
+
+  This function determines if a newly detected missing harmonics is not
+  in fact just a low-pass filtere input signal. If so, the detection is
+  removed.
+
+  \return    none.
+
+*/
+/**************************************************************************/
+static void removeLowPassDetection(UCHAR *RESTRICT pAddHarmSfb,
+                                   UCHAR **RESTRICT pDetectionVectors,
+                                   INT start,
+                                   INT stop,
+                                   INT nSfb,
+                                   const UCHAR *RESTRICT pFreqBandTable,
+                                   FIXP_DBL *RESTRICT pNrgVector,
+                                   THRES_HOLDS mhThresh)
+
+{
+  INT i,est;
+  INT maxDerivPos = pFreqBandTable[nSfb];
+  INT numBands = pFreqBandTable[nSfb];
+  FIXP_DBL nrgLow,nrgHigh;
+  FIXP_DBL nrgLD64,nrgLowLD64,nrgHighLD64,nrgDiffLD64;
+  FIXP_DBL valLD64,maxValLD64,maxValAboveLD64;
+  INT bLPsignal = 0;
+
+  maxValLD64 = FL2FXCONST_DBL(-1.0f);
+  for(i = numBands - 1 - 2; i > pFreqBandTable[0];i--){
+    nrgLow  = pNrgVector[i];
+    nrgHigh = pNrgVector[i + 2];
+
+    if(nrgLow != FL2FXCONST_DBL(0.0f) && nrgLow > nrgHigh){
+      nrgLowLD64 = CalcLdData(nrgLow>>1);
+      nrgDiffLD64 = CalcLdData((nrgLow>>1)-(nrgHigh>>1));
+      valLD64 = nrgDiffLD64-nrgLowLD64;
+      if(valLD64 > maxValLD64){
+        maxDerivPos = i;
+        maxValLD64 = valLD64;
+      }
+      if(maxValLD64 > mhThresh.derivThresMaxLD64) {
+        break;
+      }
+    }
+  }
+
+  /* Find the largest "gradient" above. (should be relatively flat, hence we expect a low value
+     if the signal is LP.*/
+  maxValAboveLD64 = FL2FXCONST_DBL(-1.0f);
+  for(i = numBands - 1 - 2; i > maxDerivPos + 2;i--){
+    nrgLow  = pNrgVector[i];
+    nrgHigh = pNrgVector[i + 2];
+
+    if(nrgLow != FL2FXCONST_DBL(0.0f) && nrgLow > nrgHigh){
+		   nrgLowLD64 = CalcLdData(nrgLow>>1);
+		   nrgDiffLD64 = CalcLdData((nrgLow>>1)-(nrgHigh>>1));
+			 valLD64 = nrgDiffLD64-nrgLowLD64;
+      if(valLD64 > maxValAboveLD64){
+        maxValAboveLD64 = valLD64;
+      }
+    }
+		 else {
+      if(nrgHigh != FL2FXCONST_DBL(0.0f) && nrgHigh > nrgLow){
+		     nrgHighLD64 = CalcLdData(nrgHigh>>1);
+		     nrgDiffLD64 = CalcLdData((nrgHigh>>1)-(nrgLow>>1));
+			   valLD64 = nrgDiffLD64-nrgHighLD64;
+        if(valLD64 > maxValAboveLD64){
+          maxValAboveLD64 = valLD64;
+        }
+      }
+		 }
+  }
+
+  if(maxValLD64 > mhThresh.derivThresMaxLD64 && maxValAboveLD64 < mhThresh.derivThresAboveLD64){
+    bLPsignal = 1;
+
+    for(i = maxDerivPos - 1; i > maxDerivPos - 5 && i >= 0 ; i--){
+      if(pNrgVector[i] != FL2FXCONST_DBL(0.0f) && pNrgVector[i] > pNrgVector[maxDerivPos + 2]){
+		     nrgDiffLD64 = CalcLdData((pNrgVector[i]>>1)-(pNrgVector[maxDerivPos + 2]>>1));
+				 nrgLD64 = CalcLdData(pNrgVector[i]>>1);
+  			 valLD64 = nrgDiffLD64-nrgLD64;
+        if(valLD64 < mhThresh.derivThresBelowLD64) {
+          bLPsignal = 0;
+          break;
+        }
+      }
+      else{
+        bLPsignal = 0;
+        break;
+      }
+    }
+  }
+
+  if(bLPsignal){
+    for(i=0;i<nSfb;i++){
+      if(maxDerivPos >= pFreqBandTable[i] && maxDerivPos < pFreqBandTable[i+1])
+        break;
+    }
+
+    if(pAddHarmSfb[i]){
+      pAddHarmSfb[i] = 0;
+      for(est = start; est < stop ; est++){
+        pDetectionVectors[est][i] = 0;
+      }
+    }
+  }
+}
+
+/**************************************************************************/
+/*!
+  \brief     Checks if it is allowed to detect a missing tone, that wasn't
+             detected previously.
+
+
+  \return    newDetectionAllowed flag.
+
+*/
+/**************************************************************************/
+static INT 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)
+{
+  INT transientFrame, newDetectionAllowed;
+
+
+  /* Determine if this is a frame where a transient starts...
+   * If the transient flag was set the previous frame but not the
+   * transient frame flag, the transient frame flag is set in the current frame.
+   *****************************************************************************/
+  transientFrame = 0;
+  if(transientFlag){
+    if(transientPos + transientPosOffset < pFrameInfo->borders[pFrameInfo->nEnvelopes])
+      transientFrame = 1;
+      if(noEstPerFrame > 1){
+        if(transientPos + transientPosOffset > h_sbrMissingHarmonicsDetector->timeSlots >> 1){
+          *pDetectionStartPos = noEstPerFrame;
+        }
+        else{
+          *pDetectionStartPos = noEstPerFrame >> 1;
+        }
+
+      }
+      else{
+        *pDetectionStartPos = noEstPerFrame;
+      }
+  }
+  else{
+    if(prevTransientFlag && !prevTransientFrame){
+      transientFrame = 1;
+      *pDetectionStartPos = 0;
+    }
+  }
+
+  /*
+   * Determine if detection of new missing harmonics are allowed.
+   * If the frame contains a transient it's ok. If the previous
+   * frame contained a transient it needs to be sufficiently close
+   * to the start of the current frame.
+   ****************************************************************/
+  newDetectionAllowed = 0;
+  if(transientFrame){
+    newDetectionAllowed = 1;
+  }
+  else {
+    if(prevTransientFrame &&
+       fixp_abs(pFrameInfo->borders[0] - (prevTransientPos + transientPosOffset -
+                                     h_sbrMissingHarmonicsDetector->timeSlots)) < deltaTime)
+      newDetectionAllowed = 1;
+      *pDetectionStartPos = 0;
+  }
+
+  h_sbrMissingHarmonicsDetector->previousTransientFlag  = transientFlag;
+  h_sbrMissingHarmonicsDetector->previousTransientFrame = transientFrame;
+  h_sbrMissingHarmonicsDetector->previousTransientPos   = transientPos;
+
+  return (newDetectionAllowed);
+}
+
+
+/**************************************************************************/
+/*!
+  \brief     Cleans up the detection after a transient.
+
+
+  \return    none.
+
+*/
+/**************************************************************************/
+static void 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)
+{
+  INT i,j,li, ui,est;
+
+  for(est=start; est < stop; est++) {
+    for(i=0; i<nSfb; i++) {
+      pAddHarmSfb[i] = pAddHarmSfb[i] || detectionVectors[est][i];
+    }
+  }
+
+  if(newDetectionAllowed == 1){
+    /*
+     * Check for duplication of sines located
+     * on the border of two scf-bands.
+     *************************************************/
+    for(i=0;i<nSfb-1;i++) {
+      li = pFreqBandTable[i];
+      ui = pFreqBandTable[i+1];
+
+      /* detection in adjacent channels.*/
+      if(pAddHarmSfb[i] && pAddHarmSfb[i+1]) {
+        FIXP_DBL maxVal1, maxVal2;
+        INT maxPos1, maxPos2, maxPosTime1, maxPosTime2;
+
+        li = pFreqBandTable[i];
+        ui = pFreqBandTable[i+1];
+
+        /* Find maximum tonality in the the two scf bands.*/
+        maxPosTime1 = start;
+        maxPos1 = li;
+        maxVal1 = quotaBuffer[start][li];
+        for(est = start; est < stop; est++){
+          for(j = li; j<ui; j++){
+            if(quotaBuffer[est][j] > maxVal1){
+              maxVal1 = quotaBuffer[est][j];
+              maxPos1 = j;
+              maxPosTime1 = est;
+            }
+          }
+        }
+
+        li = pFreqBandTable[i+1];
+        ui = pFreqBandTable[i+2];
+
+        /* Find maximum tonality in the the two scf bands.*/
+        maxPosTime2 = start;
+        maxPos2 = li;
+        maxVal2 = quotaBuffer[start][li];
+        for(est = start; est < stop; est++){
+          for(j = li; j<ui; j++){
+            if(quotaBuffer[est][j] > maxVal2){
+              maxVal2 = quotaBuffer[est][j];
+              maxPos2 = j;
+              maxPosTime2 = est;
+            }
+          }
+        }
+
+        /* If the maximum values are in adjacent QMF-channels, we need to remove
+           the lowest of the two.*/
+        if(maxPos2-maxPos1 < 2){
+
+          if(pPrevAddHarmSfb[i] == 1 && pPrevAddHarmSfb[i+1] == 0){
+            /* Keep the lower, remove the upper.*/
+            pAddHarmSfb[i+1] = 0;
+            for(est=start; est<stop; est++){
+              detectionVectors[est][i+1] = 0;
+            }
+          }
+          else{
+            if(pPrevAddHarmSfb[i] == 0 && pPrevAddHarmSfb[i+1] == 1){
+              /* Keep the upper, remove the lower.*/
+              pAddHarmSfb[i] = 0;
+              for(est=start; est<stop; est++){
+                detectionVectors[est][i] = 0;
+              }
+            }
+            else{
+             /* If the maximum values are in adjacent QMF-channels, and if the signs indicate that it is the same sine,
+                we need to remove the lowest of the two.*/
+              if(maxVal1 > maxVal2){
+                if(signBuffer[maxPosTime1][maxPos2] < 0 && signBuffer[maxPosTime1][maxPos1] > 0){
+                  /* Keep the lower, remove the upper.*/
+                  pAddHarmSfb[i+1] = 0;
+                  for(est=start; est<stop; est++){
+                    detectionVectors[est][i+1] = 0;
+                  }
+                }
+              }
+              else{
+                if(signBuffer[maxPosTime2][maxPos2] < 0 && signBuffer[maxPosTime2][maxPos1] > 0){
+                  /* Keep the upper, remove the lower.*/
+                  pAddHarmSfb[i] = 0;
+                  for(est=start; est<stop; est++){
+                    detectionVectors[est][i] = 0;
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+
+    /* Make sure that the detection is not the cut-off of a low pass filter. */
+    removeLowPassDetection(pAddHarmSfb,
+                           detectionVectors,
+                           start,
+                           stop,
+                           nSfb,
+                           pFreqBandTable,
+                           pNrgVector,
+                           mhThresh);
+  }
+  else {
+   /*
+    * If a missing harmonic wasn't missing the previous frame
+    * the transient-flag needs to be set in order to be allowed to detect it.
+    *************************************************************************/
+    for(i=0;i<nSfb;i++){
+      if(pAddHarmSfb[i] - pPrevAddHarmSfb[i] > 0)
+        pAddHarmSfb[i] = 0;
+    }
+  }
+}
+
+
+/**************************************************************************/
+/*!
+  \brief     Do detection for one tonality estimate.
+
+
+  \return    none.
+
+*/
+/**************************************************************************/
+static void 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)
+{
+
+  INT i,j,ll, lu;
+  FIXP_DBL thresTemp,thresOrig;
+
+  /*
+   * Do detection on the difference vector, i.e. the difference between
+   * the original and the transposed.
+   *********************************************************************/
+  for(i=0;i<nSfb;i++){
+
+    thresTemp = (guideVectors.guideVectorDiff[i] != FL2FXCONST_DBL(0.0f))
+                  ? fixMax(fMult(mhThresh.decayGuideDiff,guideVectors.guideVectorDiff[i]), mhThresh.thresHoldDiffGuide)
+                  : mhThresh.thresHoldDiff;
+
+    thresTemp = fixMin(thresTemp, mhThresh.thresHoldDiff);
+
+    if(pDiffVecScfb[i] > thresTemp){
+      pHarmVec[i] = 1;
+      newGuideVectors.guideVectorDiff[i] = pDiffVecScfb[i];
+    }
+    else{
+      /* If the guide wasn't zero, but the current level is to low,
+         start tracking the decay on the tone in the original rather
+         than the difference.*/
+      if(guideVectors.guideVectorDiff[i] != FL2FXCONST_DBL(0.0f)){
+        guideVectors.guideVectorOrig[i] = mhThresh.thresHoldToneGuide;
+      }
+    }
+  }
+
+  /*
+   * Trace tones in the original signal that at one point
+   * have been detected because they will be replaced by
+   * multiple tones in the sbr signal.
+   ****************************************************/
+
+  for(i=0;i<nSfb;i++){
+    ll = pFreqBandTable[i];
+    lu = pFreqBandTable[i+1];
+
+    thresOrig = fixMax(fMult(guideVectors.guideVectorOrig[i], mhThresh.decayGuideOrig), mhThresh.thresHoldToneGuide);
+    thresOrig = fixMin(thresOrig, mhThresh.thresHoldTone);
+
+    if(guideVectors.guideVectorOrig[i] != FL2FXCONST_DBL(0.0f)){
+      for(j= ll;j<lu;j++){
+        if(quotaBuffer[j] > thresOrig){
+          pHarmVec[i] = 1;
+          newGuideVectors.guideVectorOrig[i] = quotaBuffer[j];
+        }
+      }
+    }
+  }
+
+  /*
+   * Check for multiple sines in the transposed signal,
+   * where there is only one in the original.
+   ****************************************************/
+  thresOrig = mhThresh.thresHoldTone;
+
+  for(i=0;i<nSfb;i++){
+    ll = pFreqBandTable[i];
+    lu = pFreqBandTable[i+1];
+
+    if(pHarmVec[i] == 0){
+      if(lu -ll > 1){
+        for(j= ll;j<lu;j++){
+          if(quotaBuffer[j] > thresOrig && (sfmSbr[i] > mhThresh.sfmThresSbr && sfmOrig[i] < mhThresh.sfmThresOrig)){
+            pHarmVec[i] = 1;
+            newGuideVectors.guideVectorOrig[i] = quotaBuffer[j];
+          }
+        }
+      }
+      else{
+        if(i < nSfb -1){
+          ll = pFreqBandTable[i];
+
+          if(i>0){
+            if(quotaBuffer[ll] > mhThresh.thresHoldTone && (pDiffVecScfb[i+1] < mhThresh.invThresHoldTone || pDiffVecScfb[i-1] < mhThresh.invThresHoldTone)){
+                pHarmVec[i] = 1;
+                newGuideVectors.guideVectorOrig[i] = quotaBuffer[ll];
+            }
+          }
+          else{
+            if(quotaBuffer[ll] > mhThresh.thresHoldTone && pDiffVecScfb[i+1] < mhThresh.invThresHoldTone){
+                pHarmVec[i] = 1;
+                newGuideVectors.guideVectorOrig[i] = quotaBuffer[ll];
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+
+/**************************************************************************/
+/*!
+  \brief     Do detection for every tonality estimate, using forward prediction.
+
+
+  \return    none.
+
+*/
+/**************************************************************************/
+static void 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)
+{
+  INT est = 0,i;
+  INT start;
+
+  FDKmemclear(pAddHarmSfb,nSfb*sizeof(UCHAR));
+
+  if(newDetectionAllowed){
+
+    if(totNoEst > 1){
+      start = detectionStart;
+
+      if (start != 0) {
+        FDKmemcpy(guideVectors[start].guideVectorDiff,guideVectors[0].guideVectorDiff,nSfb*sizeof(FIXP_DBL));
+        FDKmemcpy(guideVectors[start].guideVectorOrig,guideVectors[0].guideVectorOrig,nSfb*sizeof(FIXP_DBL));
+        FDKmemclear(guideVectors[start-1].guideVectorDetected,nSfb*sizeof(UCHAR));
+      }
+    }
+    else{
+      start = 0;
+    }
+  }
+  else{
+    start = 0;
+  }
+
+
+  for(est = start; est < totNoEst; est++){
+
+    /*
+    * Do detection on the current frame using
+    * guide-info from the previous.
+    *******************************************/
+    if(est > 0){
+      FDKmemcpy(guideVectors[est].guideVectorDetected,detectionVectors[est-1],nSfb*sizeof(UCHAR));
+    }
+
+    FDKmemclear(detectionVectors[est], nSfb*sizeof(UCHAR));
+
+    if(est < totNoEst-1){
+      FDKmemclear(guideVectors[est+1].guideVectorDiff,nSfb*sizeof(FIXP_DBL));
+      FDKmemclear(guideVectors[est+1].guideVectorOrig,nSfb*sizeof(FIXP_DBL));
+      FDKmemclear(guideVectors[est+1].guideVectorDetected,nSfb*sizeof(UCHAR));
+
+      detection(quotaBuffer[est],
+                pDiffVecScfb[est],
+                nSfb,
+                detectionVectors[est],
+                pFreqBandTable,
+                sfmOrig[est],
+                sfmSbr[est],
+                guideVectors[est],
+                guideVectors[est+1],
+                mhParams->thresHolds);
+    }
+    else{
+      FDKmemclear(guideVectors[est].guideVectorDiff,nSfb*sizeof(FIXP_DBL));
+      FDKmemclear(guideVectors[est].guideVectorOrig,nSfb*sizeof(FIXP_DBL));
+      FDKmemclear(guideVectors[est].guideVectorDetected,nSfb*sizeof(UCHAR));
+
+      detection(quotaBuffer[est],
+                pDiffVecScfb[est],
+                nSfb,
+                detectionVectors[est],
+                pFreqBandTable,
+                sfmOrig[est],
+                sfmSbr[est],
+                guideVectors[est],
+                guideVectors[est],
+                mhParams->thresHolds);
+    }
+  }
+
+
+  /* Clean up the detection.*/
+  transientCleanUp(quotaBuffer,
+                   nSfb,
+                   detectionVectors,
+                   pAddHarmSfb,
+                   pPrevAddHarmSfb,
+                   signBuffer,
+                   pFreqBandTable,
+                   start,
+                   totNoEst,
+                   newDetectionAllowed,
+                   pNrgVector,
+                   mhParams->thresHolds);
+
+
+  /* Set flag... */
+  *pAddHarmFlag = 0;
+  for(i=0; i<nSfb; i++){
+    if(pAddHarmSfb[i]){
+      *pAddHarmFlag = 1;
+      break;
+    }
+  }
+
+  FDKmemcpy(pPrevAddHarmSfb, pAddHarmSfb, nSfb*sizeof(UCHAR));
+  FDKmemcpy(guideVectors[0].guideVectorDetected,pAddHarmSfb,nSfb*sizeof(INT));
+
+  for(i=0; i<nSfb ; i++){
+
+    guideVectors[0].guideVectorDiff[i] = FL2FXCONST_DBL(0.0f);
+    guideVectors[0].guideVectorOrig[i] = FL2FXCONST_DBL(0.0f);
+
+    if(pAddHarmSfb[i] == 1){
+      /* If we had a detection use the guide-value in the next frame from the last estimate were the detection
+      was done.*/
+      for(est=start; est < totNoEst; est++){
+        if(guideVectors[est].guideVectorDiff[i] != FL2FXCONST_DBL(0.0f)){
+          guideVectors[0].guideVectorDiff[i] = guideVectors[est].guideVectorDiff[i];
+        }
+        if(guideVectors[est].guideVectorOrig[i] != FL2FXCONST_DBL(0.0f)){
+          guideVectors[0].guideVectorOrig[i] = guideVectors[est].guideVectorOrig[i];
+        }
+      }
+    }
+  }
+
+}
+
+
+/**************************************************************************/
+/*!
+  \brief     Calculates a compensation vector for the energy data.
+
+  This function calculates a compensation vector for the energy data (i.e.
+  envelope data) that is calculated elsewhere. This is since, one sine on
+  the border of two scalefactor bands, will be replace by one sine in the
+  middle of either scalefactor band. However, since the sine that is replaced
+  will influence the energy estimate in both scalefactor bands (in the envelops
+  calculation function) a compensation value is required in order to avoid
+  noise substitution in the decoder next to the synthetic sine.
+
+  \return    none.
+
+*/
+/**************************************************************************/
+static void calculateCompVector(UCHAR *pAddHarmSfb,
+                                FIXP_DBL **pTonalityMatrix,
+                                INT ** pSignMatrix,
+                                UCHAR *pEnvComp,
+                                INT nSfb,
+                                const UCHAR *freqBandTable,
+                                INT totNoEst,
+                                INT maxComp,
+                                UCHAR *pPrevEnvComp,
+                                INT newDetectionAllowed)
+{
+
+  INT scfBand,est,l,ll,lu,maxPosF,maxPosT;
+  FIXP_DBL maxVal;
+  INT compValue;
+  FIXP_DBL tmp;
+
+  FDKmemclear(pEnvComp,nSfb*sizeof(UCHAR));
+
+  for(scfBand=0; scfBand < nSfb; scfBand++){
+
+    if(pAddHarmSfb[scfBand]){ /* A missing sine was detected */
+      ll = freqBandTable[scfBand];
+      lu = freqBandTable[scfBand+1];
+
+      maxPosF = 0;                        /* First find the maximum*/
+      maxPosT = 0;
+      maxVal = FL2FXCONST_DBL(0.0f);
+
+      for(est=0;est<totNoEst;est++){
+        for(l=ll; l<lu; l++){
+          if(pTonalityMatrix[est][l] > maxVal){
+            maxVal = pTonalityMatrix[est][l];
+            maxPosF = l;
+            maxPosT = est;
+          }
+        }
+      }
+
+      /*
+       * If the maximum tonality is at the lower border of the
+       * scalefactor band, we check the sign of the adjacent channels
+       * to see if this sine is shared by the lower channel. If so, the
+       * energy of the single sine will be present in two scalefactor bands
+       * in the SBR data, which will cause problems in the decoder, when we
+       * add a sine to just one of the channels.
+       *********************************************************************/
+      if(maxPosF == ll && scfBand){
+        if(!pAddHarmSfb[scfBand - 1]) {     /* No detection below*/
+          if (pSignMatrix[maxPosT][maxPosF - 1] > 0 && pSignMatrix[maxPosT][maxPosF] < 0) {
+            /* The comp value is calulated as the tonallity value, i.e we want to
+               reduce the envelope data for this channel with as much as the tonality
+               that is spread from the channel above. (ld64(RELAXATION) = 0.31143075889) */
+            tmp = fixp_abs((FIXP_DBL)CalcLdData(pTonalityMatrix[maxPosT][maxPosF - 1]) + RELAXATION_LD64);
+            tmp = (tmp >> (DFRACT_BITS-1-LD_DATA_SHIFT-1)) + (FIXP_DBL)1;  /* shift one bit less for rounding */
+            compValue = ((INT)(LONG)tmp) >> 1;
+
+						      /* limit the comp-value*/
+            if (compValue > maxComp)
+              compValue = maxComp;
+
+            pEnvComp[scfBand-1] = compValue;
+					     }
+				    }
+      }
+
+      /*
+       * Same as above, but for the upper end of the scalefactor-band.
+       ***************************************************************/
+      if(maxPosF == lu-1 && scfBand+1 < nSfb){        /* Upper border*/
+        if(!pAddHarmSfb[scfBand + 1]) {
+          if (pSignMatrix[maxPosT][maxPosF] > 0 && pSignMatrix[maxPosT][maxPosF + 1] < 0) {
+            tmp = fixp_abs((FIXP_DBL)CalcLdData(pTonalityMatrix[maxPosT][maxPosF + 1]) + RELAXATION_LD64);
+            tmp = (tmp >> (DFRACT_BITS-1-LD_DATA_SHIFT-1)) + (FIXP_DBL)1;  /* shift one bit less for rounding */
+            compValue = ((INT)(LONG)tmp) >> 1;
+
+            if (compValue > maxComp)
+              compValue = maxComp;
+
+            pEnvComp[scfBand+1] = compValue;
+					 }
+				 }
+      }
+		 }
+	 }
+
+  if(newDetectionAllowed == 0){
+    for(scfBand=0;scfBand<nSfb;scfBand++){
+      if(pEnvComp[scfBand] != 0 && pPrevEnvComp[scfBand] == 0)
+        pEnvComp[scfBand] = 0;
+    }
+  }
+
+  /* remember the value for the next frame.*/
+  FDKmemcpy(pPrevEnvComp,pEnvComp,nSfb*sizeof(UCHAR));
+}
+
+
+/**************************************************************************/
+/*!
+  \brief     Detects where strong tonal components will be missing after
+             HFR in the decoder.
+
+
+  \return    none.
+
+*/
+/**************************************************************************/
+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)
+{
+  INT transientFlag = pTranInfo[1];
+  INT transientPos  = pTranInfo[0];
+  INT newDetectionAllowed;
+  INT transientDetStart = 0;
+
+  UCHAR ** detectionVectors  = h_sbrMHDet->detectionVectors;
+  INT move                = h_sbrMHDet->move;
+  INT noEstPerFrame       = h_sbrMHDet->noEstPerFrame;
+  INT totNoEst            = h_sbrMHDet->totNoEst;
+  INT prevTransientFlag   = h_sbrMHDet->previousTransientFlag;
+  INT prevTransientFrame  = h_sbrMHDet->previousTransientFrame;
+  INT transientPosOffset  = h_sbrMHDet->transientPosOffset;
+  INT prevTransientPos    = h_sbrMHDet->previousTransientPos;
+  GUIDE_VECTORS* guideVectors = h_sbrMHDet->guideVectors;
+  INT deltaTime = h_sbrMHDet->mhParams->deltaTime;
+  INT maxComp = h_sbrMHDet->mhParams->maxComp;
+
+  int est;
+
+  /*
+  Buffer values.
+  */
+  FDK_ASSERT(move<=(MAX_NO_OF_ESTIMATES>>1));
+  FDK_ASSERT(noEstPerFrame<=(MAX_NO_OF_ESTIMATES>>1));
+
+  FIXP_DBL *sfmSbr[MAX_NO_OF_ESTIMATES];
+  FIXP_DBL *sfmOrig[MAX_NO_OF_ESTIMATES];
+  FIXP_DBL *tonalityDiff[MAX_NO_OF_ESTIMATES];
+
+  for (est=0; est < MAX_NO_OF_ESTIMATES/2; est++) {
+    sfmSbr[est]       = h_sbrMHDet->sfmSbr[est];
+    sfmOrig[est]      = h_sbrMHDet->sfmOrig[est];
+    tonalityDiff[est] = h_sbrMHDet->tonalityDiff[est];
+  }
+
+  C_ALLOC_SCRATCH_START(scratch_mem, FIXP_DBL, (3*MAX_NO_OF_ESTIMATES/2*MAX_FREQ_COEFFS));
+  FIXP_DBL *scratch = scratch_mem;
+  for (; est < MAX_NO_OF_ESTIMATES; est++) {
+    sfmSbr[est]       = scratch; scratch+=MAX_FREQ_COEFFS;
+    sfmOrig[est]      = scratch; scratch+=MAX_FREQ_COEFFS;
+    tonalityDiff[est] = scratch; scratch+=MAX_FREQ_COEFFS;
+  }
+
+
+
+  /* Determine if we're allowed to detect "missing harmonics" that wasn't detected before.
+     In order to be allowed to do new detection, there must be a transient in the current
+     frame, or a transient in the previous frame sufficiently close to the current frame. */
+  newDetectionAllowed = isDetectionOfNewToneAllowed(pFrameInfo,
+                                                    &transientDetStart,
+                                                    noEstPerFrame,
+                                                    prevTransientFrame,
+                                                    prevTransientPos,
+                                                    prevTransientFlag,
+                                                    transientPosOffset,
+                                                    transientFlag,
+                                                    transientPos,
+                                                    deltaTime,
+                                                    h_sbrMHDet);
+
+  /* Calulate the variables that will be used subsequently for the actual detection */
+  calculateDetectorInput(pQuotaBuffer,
+                         indexVector,
+                         tonalityDiff,
+                         sfmOrig,
+                         sfmSbr,
+                         freqBandTable,
+                         nSfb,
+                         noEstPerFrame,
+                         move);
+
+  /* Do the actual detection using information from previous detections */
+  detectionWithPrediction(pQuotaBuffer,
+                          tonalityDiff,
+                          pSignBuffer,
+                          nSfb,
+                          freqBandTable,
+                          sfmOrig,
+                          sfmSbr,
+                          detectionVectors,
+                          h_sbrMHDet->guideScfb,
+                          guideVectors,
+                          noEstPerFrame,
+                          transientDetStart,
+                          totNoEst,
+                          newDetectionAllowed,
+                          pAddHarmonicsFlag,
+                          pAddHarmonicsScaleFactorBands,
+                          pNrgVector,
+                          h_sbrMHDet->mhParams);
+
+  /* Calculate the comp vector, so that the energy can be
+     compensated for a sine between two QMF-bands. */
+  calculateCompVector(pAddHarmonicsScaleFactorBands,
+                      pQuotaBuffer,
+                      pSignBuffer,
+                      envelopeCompensation,
+                      nSfb,
+                      freqBandTable,
+                      totNoEst,
+                      maxComp,
+                      h_sbrMHDet->prevEnvelopeCompensation,
+                      newDetectionAllowed);
+
+  for (est=0; est < move; est++) {
+    FDKmemcpy(tonalityDiff[est], tonalityDiff[est + noEstPerFrame], sizeof(FIXP_DBL)*MAX_FREQ_COEFFS);
+    FDKmemcpy(sfmOrig[est], sfmOrig[est + noEstPerFrame], sizeof(FIXP_DBL)*MAX_FREQ_COEFFS);
+    FDKmemcpy(sfmSbr[est], sfmSbr[est + noEstPerFrame], sizeof(FIXP_DBL)*MAX_FREQ_COEFFS);
+  }
+  C_ALLOC_SCRATCH_END(scratch, FIXP_DBL, (3*MAX_NO_OF_ESTIMATES/2*MAX_FREQ_COEFFS));
+
+
+}
+
+/**************************************************************************/
+/*!
+  \brief     Initialize an instance of the missing harmonics detector.
+
+
+  \return    errorCode, noError if OK.
+
+*/
+/**************************************************************************/
+INT
+FDKsbrEnc_CreateSbrMissingHarmonicsDetector (
+                                   HANDLE_SBR_MISSING_HARMONICS_DETECTOR hSbrMHDet,
+                                   INT chan)
+{
+  HANDLE_SBR_MISSING_HARMONICS_DETECTOR hs = hSbrMHDet;
+  INT i;
+
+  UCHAR* detectionVectors    = GetRam_Sbr_detectionVectors(chan);
+  UCHAR* guideVectorDetected = GetRam_Sbr_guideVectorDetected(chan);
+  FIXP_DBL* guideVectorDiff  = GetRam_Sbr_guideVectorDiff(chan);
+  FIXP_DBL* guideVectorOrig  = GetRam_Sbr_guideVectorOrig(chan);
+
+  FDKmemclear (hs,sizeof(SBR_MISSING_HARMONICS_DETECTOR));
+
+  hs->prevEnvelopeCompensation = GetRam_Sbr_prevEnvelopeCompensation(chan);
+  hs->guideScfb                = GetRam_Sbr_guideScfb(chan);
+
+  for(i=0; i<MAX_NO_OF_ESTIMATES; i++) {
+    hs->guideVectors[i].guideVectorDiff = guideVectorDiff + (i*MAX_FREQ_COEFFS);
+    hs->guideVectors[i].guideVectorOrig = guideVectorOrig + (i*MAX_FREQ_COEFFS);
+    hs->detectionVectors[i] = detectionVectors + (i*MAX_FREQ_COEFFS);
+    hs->guideVectors[i].guideVectorDetected = guideVectorDetected + (i*MAX_FREQ_COEFFS);
+  }
+
+  return 0;
+}
+
+
+/**************************************************************************/
+/*!
+  \brief     Initialize an instance of the missing harmonics detector.
+
+
+  \return    errorCode, noError if OK.
+
+*/
+/**************************************************************************/
+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
+                                  )
+{
+  HANDLE_SBR_MISSING_HARMONICS_DETECTOR hs = hSbrMHDet;
+  int i;
+
+  FDK_ASSERT(totNoEst <= MAX_NO_OF_ESTIMATES);
+
+  switch(frameSize){
+  case 2048:
+      hs->transientPosOffset = FRAME_MIDDLE_SLOT_2048;
+      hs->timeSlots          = NUMBER_TIME_SLOTS_2048;
+      break;
+  case 1920:
+      hs->transientPosOffset = FRAME_MIDDLE_SLOT_1920;
+      hs->timeSlots          = NUMBER_TIME_SLOTS_1920;
+      break;
+  case 1024:
+      hs->transientPosOffset = FRAME_MIDDLE_SLOT_512LD;
+      hs->timeSlots          = 16;
+      break;
+  case 960:
+      hs->transientPosOffset = FRAME_MIDDLE_SLOT_512LD;
+      hs->timeSlots          = 15;
+      break;
+  default:
+      return -1;
+  }
+
+  if (sbrSyntaxFlags & SBR_SYNTAX_LOW_DELAY) {
+    hs->mhParams = &paramsAacLd;
+  } else
+  hs->mhParams = &paramsAac;
+
+  hs->qmfNoChannels = qmfNoChannels;
+  hs->sampleFreq = sampleFreq;
+  hs->nSfb = nSfb;
+
+  hs->totNoEst = totNoEst;
+  hs->move = move;
+  hs->noEstPerFrame = noEstPerFrame;
+
+  for(i=0; i<totNoEst; i++) {
+    FDKmemclear (hs->guideVectors[i].guideVectorDiff,sizeof(FIXP_DBL)*MAX_FREQ_COEFFS);
+    FDKmemclear (hs->guideVectors[i].guideVectorOrig,sizeof(FIXP_DBL)*MAX_FREQ_COEFFS);
+    FDKmemclear (hs->detectionVectors[i],sizeof(UCHAR)*MAX_FREQ_COEFFS);
+    FDKmemclear (hs->guideVectors[i].guideVectorDetected,sizeof(UCHAR)*MAX_FREQ_COEFFS);
+  }
+
+  //for(i=0; i<totNoEst/2; i++) {
+  for(i=0; i<MAX_NO_OF_ESTIMATES/2; i++) {
+    FDKmemclear (hs->tonalityDiff[i],sizeof(FIXP_DBL)*MAX_FREQ_COEFFS);
+    FDKmemclear (hs->sfmOrig[i],sizeof(FIXP_DBL)*MAX_FREQ_COEFFS);
+    FDKmemclear (hs->sfmSbr[i],sizeof(FIXP_DBL)*MAX_FREQ_COEFFS);
+  }
+
+  FDKmemclear ( hs->prevEnvelopeCompensation, sizeof(UCHAR)*MAX_FREQ_COEFFS);
+  FDKmemclear ( hs->guideScfb, sizeof(UCHAR)*MAX_FREQ_COEFFS);
+
+  hs->previousTransientFlag = 0;
+  hs->previousTransientFrame = 0;
+  hs->previousTransientPos = 0;
+
+  return (0);
+}
+
+/**************************************************************************/
+/*!
+  \brief     Deletes an instance of the missing harmonics detector.
+
+
+  \return    none.
+
+*/
+/**************************************************************************/
+void
+FDKsbrEnc_DeleteSbrMissingHarmonicsDetector(HANDLE_SBR_MISSING_HARMONICS_DETECTOR hSbrMHDet)
+{
+  if (hSbrMHDet) {
+    HANDLE_SBR_MISSING_HARMONICS_DETECTOR hs = hSbrMHDet;
+
+    FreeRam_Sbr_detectionVectors(&hs->detectionVectors[0]);
+    FreeRam_Sbr_guideVectorDetected(&hs->guideVectors[0].guideVectorDetected);
+    FreeRam_Sbr_guideVectorDiff(&hs->guideVectors[0].guideVectorDiff);
+    FreeRam_Sbr_guideVectorOrig(&hs->guideVectors[0].guideVectorOrig);
+    FreeRam_Sbr_prevEnvelopeCompensation(&hs->prevEnvelopeCompensation);
+    FreeRam_Sbr_guideScfb(&hs->guideScfb);
+
+  }
+}
+
+/**************************************************************************/
+/*!
+  \brief     Resets an instance of the missing harmonics detector.
+
+
+  \return    error code, noError if OK.
+
+*/
+/**************************************************************************/
+INT
+FDKsbrEnc_ResetSbrMissingHarmonicsDetector (HANDLE_SBR_MISSING_HARMONICS_DETECTOR hSbrMissingHarmonicsDetector,
+                                  INT nSfb)
+{
+  int i;
+  FIXP_DBL tempGuide[MAX_FREQ_COEFFS];
+  UCHAR tempGuideInt[MAX_FREQ_COEFFS];
+  INT nSfbPrev;
+
+  nSfbPrev = hSbrMissingHarmonicsDetector->nSfb;
+  hSbrMissingHarmonicsDetector->nSfb = nSfb;
+
+  FDKmemcpy( tempGuideInt, hSbrMissingHarmonicsDetector->guideScfb, nSfbPrev * sizeof(UCHAR) );
+
+  if ( nSfb > nSfbPrev ) {
+    for ( i = 0; i < (nSfb - nSfbPrev); i++ ) {
+      hSbrMissingHarmonicsDetector->guideScfb[i] = 0;
+    }
+
+    for ( i = 0; i < nSfbPrev; i++ ) {
+      hSbrMissingHarmonicsDetector->guideScfb[i + (nSfb - nSfbPrev)] = tempGuideInt[i];
+    }
+  }
+  else {
+    for ( i = 0; i < nSfb; i++ ) {
+      hSbrMissingHarmonicsDetector->guideScfb[i] = tempGuideInt[i + (nSfbPrev-nSfb)];
+    }
+  }
+
+  FDKmemcpy ( tempGuide, hSbrMissingHarmonicsDetector->guideVectors[0].guideVectorDiff, nSfbPrev * sizeof(FIXP_DBL) );
+
+  if (nSfb > nSfbPrev ) {
+    for ( i = 0; i < (nSfb - nSfbPrev); i++ ) {
+      hSbrMissingHarmonicsDetector->guideVectors[0].guideVectorDiff[i] = FL2FXCONST_DBL(0.0f);
+    }
+
+    for ( i = 0; i < nSfbPrev; i++ ) {
+      hSbrMissingHarmonicsDetector->guideVectors[0].guideVectorDiff[i + (nSfb - nSfbPrev)] = tempGuide[i];
+    }
+  }
+  else {
+    for ( i = 0; i < nSfb; i++  ) {
+      hSbrMissingHarmonicsDetector->guideVectors[0].guideVectorDiff[i] = tempGuide[i + (nSfbPrev-nSfb)];
+    }
+  }
+
+  FDKmemcpy ( tempGuide, hSbrMissingHarmonicsDetector->guideVectors[0].guideVectorOrig, nSfbPrev * sizeof(FIXP_DBL) );
+
+  if ( nSfb > nSfbPrev ) {
+    for ( i = 0; i< (nSfb - nSfbPrev); i++ ) {
+      hSbrMissingHarmonicsDetector->guideVectors[0].guideVectorOrig[i] = FL2FXCONST_DBL(0.0f);
+    }
+
+    for ( i = 0; i < nSfbPrev; i++ ) {
+      hSbrMissingHarmonicsDetector->guideVectors[0].guideVectorOrig[i + (nSfb - nSfbPrev)] = tempGuide[i];
+    }
+  }
+  else {
+    for ( i = 0; i < nSfb; i++ ) {
+      hSbrMissingHarmonicsDetector->guideVectors[0].guideVectorOrig[i] = tempGuide[i + (nSfbPrev-nSfb)];
+    }
+  }
+
+  FDKmemcpy ( tempGuideInt, hSbrMissingHarmonicsDetector->guideVectors[0].guideVectorDetected, nSfbPrev * sizeof(UCHAR) );
+
+  if ( nSfb > nSfbPrev ) {
+    for ( i = 0; i < (nSfb - nSfbPrev); i++ ) {
+      hSbrMissingHarmonicsDetector->guideVectors[0].guideVectorDetected[i] = 0;
+    }
+
+    for ( i = 0; i < nSfbPrev; i++ ) {
+      hSbrMissingHarmonicsDetector->guideVectors[0].guideVectorDetected[i + (nSfb - nSfbPrev)] = tempGuideInt[i];
+    }
+  }
+  else {
+    for ( i = 0; i < nSfb; i++ ) {
+      hSbrMissingHarmonicsDetector->guideVectors[0].guideVectorDetected[i] = tempGuideInt[i + (nSfbPrev-nSfb)];
+    }
+  }
+
+  FDKmemcpy ( tempGuideInt, hSbrMissingHarmonicsDetector->prevEnvelopeCompensation, nSfbPrev * sizeof(UCHAR) );
+
+  if ( nSfb > nSfbPrev ) {
+    for ( i = 0; i < (nSfb - nSfbPrev); i++ ) {
+      hSbrMissingHarmonicsDetector->prevEnvelopeCompensation[i] = 0;
+    }
+
+    for ( i = 0; i < nSfbPrev; i++ ) {
+      hSbrMissingHarmonicsDetector->prevEnvelopeCompensation[i + (nSfb - nSfbPrev)] = tempGuideInt[i];
+    }
+  }
+  else {
+    for ( i = 0; i < nSfb; i++ ) {
+      hSbrMissingHarmonicsDetector->prevEnvelopeCompensation[i] = tempGuideInt[i + (nSfbPrev-nSfb)];
+    }
+  }
+
+  return 0;
+}
+