Fixed some memory management problems in the SMS analysis process

1 files changed, 241 insertions, 249 deletions

diff --git a/sms/harmDetection.c b/sms/harmDetection.c
index 7ec3bac..1612fc8 100644
--- a/sms/harmDetection.c
+++ b/sms/harmDetection.c
@@ -46,30 +46,30 @@
 static int GetClosestPeak (int iPeakCandidate, int nHarm, SMS_Peak *pSpectralPeaks,
                            int *pICurrentPeak, int iRefHarmonic)
 {
-	int iBestPeak = *pICurrentPeak + 1, iNextPeak;
-	sfloat fBestPeakFreq = pSpectralPeaks[iBestPeak].fFreq,
-		fHarmFreq = (1 + nHarm) * pSpectralPeaks[iPeakCandidate].fFreq / iRefHarmonic, 
-		fMinDistance = fabs(fHarmFreq - fBestPeakFreq),
-		fMaxPeakDev = .5 * fHarmFreq / (nHarm + 1), fDistance;
+    int iBestPeak = *pICurrentPeak + 1, iNextPeak;
+    sfloat fBestPeakFreq = pSpectralPeaks[iBestPeak].fFreq,
+        fHarmFreq = (1 + nHarm) * pSpectralPeaks[iPeakCandidate].fFreq / iRefHarmonic, 
+        fMinDistance = fabs(fHarmFreq - fBestPeakFreq),
+        fMaxPeakDev = .5 * fHarmFreq / (nHarm + 1), fDistance;
   
-	iNextPeak = iBestPeak + 1;
-	fDistance = fabs(fHarmFreq - pSpectralPeaks[iNextPeak].fFreq);
-	while (fDistance < fMinDistance)
-	{
-		iBestPeak = iNextPeak;
-		fMinDistance = fDistance;
-		iNextPeak++;
-		fDistance = fabs (fHarmFreq - pSpectralPeaks[iNextPeak].fFreq);
-	}
+    iNextPeak = iBestPeak + 1;
+    fDistance = fabs(fHarmFreq - pSpectralPeaks[iNextPeak].fFreq);
+    while (fDistance < fMinDistance)
+    {
+        iBestPeak = iNextPeak;
+        fMinDistance = fDistance;
+        iNextPeak++;
+        fDistance = fabs (fHarmFreq - pSpectralPeaks[iNextPeak].fFreq);
+    }
   
-	/* make sure the chosen peak is good */
-	fBestPeakFreq = pSpectralPeaks[iBestPeak].fFreq;
-	/* if best peak is not in the range */
-	if (fabs (fBestPeakFreq - fHarmFreq) > fMaxPeakDev)
-		return (-1);
+    /* make sure the chosen peak is good */
+    fBestPeakFreq = pSpectralPeaks[iBestPeak].fFreq;
+    /* if best peak is not in the range */
+    if (fabs (fBestPeakFreq - fHarmFreq) > fMaxPeakDev)
+        return (-1);
   
-	*pICurrentPeak = iBestPeak;
-	return (iBestPeak);
+    *pICurrentPeak = iBestPeak;
+    return (iBestPeak);
 }
 
 /*! \brief checks if peak is substantial
@@ -87,32 +87,32 @@ static int GetClosestPeak (int iPeakCandidate, int nHarm, SMS_Peak *pSpectralPea
 static int ComparePeak (sfloat fRefHarmMag, SMS_Peak *pSpectralPeaks, int nCand, 
                         sfloat fRefHarmMagDiffFromMax)
 {
-	int iPeak;
-	sfloat fMag = 0;
+    int iPeak;
+    sfloat fMag = 0;
   
-	/* if peak is very large take it as possible fundamental */
-	if (nCand == 0 &&	
-	    fRefHarmMag > 80.)
-		return (1);
+    /* if peak is very large take it as possible fundamental */
+    if (nCand == 0 &&   
+        fRefHarmMag > 80.)
+        return (1);
   
