Convert synchronized timestamps to doubles instead of floats

medengineer · medengineer · commit 700b38f1d798 · 2020-08-19T11:09:00.000-07:00
diff --git a/JuceLibraryCode/modules/juce_audio_basics/buffers/juce_AudioSampleBuffer.h b/JuceLibraryCode/modules/juce_audio_basics/buffers/juce_AudioSampleBuffer.h
@@ -1069,5 +1069,8 @@ class AudioBuffer
 */
 typedef AudioBuffer<float> AudioSampleBuffer;
 
+// Add AudioBuffer of doubles to hold synchronized timestamps
+typedef AudioBuffer<double> SynchronizedTimestampBuffer;
+
 
 #endif   // JUCE_AUDIOSAMPLEBUFFER_H_INCLUDED
diff --git a/Source/Processors/RecordNode/BinaryFormat/BinaryRecording.cpp b/Source/Processors/RecordNode/BinaryFormat/BinaryRecording.cpp
@@ -104,7 +104,7 @@ void BinaryRecording::openFiles(File rootFolder, int experimentNumber, int recor
                 ScopedPointer<NpyFile> tFile = new NpyFile(contPath + datPath + "timestamps.npy", NpyType(BaseType::INT64,1));
                 m_dataTimestampFiles.add(tFile.release());
 
-                ScopedPointer<NpyFile> ftsFile = new NpyFile(contPath + datPath + "synchronized_timestamps.npy", NpyType(BaseType::FLOAT,1));
+                ScopedPointer<NpyFile> ftsFile = new NpyFile(contPath + datPath + "synchronized_timestamps.npy", NpyType(BaseType::DOUBLE,1));
                 m_dataFloatTimestampFiles.add(ftsFile.release());
 
                 m_fileIndexes.set(recordedChan, nInfoArrays);
@@ -513,7 +513,7 @@ void BinaryRecording::increaseEventCounts(EventRecording* rec)
     if (rec->metaDataFile) rec->metaDataFile->increaseRecordCount();
 }
 
-void BinaryRecording::writeSynchronizedData(int writeChannel, int realChannel, const float* dataBuffer, const float* ftsBuffer, int size)
+void BinaryRecording::writeSynchronizedData(int writeChannel, int realChannel, const float* dataBuffer, const double* ftsBuffer, int size)
 {
 
     if (!size)  
@@ -558,7 +558,7 @@ void BinaryRecording::writeSynchronizedData(int writeChannel, int realChannel, c
 
         //LOGD("BinaryRecording::writeSynchronizedData: ", *ftsBuffer);
 
-        m_dataFloatTimestampFiles[fileIndex]->writeData(ftsBuffer, size*sizeof(float));
+        m_dataFloatTimestampFiles[fileIndex]->writeData(ftsBuffer, size*sizeof(double));
         m_dataFloatTimestampFiles[fileIndex]->increaseRecordCount(size);
         
 	}
diff --git a/Source/Processors/RecordNode/BinaryFormat/BinaryRecording.h b/Source/Processors/RecordNode/BinaryFormat/BinaryRecording.h
@@ -21,7 +21,7 @@ class BinaryRecording : public RecordEngine
 	void closeFiles() override;
 	void resetChannels() override;
 	void writeData(int writeChannel, int realChannel, const float* buffer, int size) override;
-	void writeSynchronizedData(int writeChannel, int realChannel, const float* dataBuffer, const float* ftsBuffer, int size) override;
+	void writeSynchronizedData(int writeChannel, int realChannel, const float* dataBuffer, const double* ftsBuffer, int size) override;
 	void writeEvent(int eventIndex, const MidiMessage& event) override;
 	void addSpikeElectrode(int index, const SpikeChannel* elec) override;
 	void writeSpike(int electrodeIndex, const SpikeEvent* spike) override;
diff --git a/Source/Processors/RecordNode/DataQueue.cpp b/Source/Processors/RecordNode/DataQueue.cpp
@@ -134,7 +134,7 @@ void DataQueue::fillTimestamps(int channel, int index, int size, int64 timestamp
 	}
 }
 
