Mercurial > hg > batch-feature-extraction-tool

changeset 1:e86e9c111b29

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Updates stuff that potentially fixes the memory leak and also makes it work on Windows and Linux (Need to test). Still have to fix fftw include for linux in Jucer.
author David Ronan <d.m.ronan@qmul.ac.uk>
date Thu, 09 Jul 2015 15:01:32 +0100
parents 25bf17994ef1
children c649e493c30a
files Source/AudioReader.cpp Source/AudioReader.h Source/AudioSourceFeatureExtractor.cpp Source/AudioSourceFeatureExtractor.h Source/FFT.cpp Source/FFTW.h Source/FeatureData.cpp Source/MFCC.cpp Source/ParseCSV.cpp Source/WriteCSV.cpp
diffstat 10 files changed, 253 insertions(+), 256 deletions(-) [+]
line wrap: on
line diff
--- a/Source/AudioReader.cpp	Thu Jul 09 01:12:16 2015 +0100
+++ b/Source/AudioReader.cpp	Thu Jul 09 15:01:32 2015 +0100
@@ -20,8 +20,8 @@
 #define SAMPLERATE 22050.0f
 
 AudioReader::AudioReader()
-{
-	m_audio_format_manager.registerBasicFormats();
+{
+
 };
 
 AudioReader::~AudioReader()
@@ -29,45 +29,47 @@
 
 };
 
