comparison src/BTrack.cpp @ 20:baf35f208814 develop

Replaced switch statements in OnsetDetectionFunction with enums. Renamed lots of functions so that they have better names, in camel case. Added some unit tests for initialisation of BTrack.

 #include <algorithm>
 #include "BTrack.h"
 #include "samplerate.h"
 
 //=======================================================================
-BTrack::BTrack() : odf(512,1024,6,1)
+BTrack::BTrack() : odf(512,1024,ComplexSpectralDifferenceHWR,HanningWindow)
 {
     initialise(512, 1024);
 }
 
 //=======================================================================
-BTrack::BTrack(int hopSize) : odf(hopSize,2*hopSize,6,1)
+BTrack::BTrack(int hopSize_) : odf(hopSize_,2*hopSize_,ComplexSpectralDifferenceHWR,HanningWindow)
 {	
-    initialise(hopSize, 2*hopSize);
-}
-
-//=======================================================================
-BTrack::BTrack(int hopSize,int frameSize) : odf(hopSize,frameSize,6,1)
-{
-    initialise(hopSize, frameSize);
+    initialise(hopSize_, 2*hopSize_);
+}
+
+//=======================================================================
+BTrack::BTrack(int hopSize_,int frameSize_) : odf(hopSize_,frameSize_,ComplexSpectralDifferenceHWR,HanningWindow)
+{
+    initialise(hopSize_, frameSize_);
 }
 
 //=======================================================================
 double BTrack::getBeatTimeInSeconds(long frameNumber,int hopSize,int fs)
 {

 }
 
 
 
 //=======================================================================
-void BTrack::initialise(int hopSize, int frameSize)
+void BTrack::initialise(int hopSize_, int frameSize_)
 {
     double rayparam = 43;
 	double pi = 3.14159265;
 	
 	

 	p_fact = 60.*44100./512.;
 	
 	m0 = 10;
 	beat = -1;
 	
-	playbeat = 0;
+	beatDueInFrame = false;
 	
 	
 	
 	
 	// create rayleigh weighting vector

 	
 	// tempo is not fixed
 	tempofix = 0;
     
     // initialise algorithm given the hopsize
-    setHopSize(hopSize);
-}
-
-//=======================================================================
-void BTrack :: setHopSize(int hopSize)
+    setHopSize(hopSize_);
+}
+
+//=======================================================================
+void BTrack::setHopSize(int hopSize_)
 {	
-	framesize = hopSize;
+	hopSize = hopSize_;
 	dfbuffer_size = (512*512)/hopSize;		// calculate df buffer size
 	
-	bperiod = round(60/((((double) hopSize)/44100)*tempo));
+	beatPeriod = round(60/((((double) hopSize)/44100)*tempo));
 	
 	dfbuffer = new double[dfbuffer_size];	// create df_buffer
 	cumscore = new double[dfbuffer_size];	// create cumscore
 	
 	

 	{
 		dfbuffer[i] = 0;
 		cumscore[i] = 0;
 		
 		
-		if ((i %  ((int) round(bperiod))) == 0)
+		if ((i %  ((int) round(beatPeriod))) == 0)
 		{
 			dfbuffer[i] = 1;
 		}
 	}
+}
+
+//=======================================================================
+bool BTrack::beatDueInCurrentFrame()
+{
+    return beatDueInFrame;
+}
+
+//=======================================================================
+int BTrack::getHopSize()
+{
+    return hopSize;
 }
 
 //=======================================================================
 void BTrack::processAudioFrame(double *frame)
 {

     // to zero. this is to avoid problems further down the line
     newSample = newSample + 0.0001;
     
 	m0--;
 	beat--;
-	playbeat = 0;
+	beatDueInFrame = false;
 	
 	// move all samples back one step
 	for (int i=0;i < (dfbuffer_size-1);i++)
 	{
 		dfbuffer[i] = dfbuffer[i+1];

 	
 	// add new sample at the end
 	dfbuffer[dfbuffer_size-1] = newSample;
 	
 	// update cumulative score
-	updatecumscore(newSample);
+	updateCumulativeScore(newSample);
 	
 	// if we are halfway between beats
 	if (m0 == 0)
 	{
-		predictbeat();
+		predictBeat();
 	}
 	
 	// if we are at a beat
 	if (beat == 0)
 	{
-		playbeat = 1;	// indicate a beat should be output
+		beatDueInFrame = true;	// indicate a beat should be output
 		
 		// recalculate the tempo
-		dfconvert();	
-		calcTempo();
-	}
-}
-
-//=======================================================================
-void BTrack :: settempo(double tempo)
+		resampleOnsetDetectionFunction();
+		calculateTempo();
+	}
+}
+
+//=======================================================================
+void BTrack::setTempo(double tempo)
 {	 
 	
 	/////////// TEMPO INDICATION RESET //////////////////
 	
 	// firstly make sure tempo is between 80 and 160 bpm..

 	
 	
 	/////////// CUMULATIVE SCORE ARTIFICAL TEMPO UPDATE //////////////////
 	
 	// calculate new beat period
-	int new_bperiod = (int) round(60/((((double) framesize)/44100)*tempo));
+	int new_bperiod = (int) round(60/((((double) hopSize)/44100)*tempo));
 	
 	int bcounter = 1;
 	// initialise df_buffer to zeros
 	for (int i = (dfbuffer_size-1);i >= 0;i--)
 	{

 	// offbeat is half of new beat period away
 	m0 = (int) round(((double) new_bperiod)/2);
 }
 
 //=======================================================================
-void BTrack :: fixtempo(double tempo)
+void BTrack::fixTempo(double tempo)
 {	
 	// firstly make sure tempo is between 80 and 160 bpm..
 	while (tempo > 160)
 	{
 		tempo = tempo/2;

 	// set the tempo fix flag
 	tempofix = 1;	
 }
 
 //=======================================================================
-void BTrack :: unfixtempo()
+void BTrack::doNotFixTempo()
 {	
 	// set the tempo fix flag
 	tempofix = 0;	
 }
 
 //=======================================================================
-void BTrack :: dfconvert()
+void BTrack::resampleOnsetDetectionFunction()
 {
 	float output[512];
     float input[dfbuffer_size];
     
     for (int i = 0;i < dfbuffer_size;i++)

 		df512[i] = (double) src_data.data_out[i];
 	}
 }
 
 //=======================================================================
-void BTrack :: calcTempo()
+void BTrack::calculateTempo()
 {
 	// adaptive threshold on input
-	adapt_thresh(df512,512);
+	adaptiveThreshold(df512,512);
 		
 	// calculate auto-correlation function of detection function
-	acf_bal(df512);
+	calculateBalancedACF(df512);
 	
 	// calculate output of comb filterbank
-	getrcfoutput();
+	calculateOutputOfCombFilterBank();
 	
 	
 	// adaptive threshold on rcf
-	adapt_thresh(rcf,128);
+	adaptiveThreshold(rcf,128);
 
 	
 	int t_index;
 	int t_index2;
 	// calculate tempo observation vector from bperiod observation vector

 		
 		delta[j] = maxval*t_obs[j];
 	}
 	
 
-	normalise(delta,41);
+	normaliseArray(delta,41);
 	
 	maxind = -1;
 	maxval = -1;
 	
 	for (int j=0;j < 41;j++)

 		}
 		
 		prev_delta[j] = delta[j];
 	}
 	
