Mercurial > hg > batch-feature-extraction-tool

changeset 3:005e311b5e62

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Fixed memory leak. :) Need to fix Debug FFTW now though.
author Geogaddi\David <d.m.ronan@qmul.ac.uk>
date Fri, 10 Jul 2015 00:33:15 +0100
parents c649e493c30a
children 345acbd06029
files Source/AudioReader.cpp Source/AudioReader.h Source/AudioSourceFeatureExtractor.cpp Source/FFTW.h Source/Main.cpp
diffstat 5 files changed, 81 insertions(+), 100 deletions(-) [+]
line wrap: on
line diff
--- a/Source/AudioReader.cpp	Thu Jul 09 21:45:55 2015 +0100
+++ b/Source/AudioReader.cpp	Fri Jul 10 00:33:15 2015 +0100
@@ -45,7 +45,7 @@
 
 	for(size_t i=0; i<audioFileNames.size(); i++)
 	{
-		float percentcomplete = (float)i / (float)audioFileNames.size() * 100.0f;
+		float percentcomplete = static_cast<float>(i) / static_cast<float>(audioFileNames.size()) * 100.0f;
 
 		std::string outputStr = "Extracting features for " + audioFileNames[i] + "\n" +  std::to_string(percentcomplete) + "% complete...";
 		cout << outputStr;
@@ -53,39 +53,37 @@
 		//Create file from    our audio data
 		File audioFile(audioFileNames[i].c_str());
 
-		AudioFormatReader* m_audioFileReader = m_formatManager.createReaderFor(audioFile);
+		AudioFormatReader* audioFileReader = m_formatManager.createReaderFor(audioFile);
 
+		if(audioFileReader != nullptr)
+		{
+			float fSampleRate		= static_cast<float>(audioFileReader->sampleRate);
+			int iLengthInSamples  = static_cast<int>(audioFileReader->lengthInSamples);
+			int iNumOfChannels    = audioFileReader->numChannels;
 
-
-		if(m_audioFileReader != NULL)
-		{
-			m_fSampleRate		= (float)(m_audioFileReader->sampleRate);
-			m_iLengthInSamples  = (int)m_audioFileReader->lengthInSamples;
-			m_iNumOfChannels    = m_audioFileReader->numChannels;
-
-			if (m_fSampleRate != 22050.0f)
+			if (fSampleRate != 22050.0f)
 			{
 				cout << "\n\n\nERROR: File is not the required 22050 Hz sample rate.!!!\n\n\n";
 			}
 
 			//Get loudest 30 secs. of audio
-			int numOfSamplesToCollect = (int)(analysisWindowSize * m_fSampleRate);
+			int numOfSamplesToCollect = static_cast<int>(analysisWindowSize * fSampleRate);
 
-			if(m_iLengthInSamples <= numOfSamplesToCollect)
+			if(iLengthInSamples <= numOfSamplesToCollect)
 			{
-				numOfSamplesToCollect = m_iLengthInSamples;
+				numOfSamplesToCollect = iLengthInSamples;
 			}
 
 			//Length of the full track in stereo;
 			int* destSamples[2] = {0};
-			int* L = new int[(size_t)(m_iLengthInSamples)];
-			memset(L, 0, (size_t)m_iLengthInSamples*sizeof(float));
+			int* L = new int[static_cast<size_t>(iLengthInSamples)];
+			memset(L, 0, static_cast<size_t>(iLengthInSamples)*sizeof(float));
 			destSamples[0]=L;
 			destSamples[1]=L;
 
 			//30 sec clips to check energy levels
-			float* destSamplesFloat = new float[(size_t)numOfSamplesToCollect];
-			memset(destSamplesFloat, 0, (size_t)numOfSamplesToCollect*sizeof(float));
+			float* destSamplesFloat = new float[static_cast<size_t>(numOfSamplesToCollect)];
+			memset(destSamplesFloat, 0, static_cast<size_t>(numOfSamplesToCollect)*sizeof(float));
 
 			////30 sec clips to check energy levels
 			//float* destSamplesFloatLoudest = new float[(size_t)numOfSamplesToCollect];
@@ -93,20 +91,20 @@
 
 			int timesToLoop = 0;
 
-			if(m_iLengthInSamples == numOfSamplesToCollect)
+			if(iLengthInSamples == numOfSamplesToCollect)
 			{
 				timesToLoop = 1;
 			}
 			else
 			{
-				timesToLoop = (int)((m_iLengthInSamples - numOfSamplesToCollect) / (ENERGYSEARCHTIME * m_fSampleRate));
+				timesToLoop = static_cast<int>((iLengthInSamples - numOfSamplesToCollect) / (ENERGYSEARCHTIME * fSampleRate));
 			}
 
 			std::vector<float> thirtySecEnergy = std::vector<float>();
 
 			//float loudestEnergy = 0.0;
 
-			m_audioFileReader->readSamples(destSamples, 2, 0, 0, m_iLengthInSamples);
+			audioFileReader->readSamples(destSamples, iNumOfChannels, 0, 0, iLengthInSamples);
 
 			for(int j=0; j < timesToLoop;j++)
 			{
@@ -115,13 +113,13 @@
 				for(int n=0; n<numOfSamplesToCollect; n++)
 				{
 					//Sum to mono if needed and workout the energy for each 30 sec. frame
-					if(m_iNumOfChannels > 1)
+					if(iNumOfChannels > 1)
 					{
-						destSamplesFloat[n] = ((float)((destSamples[0][int(j * ENERGYSEARCHTIME * m_fSampleRate) + n] + destSamples[1][int( j * ENERGYSEARCHTIME * m_fSampleRate) + n]) / 2) / (0x7fffffff));
+						destSamplesFloat[n] = (static_cast<float>((destSamples[0][int(j * ENERGYSEARCHTIME * fSampleRate) + n] + destSamples[1][int( j * ENERGYSEARCHTIME * fSampleRate) + n]) / 2) / (0x7fffffff));
 					}
 					else
 					{
-						destSamplesFloat[n] = ((float)(destSamples[0][int(j * ENERGYSEARCHTIME * m_fSampleRate) + n]) / (0x7fffffff));
+						destSamplesFloat[n] = (static_cast<float>(destSamples[0][int(j * ENERGYSEARCHTIME * fSampleRate) + n]) / (0x7fffffff));
 					}
 
 					fSum+=(destSamplesFloat[n] * destSamplesFloat[n]);
@@ -143,31 +141,31 @@
 			int maxIdx = std::distance(thirtySecEnergy.begin(), max_element(thirtySecEnergy.begin(), thirtySecEnergy.end()));
 
 			int* thirtySecSamples[2] = {0};
-			int* L30 = new int[(size_t)numOfSamplesToCollect];
-			memset(L30, 0, (size_t)numOfSamplesToCollect*sizeof(float));
+			int* L30 = new int[static_cast<size_t>(numOfSamplesToCollect)];
+			memset(L30, 0, static_cast<size_t>(numOfSamplesToCollect)*sizeof(float));
 			thirtySecSamples[0]=L30; //Left channel
 			thirtySecSamples[1]=L30; //Left right
 
 			//Read the 30 secs. in
-			m_audioFileReader->readSamples(thirtySecSamples, 2, 0, int(maxIdx * ENERGYSEARCHTIME * m_fSampleRate), numOfSamplesToCollect);
-			memset(destSamplesFloat, 0, (size_t)numOfSamplesToCollect*sizeof(float));
+			audioFileReader->readSamples(thirtySecSamples, iNumOfChannels, 0, int(maxIdx * ENERGYSEARCHTIME * fSampleRate), numOfSamplesToCollect);
+			memset(destSamplesFloat, 0, static_cast<size_t>(numOfSamplesToCollect)*sizeof(float));
 
 			for(int n=0; n<numOfSamplesToCollect; n++)
 			{
 				//Sum to mono if needed
-				if(m_iNumOfChannels > 1)
+				if(iNumOfChannels > 1)
 				{
-					destSamplesFloat[n] = ((float)((thirtySecSamples[0][n] + thirtySecSamples[1][n]) / 2) / (0x7fffffff));
+					destSamplesFloat[n] = (static_cast<float>((thirtySecSamples[0][n] + thirtySecSamples[1][n]) / 2) / (0x7fffffff));
 				}
 				else
 				{
-					destSamplesFloat[n] = ((float)(thirtySecSamples[0][n]) / (0x7fffffff));
+					destSamplesFloat[n] = (static_cast<float>(thirtySecSamples[0][n]) / (0x7fffffff));
 				}
 			}
 
 			std::vector<ObservationData> newObs =  m_AudioSourceFeatureExtractor.Process(destSamplesFloat, numOfSamplesToCollect);
 
-			FeatureData newFeature = FeatureData(newObs, labels[i], audioFileNames[i], m_fSampleRate, FFTSIZE, (float)numOfSamplesToCollect, poolTimeSecs);
+			FeatureData newFeature = FeatureData(newObs, labels[i], audioFileNames[i], fSampleRate, FFTSIZE, static_cast<float>(numOfSamplesToCollect), poolTimeSecs);
 
 			writeCSV.Write(CSVFileName, newFeature);
 
@@ -176,36 +174,32 @@
 			cout << string(outputStr.length(),'\b');
 
 			//Cleanup
-			if(L != NULL)
+			if(L != nullptr)
 			{
 				delete[] L;
 				L = nullptr;
 			}
 
-			if(destSamplesFloat != NULL)
+			if (L30 != nullptr)
+			{
+				delete[] L30;
+				L30 = nullptr;
+			}
+
+			if(destSamplesFloat != nullptr)
 			{
 				delete[] destSamplesFloat;
 				destSamplesFloat = nullptr;
-				//destSamplesFloatLoudest = nullptr;
-			}
+			}			
 
-			//if(destSamplesFloatLoudest != NULL)
-			//{
-			//	delete[] destSamplesFloatLoudest;
-			//
-			//}
+			delete[] audioFileReader;
+			audioFileReader = nullptr;
+
 		}
 		else
 		{
 			cout << "\n\n\nERROR: Could not find file!!!\n\n\n";
-		}
-
-		//Cleanup
-		if(m_audioFileReader != NULL)
-		{
-			delete[] m_audioFileReader;
-			m_audioFileReader  = nullptr;
-		}
+		}		
 	}
 
 	m_AudioSourceFeatureExtractor.Finalize();
--- a/Source/AudioReader.h	Thu Jul 09 21:45:55 2015 +0100
+++ b/Source/AudioReader.h	Fri Jul 10 00:33:15 2015 +0100
@@ -29,13 +29,7 @@
 
 private:
 
-	AudioSourceFeatureExtractor m_AudioSourceFeatureExtractor;
-
-
-	float m_fSampleRate;
-	int	  m_iLengthInSamples;
-	int   m_iNumOfChannels;
-
+	AudioSourceFeatureExtractor m_AudioSourceFeatureExtractor;
 };
 
 #endif  // AUDIOREADER_H_INCLUDED