-void DataQueue::writeSynchronizedTimestampChannel(float start, float step, int destChannel, int64 nSamples)
+void DataQueue::writeSynchronizedTimestampChannel(double start, double step, int destChannel, int64 nSamples)
 {
 
 	int index1, size1, index2, size2;
@@ -153,7 +153,7 @@ void DataQueue::writeSynchronizedTimestampChannel(float start, float step, int d
 	for (int i = 0; i < size1; i++)
 	{
 		//LOGD("setSample: ", start + (float)i*step);
-		m_FTSBuffer.setSample(destChannel, index1+i, start+(float)i*step);
+		m_FTSBuffer.setSample(destChannel, index1+i, start+(double)i*step);
 		//LOGD("Set sample ", index1+i, " to ", start);
 		//m_FTSBuffer.setSample(destChannel, index1+i, start + (float)i*step);
 	}
@@ -163,7 +163,7 @@ void DataQueue::writeSynchronizedTimestampChannel(float start, float step, int d
 		for (int i = 0; i < size2; i++)
 		{
 			//m_FTSBuffer.setSample(destChannel, index2+i, start + (float)i*step);
-			m_FTSBuffer.setSample(destChannel, index2 + i, start+(float)size1*step + float(i*step));
+			m_FTSBuffer.setSample(destChannel, index2 + i, start+(double)size1*step + double(i*step));
 		}
 	}
 
@@ -217,7 +217,7 @@ const AudioSampleBuffer& DataQueue::getAudioBufferReference() const
 	return m_buffer;
 }
 
-const AudioSampleBuffer& DataQueue::getFTSBufferReference() const
+const SynchronizedTimestampBuffer& DataQueue::getFTSBufferReference() const
 {
 	return m_FTSBuffer;
 }
diff --git a/Source/Processors/RecordNode/DataQueue.h b/Source/Processors/RecordNode/DataQueue.h
@@ -50,11 +50,11 @@ class DataQueue
 	//Only the methods after this comment are considered thread-safe.
 	//Caution must be had to avoid calling more than one of the methods above simulatenously
 	void writeChannel(const AudioSampleBuffer& buffer, int srcChannel, int destChannel, int nSamples, int64 timestamp);
-	void writeSynchronizedTimestampChannel(float start, float step, int destChannel, int64 nSamples);
+	void writeSynchronizedTimestampChannel(double start, double step, int destChannel, int64 nSamples);
 	bool startRead(Array<CircularBufferIndexes>& indexes, Array<int64>& timestamps, int nMax);
 	bool startSynchronizedRead(Array<CircularBufferIndexes>& dataIndexes, Array<CircularBufferIndexes>& ftsIndexes, Array<int64>& timestamps, int nMax);
 	const AudioSampleBuffer& getAudioBufferReference() const;
-	const AudioSampleBuffer& getFTSBufferReference() const;
+	const SynchronizedTimestampBuffer& getFTSBufferReference() const;
 	void stopRead();
 	void stopSynchronizedRead();
 
@@ -67,7 +67,7 @@ class DataQueue
 	OwnedArray<AbstractFifo> m_FTSFifos;
 
 	AudioSampleBuffer m_buffer;
-	AudioSampleBuffer m_FTSBuffer;
+	SynchronizedTimestampBuffer m_FTSBuffer;
 
 	Array<int> m_readSamples;
 	Array<int> m_readFTSSamples;
diff --git a/Source/Processors/RecordNode/OpenEphysFormat/OriginalRecording.cpp b/Source/Processors/RecordNode/OpenEphysFormat/OriginalRecording.cpp
@@ -445,7 +445,7 @@ void OriginalRecording::writeTTLEvent(int eventIndex, const MidiMessage& event)
 	diskWriteLock.exit();
 }
 