-	bperiod = round((60.0*44100.0)/(((2*maxind)+80)*((double) framesize)));
-	
-	if (bperiod > 0)
-	{
-		est_tempo = 60.0/((((double) framesize) / 44100.0)*bperiod);
-	}
-	
-	//cout << bperiod << endl;
-}
-
-//=======================================================================
-void BTrack :: adapt_thresh(double *x,int N)
+	beatPeriod = round((60.0*44100.0)/(((2*maxind)+80)*((double) hopSize)));
+	
+	if (beatPeriod > 0)
+	{
+		est_tempo = 60.0/((((double) hopSize) / 44100.0)*beatPeriod);
+	}
+}
+
+//=======================================================================
+void BTrack::adaptiveThreshold(double *x,int N)
 {
 	//int N = 512; // length of df
 	int i = 0;
 	int k,t = 0;
 	double x_thresh[N];

 	
 	// find threshold for first 't' samples, where a full average cannot be computed yet 
 	for (i = 0;i <= t;i++)
 	{	
 		k = std::min((i+p_pre),N);
-		x_thresh[i] = mean_array(x,1,k);
+		x_thresh[i] = calculateMeanOfArray(x,1,k);
 	}
 	// find threshold for bulk of samples across a moving average from [i-p_pre,i+p_post]
 	for (i = t+1;i < N-p_post;i++)
 	{
-		x_thresh[i] = mean_array(x,i-p_pre,i+p_post);
+		x_thresh[i] = calculateMeanOfArray(x,i-p_pre,i+p_post);
 	}
 	// for last few samples calculate threshold, again, not enough samples to do as above
 	for (i = N-p_post;i < N;i++)
 	{
 		k = std::max((i-p_post),1);
-		x_thresh[i] = mean_array(x,k,N);
+		x_thresh[i] = calculateMeanOfArray(x,k,N);
 	}
 	
 	// subtract the threshold from the detection function and check that it is not less than 0
 	for (i = 0;i < N;i++)
 	{

 		}
 	}
 }
 
 //=======================================================================