--- a/Source/AudioSourceFeatureExtractor.cpp	Thu Jul 09 21:45:55 2015 +0100
+++ b/Source/AudioSourceFeatureExtractor.cpp	Fri Jul 10 00:33:15 2015 +0100
@@ -36,37 +36,37 @@
 //============================================================================== ~AudioSourceFeatureExtractor
 AudioSourceFeatureExtractor::~AudioSourceFeatureExtractor()
 {
-	if(m_fInputBuffer != NULL)
+	if(m_fInputBuffer != nullptr)
 	{
 		delete m_fInputBuffer;       // memory freed up
 		m_fInputBuffer = nullptr;
 	}
 
-	if(m_fMagnitudeSpectrum != NULL)
+	if(m_fMagnitudeSpectrum != nullptr)
 	{
 		delete m_fMagnitudeSpectrum;       // memory freed up
 		m_fMagnitudeSpectrum = nullptr;
 	}
 
-	if(m_fPreviousMagnitudeSpectrum != NULL)
+	if(m_fPreviousMagnitudeSpectrum != nullptr)
 	{
 		delete m_fPreviousMagnitudeSpectrum;       // memory freed up
 		m_fPreviousMagnitudeSpectrum = nullptr;
 	}
 
-	if (m_OutReal != NULL)
+	if (m_OutReal != nullptr)
 	{
 		delete[] m_OutReal;
 		m_OutReal  = nullptr;
 	}
 
-	if (m_OutImag != NULL)
+	if (m_OutImag != nullptr)
 	{
 		delete[] m_OutImag;
 		m_OutImag  = nullptr;
 	}
 
-	if (m_fft != NULL)
+	if (m_fft != nullptr)
 	{
 		delete m_fft;
 		m_fft  = nullptr;
@@ -87,8 +87,6 @@
 	}
 
 	m_MFCC.initMFFCvariables(12, MAGNITUDESIZE, m_fSampleRate);
-
-
 }
 
 //==============================================================================  process
