comparison src/BTrack.cpp @ 51:68d01fea1e8d

Added a unit testing project, and did some commenting. Also moved python-module into a modules-and-plug-ins folder

 using namespace std;
 
 
 
 
-//-------------------------------------------------------------------------------
-// Constructor
+//=======================================================================
 BTrack :: BTrack()
 {	
 	float rayparam = 43;
 	float pi = 3.14159265;
 	

 	
 	// tempo is not fixed
 	tempofix = 0;
 }
 
-//-------------------------------------------------------------------------------
-// Destructor
+//=======================================================================
 BTrack :: ~BTrack()
 {	
 	
 }
 
-//-------------------------------------------------------------------------------
-// Initialise with frame size and set all frame sizes accordingly
+
+
+//=======================================================================
 void BTrack :: initialise(int fsize)
 {	
 	framesize = fsize;
 	dfbuffer_size = (512*512)/fsize;		// calculate df buffer size
 	

 			dfbuffer[i] = 1;
 		}
 	}
 }
 
-//-------------------------------------------------------------------------------
-// Add new sample to buffer and apply beat tracking
+//=======================================================================
 void BTrack :: process(float df_sample)
 {	 
 	m0--;
 	beat--;
 	playbeat = 0;

 		dfconvert();	
 		calcTempo();
 	}
 }
 
-//-------------------------------------------------------------------------------
-// Set the tempo of the beat tracker
+//=======================================================================
 void BTrack :: settempo(float tempo)
 {	 
 	
 	/////////// TEMPO INDICATION RESET //////////////////
 	

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

 		
 	// set the tempo fix flag
 	tempofix = 1;	
 }
 
-//-------------------------------------------------------------------------------
-// do not fix the tempo anymore
+//=======================================================================
 void BTrack :: unfixtempo()
 {	
 	// set the tempo fix flag
 	tempofix = 0;	
 }
 
-//-------------------------------------------------------------------------------
-// Convert detection function from N samples to 512
+//=======================================================================
 void BTrack :: dfconvert()
 {
 	float output[512];
 		
 	double src_ratio = 512.0/((double) dfbuffer_size);

 	{
 		df512[i] = src_data.data_out[i];
 	}
 }
 
-//-------------------------------------------------------------------------------
-// To calculate the current tempo expressed as the beat period in detection function samples
+//=======================================================================
 void BTrack :: calcTempo()
 {
 	// adaptive threshold on input
 	adapt_thresh(df512,512);
 		

 	}
 	
 	//cout << bperiod << endl;
 }
 
-//-------------------------------------------------------------------------------
-// calculates an adaptive threshold which is used to remove low level energy from detection function and emphasise peaks
+//=======================================================================
 void BTrack :: adapt_thresh(float x[],int N)
 {
 	//int N = 512; // length of df
 	int i = 0;
 	int k,t = 0;

 			x[i] = 0;
 		}
 	}
 }
 
-//-------------------------------------------------------------------------------
-// returns the output of the comb filter
+//=======================================================================
 void BTrack :: getrcfoutput()
 {
 	int numelem;
 	
 	for (int i = 0;i < 128;i++)

 			}
 		}
 	}
 }
 
-//-------------------------------------------------------------------------------
-// calculates the balanced autocorrelation of the smoothed detection function
+//=======================================================================
 void BTrack :: acf_bal(float df_thresh[])
 {
 	int l, n = 0;
 	float sum, tmp;
 	

 		
 		acf[l] = sum / (512-l);		// weight by number of mults and add to acf buffer
 	}
 }
 
-
-//-------------------------------------------------------------------------------
-// calculates the mean of values in an array from index locations [start,end]
+//=======================================================================
 float BTrack :: mean_array(float array[],int start,int end)
 {
 	int i;
 	double sum = 0;
 

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

 			array[i] = array[i] / sum;
 		}
 	}
 }
 
-//-------------------------------------------------------------------------------
-// plot contents of detection function buffer
-void BTrack :: plotdfbuffer()
-{	 
-	for (int i=0;i < dfbuffer_size;i++)
-	{
-		cout << dfbuffer[i] << endl;
-	}
-	
-	cout << "--------------------------------" << endl;
-}
-
-//-------------------------------------------------------------------------------
-// update the cumulative score
+//=======================================================================
 void BTrack :: updatecumscore(float df_sample)
 {	 
 	int start, end, winsize;
 	float max;
 	

 	
 	//cout << cumscore[dfbuffer_size-1] << endl;
 		
 }
 
-//-------------------------------------------------------------------------------
-// plot contents of detection function buffer
+//=======================================================================
 void BTrack :: predictbeat()
 {	 
 	int winsize = (int) bperiod;
 	float fcumscore[dfbuffer_size + winsize];
 	float w2[winsize];

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