-
-
 std::vector<FeatureData> AudioReader::Read(AudioFileData audioFileData, float poolTimeSecs, int analysisWindowSize)
 {
 	WriteCSV writeCSV = WriteCSV();
 	std::vector<FeatureData> featureData = std::vector<FeatureData>();
 	std::string CSVFileName = "..\\FeatureData" + writeCSV.currentDateTime();
-		
+
 	vector<string> audioFileNames = audioFileData.GetFileNames();
-	vector<string> labels = audioFileData.GetLabels();
+	vector<string> labels = audioFileData.GetLabels();
+
+	AudioFormatManager m_formatManager;
+    m_formatManager.registerBasicFormats();
+	//AudioSourceFeatureExtractor audioSourceFeatureExtractor = AudioSourceFeatureExtractor();
+	m_AudioSourceFeatureExtractor.Initialise(SAMPLERATE);
 
-	//AudioSourceFeatureExtractor audioSourceFeatureExtractor = AudioSourceFeatureExtractor();	
-	m_AudioSourceFeatureExtractor.Initialise(SAMPLERATE);
-	
 	for(size_t i=0; i<audioFileNames.size(); i++)
 	{
-		float percentcomplete = static_cast<float>(i) / static_cast<float>(audioFileNames.size()) * 100.0f;
+		float percentcomplete = (float)i / (float)audioFileNames.size() * 100.0f;
 
 		std::string outputStr = "Extracting features for " + audioFileNames[i] + "\n" +  std::to_string(percentcomplete) + "% complete...";
 		cout << outputStr;
 
 		//Create file from    our audio data
 		File audioFile(audioFileNames[i].c_str());
-		
-		AudioFormatReader* audio_format_reader = m_audio_format_manager.createReaderFor(audioFile);		
 
-		if(audio_format_reader != nullptr)
+		AudioFormatReader* m_audioFileReader = m_formatManager.createReaderFor(audioFile);
+
+
+
+		if(m_audioFileReader != NULL)
 		{
-			m_fSampleRate		= static_cast<float>(audio_format_reader->sampleRate);
-			m_iLengthInSamples  = static_cast<int>(audio_format_reader->lengthInSamples);
-			m_iNumOfChannels    = audio_format_reader->numChannels;
+			m_fSampleRate		= (float)(m_audioFileReader->sampleRate);
+			m_iLengthInSamples  = (int)m_audioFileReader->lengthInSamples;
+			m_iNumOfChannels    = m_audioFileReader->numChannels;
 
 			if (m_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 = static_cast<int>(analysisWindowSize * m_fSampleRate);
+			int numOfSamplesToCollect = (int)(analysisWindowSize * m_fSampleRate);
 
 			if(m_iLengthInSamples <= numOfSamplesToCollect)
 			{
@@ -76,20 +78,20 @@
 
 			//Length of the full track in stereo;
 			int* destSamples[2] = {0};
-			int* L = new int[static_cast<size_t>(m_iLengthInSamples)]; 
-			memset(L, 0, static_cast<size_t>(m_iLengthInSamples)*sizeof(float)); 
+			int* L = new int[(size_t)(m_iLengthInSamples)];
+			memset(L, 0, (size_t)m_iLengthInSamples*sizeof(float));
 			destSamples[0]=L;
-			destSamples[1]=L;				
-	
+			destSamples[1]=L;
+
 			//30 sec clips to check energy levels
-			float* destSamplesFloat = new float[static_cast<size_t>(numOfSamplesToCollect)];
-			memset(destSamplesFloat, 0, static_cast<size_t>(numOfSamplesToCollect)*sizeof(float)); 
+			float* destSamplesFloat = new float[(size_t)numOfSamplesToCollect];
+			memset(destSamplesFloat, 0, (size_t)numOfSamplesToCollect*sizeof(float));
 
 			////30 sec clips to check energy levels
 			//float* destSamplesFloatLoudest = new float[(size_t)numOfSamplesToCollect];
-			//memset(destSamplesFloatLoudest, 0, (size_t)numOfSamplesToCollect*sizeof(float)); 
+			//memset(destSamplesFloatLoudest, 0, (size_t)numOfSamplesToCollect*sizeof(float));
 
-			int timesToLoop;
+			int timesToLoop = 0;
 
 			if(m_iLengthInSamples == numOfSamplesToCollect)
 			{
@@ -97,17 +99,17 @@
 			}
 			else
 			{
-				timesToLoop = static_cast<int>((m_iLengthInSamples - numOfSamplesToCollect) / (ENERGYSEARCHTIME * m_fSampleRate));
+				timesToLoop = (int)((m_iLengthInSamples - numOfSamplesToCollect) / (ENERGYSEARCHTIME * m_fSampleRate));
 			}
 
 			std::vector<float> thirtySecEnergy = std::vector<float>();
 
 			//float loudestEnergy = 0.0;
 
-			audio_format_reader->readSamples(destSamples, m_iNumOfChannels, 0, 0, m_iLengthInSamples);
+			m_audioFileReader->readSamples(destSamples, 2, 0, 0, m_iLengthInSamples);
 
 			for(int j=0; j < timesToLoop;j++)
-			{	
+			{
 				float fSum=0.f;
 
 				for(int n=0; n<numOfSamplesToCollect; n++)
@@ -115,11 +117,11 @@
 					//Sum to mono if needed and workout the energy for each 30 sec. frame
 					if(m_iNumOfChannels > 1)
 					{
-						destSamplesFloat[n] = (static_cast<float>((destSamples[0][int(j * ENERGYSEARCHTIME * m_fSampleRate) + n] + destSamples[1][int( j * ENERGYSEARCHTIME * m_fSampleRate) + n]) / 2) / (0x7fffffff));
+						destSamplesFloat[n] = ((float)((destSamples[0][int(j * ENERGYSEARCHTIME * m_fSampleRate) + n] + destSamples[1][int( j * ENERGYSEARCHTIME * m_fSampleRate) + n]) / 2) / (0x7fffffff));
 					}
 					else
 					{
-						destSamplesFloat[n] = (static_cast<float>(destSamples[0][int(j * ENERGYSEARCHTIME * m_fSampleRate) + n]) / (0x7fffffff));
+						destSamplesFloat[n] = ((float)(destSamples[0][int(j * ENERGYSEARCHTIME * m_fSampleRate) + n]) / (0x7fffffff));
 					}
 
 					fSum+=(destSamplesFloat[n] * destSamplesFloat[n]);
@@ -137,82 +139,75 @@
 				thirtySecEnergy.push_back(fSum);
 			}
 
-			//Find the index of the section with the most energy 
+			//Find the index of the section with the most energy
 			int maxIdx = std::distance(thirtySecEnergy.begin(), max_element(thirtySecEnergy.begin(), thirtySecEnergy.end()));
 
 			int* thirtySecSamples[2] = {0};
-			int* L30 = new int[static_cast<size_t>(numOfSamplesToCollect)];
-			memset(L30, 0, static_cast<size_t>(numOfSamplesToCollect)*sizeof(float));
+			int* L30 = new int[(size_t)numOfSamplesToCollect];
+			memset(L30, 0, (size_t)numOfSamplesToCollect*sizeof(float));
 			thirtySecSamples[0]=L30; //Left channel
-			thirtySecSamples[1]=L30; //Left right		
+			thirtySecSamples[1]=L30; //Left right
 
 			//Read the 30 secs. in
-			audio_format_reader->readSamples(thirtySecSamples, m_iNumOfChannels, 0, int(maxIdx * ENERGYSEARCHTIME * m_fSampleRate), numOfSamplesToCollect);
-			memset(destSamplesFloat, 0, static_cast<size_t>(numOfSamplesToCollect)*sizeof(float)); 
+			m_audioFileReader->readSamples(thirtySecSamples, 2, 0, int(maxIdx * ENERGYSEARCHTIME * m_fSampleRate), numOfSamplesToCollect);
+			memset(destSamplesFloat, 0, (size_t)numOfSamplesToCollect*sizeof(float));
 
 			for(int n=0; n<numOfSamplesToCollect; n++)
-			{			
-				//Sum to mono if needed 
+			{
+				//Sum to mono if needed
 				if(m_iNumOfChannels > 1)
 				{
-					destSamplesFloat[n] = (static_cast<float>((thirtySecSamples[0][n] + thirtySecSamples[1][n]) / 2) / (0x7fffffff));
+					destSamplesFloat[n] = ((float)((thirtySecSamples[0][n] + thirtySecSamples[1][n]) / 2) / (0x7fffffff));
 				}
 				else
 				{
-					destSamplesFloat[n] = (static_cast<float>(thirtySecSamples[0][n]) / (0x7fffffff));
+					destSamplesFloat[n] = ((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, static_cast<float>(numOfSamplesToCollect), poolTimeSecs);
-		
+			std::vector<ObservationData> newObs =  m_AudioSourceFeatureExtractor.Process(destSamplesFloat, numOfSamplesToCollect);
+
+			FeatureData newFeature = FeatureData(newObs, labels[i], audioFileNames[i], m_fSampleRate, FFTSIZE, (float)numOfSamplesToCollect, poolTimeSecs);
+
 			writeCSV.Write(CSVFileName, newFeature);
-			
+
 			//Update the screen information;
-			
-			cout << string(outputStr.length(), '\b');
-		
+			cout << cout << string(outputStr.length(),'\b');
+
 			//Cleanup
-			if(L != nullptr)
+			if(L != NULL)
 			{
 				delete[] L;
 				L = nullptr;
 			}
 
-			if(destSamplesFloat != nullptr)
+			if(destSamplesFloat != NULL)
 			{
 				delete[] destSamplesFloat;
 				destSamplesFloat = nullptr;
 				//destSamplesFloatLoudest = nullptr;
 			}
-			//Cleanup
-			if (audio_format_reader != nullptr)
-			{
-				delete[] audio_format_reader;
-				audio_format_reader = nullptr;
-			}
+
 			//if(destSamplesFloatLoudest != NULL)
 			//{
 			//	delete[] destSamplesFloatLoudest;
-			//	
+			//
 			//}
 		}
 		else
 		{
 			cout << "\n\n\nERROR: Could not find file!!!\n\n\n";
-
-			if (audio_format_reader != nullptr)
-			{
-				delete[] audio_format_reader;
-				audio_format_reader = nullptr;
-			}
 		}
 
-		
+		//Cleanup
+		if(m_audioFileReader != NULL)
+		{
+			delete[] m_audioFileReader;
+			m_audioFileReader  = nullptr;
+		}
 	}
 
 	m_AudioSourceFeatureExtractor.Finalize();
-	
+
 	return featureData;
-};
\ No newline at end of file
+};
--- a/Source/AudioReader.h	Thu Jul 09 01:12:16 2015 +0100
+++ b/Source/AudioReader.h	Thu Jul 09 15:01:32 2015 +0100
@@ -23,13 +23,14 @@
 class AudioReader
 {
 public:
-	AudioReader();	
+	AudioReader();
 	~AudioReader();
 	std::vector<FeatureData> Read(AudioFileData audioFileData, float poolTimeSecs, int analysisWindowSize);
 
 private:
-	AudioSourceFeatureExtractor m_AudioSourceFeatureExtractor;
-	AudioFormatManager m_audio_format_manager;
+
+	AudioSourceFeatureExtractor m_AudioSourceFeatureExtractor;
+
 
 	float m_fSampleRate;
 	int	  m_iLengthInSamples;
--- a/Source/AudioSourceFeatureExtractor.cpp	Thu Jul 09 01:12:16 2015 +0100
+++ b/Source/AudioSourceFeatureExtractor.cpp	Thu Jul 09 15:01:32 2015 +0100
@@ -14,7 +14,7 @@
 #include <cmath>
 #include <algorithm>
 #include <string>
-#include <windows.h>
+//#include <windows.h>
 
 //==============================================================================  AudioSourceFeatureExtractor
 AudioSourceFeatureExtractor::AudioSourceFeatureExtractor() // m_fft(FFTSIZE)
@@ -30,43 +30,43 @@
 	memset(m_fMagnitudeSpectrum, 0, MAGNITUDESIZE * sizeof(float));
 	memset(m_fPreviousMagnitudeSpectrum, 0, MAGNITUDESIZE * sizeof(float));
 
-	
+
 }
 
 //============================================================================== ~AudioSourceFeatureExtractor
 AudioSourceFeatureExtractor::~AudioSourceFeatureExtractor()
 {
-	if(m_fInputBuffer != nullptr)
+	if(m_fInputBuffer != NULL)
 	{
 		delete m_fInputBuffer;       // memory freed up
 		m_fInputBuffer = nullptr;
 	}
 
-	if(m_fMagnitudeSpectrum != nullptr)
+	if(m_fMagnitudeSpectrum != NULL)
 	{
 		delete m_fMagnitudeSpectrum;       // memory freed up
 		m_fMagnitudeSpectrum = nullptr;
 	}
 
-	if(m_fPreviousMagnitudeSpectrum != nullptr)
+	if(m_fPreviousMagnitudeSpectrum != NULL)
 	{
 		delete m_fPreviousMagnitudeSpectrum;       // memory freed up
 		m_fPreviousMagnitudeSpectrum = nullptr;
 	}
 
-	if (m_OutReal != nullptr)
+	if (m_OutReal != NULL)
 	{
 		delete[] m_OutReal;
 		m_OutReal  = nullptr;
 	}
 
-	if (m_OutImag != nullptr)
+	if (m_OutImag != NULL)
 	{
 		delete[] m_OutImag;
 		m_OutImag  = nullptr;
 	}
 
-	if (m_fft != nullptr)
+	if (m_fft != NULL)
 	{
 		delete m_fft;
 		m_fft  = nullptr;
@@ -76,9 +76,9 @@
 
 //==============================================================================  init
 void AudioSourceFeatureExtractor::Initialise(float fSampleRate)
-{	
+{
 	m_fSampleRate = fSampleRate;
-	m_iWriteIdx = 0;	
+	m_iWriteIdx = 0;
 
 	for (int i = 1; i <= MAGNITUDESIZE; i++)
 	{
@@ -88,12 +88,12 @@
 
 	m_MFCC.initMFFCvariables(12, MAGNITUDESIZE, m_fSampleRate);
 
-	
+
 }
 
 //==============================================================================  process
 std::vector<ObservationData> AudioSourceFeatureExtractor::Process( const float* data, size_t numSamples)
-{	
+{
 	std::vector<ObservationData> observations = std::vector<ObservationData>();
 
 	memset(m_fInputBuffer,       0, FFTSIZE * sizeof(float));
@@ -103,7 +103,7 @@
 
 	float perdiodicity = EstimatePerdiodicity(const_cast<float*>(data), numSamples);
 
-	float entropyofenergy = EntropyOfEnergy(const_cast<float*>(data), numSamples);	
+	float entropyofenergy = EntropyOfEnergy(const_cast<float*>(data), numSamples);
 
 	for(size_t n = 0; n < numSamples; n++)
 	{
@@ -126,21 +126,21 @@
 
 				rms += (m_fInputBuffer[i] * m_fInputBuffer[i]);
 			}
-			
+
 			rms /= FFTSIZE;
-			rms = sqrt(rms);	
+			rms = sqrt(rms);
 
 			crestfactor = peakvalue/(rms + std::numeric_limits<float>::epsilon());
 
 			float ZCR = 0;
 			float inputBuffer2[FFTSIZE] = {0.0};
 
-			for (int i = 1; i < FFTSIZE; i++) 
+			for (int i = 1; i < FFTSIZE; i++)
 			{
 				inputBuffer2[i] = m_fInputBuffer[i -1];
 			}
 
-			for (int i = 0; i < FFTSIZE; i++) 
+			for (int i = 0; i < FFTSIZE; i++)
 			{
 				ZCR += (abs(Sign(m_fInputBuffer[i]) - Sign(inputBuffer2[i])));
 			}
@@ -148,14 +148,14 @@
 			ZCR /= (2 * FFTSIZE);
 
 			//////////////////////////////////////////////////////////////////
-			for (int i = 0; i < FFTSIZE; i++) 
+			for (int i = 0; i < FFTSIZE; i++)
 			{
-				float multiplier = static_cast<float>(0.5 * (1 - cos(2 * PI * i / (FFTSIZE - 1))));
+				float multiplier = (float) (0.5 * (1 - cos(2*PI*i/(FFTSIZE -1))));
 				m_fInputBuffer[i] = multiplier * m_fInputBuffer[i];
 			}
 
 			//Compute the FFT
-			
+
 			memset(m_OutReal, 0, sizeof(float)*FFTSIZE);
 			memset(m_OutImag, 0, sizeof(float)*FFTSIZE);
 
@@ -175,18 +175,18 @@
 			float spectralentropy = 0;
 			float flatness = 0;
 			float spectralcf = 0;
-			float spectralflux = 0;		
+			float spectralflux = 0;
 			std::vector<float> mfccs;
 
-			SpectralFeatures(m_fMagnitudeSpectrum, m_fPreviousMagnitudeSpectrum, MAGNITUDESIZE, centroid, spread, skewness, kurtosis, brightness, rolloff85, rolloff95, spectralentropy, flatness, spectralcf, spectralflux);		
-						
+			SpectralFeatures(m_fMagnitudeSpectrum, m_fPreviousMagnitudeSpectrum, MAGNITUDESIZE, centroid, spread, skewness, kurtosis, brightness, rolloff85, rolloff95, spectralentropy, flatness, spectralcf, spectralflux);
+
 			m_MFCC.ComputeMFCC(m_fMagnitudeSpectrum, mfccs);
 
 			//Update for Spectral Flux
 			for(int i = 0; i < MAGNITUDESIZE; i++)
 			{
 				m_fPreviousMagnitudeSpectrum[i] = m_fMagnitudeSpectrum[i];
-			}			
+			}
 
 			//50% Hop size
 			for(int i = MAGNITUDESIZE; i < FFTSIZE; i++)
@@ -194,14 +194,14 @@
 				m_fInputBuffer[i - MAGNITUDESIZE] = m_fInputBuffer[i];
 				m_iWriteIdx = MAGNITUDESIZE;
 			}
-					
+
 			//create an observation for this window and push it to the list of observations for this 30 sec. audio clip
 			ObservationData newObservation = ObservationData(rms, peakvalue, crestfactor, ZCR, centroid, spread, skewness, kurtosis, brightness, rolloff85, rolloff95, spectralentropy, flatness, spectralcf, spectralflux, mfccs, perdiodicity, entropyofenergy);
-			observations.push_back(newObservation);			
-					
+			observations.push_back(newObservation);
+
 		}
 	}
-	
+
 	return observations;
 }
 
@@ -244,7 +244,7 @@
 
 	for (size_t i = 0; i < windowSize; i++)
 	{
-		//Moments		
+		//Moments
 		summagbin += (m_fFreqBins[i] * magnitude[i]);
 		summag += magnitude[i];
 		sumprevmag += prevmagnitude[i];
@@ -256,15 +256,15 @@
 		}
 
 		float energy = magnitude[i] * magnitude[i];
-		
+
 		//Roll off + Flatness
-		
+
 		totalenergy += energy;
-		float exponent = static_cast<float>(1.0/static_cast<float>(windowSize));
-		
+		float exponent = (float)(1.0/(float)windowSize);
+
 		if(energy != 0)
 		{
-			geo *= pow(energy, exponent);	
+			geo *= pow(energy, exponent);
 		}
 	}
 
@@ -285,7 +285,7 @@
 		//Spectral Flux
 		spectralflux += ((norm - normprev) * (norm - normprev));
 
-		//Entropy		
+		//Entropy
 		normalisedMagSumEntropy += (norm * log(norm + std::numeric_limits<float>::epsilon()));
 
 		//Moments
@@ -331,7 +331,7 @@
 	//Roll off 85% - 95%
 	/////////////////////////////////////////////////////////
 
-	while ((currEnergy95 <= 0.95 * totalenergy) && (countFFT95 < static_cast<int>(windowSize)))
+	while ((currEnergy95 <= 0.95 * totalenergy) && (countFFT95 < (int)windowSize))
 	{
 		currEnergy95 += (magnitude[countFFT95] * magnitude[countFFT95]);
 		countFFT95 += 1;
@@ -355,7 +355,7 @@
 	}
 	else
 	{
-		rolloff85 = (static_cast<float>(countFFT85) / static_cast<float>(windowSize));
+		rolloff85 = (((float)countFFT85) / (float)windowSize);
 	}
 
 	//Normalization
@@ -366,7 +366,7 @@
 	}
 	else
 	{
-		rolloff95 = (static_cast<float>(countFFT95) / static_cast<float>(windowSize));
+		rolloff95 = (((float)countFFT95) / (float)windowSize);
 	}
 
 	/////////////////////////////////////////////////////
@@ -374,7 +374,7 @@
 	//Spectral Entropy
 	/////////////////////////////////////////////////////////
 
-	spectralentropy = static_cast<float>((normalisedMagSumEntropy / log(static_cast<float>(windowSize))) * - 1);
+	spectralentropy = (float) ((normalisedMagSumEntropy / log((float)windowSize)) * - 1);
 
 	/////////////////////////////////////////////////////////
 
@@ -384,7 +384,7 @@
 	/////////////////////////////////////////////////////////
 	if(totalenergy != 0 && geo != 0)
 	{
-		flatness = geo / (totalenergy / static_cast<float>(windowSize));
+		flatness = geo / (totalenergy / (float)windowSize);
 	}
 	else
 	{
@@ -419,21 +419,21 @@
 
 	zptr = z;
 
-	for (size_t i = 0; i < lenz; i++) 
+	for (size_t i = 0; i < lenz; i++)
 	{
 		s = 0.0;
 		n_lo = 0 > (i - leny + 1 ) ? 0 : (i - leny + 1);
 		n_hi = (lenx - 1) < i ? (lenx - 1): i;
 	    xp = &x[0] + n_lo;
 		yp = &y[0] + i - n_lo;
-		
-		for (size_t n = n_lo; n <= n_hi; n++) 
+
+		for (size_t n = n_lo; n <= n_hi; n++)
 		{
 			s += *xp * *yp;
 			xp++;
 			yp--;
 		}
-		
+
 		*zptr=s;
 		zptr++;
 	}
@@ -449,10 +449,10 @@
     {
         fftSize *= 2;
     }
-    
+
 	FFTW fft1 = FFTW(fftSize);
 	FFTW fft2 = FFTW(fftSize);
-	
+
     // allocate space for FFTW processing
     float *in1 = new float[fftSize];
     float *in2 = new float[fftSize];
@@ -525,41 +525,41 @@
 	fftwf_free(result);
 	fftwf_free(product);
 
-	if(in1 != nullptr)
+	if(in1 != NULL)
 	{
 		delete[] in1;
 		in1 = nullptr;
 	}
 
-	if(in2 != nullptr)
+	if(in2 != NULL)
 	{
 		delete[] in2;
 		in2 = nullptr;
 	}
 
-	if(out1Real != nullptr)
+	if(out1Real != NULL)
 	{
 		delete[] out1Real;
 		out1Real= nullptr;
 	}
 
-	if(out1Imag != nullptr)
+	if(out1Imag != NULL)
 	{
 		delete[] out1Imag;
 		out1Imag= nullptr;
 	}
 
-	if(out2Real != nullptr)
+	if(out2Real != NULL)
 	{
 		delete[] out2Real;
 		out2Real= nullptr;
 	}
 
-	if(out2Imag != nullptr)
+	if(out2Imag != NULL)
 	{
 		delete[] out2Imag;
 		out2Imag= nullptr;
-	}	
+	}
 }
 
 float AudioSourceFeatureExtractor::EstimatePerdiodicity(float* data, size_t numSamples)
@@ -578,7 +578,7 @@
 
 	EnvelopeCurve(downsampleddata, downsampleddata, numSamples, m_fSampleRate);
 
-	auto startLag = static_cast<int>(floor(static_cast<float>(60.0 / 480.0 * 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));
 
@@ -586,7 +586,7 @@
 	//Normalise(downsampleddata, downsampleddata, downsamplelength);
 
 	size_t xcorrlen = 0;
-	XCorr(xcorr, downsampleddata, downsampleddata, xcorrlen, numSamples, endLag);    
+	XCorr(xcorr, downsampleddata, downsampleddata, xcorrlen, numSamples, endLag);
 
 	int i = (int)floor(xcorrlen / 2);
 
@@ -597,7 +597,7 @@
 	}
 
 	std::vector<float> temp2;
-	for(size_t j = static_cast<size_t>(max(1,startLag)); j < static_cast<size_t>(min(endLag,temp.size())); j++)
+	for(size_t j = (size_t)std::max(1,startLag); j < (size_t)std::min(endLag,(int)temp.size()); j++)
 	{
 		temp2.push_back(temp[j]);
 	}
@@ -613,31 +613,31 @@
 		}
 	}
 
-	int from = max(1, maxIdx-thresh);
-	int to = min(temp2.size(), maxIdx+thresh);
+	int from = std::max(1, maxIdx-thresh);
+	int to = std::min((int)temp2.size(), maxIdx+thresh);
 
-	float minValInRange = FLT_MAX;
+	float minValInRange = std::numeric_limits<float>::max();
 
-	for(size_t j = static_cast<size_t>(from); j < to; j++)
-	{	
+	for(size_t j = (size_t)from; j < to; j++)
+	{
 		if(temp2[j] < minValInRange)
 		{
 			minValInRange = temp2[j];
 		}
 	}
-    
+
     periodicity = (maxVal-minValInRange);
 
 	std::string dave = "Periodicity " + std::to_string(periodicity) + "\n";
-	OutputDebugString(dave.c_str());
+	//OutputDebugString(dave.c_str());
 
-	if(xcorr != nullptr)
+	if(xcorr != NULL)
 	{
 		delete[] xcorr;
 		xcorr = nullptr;
 	}
-	
-	if(downsampleddata != nullptr)
+
+	if(downsampleddata != NULL)
 	{
 		delete[] downsampleddata;
 		downsampleddata = nullptr;
@@ -663,14 +663,14 @@
  //
  //
  //   // apply the filter to each input sample
- //   for (size_t n = 0; n < lenIn; n++ ) 
+ //   for (size_t n = 0; n < lenIn; n++ )
 	//{
  //       // calculate output n
  //       coeffp = &coeffs[0];
  //       inputp = &data[filterlength - 1 + n];
 
 	//	acc = 0.0f;
-	//	for (int k = 0; k < filterlength; k++ ) 
+	//	for (int k = 0; k < filterlength; k++ )
 	//	{
 	//		if(inputp <= endp)
 	//			acc += (*coeffp++) * (*inputp--);
@@ -682,8 +682,8 @@
 	//		}
 	//	}
 
-	//	tempdata[n] = acc;		
- //   }		
+	//	tempdata[n] = acc;
+ //   }
 	//int ratio = (int) (currentSampleRate / futureSampleRate);
 	//
 	//lenOut = lenIn / ratio;
@@ -696,8 +696,8 @@
 	//for(size_t i = 0; i < lenIn; i = i + ratio)
 	//{
 	//	out[idx] = tempdata[i];
-	//	idx++;		
-	//}	
+	//	idx++;
+	//}
 
 	//if(tempdata != NULL)
 	//{
@@ -711,10 +711,10 @@
     float release = 0.02f;
 	float envelope = 0.0f;
 
-	float gr = exp(-1 / (sampleRate * release));	
+	float gr = exp(-1 / (sampleRate * release));
 
     for (size_t i = 0; i < dataLen; i++)
-	{ 
+	{
 		float EnvIn = abs(data[i]);
 
 		if(envelope < EnvIn)
@@ -725,9 +725,9 @@
 		{
 			envelope = envelope * gr;
 			envelope = envelope + (1 - gr) * EnvIn;
-		}    
-    
-		out[i] = envelope;    
+		}
+
+		out[i] = envelope;
 	}
 }
 
@@ -829,7 +829,7 @@
 
 			std::vector<int> idxLow;
 			std::vector<int> idxHigh;
-			std::vector<int> filtIdx;			
+			std::vector<int> filtIdx;
 
 			for (size_t j = (size_t)ceilNextBinDown; j <= (size_t)floorFreqBinLin; j++ )
 			{
@@ -864,9 +864,9 @@
 
 			for (size_t j = 0; j < rampUp.size(); j++)
 			{
-				filt.push_back(min(rampUp[j], rampDown[j]));
+				filt.push_back(std::min(rampUp[j], rampDown[j]));
 			}
-			
+
 			float sumfilt = 0.0f;
 			for (size_t j = 0; j < filt.size(); j++)
 			{
@@ -881,7 +881,7 @@
 			for (size_t j = 0; j < filtIdx.size(); j++)
 			{
 				outKrnl[i][filtIdx[j] - 1] = filt[j];
-			}			
+			}
 		}
 	}
 
@@ -909,7 +909,7 @@
 	float ceilNextBinDown = ceil(nextBinDown); //Subtract by -1 because of array
 	float floorFreqBinLin = floor(freqBinLin);
 
-	std::vector<int> filtIdx;			
+	std::vector<int> filtIdx;
 
 	for (size_t i = (size_t)ceilNextBinDown; i <= (size_t)floorFreqBinLin; i++ )
 	{
@@ -919,7 +919,7 @@
 	std::vector<float> filt2;
 	for (size_t i = 0; i < filtIdx.size(); i++)
 	{
-		filt2.push_back(1 - (freqBinLin - filtIdx[i]) / (freqBinLin - nextBinDown));	
+		filt2.push_back(1 - (freqBinLin - filtIdx[i]) / (freqBinLin - nextBinDown));
 	}
 
 	float sumfilt = 0.0f;
@@ -939,10 +939,10 @@
 	}
 }
 
-float AudioSourceFeatureExtractor::Log2(float n)  
-{  
-	// log(n)/log(2) is log2.  
-	return logf( n ) / logf( 2 );  
+float AudioSourceFeatureExtractor::Log2(float n)
+{
+	// log(n)/log(2) is log2.
+	return logf( n ) / logf( 2 );
 }
 
 int AudioSourceFeatureExtractor::Sign(float x)
--- a/Source/AudioSourceFeatureExtractor.h	Thu Jul 09 01:12:16 2015 +0100
+++ b/Source/AudioSourceFeatureExtractor.h	Thu Jul 09 15:01:32 2015 +0100
@@ -55,7 +55,7 @@
 
 	float EntropyOfEnergy(float* data, size_t numSamples);
 
-	void AudioSourceFeatureExtractor::PDF_getResampleKrnl(std::vector<float> freqVec, float fsProc, int nfft, int nBin, std::vector<float> &outLogFreqVec, std::vector<std::vector<float>> &outKrnl);
+	void PDF_getResampleKrnl(std::vector<float> freqVec, float fsProc, int nfft, int nBin, std::vector<float> &outLogFreqVec, std::vector<std::vector<float>> &outKrnl);
 
 	float Log2(float n);
 
@@ -65,8 +65,8 @@
 
 	std::vector<float> LogSpace(float min, float max, int n);
 
-	size_t m_iWriteIdx;	
-	size_t m_iFlucIdx;	
+	size_t m_iWriteIdx;
+	size_t m_iFlucIdx;
 	float  m_fSampleRate;
 	FFTW   *m_fft;
 	float *m_OutReal;
--- a/Source/FFT.cpp	Thu Jul 09 01:12:16 2015 +0100
+++ b/Source/FFT.cpp	Thu Jul 09 15:01:32 2015 +0100
@@ -9,7 +9,7 @@
 */
 
 #include "FFT.h"
-FFT::FastFourierTransform()
-{
-
-}
\ No newline at end of file
+//FFT::FastFourierTransform()
+//{
+//
+//}
--- a/Source/FFTW.h	Thu Jul 09 01:12:16 2015 +0100
+++ b/Source/FFTW.h	Thu Jul 09 15:01:32 2015 +0100
@@ -2,11 +2,11 @@
 /**
  \author André Bergner
  \date   Feb/2013
- 
+
  \class FFTW
- 
+
  Encapsulates the FFT of lib-fftw
- 
+
  (c) Copyright NATIVE INSTRUMENTS, Berlin, Germany
  ALL RIGHTS RESERVED
  */
@@ -15,9 +15,10 @@
 #pragma once
 
 #include "fftw3.h"
-#include <vector>
-#include <windows.h>
-#include <string>
+#include <vector>
+#include <stdio.h>
+//#include <windows.h>
+#include <string.h>
 //#include <itl/dsp/SimdTools.h>
 
 
@@ -29,7 +30,7 @@
    fftwf_plan  m_plan;
   unsigned m_iFFTSize;
 
-  FFTW(); 
+  FFTW();
   FFTW( unsigned fftLength )
   {
 	m_iFFTSize = fftLength;
@@ -71,7 +72,7 @@
 
 	//Multiply results by 2 to match the iOS output
 	for(size_t i = 0; i < m_iFFTSize; i++)
-	{		
+	{
 		realPart[i] *= 2.f;
 		imagPart[i] *= 2.f;
 	}
--- a/Source/FeatureData.cpp	Thu Jul 09 01:12:16 2015 +0100
+++ b/Source/FeatureData.cpp	Thu Jul 09 15:01:32 2015 +0100
@@ -519,7 +519,7 @@
 	avgdeltamfcc.push_back(Average(m_deltamfccs[10]));
 	avgdeltamfcc.push_back(Average(m_deltamfccs[11]));
 
-	//for(size_t i =0; i < m_PooledObservationDataAverage.size(); i++)
+	for(size_t i =0; i < m_PooledObservationDataAverage.size(); i++)
 	{
 		obs = ObservationData(avgrms, avgpeak, avgcrestFactor, avgzcr, avgcentroid, avgspread, avgskewness, avgkurtosis, avgbrightness, avgrolloff85, avgrolloff95, avgspectralentropy, avgflatness, avgspectralcf, avgspectralflux, avgmfcc, avgdeltamfcc, m_ObservationData[0].GetPeriodicity(), m_ObservationData[0].GetEntropyOfEnergy());
 		obs.SetLowEnergy(m_ObservationData[0].GetLowEnergy());
--- a/Source/MFCC.cpp	Thu Jul 09 01:12:16 2015 +0100
+++ b/Source/MFCC.cpp	Thu Jul 09 15:01:32 2015 +0100
@@ -10,14 +10,14 @@
 
 #include "MFCC.h"
 #include <math.h>
-#include <windows.h>
+//#include <windows.h>
 
 //-----------------------------------------------------------------------------  ComputeMFCC
 void MFCC::ComputeMFCC(float* magnitude, std::vector<float> &mfccs)
 {
   //Apply the Mel Filters to the spectrum magnitude:
   for(int i=0; i<m_iTotalMFCCFilters; i++)
-  {  
+  {
 	//Multiply spectrum with spectral mask
 	vDSP_vmul(magnitude, 1,	m_ppMFCCFilters[i],	1, m_pfTempMelFilterResult, 1, m_pMFCCFilterLength[i]);
 
@@ -27,12 +27,12 @@
     //Log compression
     float filterOut = log10(m_fMelFilteredFFT[i]*10.f+1.f);
     m_fMelFilteredFFT[i]=filterOut;
-  }  
+  }
 
   for(int j = 0; j < m_iNumMFCCCoefs; j++)
   {
 	  //Cosine Transform to reduce dimensionality:
-	  vDSP_mmul(m_ppMFFC_DCT, 1, m_fMelFilteredFFT, 1, m_pMFCC, 1, m_iNumMFCCCoefs, 1, m_iTotalMFCCFilters);  
+	  vDSP_mmul(m_ppMFFC_DCT, 1, m_fMelFilteredFFT, 1, m_pMFCC, 1, m_iNumMFCCCoefs, 1, m_iTotalMFCCFilters);
 	  mfccs.push_back(m_pMFCC[j]);
   }
 
@@ -47,7 +47,7 @@
   m_pMFCC = new float[m_iNumMFCCCoefs];
 
   //Add a value to take into account the 0 coefficient
-  int iStartMfccCoeff = 1;   
+  int iStartMfccCoeff = 1;
 
   //Mel FilterBank parameters
   float fLowestFreq       = 133.3333f;
@@ -132,54 +132,54 @@
 //-----------------------------------------------------------------------------  freeMFCCmemory
 void MFCC::freeMFCCmemory()
 {
-	if(m_pMFCC != NULL)
-	{				        
-		delete(m_pMFCC);					        
+	if(m_pMFCC != nullptr)
+	{
+		delete(m_pMFCC);
 		m_pMFCC=nullptr;
 	}
-  
-	if(m_ppMFFC_DCT != NULL)
-	{						
-		delete(m_ppMFFC_DCT);				      
+
+	if(m_ppMFFC_DCT != nullptr)
+	{
+		delete(m_ppMFFC_DCT);
 		m_ppMFFC_DCT=nullptr;
 	}
-  
-	if(m_fMelFilteredFFT != NULL)
-	{				
-		delete(m_fMelFilteredFFT);		    
+
+	if(m_fMelFilteredFFT != nullptr)
+	{
+		delete(m_fMelFilteredFFT);
 		m_fMelFilteredFFT=nullptr;
 	}
-  
-	if(m_pMFCCFilterStart != NULL)
-	{				
-		delete(m_pMFCCFilterStart);		    
+
+	if(m_pMFCCFilterStart != nullptr)
+	{
+		delete(m_pMFCCFilterStart);
 		m_pMFCCFilterStart=nullptr;
 	}
-  
-	if(m_pMFCCFilterLength != NULL)
-	{				
-		delete(m_pMFCCFilterLength);		  
+
+	if(m_pMFCCFilterLength != nullptr)
+	{
+		delete(m_pMFCCFilterLength);
 		m_pMFCCFilterLength=nullptr;
 	}
-  
-	if(m_pfTempMelFilterResult != NULL)
+
+	if(m_pfTempMelFilterResult != nullptr)
 	{
-		delete(m_pfTempMelFilterResult);  
+		delete(m_pfTempMelFilterResult);
 		m_pfTempMelFilterResult=nullptr;
 	}
 
-	if(m_ppMFCCFilters != NULL)
+	if(m_ppMFCCFilters != nullptr)
 	{
 		for(int i=0; i<m_iTotalMFCCFilters; i++)
 		{
-			if(m_ppMFCCFilters[i] != NULL)
-			{ 
+			if(m_ppMFCCFilters[i] != nullptr)
+			{
 				delete(m_ppMFCCFilters[i]);
 				m_ppMFCCFilters[i]=nullptr;
 			}
 		}
 
-		delete (m_ppMFCCFilters); 
+		delete (m_ppMFCCFilters);
 		m_ppMFCCFilters=nullptr;
 	}
 }
@@ -217,7 +217,7 @@
     {
       fProdSum+=v1[m * P + p] * v2[p];
     }
-    
+
 	vout[m]=fProdSum;
   }
-}
\ No newline at end of file
+}
--- a/Source/ParseCSV.cpp	Thu Jul 09 01:12:16 2015 +0100
+++ b/Source/ParseCSV.cpp	Thu Jul 09 15:01:32 2015 +0100
@@ -22,13 +22,13 @@
 
 ParseCSV::~ParseCSV()
 {
-	
+
 };
 
 AudioFileData ParseCSV::Parse(std::string fileName)
 {
 	//open the file from which to read the data
-	std::ifstream myFile = std::ifstream();
+	std::ifstream myFile;// = std::ifstream();
 
 	myFile.open(fileName, std::ifstream::in);
 
@@ -68,7 +68,7 @@
 		}
 
 		fileNames.push_back(newfile);
-		labels.push_back(newlabel);		
+		labels.push_back(newlabel);
 	}
 
 	m_AudioFileData = AudioFileData(fileNames, labels);
@@ -89,4 +89,4 @@
 	}
 
 	return lines;
-}
\ No newline at end of file
+}
--- a/Source/WriteCSV.cpp	Thu Jul 09 01:12:16 2015 +0100
+++ b/Source/WriteCSV.cpp	Thu Jul 09 15:01:32 2015 +0100
@@ -14,7 +14,7 @@
 #include <string>
 #include <vector>
 #include <time.h>
-#include <windows.h>
+//#include <windows.h>
 
 WriteCSV::WriteCSV(){};
 WriteCSV::~WriteCSV(){};
@@ -24,7 +24,7 @@
 void WriteCSV::Write(std::string filename, FeatureData data)
 {
 	//Pooled
-	std::string pooledfilename = filename + "Pooled" + std::to_string(data.GetPoolingTimeFactor()) + "Sec.csv"; 
+	std::string pooledfilename = filename + "Pooled" + std::to_string(data.GetPoolingTimeFactor()) + "Sec.csv";
 	std::ofstream foutPooled(pooledfilename, std::ios::app|std::ios::out);
 
 	std::vector<ObservationData> observationDataAverage = data.GetPooldedObservationDataAverage();
@@ -56,38 +56,38 @@
 				<< observationDataStd[j].GetZCR() << ','
 				<< observationDataMax[j].GetZCR() << ','
 				<< observationDataMin[j].GetZCR() << ','
-				<< observationDataAverage[j].GetCentroid() << ',' 
-				<< observationDataStd[j].GetCentroid() << ',' 
-				<< observationDataMax[j].GetCentroid() << ',' 
-				<< observationDataMin[j].GetCentroid() << ',' 
-				<< observationDataAverage[j].GetSpread() << ',' 
-				<< observationDataStd[j].GetSpread() << ',' 
-				<< observationDataMax[j].GetSpread() << ',' 
-				<< observationDataMin[j].GetSpread() << ',' 
-				<< observationDataAverage[j].GetSkewness() << ',' 
-				<< observationDataStd[j].GetSkewness() << ',' 
-				<< observationDataMax[j].GetSkewness() << ',' 
-				<< observationDataMin[j].GetSkewness() << ',' 
-				<< observationDataAverage[j].GetKurtosis() << ',' 
-				<< observationDataStd[j].GetKurtosis() << ',' 
-				<< observationDataMax[j].GetKurtosis() << ',' 
-				<< observationDataMin[j].GetKurtosis() << ',' 
-				<< observationDataAverage[j].GetBrightness() << ',' 
-				<< observationDataStd[j].GetBrightness() << ',' 
-				<< observationDataMax[j].GetBrightness() << ',' 
-				<< observationDataMin[j].GetBrightness() << ',' 
+				<< observationDataAverage[j].GetCentroid() << ','
+				<< observationDataStd[j].GetCentroid() << ','
+				<< observationDataMax[j].GetCentroid() << ','
+				<< observationDataMin[j].GetCentroid() << ','
+				<< observationDataAverage[j].GetSpread() << ','
+				<< observationDataStd[j].GetSpread() << ','
+				<< observationDataMax[j].GetSpread() << ','
+				<< observationDataMin[j].GetSpread() << ','
+				<< observationDataAverage[j].GetSkewness() << ','
+				<< observationDataStd[j].GetSkewness() << ','
+				<< observationDataMax[j].GetSkewness() << ','
+				<< observationDataMin[j].GetSkewness() << ','
+				<< observationDataAverage[j].GetKurtosis() << ','
+				<< observationDataStd[j].GetKurtosis() << ','
+				<< observationDataMax[j].GetKurtosis() << ','
+				<< observationDataMin[j].GetKurtosis() << ','
+				<< observationDataAverage[j].GetBrightness() << ','
+				<< observationDataStd[j].GetBrightness() << ','
+				<< observationDataMax[j].GetBrightness() << ','
+				<< observationDataMin[j].GetBrightness() << ','
 				<< observationDataAverage[j].GetFlatness() << ','
 				<< observationDataStd[j].GetFlatness() << ','
 				<< observationDataMax[j].GetFlatness() << ','
 				<< observationDataMin[j].GetFlatness() << ','
-				<< observationDataAverage[j].GetRollOff85() << ','  
-				<< observationDataStd[j].GetRollOff85() << ','  
-				<< observationDataMax[j].GetRollOff85() << ','  
-				<< observationDataMin[j].GetRollOff85() << ','  
-				<< observationDataAverage[j].GetRollOff95() << ','  
-				<< observationDataStd[j].GetRollOff95() << ','  
-				<< observationDataMax[j].GetRollOff95() << ','  
-				<< observationDataMin[j].GetRollOff95() << ','  
+				<< observationDataAverage[j].GetRollOff85() << ','
+				<< observationDataStd[j].GetRollOff85() << ','
+				<< observationDataMax[j].GetRollOff85() << ','
+				<< observationDataMin[j].GetRollOff85() << ','
+				<< observationDataAverage[j].GetRollOff95() << ','
+				<< observationDataStd[j].GetRollOff95() << ','
+				<< observationDataMax[j].GetRollOff95() << ','
+				<< observationDataMin[j].GetRollOff95() << ','
 				<< observationDataAverage[j].GetSpectralEntropy() << ','
 				<< observationDataStd[j].GetSpectralEntropy() << ','
 				<< observationDataMax[j].GetSpectralEntropy() << ','
@@ -196,23 +196,23 @@
 				<< observationDataStd[j].GetDeltaMFCCs()[11] << ','
 				<< observationDataMax[j].GetDeltaMFCCs()[11] << ','
 				<< observationDataMin[j].GetDeltaMFCCs()[11] << ','
-				<< observationDataAverage[j].GetLowEnergy() << ',' 
-				<< observationDataAverage[j].GetPeriodicity() << ',' 
-				<< observationDataAverage[j].GetEntropyOfEnergy() << ',' 
+				<< observationDataAverage[j].GetLowEnergy() << ','
+				<< observationDataAverage[j].GetPeriodicity() << ','
+				<< observationDataAverage[j].GetEntropyOfEnergy() << ','
 				<< label << ',' ;
 			foutPooled << "\n";
-		} 
+		}
 	}
 	else
 	{
 		std::cout << "ERROR: Can't write to .csv.";
 	}
-	   
+
 	 foutPooled.close();
 
 	//WholeTrack
 
-	std::string wholetrackfilename = filename + "Whole" + std::to_string(data.GetPoolingTimeFactor()) + "Sec.csv"; 
+	std::string wholetrackfilename = filename + "Whole" + std::to_string(data.GetPoolingTimeFactor()) + "Sec.csv";
 	std::ofstream foutWholeTrack(wholetrackfilename, std::ios::app|std::ios::out);
 
 	std::vector<ObservationData> wholeTrackobservationDataAverage = data.GetWholeTrackObservationDataAverage();
@@ -249,7 +249,7 @@
 				<< wholeTrackobservationDataStd[j].GetSpread() << ',' //22
 				<< wholeTrackobservationDataMax[j].GetSpread() << ',' //23
 				<< wholeTrackobservationDataMin[j].GetSpread() << ',' //24
-				<< wholeTrackobservationDataAverage[j].GetSkewness() << ',' //25 
+				<< wholeTrackobservationDataAverage[j].GetSkewness() << ',' //25
 				<< wholeTrackobservationDataStd[j].GetSkewness() << ',' //26
 				<< wholeTrackobservationDataMax[j].GetSkewness() << ',' //27
 				<< wholeTrackobservationDataMin[j].GetSkewness() << ',' //28
@@ -257,7 +257,7 @@
 				<< wholeTrackobservationDataStd[j].GetKurtosis() << ',' //30
 				<< wholeTrackobservationDataMax[j].GetKurtosis() << ',' //31
 				<< wholeTrackobservationDataMin[j].GetKurtosis() << ',' //32
-				<< wholeTrackobservationDataAverage[j].GetBrightness() << ',' //33 
+				<< wholeTrackobservationDataAverage[j].GetBrightness() << ',' //33
 				<< wholeTrackobservationDataStd[j].GetBrightness() << ',' //34
 				<< wholeTrackobservationDataMax[j].GetBrightness() << ','  //35
 				<< wholeTrackobservationDataMin[j].GetBrightness() << ',' //36
@@ -265,7 +265,7 @@
 				<< wholeTrackobservationDataStd[j].GetFlatness() << ',' //38
 				<< wholeTrackobservationDataMax[j].GetFlatness() << ','//39
 				<< wholeTrackobservationDataMin[j].GetFlatness() << ','//40
-				<< wholeTrackobservationDataAverage[j].GetRollOff85() << ',' //41  
+				<< wholeTrackobservationDataAverage[j].GetRollOff85() << ',' //41
 				<< wholeTrackobservationDataStd[j].GetRollOff85() << ','  //42
 				<< wholeTrackobservationDataMax[j].GetRollOff85() << ','  //43
 				<< wholeTrackobservationDataMin[j].GetRollOff85() << ','  //44
@@ -382,26 +382,26 @@
 				<< wholeTrackobservationDataMax[j].GetDeltaMFCCs()[11] << ',' //91
 				<< wholeTrackobservationDataMin[j].GetDeltaMFCCs()[11] << ',' //92
 				<< wholeTrackobservationDataAverage[j].GetLowEnergy() << ',' //93
-				<< wholeTrackobservationDataAverage[j].GetPeriodicity() << ',' //94 
-				<< wholeTrackobservationDataAverage[j].GetEntropyOfEnergy() << ',' //95 
+				<< wholeTrackobservationDataAverage[j].GetPeriodicity() << ',' //94
+				<< wholeTrackobservationDataAverage[j].GetEntropyOfEnergy() << ',' //95
 				<< label << ',' ;
 			foutWholeTrack << "\n";
-		} 
+		}
 	}
 	else
 	{
 		std::cout << "ERROR: Can't write to .csv.";
 	}
-	   
+
 	 foutWholeTrack.close();
 
 	 std::string dave = "Files written: " + std::to_string(count) + "  Obs Data Size:" + std::to_string(wholeTrackobservationDataAverage.size())+  "\n";
-	 OutputDebugString(dave.c_str());
+//	 OutputDebugString(dave.c_str());
 	 count++;
 };
 
 // Get current date/time, format is YYYY-MM-DD.HH:mm:ss
-const std::string WriteCSV::currentDateTime() 
+const std::string WriteCSV::currentDateTime()
 {
     time_t     now = time(0);
     struct tm  tstruct;
@@ -410,4 +410,4 @@
     strftime(buf, sizeof(buf), "%Y-%m-%d.%H-%M-%S", &tstruct);
 
     return buf;
-}
\ No newline at end of file
+}