Merge branch 'fix-rec-node' of https://github.com/medengineer/plugin-GUI into development

Author: anjaldoshi

Resources/Python/record_control_example_client.py

@@ -77,4 +77,4 @@ def run_client():
 
 
 if __name__ == '__main__':
-    run_client()
+    run_client()

Source/Processors/ProcessorGraph/ProcessorGraph.cpp

@@ -266,10 +266,10 @@ void ProcessorGraph::clearConnections()
 
     }
 
-    /*
-    addConnection(MESSAGE_CENTER_ID, midiChannelIndex,
-                  RECORD_NODE_ID, midiChannelIndex);
-    */
+    for (auto& recordNode : getRecordNodes())
+        addConnection(MESSAGE_CENTER_ID, midiChannelIndex,
+                  recordNode->getNodeId(), midiChannelIndex);
+
 }
 
 
@@ -278,10 +278,6 @@ void ProcessorGraph::updateConnections(Array<SignalChainTabButton*, CriticalSect
 
     clearConnections(); // clear processor graph
 
-    std::cout << "Updating connections:" << std::endl;
-    std::cout << std::endl;
-    std::cout << std::endl;
-
     Array<GenericProcessor*> splitters;
 
     // keep track of which splitter is currently being explored, in case there's another
@@ -453,10 +449,13 @@ void ProcessorGraph::updateConnections(Array<SignalChainTabButton*, CriticalSect
     }
 
 	getAudioNode()->updatePlaybackBuffer();
-	//Update RecordNode internal channel mappings
+
 	Array<EventChannel*> extraChannels;
 	getMessageCenter()->addSpecialProcessorChannels(extraChannels);
-	//getRecordNode()->addSpecialProcessorChannels(extraChannels);
+
+    for (auto& recordNode : getRecordNodes())
+        recordNode->addSpecialProcessorChannels(extraChannels);
+
 } // end method
 
 void ProcessorGraph::connectProcessors(GenericProcessor* source, GenericProcessor* dest,
@@ -492,12 +491,6 @@ void ProcessorGraph::connectProcessors(GenericProcessor* source, GenericProcesso
                       midiChannelIndex);      // destNodeChannelIndex
     }
 
-    // 3. connect record nodes
-    if (dest->isRecordNode())
-    {
-        ((RecordNode*)dest)->registerProcessor(source);
-    }
-
 }
 
 void ProcessorGraph::connectProcessorToAudioNode(GenericProcessor* source)
@@ -702,7 +695,10 @@ bool ProcessorGraph::enableProcessors()
 
 	//Update special channels indexes, at the end
 	//To change, as many other things, when the probe system is implemented
-	//getRecordNode()->updateRecordChannelIndexes();
+    for (auto& node : getRecordNodes())
+    {
+        node->updateRecordChannelIndexes();
+    }
 	getAudioNode()->updateRecordChannelIndexes();
 
     //	sendActionMessage("Acquisition started.");
@@ -748,15 +744,6 @@ bool ProcessorGraph::disableProcessors()
 
 void ProcessorGraph::setRecordState(bool isRecording)
 {
-    // actually start recording
-    if (isRecording)
-    {
-        //getRecordNode()->setParameter(1,10.0f);
-    }
-    else
-    {
-        //getRecordNode()->setParameter(0,10.0f);
-    }
 
     for (int i = 0; i < getNumNodes(); i++)
     {
@@ -769,7 +756,6 @@ void ProcessorGraph::setRecordState(bool isRecording)
         }
     }
 
-
 }
 
 

Source/Processors/RecordNode/BinaryFormat/BinaryRecording.cpp