-void OriginalRecording::writeSynchronizedData(int writeChannel, int realChannel, const float* dataBuffer, const float* ftsBuffer, int size) {};
+void OriginalRecording::writeSynchronizedData(int writeChannel, int realChannel, const float* dataBuffer, const double* ftsBuffer, int size) {};
 
 void OriginalRecording::writeData(int writeChannel, int realChannel, const float* buffer, int size)
 {
diff --git a/Source/Processors/RecordNode/OpenEphysFormat/OriginalRecording.h b/Source/Processors/RecordNode/OpenEphysFormat/OriginalRecording.h
@@ -47,7 +47,7 @@ class OriginalRecording : public RecordEngine
 	void openFiles(File rootFolder, int experimentNumber, int recordingNumber) override;
 	void closeFiles() override;
 	void writeData(int writeChannel, int realChannel, const float* buffer, int size) override;
-	void writeSynchronizedData(int writeChannel, int realChannel, const float* dataBuffer, const float* ftsBuffer, int size) override;
+	void writeSynchronizedData(int writeChannel, int realChannel, const float* dataBuffer, const double* ftsBuffer, int size) override;
 	void writeEvent(int eventIndex, const MidiMessage& event) override;
 	void resetChannels() override;
 	void addSpikeElectrode(int index, const SpikeChannel* elec) override;
diff --git a/Source/Processors/RecordNode/RecordEngine.h b/Source/Processors/RecordNode/RecordEngine.h
@@ -103,7 +103,7 @@ class PLUGIN_API RecordEngine
 	virtual void writeData(int writeChannel, int realChannel, const float* buffer, int size) = 0;
 
 	/** Write continuous data for a channel with synchronized float timestamps */
-	virtual void writeSynchronizedData(int writeChannel, int realChannel, const float* dataBuffer, const float* ftsBuffer, int size) = 0;
+	virtual void writeSynchronizedData(int writeChannel, int realChannel, const float* dataBuffer, const double* ftsBuffer, int size) = 0;
 
 	/** Called by the record thread after it has written a channel block */
 	virtual void endChannelBlock(bool lastBlock);
diff --git a/Source/Processors/RecordNode/RecordNode.cpp b/Source/Processors/RecordNode/RecordNode.cpp
@@ -587,8 +587,8 @@ void RecordNode::process(AudioSampleBuffer& buffer)
 
 				if (isFirstChannelInRecordedSubprocessor(channelMap[ch]))
 				{
-					float first = synchronizer->convertTimestamp(sourceID, subProcIdx, timestamp);
-					float second = synchronizer->convertTimestamp(sourceID, subProcIdx, timestamp + 1);
+					double first = synchronizer->convertTimestamp(sourceID, subProcIdx, timestamp);
+					double second = synchronizer->convertTimestamp(sourceID, subProcIdx, timestamp + 1);
 					dataQueue->writeSynchronizedTimestampChannel(first, second - first, ftsChannelMap[ch], numSamples);
 				}
 
diff --git a/Source/Processors/RecordNode/RecordThread.cpp b/Source/Processors/RecordNode/RecordThread.cpp
@@ -89,7 +89,7 @@ void RecordThread::setFirstBlockFlag(bool state)
 void RecordThread::run()
 {
 	const AudioSampleBuffer& dataBuffer = m_dataQueue->getAudioBufferReference();
-	const AudioSampleBuffer& ftsBuffer = m_dataQueue->getFTSBufferReference();
+	const SynchronizedTimestampBuffer& ftsBuffer = m_dataQueue->getFTSBufferReference();
 
 	bool closeEarly = true;
 	//1-Wait until the first block has arrived, so we can align the timestamps
@@ -147,7 +147,7 @@ void RecordThread::run()
 
 }
 
-void RecordThread::writeSynchronizedData(const AudioSampleBuffer& dataBuffer, const AudioSampleBuffer& ftsBuffer, int maxSamples, int maxEvents, int maxSpikes, bool lastBlock)
+void RecordThread::writeSynchronizedData(const AudioSampleBuffer& dataBuffer, const SynchronizedTimestampBuffer& ftsBuffer, int maxSamples, int maxEvents, int maxSpikes, bool lastBlock)
 {
 
 	Array<int64> timestamps;
diff --git a/Source/Processors/RecordNode/RecordThread.h b/Source/Processors/RecordNode/RecordThread.h
@@ -57,7 +57,7 @@ class RecordThread : public Thread
 
 private:
 	void writeData(const AudioSampleBuffer& buffer, int maxSamples, int maxEvents, int maxSpikes, bool lastBlock = false);
-	void writeSynchronizedData(const AudioSampleBuffer& dataBuffer, const AudioSampleBuffer& ftsBuffer, int maxSamples, int maxEvents, int maxSpikes, bool lastBlock = false);
+	void writeSynchronizedData(const AudioSampleBuffer& dataBuffer, const SynchronizedTimestampBuffer& ftsBuffer, int maxSamples, int maxEvents, int maxSpikes, bool lastBlock = false);
 
 	//const OwnedArray<RecordEngine>& m_engineArray;
 	const ScopedPointer<RecordEngine>& m_engine;
diff --git a/Source/Processors/RecordNode/Synchronizer.cpp b/Source/Processors/RecordNode/Synchronizer.cpp
@@ -113,6 +113,12 @@ void Subprocessor::reset()
 	startSampleMasterTime = -1.0f;
 	lastSampleMasterTime = -1.0f;
 
+	actualSampleRate = -1.0f;
+	startSample = -1;
+	lastSample = -1;
+
+	receivedEventInWindow = false;
+	receivedMasterTimeInWindow = false;
 	isSynchronized = false;
 
 }
@@ -157,9 +163,7 @@ void Subprocessor::closeSyncWindow()
 			lastSample = tempSampleNum;
 			lastSampleMasterTime = tempMasterTime;
 
-			float expectedIntervalSec = (lastSample - startSample) / expectedSampleRate;
-			float ratio = (lastSampleMasterTime - startSampleMasterTime) / expectedIntervalSec;
-			float tempSampleRate = expectedSampleRate / ratio;
+			double tempSampleRate = (lastSample - startSample) / (lastSampleMasterTime - startSampleMasterTime);
 
 			if (actualSampleRate < 0.0f)
 			{
@@ -299,17 +303,17 @@ void Synchronizer::addEvent(int sourceID, int subProcIdx, int ttlChannel, int sa
 	}
 }
 
-float Synchronizer::convertTimestamp(int sourceID, int subProcID, int sampleNumber)
+double Synchronizer::convertTimestamp(int sourceID, int subProcID, int sampleNumber)
 {
 
 	if (subprocessors[sourceID][subProcID]->isSynchronized)
 	{
-		return (sampleNumber - subprocessors[sourceID][subProcID]->startSample) /
+		return (double)(sampleNumber - subprocessors[sourceID][subProcID]->startSample) /
 			subprocessors[sourceID][subProcID]->actualSampleRate +
 			subprocessors[sourceID][subProcID]->startSampleMasterTime;
 	}
 	else {
-		return -1.0f;
+		return (double)-1.0;
 	}
 }
 
diff --git a/Source/Processors/RecordNode/Synchronizer.h b/Source/Processors/RecordNode/Synchronizer.h
@@ -94,7 +94,7 @@ class Synchronizer : public HighResolutionTimer
 
     void addEvent(int sourceID, int subProcessorID, int ttlChannel, int sampleNumber);
 
-    float convertTimestamp(int sourceID, int subProcID, int sampleNumber);
+    double convertTimestamp(int sourceID, int subProcID, int sampleNumber);
 
     std::map<int, std::map<int, Subprocessor*>> subprocessors;
 

Original file line number	Diff line number	Diff line change
`@@ -104,7 +104,7 @@ void BinaryRecording::openFiles(File rootFolder, int experimentNumber, int recor`
`104`	`104`	`ScopedPointer<NpyFile> tFile = new NpyFile(contPath + datPath + "timestamps.npy", NpyType(BaseType::INT64,1));`
`105`	`105`	`m_dataTimestampFiles.add(tFile.release());`
`106`	`106`
`107`		`- ScopedPointer<NpyFile> ftsFile = new NpyFile(contPath + datPath + "synchronized_timestamps.npy", NpyType(BaseType::FLOAT,1));`
	`107`	`+ ScopedPointer<NpyFile> ftsFile = new NpyFile(contPath + datPath + "synchronized_timestamps.npy", NpyType(BaseType::DOUBLE,1));`
`108`	`108`	`m_dataFloatTimestampFiles.add(ftsFile.release());`
`109`	`109`
`110`	`110`	`m_fileIndexes.set(recordedChan, nInfoArrays);`
`@@ -513,7 +513,7 @@ void BinaryRecording::increaseEventCounts(EventRecording* rec)`
`513`	`513`	`if (rec->metaDataFile) rec->metaDataFile->increaseRecordCount();`
`514`	`514`	`}`
`515`	`515`
`516`		`-void BinaryRecording::writeSynchronizedData(int writeChannel, int realChannel, const float* dataBuffer, const float* ftsBuffer, int size)`
	`516`	`+void BinaryRecording::writeSynchronizedData(int writeChannel, int realChannel, const float* dataBuffer, const double* ftsBuffer, int size)`
`517`	`517`	`{`
`518`	`518`
`519`	`519`	`if (!size)`
`@@ -558,7 +558,7 @@ void BinaryRecording::writeSynchronizedData(int writeChannel, int realChannel, c`
`558`	`558`
`559`	`559`	`//LOGD("BinaryRecording::writeSynchronizedData: ", *ftsBuffer);`
`560`	`560`
`561`		`- m_dataFloatTimestampFiles[fileIndex]->writeData(ftsBuffer, size*sizeof(float));`
	`561`	`+ m_dataFloatTimestampFiles[fileIndex]->writeData(ftsBuffer, size*sizeof(double));`
`562`	`562`	`m_dataFloatTimestampFiles[fileIndex]->increaseRecordCount(size);`
`563`	`563`
`564`	`564`	`}`
Original file line number	Diff line number	Diff line change
`@@ -134,7 +134,7 @@ void DataQueue::fillTimestamps(int channel, int index, int size, int64 timestamp`
`134`	`134`	`}`
`135`	`135`	`}`
`136`	`136`
`137`		`-void DataQueue::writeSynchronizedTimestampChannel(float start, float step, int destChannel, int64 nSamples)`
	`137`	`+void DataQueue::writeSynchronizedTimestampChannel(double start, double step, int destChannel, int64 nSamples)`
`138`	`138`	`{`
`139`	`139`
`140`	`140`	`int index1, size1, index2, size2;`
`@@ -153,7 +153,7 @@ void DataQueue::writeSynchronizedTimestampChannel(float start, float step, int d`
`153`	`153`	`for (int i = 0; i < size1; i++)`
`154`	`154`	`{`
`155`	`155`	`//LOGD("setSample: ", start + (float)i*step);`
`156`		`- m_FTSBuffer.setSample(destChannel, index1+i, start+(float)i*step);`
	`156`	`+ m_FTSBuffer.setSample(destChannel, index1+i, start+(double)i*step);`
`157`	`157`	`//LOGD("Set sample ", index1+i, " to ", start);`
`158`	`158`	`//m_FTSBuffer.setSample(destChannel, index1+i, start + (float)i*step);`
`159`	`159`	`}`
`@@ -163,7 +163,7 @@ void DataQueue::writeSynchronizedTimestampChannel(float start, float step, int d`
`163`	`163`	`for (int i = 0; i < size2; i++)`
`164`	`164`	`{`
`165`	`165`	`//m_FTSBuffer.setSample(destChannel, index2+i, start + (float)i*step);`
`166`		`- m_FTSBuffer.setSample(destChannel, index2 + i, start+(float)size1step + float(istep));`
	`166`	`+ m_FTSBuffer.setSample(destChannel, index2 + i, start+(double)size1step + double(istep));`
`167`	`167`	`}`
`168`	`168`	`}`
`169`	`169`
`@@ -217,7 +217,7 @@ const AudioSampleBuffer& DataQueue::getAudioBufferReference() const`
`217`	`217`	`return m_buffer;`
`218`	`218`	`}`
`219`	`219`
`220`		`-const AudioSampleBuffer& DataQueue::getFTSBufferReference() const`
	`220`	`+const SynchronizedTimestampBuffer& DataQueue::getFTSBufferReference() const`
`221`	`221`	`{`
`222`	`222`	`return m_FTSBuffer;`
`223`	`223`	`}`
Original file line number	Diff line number	Diff line change
`@@ -445,7 +445,7 @@ void OriginalRecording::writeTTLEvent(int eventIndex, const MidiMessage& event)`
`445`	`445`	`diskWriteLock.exit();`
`446`	`446`	`}`
`447`	`447`
`448`		`-void OriginalRecording::writeSynchronizedData(int writeChannel, int realChannel, const float* dataBuffer, const float* ftsBuffer, int size) {};`
	`448`	`+void OriginalRecording::writeSynchronizedData(int writeChannel, int realChannel, const float* dataBuffer, const double* ftsBuffer, int size) {};`
`449`	`449`
`450`	`450`	`void OriginalRecording::writeData(int writeChannel, int realChannel, const float* buffer, int size)`
`451`	`451`	`{`
Original file line number	Diff line number	Diff line change
`@@ -587,8 +587,8 @@ void RecordNode::process(AudioSampleBuffer& buffer)`
`587`	`587`
`588`	`588`	`if (isFirstChannelInRecordedSubprocessor(channelMap[ch]))`
`589`	`589`	`{`
`590`		`- float first = synchronizer->convertTimestamp(sourceID, subProcIdx, timestamp);`
`591`		`- float second = synchronizer->convertTimestamp(sourceID, subProcIdx, timestamp + 1);`
	`590`	`+ double first = synchronizer->convertTimestamp(sourceID, subProcIdx, timestamp);`
	`591`	`+ double second = synchronizer->convertTimestamp(sourceID, subProcIdx, timestamp + 1);`
`592`	`592`	`dataQueue->writeSynchronizedTimestampChannel(first, second - first, ftsChannelMap[ch], numSamples);`
`593`	`593`	`}`
`594`	`594`
Original file line number	Diff line number	Diff line change
`@@ -89,7 +89,7 @@ void RecordThread::setFirstBlockFlag(bool state)`
`89`	`89`	`void RecordThread::run()`
`90`	`90`	`{`
`91`	`91`	`const AudioSampleBuffer& dataBuffer = m_dataQueue->getAudioBufferReference();`
`92`		`- const AudioSampleBuffer& ftsBuffer = m_dataQueue->getFTSBufferReference();`
	`92`	`+ const SynchronizedTimestampBuffer& ftsBuffer = m_dataQueue->getFTSBufferReference();`
`93`	`93`
`94`	`94`	`bool closeEarly = true;`
`95`	`95`	`//1-Wait until the first block has arrived, so we can align the timestamps`
`@@ -147,7 +147,7 @@ void RecordThread::run()`
`147`	`147`
`148`	`148`	`}`
`149`	`149`
`150`		`-void RecordThread::writeSynchronizedData(const AudioSampleBuffer& dataBuffer, const AudioSampleBuffer& ftsBuffer, int maxSamples, int maxEvents, int maxSpikes, bool lastBlock)`
	`150`	`+void RecordThread::writeSynchronizedData(const AudioSampleBuffer& dataBuffer, const SynchronizedTimestampBuffer& ftsBuffer, int maxSamples, int maxEvents, int maxSpikes, bool lastBlock)`
`151`	`151`	`{`
`152`	`152`
`153`	`153`	`Array<int64> timestamps;`