-void BTrack :: getrcfoutput()
+void BTrack::calculateOutputOfCombFilterBank()
 {
 	int numelem;
 	
 	for (int i = 0;i < 128;i++)
 	{

 		}
 	}
 }
 
 //=======================================================================
-void BTrack :: acf_bal(double *df_thresh)
+void BTrack::calculateBalancedACF(double *df_thresh)
 {
 	int l, n = 0;
 	double sum, tmp;
 	
 	// for l lags from 0-511

 		acf[l] = sum / (512-l);		// weight by number of mults and add to acf buffer
 	}
 }
 
 //=======================================================================
-double BTrack :: mean_array(double *array,int start,int end)
+double BTrack::calculateMeanOfArray(double *array,int start,int end)
 {
 	int i;
 	double sum = 0;
 
     int length = end - start;

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

 		}
 	}
 }
 
 //=======================================================================
-void BTrack :: updatecumscore(double df_sample)
+void BTrack::updateCumulativeScore(double df_sample)
 {	 
 	int start, end, winsize;
 	double max;
 	
-	start = dfbuffer_size - round(2*bperiod);
-	end = dfbuffer_size - round(bperiod/2);
+	start = dfbuffer_size - round(2*beatPeriod);
+	end = dfbuffer_size - round(beatPeriod/2);
 	winsize = end-start+1;
 	
 	double w1[winsize];
-	double v = -2*bperiod;
+	double v = -2*beatPeriod;
 	double wcumscore;
 	
 	
 	// create window
 	for (int i = 0;i < winsize;i++)
 	{
-		w1[i] = exp((-1*pow(tightness*log(-v/bperiod),2))/2);
+		w1[i] = exp((-1*pow(tightness*log(-v/beatPeriod),2))/2);
 		v = v+1;
 	}	
 	
 	// calculate new cumulative score value
 	max = 0;

 	//cout << cumscore[dfbuffer_size-1] << endl;
 		
 }
 
 //=======================================================================
-void BTrack :: predictbeat()
+void BTrack::predictBeat()
 {	 
-	int winsize = (int) bperiod;
+	int winsize = (int) beatPeriod;
 	double fcumscore[dfbuffer_size + winsize];
 	double w2[winsize];
 	// copy cumscore to first part of fcumscore
 	for (int i = 0;i < dfbuffer_size;i++)
 	{

 	
 	// create future window
 	double v = 1;
 	for (int i = 0;i < winsize;i++)
 	{
-		w2[i] = exp((-1*pow((v - (bperiod/2)),2))   /  (2*pow((bperiod/2) ,2)));
+		w2[i] = exp((-1*pow((v - (beatPeriod/2)),2))   /  (2*pow((beatPeriod/2) ,2)));
 		v++;
 	}
 	
 	// create past window
-	v = -2*bperiod;
-	int start = dfbuffer_size - round(2*bperiod);
-	int end = dfbuffer_size - round(bperiod/2);
+	v = -2*beatPeriod;
+	int start = dfbuffer_size - round(2*beatPeriod);
+	int end = dfbuffer_size - round(beatPeriod/2);
 	int pastwinsize = end-start+1;
 	double w1[pastwinsize];
 
 	for (int i = 0;i < pastwinsize;i++)
 	{
-		w1[i] = exp((-1*pow(tightness*log(-v/bperiod),2))/2);
+		w1[i] = exp((-1*pow(tightness*log(-v/beatPeriod),2))/2);
 		v = v+1;
 	}
 
 	
 

 	double max;
 	int n;
 	double wcumscore;
 	for (int i = dfbuffer_size;i < (dfbuffer_size+winsize);i++)
 	{
-		start = i - round(2*bperiod);
-		end = i - round(bperiod/2);
+		start = i - round(2*beatPeriod);
+		end = i - round(beatPeriod/2);
 		
 		max = 0;
 		n = 0;
 		for (int k=start;k <= end;k++)
 		{

 		
 		n++;
 	}
 		
 	// set next prediction time
-	m0 = beat+round(bperiod/2);
-	
-
-}
+	m0 = beat+round(beatPeriod/2);
+	
+
+}