comparison dsp/onsets/DetectionFunction.cpp @ 347:e3dedded9c4d

Merge from pvoc branch

 
 
 void DetectionFunction::initialise( DFConfig Config )
 {
     m_dataLength = Config.frameLength;
-    m_halfLength = m_dataLength/2;
+    m_halfLength = m_dataLength/2 + 1;
 
     m_DFType = Config.DFType;
     m_stepSize = Config.stepSize;
 
     m_whiten = Config.adaptiveWhitening;

     memset(m_phaseHistoryOld,0, m_halfLength*sizeof(double));
 
     m_magPeaks = new double[ m_halfLength ];
     memset(m_magPeaks,0, m_halfLength*sizeof(double));
 
-    // See note in process(const double *) below
+    // See note in processTimeDomain below
     int actualLength = MathUtilities::previousPowerOfTwo(m_dataLength);
-    m_phaseVoc = new PhaseVocoder(actualLength);
-
-    m_DFWindowedFrame = new double[ m_dataLength ];
+    m_phaseVoc = new PhaseVocoder(actualLength, m_stepSize);
+
     m_magnitude = new double[ m_halfLength ];
     m_thetaAngle = new double[ m_halfLength ];
+    m_unwrapped = new double[ m_halfLength ];
 
     m_window = new Window<double>(HanningWindow, m_dataLength);
+    m_windowed = new double[ m_dataLength ];
 }
 
 void DetectionFunction::deInitialise()
 {
     delete [] m_magHistory ;

     delete [] m_phaseHistoryOld ;
     delete [] m_magPeaks ;
 
     delete m_phaseVoc;
 
-    delete [] m_DFWindowedFrame;
     delete [] m_magnitude;
     delete [] m_thetaAngle;
+    delete [] m_windowed;
+    delete [] m_unwrapped;
 
     delete m_window;
 }
 
-double DetectionFunction::process( const double *TDomain )
-{
-    m_window->cut( TDomain, m_DFWindowedFrame );
+double DetectionFunction::processTimeDomain(const double *samples)
+{
+    m_window->cut(samples, m_windowed);
 
     // Our own FFT implementation supports power-of-two sizes only.
     // If we have to use this implementation (as opposed to the
     // version of process() below that operates on frequency domain
     // data directly), we will have to use the next smallest power of

             m_magnitude[i] = 0;
             m_thetaAngle[0] = 0;
         }
     }
 
-    m_phaseVoc->process(m_DFWindowedFrame, m_magnitude, m_thetaAngle);
+    m_phaseVoc->processTimeDomain(m_windowed, 
+                                  m_magnitude, m_thetaAngle, m_unwrapped);
 
     if (m_whiten) whiten();
 
     return runDF();
 }
 
-double DetectionFunction::process( const double *magnitudes, const double *phases )
-{
-    for (size_t i = 0; i < m_halfLength; ++i) {
-        m_magnitude[i] = magnitudes[i];
-        m_thetaAngle[i] = phases[i];
-    }
+double DetectionFunction::processFrequencyDomain(const double *reals,
+                                                 const double *imags)
+{
+    m_phaseVoc->processFrequencyDomain(reals, imags,
+                                       m_magnitude, m_thetaAngle, m_unwrapped);
 
     if (m_whiten) whiten();
 
     return runDF();
 }

     case DF_SPECDIFF:
 	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;
 	
     case DF_COMPLEXSD:
 	retVal = complexSD( m_halfLength, m_magnitude, m_thetaAngle);

         val += tmpVal ;
 
 	m_phaseHistoryOld[ i ] = m_phaseHistory[ i ] ;
 	m_phaseHistory[ i ] = srcPhase[ i ];
     }
-	
 	
     return val;
 }