@@ -150,7 +148,7 @@
 			//////////////////////////////////////////////////////////////////
 			for (int i = 0; i < FFTSIZE; i++)
 			{
-				float multiplier = (float) (0.5 * (1 - cos(2*PI*i/(FFTSIZE -1))));
+				float multiplier = static_cast<float>(0.5 * (1 - cos(2*PI*i/(FFTSIZE -1))));
 				m_fInputBuffer[i] = multiplier * m_fInputBuffer[i];
 			}
 
@@ -260,7 +258,7 @@
 		//Roll off + Flatness
 
 		totalenergy += energy;
-		float exponent = (float)(1.0/(float)windowSize);
+		float exponent = static_cast<float>(1.0/static_cast<float>(windowSize));
 
 		if(energy != 0)
 		{
@@ -331,7 +329,7 @@
 	//Roll off 85% - 95%
 	/////////////////////////////////////////////////////////
 
-	while ((currEnergy95 <= 0.95 * totalenergy) && (countFFT95 < (int)windowSize))
+	while ((currEnergy95 <= 0.95 * totalenergy) && (countFFT95 < static_cast<int>(windowSize)))
 	{
 		currEnergy95 += (magnitude[countFFT95] * magnitude[countFFT95]);
 		countFFT95 += 1;
@@ -355,7 +353,7 @@
 	}
 	else
 	{
-		rolloff85 = (((float)countFFT85) / (float)windowSize);
+		rolloff85 = (static_cast<float>(countFFT85) / static_cast<float>(windowSize));
 	}
 
 	//Normalization
@@ -366,7 +364,7 @@
 	}
 	else
 	{
-		rolloff95 = (((float)countFFT95) / (float)windowSize);
+		rolloff95 = (static_cast<float>(countFFT95) / static_cast<float>(windowSize));
 	}
 
 	/////////////////////////////////////////////////////