-	/* compare the peak with the first N_FUND_HARM peaks */
-	/* if too small forget it */
-	for (iPeak = 0; iPeak < N_FUND_HARM; iPeak++)
-		if (pSpectralPeaks[iPeak].fMag > 0 &&
-		    fRefHarmMag - pSpectralPeaks[iPeak].fMag < - fRefHarmMagDiffFromMax)
-			return (-1);
+    /* compare the peak with the first N_FUND_HARM peaks */
+    /* if too small forget it */
+    for (iPeak = 0; iPeak < N_FUND_HARM; iPeak++)
+        if (pSpectralPeaks[iPeak].fMag > 0 &&
+            fRefHarmMag - pSpectralPeaks[iPeak].fMag < - fRefHarmMagDiffFromMax)
+            return (-1);
   
-	/* if it is much bigger than rest take it */
-	for (iPeak = 0; iPeak < N_FUND_HARM; iPeak++)
-	{
-		fMag = pSpectralPeaks[iPeak].fMag;
-		if (fMag <= 0 ||
-		    ((fMag != fRefHarmMag) &&
-		    (nCand > 0) && (fRefHarmMag - fMag < 30.0)) ||
-		    ((nCand == 0) && (fRefHarmMag - fMag < 15.0)))
-			return (0);
-	}
-	return (1);
+    /* if it is much bigger than rest take it */
+    for (iPeak = 0; iPeak < N_FUND_HARM; iPeak++)
+    {
+        fMag = pSpectralPeaks[iPeak].fMag;
+        if (fMag <= 0 ||
+            ((fMag != fRefHarmMag) &&
+            (nCand > 0) && (fRefHarmMag - fMag < 30.0)) ||
+            ((nCand == 0) && (fRefHarmMag - fMag < 15.0)))
+            return (0);
+    }
+    return (1);
 }
 
 