@@ -20,18 +20,9 @@ String BinaryRecording::getEngineID() const
 
 String BinaryRecording::getProcessorString(const InfoObjectCommon* channelInfo)
 {
-	String fName = (channelInfo->getCurrentNodeName().replaceCharacter(' ', '_') + "-" +
-		String(channelInfo->getCurrentNodeID()));
-	if (channelInfo->getCurrentNodeID() == channelInfo->getSourceNodeID())
-		// found the channel source
-	{
-		fName += "." + String(channelInfo->getSubProcessorIdx());
-	}
-	else
-	{
-		fName += "_" + String(channelInfo->getSourceNodeID()) + "." +
-			String(channelInfo->getSubProcessorIdx());
-	}
+	String fName = (channelInfo->getSourceName().replaceCharacter(' ', '_') + "-" +
+		String(channelInfo->getSourceNodeID()));
+    fName += "." + String(channelInfo->getSubProcessorIdx());
 	fName += File::separatorString;
 	return fName;
 }

Source/Processors/RecordNode/DataQueue.cpp

@@ -134,7 +134,7 @@ void DataQueue::fillTimestamps(int channel, int index, int size, int64 timestamp
 	}
 }
 
-void DataQueue::writeSynchronizedTimestampChannel(double start, double step, int destChannel, int64 nSamples)
+float DataQueue::writeSynchronizedTimestampChannel(double start, double step, int destChannel, int64 nSamples)
 {
 
 	int index1, size1, index2, size2;
@@ -169,6 +169,8 @@ void DataQueue::writeSynchronizedTimestampChannel(double start, double step, int
 
 	m_FTSFifos[destChannel]->finishedWrite(size1 + size2);
 
+	return 1.0f - (float)m_FTSFifos[destChannel]->getFreeSpace() / (float)m_FTSFifos[destChannel]->getTotalSize();
+
 }
 
 

Source/Processors/RecordNode/DataQueue.h

@@ -50,7 +50,7 @@ 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(double start, double step, int destChannel, int64 nSamples);
+	float 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;

Source/Processors/RecordNode/RecordNode.cpp

@@ -10,6 +10,7 @@
 using namespace std::chrono;
 
 #define CONTINUOUS_CHANNELS_ON_BY_DEFAULT true
+#define RECEIVED_SOFTWARE_TIME (event.getVelocity() == 136)
 
 EventMonitor::EventMonitor()
 	: receivedEvents(0) {}
@@ -37,7 +38,8 @@ RecordNode::RecordNode()
 	recordingNumber(0),
 	isRecording(false),
 	hasRecorded(false),
-	settingsNeeded(false)
+	settingsNeeded(false),
+	receivedSoftwareTime(false)
 {
 	setProcessorType(PROCESSOR_TYPE_RECORD_NODE);
 
@@ -66,6 +68,45 @@ RecordNode::~RecordNode()
 {
 }
 
+void RecordNode::addInputChannel(const GenericProcessor* sourceNode, int chan)
+{
+
+	if (chan != AccessClass::getProcessorGraph()->midiChannelIndex)
+	{
+		int channelIndex = getNextChannel(false);
+
+		const DataChannel* orig = sourceNode->getDataChannel(chan);
+		DataChannel* newChannel = new DataChannel(*orig);
+		newChannel->setRecordState(orig->getRecordState());
+		dataChannelArray.add(newChannel);
+		recordEngine->addDataChannel(channelIndex, dataChannelArray[channelIndex]);
+
+	}
+	else
+	{
+
+		for (int n = 0; n < sourceNode->getTotalEventChannels(); n++)
+		{
+			const EventChannel* orig = sourceNode->getEventChannel(n);
+			//only add to the record node the events originating from this processor, to avoid duplicates
+			if (orig->getSourceNodeID() == sourceNode->getNodeId())
+				eventChannelArray.add(new EventChannel(*orig));
+
+		}
+
+	}
+
+}
+
+void RecordNode::addSpecialProcessorChannels(Array<EventChannel*>& channels)
+{
+
+	eventChannelArray.addArray(channels);
+	settings.numInputs = dataChannelArray.size();
+	setPlayConfigDetails(getNumInputs(), getNumOutputs(), 44100.0, 1024);
+
+}
+
 void RecordNode::setEngine(int index)
 {
 	availableEngines = getAvailableRecordEngines();
@@ -213,6 +254,12 @@ void RecordNode::setParameter(int parameterIndex, float newValue)
 
 }
 
+void RecordNode::updateRecordChannelIndexes()
+{
+	//Keep the nodeIDs of the original processor from each channel comes from
+	updateChannelIndexes(false);
+}
+
 void RecordNode::updateChannelStates(int srcIndex, int subProcIdx, std::vector<bool> channelStates)
 {
 	this->dataChannelStates[srcIndex][subProcIdx] = channelStates;
@@ -255,6 +302,8 @@ void RecordNode::updateSubprocessorMap()
 				ch++;
 			}
 			ch--;
+
+			fifoUsage[sourceID][subProcID] = 0.0f;
 		}
 
 	}
