summaryrefslogtreecommitdiffstats
path: root/libSBRenc/src/mh_det.cpp
diff options
context:
space:
mode:
authorDave Burke <daveburke@google.com>2012-04-17 09:51:45 -0700
committerDave Burke <daveburke@google.com>2012-04-17 23:04:43 -0700
commit9bf37cc9712506b2483650c82d3c41152337ef7e (patch)
tree77db44e2bae06e3d144b255628be2b7a55c581d3 /libSBRenc/src/mh_det.cpp
parenta37315fe10ee143d6d0b28c19d41a476a23e63ea (diff)
downloadODR-AudioEnc-9bf37cc9712506b2483650c82d3c41152337ef7e.tar.gz
ODR-AudioEnc-9bf37cc9712506b2483650c82d3c41152337ef7e.tar.bz2
ODR-AudioEnc-9bf37cc9712506b2483650c82d3c41152337ef7e.zip
Fraunhofer AAC codec.
License boilerplate update to follow. Change-Id: I2810460c11a58b6d148d84673cc031f3685e79b5
Diffstat (limited to 'libSBRenc/src/mh_det.cpp')
-rw-r--r--libSBRenc/src/mh_det.cpp1381
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;
+}
+