@@ -125,17 +125,17 @@ static int ComparePeak (sfloat fRefHarmMag, SMS_Peak *pSpectralPeaks, int nCand,
  */
 int CheckIfHarmonic (sfloat fFundFreq, SMS_HarmCandidate *pCHarmonic, int nCand)
 {
-	int iPeak;
+    int iPeak;
   
-	/* go through all the candidates checking if they are fundamentals */
-	/*   of the peak to be considered */
-	for (iPeak = 0; iPeak < nCand; iPeak++)
-		if (fabs(floor((double)(fFundFreq 
-		                        / pCHarmonic[iPeak].fFreq) + .5) -
-		         (fFundFreq / pCHarmonic[iPeak].fFreq))
-		     <= .1)
-			return (1);
-	return (0);
+    /* go through all the candidates checking if they are fundamentals */
+    /*   of the peak to be considered */
+    for (iPeak = 0; iPeak < nCand; iPeak++)
+        if (fabs(floor((double)(fFundFreq 
+                                / pCHarmonic[iPeak].fFreq) + .5) -
+                 (fFundFreq / pCHarmonic[iPeak].fFreq))
+             <= .1)
+            return (1);
+    return (0);
 }
 
 
@@ -156,106 +156,100 @@ static int GoodCandidate (int iPeak, SMS_Peak *pSpectralPeaks, SMS_HarmCandidate
                           int nCand, int soundType, sfloat fRefFundamental,
                           sfloat minRefHarmMag, sfloat refHarmMagDiffFromMax, sfloat refHarmonic)
 {
-	sfloat fHarmFreq, fRefHarmFreq, fRefHarmMag, fTotalMag = 0, fTotalDev = 0,
-		   fTotalMaxMag = 0, fAvgMag = 0, fAvgDev = 0, fHarmRatio = 0;
-	int iHarm = 0, iChosenPeak = 0, iPeakComp, iCurrentPeak, nGoodHarm = 0, i;
+    sfloat fHarmFreq, fRefHarmFreq, fRefHarmMag, fTotalMag = 0, fTotalDev = 0,
+           fTotalMaxMag = 0, fAvgMag = 0, fAvgDev = 0, fHarmRatio = 0;
+    int iHarm = 0, iChosenPeak = 0, iPeakComp, iCurrentPeak, nGoodHarm = 0, i;
 
-	fRefHarmFreq = fHarmFreq = pSpectralPeaks[iPeak].fFreq;
+    fRefHarmFreq = fHarmFreq = pSpectralPeaks[iPeak].fFreq;
 
-	fTotalDev = 0;
-	fRefHarmMag = pSpectralPeaks[iPeak].fMag;
-	fTotalMag = fRefHarmMag;
+    fTotalDev = 0;
+    fRefHarmMag = pSpectralPeaks[iPeak].fMag;
+    fTotalMag = fRefHarmMag;
 
-	/* check if magnitude is big enough */
+    /* check if magnitude is big enough */
         /*! \bug sfloat comparison to 0 */
-	if (((fRefFundamental > 0) &&
+    if (((fRefFundamental > 0) &&
              (fRefHarmMag < minRefHarmMag - 10)) ||
             ((fRefFundamental <= 0) &&
              (fRefHarmMag < minRefHarmMag)))
-		return (-1);
-
-	/* check that it is not a harmonic of a previous candidate */
-	if (nCand > 0 &&
-		CheckIfHarmonic (fRefHarmFreq / refHarmonic, pCHarmonic,
-			             nCand))
-		return (-1);
-
-	/* check if it is very big or very small */
-	iPeakComp = ComparePeak (fRefHarmMag, pSpectralPeaks, nCand, refHarmMagDiffFromMax);
-	/* too small */
-	if (iPeakComp == -1)
-		return (-1);
-	/* very big */
-	else if (iPeakComp == 1)
-	{
-		pCHarmonic[nCand].fFreq = fRefHarmFreq;
-		pCHarmonic[nCand].fMag = fRefHarmMag;
-		pCHarmonic[nCand].fMagPerc = 1;
-		pCHarmonic[nCand].fFreqDev = 0;
-		pCHarmonic[nCand].fHarmRatio = 1;
-		return (-2);
-	}
-
-	/* get a weight on the peak by comparing its harmonic series   */
-	/* with the existing peaks */
-	if (soundType != SMS_SOUND_TYPE_NOTE)
-	{
-		fHarmFreq = fRefHarmFreq;
-		iCurrentPeak = iPeak;
-		nGoodHarm = 0;
-		for (iHarm = refHarmonic; iHarm < N_FUND_HARM; iHarm++)
-		{
-			fHarmFreq += fRefHarmFreq / refHarmonic;
-			iChosenPeak = GetClosestPeak(iPeak, iHarm, pSpectralPeaks,
-			                             &iCurrentPeak, refHarmonic);
-			if (iChosenPeak > 0)
-			{
-				fTotalDev +=
-					fabs(fHarmFreq - pSpectralPeaks[iChosenPeak].fFreq) /
-					fHarmFreq;
-				fTotalMag += pSpectralPeaks[iChosenPeak].fMag;
-				nGoodHarm++;
-			}
-		}
-
-		for (i = 0; i <= iCurrentPeak; i++)
-			fTotalMaxMag +=  pSpectralPeaks[i].fMag;
-
-		fAvgDev = fTotalDev / (iHarm + 1);
-		fAvgMag = fTotalMag / fTotalMaxMag;
-		fHarmRatio = (sfloat) nGoodHarm / (N_FUND_HARM - 1);
-
-	}
-
-/*         fprintf(stdout,  */
-/*                 "Harmonic Candidate: frq: %f mag: %f frqDev: %f magPrc: %f harmDev %f\n", */
-/*                 fRefHarmFreq, fRefHarmMag, fAvgDev, fAvgMag, fHarmRatio); */
-
-	if (soundType != SMS_SOUND_TYPE_NOTE)
-	{
-		if (fRefFundamental > 0)
-		{
-			if(fAvgDev > FREQ_DEV_THRES || fAvgMag < MAG_PERC_THRES - .1 ||
-			   fHarmRatio < HARM_RATIO_THRES - .1)
-				return (-1);
-		}
-		else
-		{
-			if (fAvgDev > FREQ_DEV_THRES || fAvgMag < MAG_PERC_THRES ||
-			    fHarmRatio < HARM_RATIO_THRES)
-				return (-1);
-		}
-
-
-
-	}
-	pCHarmonic[nCand].fFreq = fRefHarmFreq;
-	pCHarmonic[nCand].fMag = fRefHarmMag;
-	pCHarmonic[nCand].fMagPerc = fAvgMag;
-	pCHarmonic[nCand].fFreqDev = fAvgDev;
-	pCHarmonic[nCand].fHarmRatio = fHarmRatio;
-
-	return (1);
+        return (-1);
+
+    /* check that it is not a harmonic of a previous candidate */
+    if (nCand > 0 &&
+        CheckIfHarmonic (fRefHarmFreq / refHarmonic, pCHarmonic,
+                         nCand))
+        return (-1);
+
+    /* check if it is very big or very small */
+    iPeakComp = ComparePeak (fRefHarmMag, pSpectralPeaks, nCand, refHarmMagDiffFromMax);
+    /* too small */
+    if (iPeakComp == -1)
+        return (-1);
+    /* very big */
+    else if (iPeakComp == 1)
+    {
+        pCHarmonic[nCand].fFreq = fRefHarmFreq;
+        pCHarmonic[nCand].fMag = fRefHarmMag;
+        pCHarmonic[nCand].fMagPerc = 1;
+        pCHarmonic[nCand].fFreqDev = 0;
+        pCHarmonic[nCand].fHarmRatio = 1;
+        return (-2);
+    }
+
+    /* get a weight on the peak by comparing its harmonic series   */
+    /* with the existing peaks */
+    if (soundType != SMS_SOUND_TYPE_NOTE)
+    {
+        fHarmFreq = fRefHarmFreq;
+        iCurrentPeak = iPeak;
+        nGoodHarm = 0;
+        for (iHarm = refHarmonic; iHarm < N_FUND_HARM; iHarm++)
+        {
+            fHarmFreq += fRefHarmFreq / refHarmonic;
+            iChosenPeak = GetClosestPeak(iPeak, iHarm, pSpectralPeaks,
+                                         &iCurrentPeak, refHarmonic);
+            if (iChosenPeak > 0)
+            {
+                fTotalDev +=
+                    fabs(fHarmFreq - pSpectralPeaks[iChosenPeak].fFreq) /
+                    fHarmFreq;
+                fTotalMag += pSpectralPeaks[iChosenPeak].fMag;
+                nGoodHarm++;
+            }
+        }
+
+        for (i = 0; i <= iCurrentPeak; i++)
+            fTotalMaxMag +=  pSpectralPeaks[i].fMag;
+
+        fAvgDev = fTotalDev / (iHarm + 1);
+        fAvgMag = fTotalMag / fTotalMaxMag;
+        fHarmRatio = (sfloat) nGoodHarm / (N_FUND_HARM - 1);
+
+    }
+
+    if (soundType != SMS_SOUND_TYPE_NOTE)
+    {
+        if (fRefFundamental > 0)
+        {
+            if(fAvgDev > FREQ_DEV_THRES || fAvgMag < MAG_PERC_THRES - .1 ||
+               fHarmRatio < HARM_RATIO_THRES - .1)
+                return (-1);
+        }
+        else
+        {
+            if (fAvgDev > FREQ_DEV_THRES || fAvgMag < MAG_PERC_THRES ||
+                fHarmRatio < HARM_RATIO_THRES)
+                return (-1);
+        }
+    }
+
+    pCHarmonic[nCand].fFreq = fRefHarmFreq;
+    pCHarmonic[nCand].fMag = fRefHarmMag;
+    pCHarmonic[nCand].fMagPerc = fAvgMag;
+    pCHarmonic[nCand].fFreqDev = fAvgDev;
+    pCHarmonic[nCand].fHarmRatio = fHarmRatio;
+
+    return (1);
 }
 
 /*! \brief  choose the best fundamental out of all the candidates
@@ -269,49 +263,49 @@ static int GoodCandidate (int iPeak, SMS_Peak *pSpectralPeaks, SMS_HarmCandidate
 static int GetBestCandidate (SMS_HarmCandidate *pCHarmonic, 
                              int iRefHarmonic, int nGoodPeaks, sfloat fPrevFund)
 {
-	int iBestCandidate = 0, iPeak;
-	sfloat fBestFreq, fHarmFreq, fDev;
+    int iBestCandidate = 0, iPeak;
+    sfloat fBestFreq, fHarmFreq, fDev;
   
-	/* if a fundamental existed in previous frame take the closest candidate */
-	if (fPrevFund > 0)
-		for (iPeak = 1; iPeak < nGoodPeaks; iPeak++)
-		{
-			if (fabs (fPrevFund - pCHarmonic[iPeak].fFreq / iRefHarmonic) <
-			    fabs(fPrevFund - pCHarmonic[iBestCandidate].fFreq / iRefHarmonic))
-				iBestCandidate = iPeak;
-		}
-	else
-		/* try to find the best candidate */
-		for (iPeak = 1; iPeak < nGoodPeaks; iPeak++)
-		{
-			fBestFreq = pCHarmonic[iBestCandidate].fFreq / iRefHarmonic;
-			fHarmFreq = fBestFreq * 
-				floor (.5 + 
-				       (pCHarmonic[iPeak].fFreq / iRefHarmonic) / 
-			           fBestFreq);
-			fDev = fabs (fHarmFreq - (pCHarmonic[iPeak].fFreq / 
-			             iRefHarmonic)) / fHarmFreq;
-	
-			/* if candidate is far from harmonic from best candidate and */
-			/* bigger, take it */
-			if (fDev > .2 &&
-			    pCHarmonic[iPeak].fMag >
-			    pCHarmonic[iBestCandidate].fMag)
-				iBestCandidate = iPeak;
-			/* if frequency deviation is much smaller, take it */
-			else if (pCHarmonic[iPeak].fFreqDev < 
-				       .2 * pCHarmonic[iBestCandidate].fFreqDev)
-				iBestCandidate = iPeak;
-			/* if freq. deviation is smaller and bigger amplitude, take it */
-			else if (pCHarmonic[iPeak].fFreqDev < 
-		         pCHarmonic[iBestCandidate].fFreqDev &&
-		         pCHarmonic[iPeak].fMagPerc >
-		         pCHarmonic[iBestCandidate].fMagPerc &&
-		         pCHarmonic[iPeak].fMag >
-		         pCHarmonic[iBestCandidate].fMag)
-				iBestCandidate = iPeak;
-		}
-	return (iBestCandidate);
+    /* if a fundamental existed in previous frame take the closest candidate */
+    if (fPrevFund > 0)
+        for (iPeak = 1; iPeak < nGoodPeaks; iPeak++)
+        {
+            if (fabs (fPrevFund - pCHarmonic[iPeak].fFreq / iRefHarmonic) <
+                fabs(fPrevFund - pCHarmonic[iBestCandidate].fFreq / iRefHarmonic))
+                iBestCandidate = iPeak;
+        }
+    else
+        /* try to find the best candidate */
+        for (iPeak = 1; iPeak < nGoodPeaks; iPeak++)
+        {
+            fBestFreq = pCHarmonic[iBestCandidate].fFreq / iRefHarmonic;
+            fHarmFreq = fBestFreq * 
+                floor (.5 + 
+                       (pCHarmonic[iPeak].fFreq / iRefHarmonic) / 
+                       fBestFreq);
+            fDev = fabs (fHarmFreq - (pCHarmonic[iPeak].fFreq / 
+                         iRefHarmonic)) / fHarmFreq;
+    
+            /* if candidate is far from harmonic from best candidate and */
+            /* bigger, take it */
+            if (fDev > .2 &&
+                pCHarmonic[iPeak].fMag >
+                pCHarmonic[iBestCandidate].fMag)
+                iBestCandidate = iPeak;
+            /* if frequency deviation is much smaller, take it */
+            else if (pCHarmonic[iPeak].fFreqDev < 
+                       .2 * pCHarmonic[iBestCandidate].fFreqDev)
+                iBestCandidate = iPeak;
+            /* if freq. deviation is smaller and bigger amplitude, take it */
+            else if (pCHarmonic[iPeak].fFreqDev < 
+                 pCHarmonic[iBestCandidate].fFreqDev &&
+                 pCHarmonic[iPeak].fMagPerc >
+                 pCHarmonic[iBestCandidate].fMagPerc &&
+                 pCHarmonic[iPeak].fMag >
+                 pCHarmonic[iBestCandidate].fMag)
+                iBestCandidate = iPeak;
+        }
+    return (iBestCandidate);
 }
 
 /*! \brief  main harmonic detection function
@@ -328,65 +322,63 @@ static int GetBestCandidate (SMS_HarmCandidate *pCHarmonic,
  * This really should only be for sms_analyzeFrame
  */
 sfloat sms_harmDetection(int numPeaks, SMS_Peak* spectralPeaks, sfloat refFundamental,
-					     sfloat refHarmonic, sfloat lowestFreq, sfloat highestFreq,
-					     int soundType, sfloat minRefHarmMag, sfloat refHarmMagDiffFromMax)
+                         sfloat refHarmonic, sfloat lowestFreq, sfloat highestFreq,
+                         int soundType, sfloat minRefHarmMag, sfloat refHarmMagDiffFromMax)
 {
-	int iPeak = -1, nGoodPeaks = 0, iCandidate, iBestCandidate;
-	sfloat peakFreq=0;
-	SMS_HarmCandidate pCHarmonic[N_HARM_PEAKS];
-
-	/* find all possible candidates to use as harmonic reference */
-	lowestFreq = lowestFreq * refHarmonic;
-	highestFreq = highestFreq * refHarmonic;
-
-	while(peakFreq < highestFreq)
-	{
-		iPeak++;
-		peakFreq = spectralPeaks[iPeak].fFreq;
-		if (peakFreq > highestFreq)
-			break;
-
-		/* no more peaks */
-		if (spectralPeaks[iPeak].fMag <= 0) /*!< \bug sfloat comparison to zero */
-			break;
-
-		/* peak too low */
-		if (peakFreq < lowestFreq)
-			continue;
-
-		/* if previous fundamental look only around it */
-		if (refFundamental > 0 &&
-			fabs(peakFreq - (refHarmonic * refFundamental)) / refFundamental > .5)
-			continue;
-
-		iCandidate = GoodCandidate(iPeak, spectralPeaks, pCHarmonic,
-				                   nGoodPeaks, soundType, refFundamental,
-		                           minRefHarmMag, refHarmMagDiffFromMax, refHarmonic);
-
-		/* good candiate found */
-		if (iCandidate == 1)
-			nGoodPeaks++;
-
-		/* a perfect candiate found */
-		else
-		if (iCandidate == -2)
-		{
-			nGoodPeaks++;
-			break;
-		}
-	}
-
-	/* if no candidate for fundamental, continue */
-	if (nGoodPeaks == 0)
-		return -1;
-	/* if only 1 candidate for fundamental take it */
-	else
-		if (nGoodPeaks == 1)
-			return pCHarmonic[0].fFreq / refHarmonic;
-	/* if more than one candidate choose the best one */
-	else
-	{
-		iBestCandidate = GetBestCandidate (pCHarmonic, refHarmonic, nGoodPeaks, refFundamental);
-		return pCHarmonic[iBestCandidate].fFreq / refHarmonic;
-	}
+    int iPeak = -1, nGoodPeaks = 0, iCandidate, iBestCandidate;
+    sfloat peakFreq=0;
+    SMS_HarmCandidate pCHarmonic[N_HARM_PEAKS];
+
+    /* find all possible candidates to use as harmonic reference */
+    lowestFreq = lowestFreq * refHarmonic;
+    highestFreq = highestFreq * refHarmonic;
+
+    while((peakFreq < highestFreq) && (iPeak < numPeaks))
+    {
+        iPeak++;
+        peakFreq = spectralPeaks[iPeak].fFreq;
+        if(peakFreq > highestFreq)
+            break;
+
+        /* no more peaks */
+        if(spectralPeaks[iPeak].fMag <= 0) /*!< \bug sfloat comparison to zero */
+            break;
+
+        /* peak too low */
+        if(peakFreq < lowestFreq)
+            continue;
+
+        /* if previous fundamental look only around it */
+        if(refFundamental > 0 &&
+           fabs(peakFreq - (refHarmonic * refFundamental)) / refFundamental > .5)
+            continue;
+
+        iCandidate = GoodCandidate(iPeak, spectralPeaks, pCHarmonic,
+                                   nGoodPeaks, soundType, refFundamental,
+                                   minRefHarmMag, refHarmMagDiffFromMax, refHarmonic);
+
+        /* good candiate found */
+        if(iCandidate == 1)
+            nGoodPeaks++;
+
+        /* a perfect candiate found */
+        else if(iCandidate == -2)
+        {
+            nGoodPeaks++;
+            break;
+        }
+    }
+
+    /* if no candidate for fundamental, continue */
+    if(nGoodPeaks == 0)
+        return -1;
+    /* if only 1 candidate for fundamental take it */
+    else if(nGoodPeaks == 1)
+        return pCHarmonic[0].fFreq / refHarmonic;
+    /* if more than one candidate choose the best one */
+    else
+    {
+        iBestCandidate = GetBestCandidate(pCHarmonic, refHarmonic, nGoodPeaks, refFundamental);
+        return pCHarmonic[iBestCandidate].fFreq / refHarmonic;
+    }
 }