@@ -374,7 +372,7 @@
 	//Spectral Entropy
 	/////////////////////////////////////////////////////////
 
-	spectralentropy = (float) ((normalisedMagSumEntropy / log((float)windowSize)) * - 1);
+	spectralentropy = static_cast<float>((normalisedMagSumEntropy / log(static_cast<float>(windowSize))) * - 1);
 
 	/////////////////////////////////////////////////////////
 
@@ -384,7 +382,7 @@
 	/////////////////////////////////////////////////////////
 	if(totalenergy != 0 && geo != 0)
 	{
-		flatness = geo / (totalenergy / (float)windowSize);
+		flatness = geo / (totalenergy / static_cast<float>(windowSize));
 	}
 	else
 	{
@@ -481,7 +479,7 @@
 	fft2.process(in2, out2Real, out2Imag);
 
     // multiply out1*conj(out2) in FFT domain
-    fftwf_complex *product = (fftwf_complex*)fftwf_malloc(sizeof(fftwf_complex)*fftSize);
+    fftwf_complex *product = static_cast<fftwf_complex*>(fftwf_malloc(sizeof(fftwf_complex)*fftSize));
     for (size_t i = 0; i < fftSize; ++i)
     {
         product[i][0] = (out1Real[i]*out2Real[i] + out1Imag[i]*out2Imag[i]);
@@ -498,8 +496,8 @@
 
     fftwf_plan plan;
 
-    float *result = (float*) fftwf_malloc(sizeof(float)*fftSize);
-    plan = fftwf_plan_guru_dft_c2r(1, &dim, 0, NULL, product, result, FFTW_ESTIMATE);
+    float *result = static_cast<float*>(fftwf_malloc(sizeof(float)*fftSize));
+    plan = fftwf_plan_guru_dft_c2r(1, &dim, 0, nullptr, product, result, FFTW_ESTIMATE);
     fftwf_execute_dft_c2r(plan, product, result);
     fftwf_destroy_plan(plan);
 
@@ -517,7 +515,7 @@
         output[i - fftSize + maxLag] = result[i] / fftSize;
     }
 
-    for (unsigned i = 0; i <= (unsigned)maxLag; ++i)
+    for (unsigned i = 0; i <= static_cast<unsigned>(maxLag); ++i)
     {
         output[i + maxLag] = result[i] / fftSize;
     }
@@ -525,37 +523,37 @@
 	fftwf_free(result);
 	fftwf_free(product);
 
-	if(in1 != NULL)
+	if(in1 != nullptr)
 	{
 		delete[] in1;
 		in1 = nullptr;
 	}
 
-	if(in2 != NULL)
+	if(in2 != nullptr)
 	{
 		delete[] in2;
 		in2 = nullptr;
 	}
 
-	if(out1Real != NULL)
+	if(out1Real != nullptr)
 	{
 		delete[] out1Real;
 		out1Real= nullptr;
 	}
 
-	if(out1Imag != NULL)
+	if(out1Imag != nullptr)
 	{
 		delete[] out1Imag;
 		out1Imag= nullptr;
 	}
 
-	if(out2Real != NULL)
+	if(out2Real != nullptr)
 	{
 		delete[] out2Real;
 		out2Real= nullptr;
 	}
 
-	if(out2Imag != NULL)
+	if(out2Imag != nullptr)
 	{
 		delete[] out2Imag;
 		out2Imag= nullptr;
@@ -574,21 +572,17 @@
 		downsampleddata[k] = data[k];
 	}
 
-	//DownSampler(data, downsampleddata, numSamples, downsamplelength, m_fSampleRate, 11025.0);
 
 	EnvelopeCurve(downsampleddata, downsampleddata, numSamples, m_fSampleRate);
 
-	int startLag = (int)floor((float)(60.0 / 480.0 * m_fSampleRate));
-	int endLag = (int)floor((float)(60.0 / 30.0 * m_fSampleRate));
-	int thresh = (int)floor((float)(.2 * m_fSampleRate));
-
-	//Normalise
-	//Normalise(downsampleddata, downsampleddata, downsamplelength);
+	int startLag = static_cast<int>(floor(static_cast<float>(60.0 / 480.0 * m_fSampleRate)));
+	int endLag = static_cast<int>(floor(static_cast<float>(60.0 / 30.0 * m_fSampleRate)));
+	int thresh = static_cast<int>(floor(static_cast<float>(.2 * m_fSampleRate)));	
 
 	size_t xcorrlen = 0;
 	XCorr(xcorr, downsampleddata, downsampleddata, xcorrlen, numSamples, endLag);
 
-	int i = (int)floor(xcorrlen / 2);
+	int i = static_cast<int>(floor(xcorrlen / 2));
 
 	std::vector<float> temp;
 	for(size_t j = i; j < xcorrlen; j++)
@@ -597,7 +591,7 @@
 	}
 
 	std::vector<float> temp2;
