comparison src/BTrack.cpp @ 93:4aa362058011

Added Kiss FFT option

 
 //=======================================================================
 BTrack::BTrack()
  :  odf (512, 1024, ComplexSpectralDifferenceHWR, HanningWindow)
 {
-    initialise(512, 1024);
+    initialise (512, 1024);
 }
 
 //=======================================================================
 BTrack::BTrack (int hopSize_)
  :  odf(hopSize_, 2*hopSize_, ComplexSpectralDifferenceHWR, HanningWindow)
 {	
-    initialise(hopSize_, 2*hopSize_);
+    initialise (hopSize_, 2*hopSize_);
 }
 
 //=======================================================================
 BTrack::BTrack (int hopSize_, int frameSize_)
  : odf (hopSize_, frameSize_, ComplexSpectralDifferenceHWR, HanningWindow)

 }
 
 //=======================================================================
 BTrack::~BTrack()
 {
+#ifdef USE_FFTW
     // destroy fft plan
     fftw_destroy_plan (acfForwardFFT);
     fftw_destroy_plan (acfBackwardFFT);
     fftw_free (complexIn);
     fftw_free (complexOut);
+#endif
+    
+#ifdef USE_KISS_FFT
+    free (cfgForwards);
+    free (cfgBackwards);
+    delete [] fftIn;
+    delete [] fftOut;
+#endif
 }
 
 //=======================================================================
 double BTrack::getBeatTimeInSeconds (long frameNumber, int hopSize, int fs)
 {

     
     
     // Set up FFT for calculating the auto-correlation function
     FFTLengthForACFCalculation = 1024;
     
+#ifdef USE_FFTW
     complexIn = (fftw_complex*) fftw_malloc (sizeof(fftw_complex) * FFTLengthForACFCalculation);		// complex array to hold fft data
     complexOut = (fftw_complex*) fftw_malloc (sizeof(fftw_complex) * FFTLengthForACFCalculation);	// complex array to hold fft data
     
     acfForwardFFT = fftw_plan_dft_1d (FFTLengthForACFCalculation, complexIn, complexOut, FFTW_FORWARD, FFTW_ESTIMATE);	// FFT plan initialisation
     acfBackwardFFT = fftw_plan_dft_1d (FFTLengthForACFCalculation, complexOut, complexIn, FFTW_BACKWARD, FFTW_ESTIMATE);	// FFT plan initialisation
+#endif
+    
+#ifdef USE_KISS_FFT
+    fftIn = new kiss_fft_cpx[FFTLengthForACFCalculation];
+    fftOut = new kiss_fft_cpx[FFTLengthForACFCalculation];
+    cfgForwards = kiss_fft_alloc (FFTLengthForACFCalculation, 0, 0, 0);
+    cfgBackwards = kiss_fft_alloc (FFTLengthForACFCalculation, 1, 0, 0);
+#endif
 }
 
 //=======================================================================
 void BTrack::setHopSize (int hopSize_)
 {	

 		estimatedTempo = 60.0/((((double) hopSize) / 44100.0) * beatPeriod);
 	}
 }
 
 //=======================================================================
-void BTrack::adaptiveThreshold (double*x, int N)
+void BTrack::adaptiveThreshold (double* x, int N)
 {
 	int i = 0;
 	int k,t = 0;
 	double x_thresh[N];
 	

 //=======================================================================
 void BTrack::calculateBalancedACF (double* onsetDetectionFunction)
 {
     int onsetDetectionFunctionLength = 512;
     
+#ifdef USE_FFTW
     // copy into complex array and zero pad
     for (int i = 0;i < FFTLengthForACFCalculation;i++)
     {
         if (i < onsetDetectionFunctionLength)
         {

     }
     
     // perform the ifft
     fftw_execute (acfBackwardFFT);
     
+#endif
+    
+#ifdef USE_KISS_FFT
+    // copy into complex array and zero pad
+    for (int i = 0;i < FFTLengthForACFCalculation;i++)
+    {
+        if (i < onsetDetectionFunctionLength)
+        {
+            fftIn[i].r = onsetDetectionFunction[i];
+            fftIn[i].i = 0.0;
+        }
+        else
+        {
+            fftIn[i].r = 0.0;
+            fftIn[i].i = 0.0;
+        }
+    }
+    
+    // execute kiss fft
+    kiss_fft (cfgForwards, fftIn, fftOut);
+    
+    // multiply by complex conjugate
+    for (int i = 0;i < FFTLengthForACFCalculation;i++)
+    {
+        fftOut[i].r = fftOut[i].r * fftOut[i].r + fftOut[i].i * fftOut[i].i;
+        fftOut[i].i = 0.0;
+    }
+    
+    // perform the ifft
+    kiss_fft (cfgBackwards, fftOut, fftIn);
+    
+#endif
     
     double lag = 512;
     
     for (int i = 0; i < 512; i++)
     {
+#ifdef USE_FFTW
         // calculate absolute value of result
         double absValue = sqrt (complexIn[i][0]*complexIn[i][0] + complexIn[i][1]*complexIn[i][1]);
+#endif
         
+#ifdef USE_KISS_FFT
+        // calculate absolute value of result
+        double absValue = sqrt (fftIn[i].r * fftIn[i].r + fftIn[i].i * fftIn[i].i);
+#endif
         // divide by inverse lad to deal with scale bias towards small lags
         acf[i] = absValue / lag;
         
         // this division by 1024 is technically unnecessary but it ensures the algorithm produces
         // exactly the same ACF output as the old time domain implementation. The time difference is

         return 0;
     }
 }
 
 //=======================================================================
-void BTrack::normaliseArray(double* array, int N)
+void BTrack::normaliseArray (double* array, int N)
 {
 	double sum = 0;
 	
 	for (int i = 0; i < N; i++)
 	{

 	
 	double w1[winsize];
 	double v = -2*beatPeriod;
 	double wcumscore;
 	
-	
 	// create window
 	for (int i = 0; i < winsize; i++)
 	{
-		w1[i] = exp((-1*pow (tightness * log (-v / beatPeriod), 2)) / 2);
+		w1[i] = exp((-1 * pow (tightness * log (-v / beatPeriod), 2)) / 2);
 		v = v+1;
 	}	
 	
 	// calculate new cumulative score value
 	max = 0;

 				max = wcumscore;
 			}
 		n++;
 	}
 	
-		
-    latestCumulativeScoreValue = ((1-alpha)*odfSample) + (alpha*max);
+    latestCumulativeScoreValue = ((1 - alpha) * odfSample) + (alpha * max);
     
     cumulativeScore.addSampleToEnd (latestCumulativeScoreValue);
 }
 
 //=======================================================================
 void BTrack::predictBeat()
 {	 
 	int windowSize = (int) beatPeriod;
 	double futureCumulativeScore[onsetDFBufferSize + windowSize];
 	double w2[windowSize];
+    
 	// copy cumscore to first part of fcumscore
 	for (int i = 0;i < onsetDFBufferSize;i++)
 	{
 		futureCumulativeScore[i] = cumulativeScore[i];
 	}

 	for (int i = 0;i < pastwinsize;i++)
 	{
 		w1[i] = exp((-1*pow(tightness*log(-v/beatPeriod),2))/2);
 		v = v+1;
 	}
-
-	
 
 	// calculate future cumulative score
 	double max;
 	int n;
 	double wcumscore;

 		}
 		
 		futureCumulativeScore[i] = max;
 	}
 	
-	
 	// predict beat
 	max = 0;
 	n = 0;
 	
 	for (int i = onsetDFBufferSize; i < (onsetDFBufferSize + windowSize); i++)