@@ -274,7 +323,7 @@ void RecordNode::updateSubprocessorMap()
 		}
 	}
 
-	eventChannelMap.clear();
+	eventMap.clear();
 	syncChannelMap.clear();
 	syncOrderMap.clear();
 	for (int ch = 0; ch < eventChannelArray.size(); ch++)
@@ -284,12 +333,10 @@ void RecordNode::updateSubprocessorMap()
 		int sourceID = chan->getSourceNodeID();
 		int subProcID = chan->getSubProcessorIdx();
 
-		int chCount = 0;
+		eventMap[sourceID][subProcID] = chan->getNumChannels();
 
-		if (!syncChannelMap[sourceID][subProcID])
+		if (dataChannelStates[sourceID][subProcID].size() && !syncChannelMap[sourceID][subProcID])
 		{
-			EventChannel* chan = eventChannelArray[ch];
-			eventChannelMap[sourceID][subProcID] = chan->getNumChannels();
 			syncOrderMap[sourceID][subProcID] = ch;
 			syncChannelMap[sourceID][subProcID] = 0;
 			synchronizer->setSyncChannel(chan->getSourceNodeID(), chan->getSubProcessorIdx(), ch);
@@ -311,7 +358,6 @@ void RecordNode::setMasterSubprocessor(int srcIndex, int subProcIdx)
 
 void RecordNode::setSyncChannel(int srcIndex, int subProcIdx, int channel)
 {
-	//eventChannelMap[srcIndex][subProcIdx]; 
 	syncChannelMap[srcIndex][subProcIdx] = channel;
 	synchronizer->setSyncChannel(srcIndex, subProcIdx, syncOrderMap[srcIndex][subProcIdx]+channel);
 }
@@ -330,11 +376,7 @@ bool RecordNode::isMasterSubprocessor(int srcIndex, int subProcIdx)
 void RecordNode::updateSettings()
 {
 
-	if (dataChannelArray.size() != lastDataChannelArraySize)
-	{
-		lastDataChannelArraySize = dataChannelArray.size();
-		updateSubprocessorMap();
-	}
+	updateSubprocessorMap();
 
 }
 
@@ -373,7 +415,7 @@ void RecordNode::startRecording()
 
 	int recordedProcessorIdx = -1;	
 
-	LOGD("Record Node ", getNodeId(), ": Total channels: ", totChans);
+	//LOGD("Record Node ", getNodeId(), ": Total channels: ", totChans, " Total event channels: ", getTotalEventChannels());
 
 	for (int ch = 0; ch < totChans; ++ch)
 	{
@@ -506,15 +548,15 @@ void RecordNode::handleEvent(const EventChannel* eventInfo, const MidiMessage& e
 		int64 timestamp = Event::getTimestamp(event);
 		uint64 eventChan = event.getChannel();
 		int eventIndex;
-		if (eventInfo && samplePosition > 0)
-		{
+		if (eventInfo)
 			eventIndex = getEventChannelIndex(Event::getSourceIndex(event), Event::getSourceID(event), Event::getSubProcessorIdx(event));
-			synchronizer->addEvent(Event::getSourceID(event), Event::getSubProcessorIdx(event), eventIndex, timestamp);
-		}
 		else
 			eventIndex = -1;
 
-		if (isRecording && eventIndex >= 0)
+		if (samplePosition > 0 && dataChannelStates[Event::getSourceID(event)][Event::getSubProcessorIdx(event)].size())
+			synchronizer->addEvent(Event::getSourceID(event), Event::getSubProcessorIdx(event), eventIndex, timestamp);
+
+		if (isRecording)
 			eventQueue->addEvent(event, timestamp, eventIndex);
 
 	}
@@ -541,7 +583,20 @@ void RecordNode::handleSpike(const SpikeChannel* spikeInfo, const MidiMessage& e
 
 void RecordNode::handleTimestampSyncTexts(const MidiMessage& event)
 {
-	handleEvent(nullptr, event, 0);
+
+	if (event.getVelocity() == 136)
+	{
+		if (!receivedSoftwareTime)
+		{
+			handleEvent(nullptr, event, 0);
+			receivedSoftwareTime = true;
+		}
+	}
+	else
+	{
+		handleEvent(nullptr, event, 0);
+	}
+
 }
 
 void RecordNode::process(AudioSampleBuffer& buffer)
@@ -589,7 +644,7 @@ void RecordNode::process(AudioSampleBuffer& buffer)
 				{
 					double first = synchronizer->convertTimestamp(sourceID, subProcIdx, timestamp);
 					double second = synchronizer->convertTimestamp(sourceID, subProcIdx, timestamp + 1);
-					dataQueue->writeSynchronizedTimestampChannel(first, second - first, ftsChannelMap[ch], numSamples);
+					fifoUsage[sourceID][subProcIdx] = dataQueue->writeSynchronizedTimestampChannel(first, second - first, ftsChannelMap[ch], numSamples);
 				}
 
 				dataQueue->writeChannel(buffer, channelMap[ch], ch, numSamples, timestamp);
@@ -626,13 +681,10 @@ bool RecordNode::isFirstChannelInRecordedSubprocessor(int ch)
 	return std::find(startRecChannels.begin(), startRecChannels.end(), ch) != startRecChannels.end();
 }
 
-//TODO: Need to validate these methods
-
 void RecordNode::registerProcessor(const GenericProcessor* sourceNode)
 {
 	settings.numInputs += sourceNode->getNumOutputs();
 	setPlayConfigDetails(getNumInputs(), getNumOutputs(), 44100.0, 128);
-
 	recordEngine->registerProcessor(sourceNode);
 }
 

Source/Processors/RecordNode/RecordNode.h

@@ -49,10 +49,13 @@ class RecordNode : public GenericProcessor, public FilenameComponentListener
 	RecordNode();
 	~RecordNode();
 
+	void updateRecordChannelIndexes();
+
 	AudioProcessorEditor* createEditor() override;
 	bool hasEditor() const override { return true; }
 
-	
+	void addSpecialProcessorChannels(Array<EventChannel*>& channels);
+
 	void updateSubprocessorMap();
 	void setMasterSubprocessor(int srcIdx, int subProcIdx);
 	bool isMasterSubprocessor(int srcIdx, int subProcIdx);
@@ -108,10 +111,12 @@ class RecordNode : public GenericProcessor, public FilenameComponentListener
 	std::map<int, std::map<int, std::vector<bool>>> dataChannelStates;
 	std::map<int, int> dataChannelOrder;
 
-	std::map<int, std::map<int, int>> eventChannelMap;
+	std::map<int, std::map<int, int>> eventMap;
 	std::map<int, std::map<int, int>> syncChannelMap;
 	std::map<int, std::map<int, int>> syncOrderMap;
 
+	std::map<int, std::map<int, float>> fifoUsage;
+
 	Array<int> channelMap; //Map from record channel index to source channel index
 	Array<int> ftsChannelMap; // Map from recorded channel index to recorded source processor idx
 	std::vector<std::vector<int>> subProcessorMap;
@@ -120,6 +125,7 @@ class RecordNode : public GenericProcessor, public FilenameComponentListener
     bool isSyncReady;
 
     //TODO: Need to validate these new methods
+	void addInputChannel(const GenericProcessor* sourceNode, int chan);
 
     /** Must be called by a spike recording source on the "enable" method
     */
@@ -161,6 +167,8 @@ class RecordNode : public GenericProcessor, public FilenameComponentListener
 
 private:
 
+	bool receivedSoftwareTime;
+
 	int lastDataChannelArraySize;
 
     bool isProcessing;