comparison dsp/onsets/DetectionFunction.cpp @ 344:5eb9c2387108

Phase vocoder: provide time-domain and freq-domain inputs separately; update tests etc

     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_stepSize);
 
-    m_DFWindowedFrame = new double[ m_dataLength ];
     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_unwrapped);
+    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();
 }

 
 	m_phaseHistoryOld[ i ] = m_phaseHistory[ i ] ;
 	m_phaseHistory[ i ] = srcPhase[ i ];
     }
 	
-	
     return val;
 }
 
 
 double DetectionFunction::complexSD(unsigned int length, double *srcMagnitude, double *srcPhase)