comparison dsp/onsets/DetectionFunction.cpp @ 505:930b5b0f707d

Merge branch 'codestyle-and-tidy'

 
 //////////////////////////////////////////////////////////////////////
 // Construction/Destruction
 //////////////////////////////////////////////////////////////////////
 
-DetectionFunction::DetectionFunction( DFConfig Config ) :
+DetectionFunction::DetectionFunction( DFConfig config ) :
     m_window(0)
 {
     m_magHistory = NULL;
     m_phaseHistory = NULL;
     m_phaseHistoryOld = NULL;
     m_magPeaks = NULL;
 
-    initialise( Config );
+    initialise( config );
 }
 
 DetectionFunction::~DetectionFunction()
 {
     deInitialise();

     if (m_whitenRelaxCoeff < 0) m_whitenRelaxCoeff = 0.9997;
     if (m_whitenFloor < 0) m_whitenFloor = 0.01;
 
     m_magHistory = new double[ m_halfLength ];
     memset(m_magHistory,0, m_halfLength*sizeof(double));
-		
+                
     m_phaseHistory = new double[ m_halfLength ];
     memset(m_phaseHistory,0, m_halfLength*sizeof(double));
 
     m_phaseHistoryOld = new double[ m_halfLength ];
     memset(m_phaseHistoryOld,0, m_halfLength*sizeof(double));

     return runDF();
 }
 
 void DetectionFunction::whiten()
 {
-    for (unsigned int i = 0; i < m_halfLength; ++i) {
+    for (int i = 0; i < m_halfLength; ++i) {
         double m = m_magnitude[i];
         if (m < m_magPeaks[i]) {
             m = m + (m_magPeaks[i] - m) * m_whitenRelaxCoeff;
         }
         if (m < m_whitenFloor) m = m_whitenFloor;

     double retVal = 0;
 
     switch( m_DFType )
     {
     case DF_HFC:
-	retVal = HFC( m_halfLength, m_magnitude);
-	break;
-	
+        retVal = HFC( m_halfLength, m_magnitude);
+        break;
+        
     case DF_SPECDIFF:
-	retVal = specDiff( m_halfLength, m_magnitude);
-	break;
-	
+        retVal = specDiff( m_halfLength, m_magnitude);
+        break;
+        
     case DF_PHASEDEV:
         // Using the instantaneous phases here actually provides the
         // same results (for these calculations) as if we had used
         // unwrapped phases, but without the possible accumulation of
         // phase error over time
-	retVal = phaseDev( m_halfLength, m_thetaAngle);
-	break;
-	
+        retVal = phaseDev( m_halfLength, m_thetaAngle);
+        break;
+        
     case DF_COMPLEXSD:
-	retVal = complexSD( m_halfLength, m_magnitude, m_thetaAngle);
-	break;
+        retVal = complexSD( m_halfLength, m_magnitude, m_thetaAngle);
+        break;
 
     case DF_BROADBAND:
         retVal = broadband( m_halfLength, m_magnitude);
         break;
     }
-	
+        
     return retVal;
 }
 
-double DetectionFunction::HFC(unsigned int length, double *src)
-{
-    unsigned int i;
-    double val = 0;
-
-    for( i = 0; i < length; i++)
-    {
-	val += src[ i ] * ( i + 1);
-    }
-    return val;
-}
-
-double DetectionFunction::specDiff(unsigned int length, double *src)
-{
-    unsigned int i;
+double DetectionFunction::HFC(int length, double *src)
+{
+    double val = 0;
+    for (int i = 0; i < length; i++) {
+        val += src[ i ] * ( i + 1);
+    }
+    return val;
+}
+
+double DetectionFunction::specDiff(int length, double *src)
+{
     double val = 0.0;
     double temp = 0.0;
     double diff = 0.0;
 
-    for( i = 0; i < length; i++)
-    {
-	temp = fabs( (src[ i ] * src[ i ]) - (m_magHistory[ i ] * m_magHistory[ i ]) );
-		
-	diff= sqrt(temp);
+    for (int i = 0; i < length; i++) {
+        
+        temp = fabs( (src[ i ] * src[ i ]) - (m_magHistory[ i ] * m_magHistory[ i ]) );
+                
+        diff= sqrt(temp);
 
         // (See note in phaseDev below.)
 
         val += diff;
 
-	m_magHistory[ i ] = src[ i ];
-    }
-
-    return val;
-}
-
-
-double DetectionFunction::phaseDev(unsigned int length, double *srcPhase)
-{
-    unsigned int i;
+        m_magHistory[ i ] = src[ i ];
+    }
+
+    return val;
+}
+
+
+double DetectionFunction::phaseDev(int length, double *srcPhase)
+{
     double tmpPhase = 0;
     double tmpVal = 0;
     double val = 0;
 
     double dev = 0;
 
-    for( i = 0; i < length; i++)
-    {
-	tmpPhase = (srcPhase[ i ]- 2*m_phaseHistory[ i ]+m_phaseHistoryOld[ i ]);
-	dev = MathUtilities::princarg( tmpPhase );
+    for (int i = 0; i < length; i++) {
+        tmpPhase = (srcPhase[ i ]- 2*m_phaseHistory[ i ]+m_phaseHistoryOld[ i ]);
+        dev = MathUtilities::princarg( tmpPhase );
 
         // A previous version of this code only counted the value here
         // if the magnitude exceeded 0.1.  My impression is that
         // doesn't greatly improve the results for "loud" music (so
         // long as the peak picker is reasonably sophisticated), but
         // does significantly damage its ability to work with quieter
         // music, so I'm removing it and counting the result always.
         // Same goes for the spectral difference measure above.
-		
+                
         tmpVal  = fabs(dev);
         val += tmpVal ;
 
-	m_phaseHistoryOld[ i ] = m_phaseHistory[ i ] ;
-	m_phaseHistory[ i ] = srcPhase[ i ];
-    }
-	
-    return val;
-}
-
-
-double DetectionFunction::complexSD(unsigned int length, double *srcMagnitude, double *srcPhase)
-{
-    unsigned int i;
+        m_phaseHistoryOld[ i ] = m_phaseHistory[ i ] ;
+        m_phaseHistory[ i ] = srcPhase[ i ];
+    }
+        
+    return val;
+}
+
+
+double DetectionFunction::complexSD(int length, double *srcMagnitude, double *srcPhase)
+{
     double val = 0;
     double tmpPhase = 0;
     double tmpReal = 0;
     double tmpImag = 0;
    
     double dev = 0;
     ComplexData meas = ComplexData( 0, 0 );
     ComplexData j = ComplexData( 0, 1 );
 
-    for( i = 0; i < length; i++)
-    {
-	tmpPhase = (srcPhase[ i ]- 2*m_phaseHistory[ i ]+m_phaseHistoryOld[ i ]);
-	dev= MathUtilities::princarg( tmpPhase );
-		
-	meas = m_magHistory[i] - ( srcMagnitude[ i ] * exp( j * dev) );
-
-	tmpReal = real( meas );
-	tmpImag = imag( meas );
-
-	val += sqrt( (tmpReal * tmpReal) + (tmpImag * tmpImag) );
-		
-	m_phaseHistoryOld[ i ] = m_phaseHistory[ i ] ;
-	m_phaseHistory[ i ] = srcPhase[ i ];
-	m_magHistory[ i ] = srcMagnitude[ i ];
-    }
-
-    return val;
-}
-
-double DetectionFunction::broadband(unsigned int length, double *src)
-{
-    double val = 0;
-    for (unsigned int i = 0; i < length; ++i) {
+    for (int i = 0; i < length; i++) {
+        
+        tmpPhase = (srcPhase[ i ]- 2*m_phaseHistory[ i ]+m_phaseHistoryOld[ i ]);
+        dev= MathUtilities::princarg( tmpPhase );
+                
+        meas = m_magHistory[i] - ( srcMagnitude[ i ] * exp( j * dev) );
+
+        tmpReal = real( meas );
+        tmpImag = imag( meas );
+
+        val += sqrt( (tmpReal * tmpReal) + (tmpImag * tmpImag) );
+                
+        m_phaseHistoryOld[ i ] = m_phaseHistory[ i ] ;
+        m_phaseHistory[ i ] = srcPhase[ i ];
+        m_magHistory[ i ] = srcMagnitude[ i ];
+    }
+
+    return val;
+}
+
+double DetectionFunction::broadband(int length, double *src)
+{
+    double val = 0;
+    for (int i = 0; i < length; ++i) {
         double sqrmag = src[i] * src[i];
         if (m_magHistory[i] > 0.0) {
             double diff = 10.0 * log10(sqrmag / m_magHistory[i]);
             if (diff > m_dbRise) val = val + 1;
         }