-	for(size_t j = (size_t)std::max(1,startLag); j < (size_t)std::min(endLag,(int)temp.size()); j++)
+	for(size_t j = static_cast<size_t>(std::max(1,startLag)); j < static_cast<size_t>(std::min(endLag,static_cast<int>(temp.size()))); j++)
 	{
 		temp2.push_back(temp[j]);
 	}
@@ -614,11 +608,11 @@
 	}
 
 	int from = std::max(1, maxIdx-thresh);
-	int to = std::min((int)temp2.size(), maxIdx+thresh);
+	int to = std::min(static_cast<int>(temp2.size()), maxIdx+thresh);
 
 	float minValInRange = std::numeric_limits<float>::max();
 
-	for(size_t j = (size_t)from; j < to; j++)
+	for(size_t j = static_cast<size_t>(from); j < to; j++)
 	{
 		if(temp2[j] < minValInRange)
 		{
@@ -631,13 +625,13 @@
 	std::string dave = "Periodicity " + std::to_string(periodicity) + "\n";
 	//OutputDebugString(dave.c_str());
 
-	if(xcorr != NULL)
+	if(xcorr != nullptr)
 	{
 		delete[] xcorr;
 		xcorr = nullptr;
 	}
 
-	if(downsampleddata != NULL)
+	if(downsampleddata != nullptr)
 	{
 		delete[] downsampleddata;
 		downsampleddata = nullptr;
@@ -765,7 +759,7 @@
 	{
 		float val = 0.0;
 
-		for (size_t j = 0; j < (size_t)subFrameSize; j++)
+		for (size_t j = 0; j < static_cast<size_t>(subFrameSize); j++)
 		{
 			val += (data[j + (i * subFrameSize)] * data[j + (i * subFrameSize)]);
 		}
@@ -786,7 +780,7 @@
 	outLogFreqVec = LinSpace(log(f1), log(f2), nBin);
 	std::vector<float> f(nfft / 2, 0.0f);
 
-	for (size_t i = 0; i < (size_t)nBin; i++)
+	for (size_t i = 0; i < static_cast<size_t>(nBin); i++)
 	{
 		outKrnl.push_back(f);
 	}
@@ -796,7 +790,7 @@
 		outLogFreqVec[i] = exp(outLogFreqVec[i]);
 	}
 
-	for (size_t i = 1; i < (size_t)nBin - 2; i++)
+	for (size_t i = 1; i < static_cast<size_t>(nBin) - 2; i++)
 	{
 		float freqBinLin = outLogFreqVec[i] / (fsProc / nfft);
 
--- a/Source/FFTW.h	Thu Jul 09 21:45:55 2015 +0100
+++ b/Source/FFTW.h	Fri Jul 10 00:33:15 2015 +0100
@@ -45,7 +45,7 @@
     dim.n =  fftLength;
     dim.is = 1;
     dim.os = 1;
-    m_plan = fftwf_plan_guru_split_dft_r2c( 1, &dim, 0, NULL, tempInput, tempReal, tempImag, FFTW_ESTIMATE );
+    m_plan = fftwf_plan_guru_split_dft_r2c( 1, &dim, 0, nullptr, tempInput, tempReal, tempImag, FFTW_ESTIMATE );
 	delete[] tempInput;
 	tempInput = nullptr;
 	delete[] tempReal;
@@ -57,7 +57,7 @@
 
  ~FFTW()
   {
-	  if(m_plan != NULL)
+	  if(m_plan != nullptr)
 	  {
 			fftwf_destroy_plan( m_plan );
 	  }
--- a/Source/Main.cpp	Thu Jul 09 21:45:55 2015 +0100
+++ b/Source/Main.cpp	Fri Jul 10 00:33:15 2015 +0100
@@ -23,8 +23,7 @@
 {
 	if(argc == 4)
 	{
-		cout << "*** Feature Extraction Tool ***\n";
-		cout << "*** Native Instruments 2014 ***\n";
+		cout << "*** Batch Feature Extraction Tool ***\n";
 		cout << "*** Written by David Ronan  ***\n\n\n";
 
 		std::string fileName;