Update Record Node and Synchronizer logic for setting main sync stream

Author: anjaldoshi

Source/Processors/GenericProcessor/GenericProcessor.cpp

@@ -1060,12 +1060,25 @@ void GenericProcessor::update()
                 else if (param->getType() == Parameter::TTL_LINE_PARAM)
                 {
                     TtlLineParameter* p = (TtlLineParameter*) param;
-                    stream->addParameter (new TtlLineParameter (*p));
 
                     // If the stream is hardware synchronized, default the sync line to None
                     if (p->syncModeEnabled() && stream->generatesTimestamps())
                     {
-                        stream->getParameter (p->getName())->currentValue = -1;
+                        TtlLineParameter* p2 = new TtlLineParameter (nullptr,
+                                                                     p->getScope(),
+                                                                     p->getName(),
+                                                                     p->getDisplayName(),
+                                                                     p->getDescription(),
+                                                                     p->getMaxAvailableLines(),
+                                                                     true,
+                                                                     true,
+                                                                     p->shouldDeactivateDuringAcquisition());
+                        p2->currentValue = -1;
+                        stream->addParameter (p2);
+                    }
+                    else
+                    {
+                        stream->addParameter (new TtlLineParameter (*p));
                     }
                 }
             }
@@ -1135,8 +1148,8 @@ void GenericProcessor::update()
 
     if (! isMerger() && ! isSource())
         updateSettings(); // allow processors to change custom settings,
-            // including creation of streams / channels and
-            // setting isEnabled variable
+    // including creation of streams / channels and
+    // setting isEnabled variable
 
     LOGG ("    Updated custom settings in ", MS_FROM_START, " milliseconds");
 

Source/Processors/Parameter/Parameter.cpp

@@ -1123,10 +1123,6 @@ TtlLineParameter::TtlLineParameter (ParameterOwner* owner,
 {
     jassert ((lineCount >= 0 && lineCount < 256));
     jassert (scope == ParameterScope::STREAM_SCOPE);
-
-    // Can't have both sync mode and select none
-    if (syncMode && selectNone)
-        jassertfalse;
 }
 
 void TtlLineParameter::setNextValue (var newValue_, bool undoable)
@@ -1135,7 +1131,7 @@ void TtlLineParameter::setNextValue (var newValue_, bool undoable)
         return;
 
     if (((int) newValue_ < lineCount && (int) newValue_ >= 0)
-        || (! syncMode && (int) newValue_ == -1)) // -1 is a valid value for non-sync mode
+        || (selectNone && (int) newValue_ == -1)) // -1 is a valid value for non-sync mode
     {
         newValue = newValue_;
 
@@ -1339,7 +1335,7 @@ void SelectedStreamParameter::setNextValue (var newValue_, bool undoable)
         return;
 
     if (newValue_.isInt()
-        && (int) newValue_ >= 0
+        && (int) newValue_ >= -1
         && (int) newValue_ < streamNames.size())
     {
         newValue = newValue_;
@@ -1395,7 +1391,7 @@ int SelectedStreamParameter::getSelectedIndex()
 String SelectedStreamParameter::getValueAsString()
 {
     if ((int) currentValue == -1 || streamNames.size() == 0)
-        return String();
+        return "None";
     else
         return streamNames[(int) currentValue];
 }
@@ -1413,7 +1409,7 @@ void SelectedStreamParameter::fromXml (XmlElement* xml)
 
 String SelectedStreamParameter::getChangeDescription()
 {
-    return streamNames[(int) currentValue];
+    return getValueAsString();
 }
 
 TimeParameter::TimeParameter (ParameterOwner* owner,

Source/Processors/Parameter/ParameterEditor.cpp

@@ -892,11 +892,11 @@ void SyncControlButton::paintButton (Graphics& g, bool isMouseOver, bool isButto
         {
             if (isMouseOver)
             {
-                g.setColour (Colours::deepskyblue.contrasting (0.1f));
+                g.setColour (Colour (30, 112, 255).contrasting (0.1f));
             }
             else
             {
-                g.setColour (Colours::deepskyblue);
+                g.setColour (Colour (30, 112, 255));
             }
             break;
         }

Source/Processors/RecordNode/RecordNode.cpp

@@ -170,7 +170,8 @@ void RecordNode::parameterValueChanged (Parameter* p)
         for (auto stream : dataStreams)
         {
             String key = stream->getKey();
-            if (key == streamNames[((SelectedStreamParameter*) p)->getSelectedIndex()])
+            if (key == streamNames[((SelectedStreamParameter*) p)->getSelectedIndex()]
+                && ! synchronizer.streamGeneratesTimestamps (key))
             {
                 synchronizer.setMainDataStream (stream->getKey());
                 break;
@@ -580,6 +581,28 @@ void RecordNode::updateSettings()
         else
             ++it;
     }
+
+    // Set the main sync stream from the synchronizer
+    auto param = getParameter ("main_sync");
+    Array<String> streamNames = ((SelectedStreamParameter*) param)->getStreamNames();
+    String mainStreamKey = synchronizer.mainStreamKey;
+    if (mainStreamKey.isEmpty())
+    {
+        param->setNextValue (-1, false); // no main stream selected
+    }
+    else
+    {
+        int mainStreamIndex = -1;
+        for (int i = 0; i < streamNames.size(); i++)
+        {
+            if (streamNames[i] == mainStreamKey)
+            {
+                mainStreamIndex = i;
+                break;
+            }
+        }
+        param->setNextValue (mainStreamIndex, false); // set main stream index
+    }
 }
 
 bool RecordNode::isSynchronized()

Source/Processors/Synchronizer/Synchronizer.cpp

@@ -52,7 +52,7 @@ void SyncStream::reset (String mainStreamKey)
         actualSampleRate = expectedSampleRate;
         globalStartTime = 0.0;
         isSynchronized = true;
-        overrideHardwareTimestamps = false; // do not override hardware timestamps for the main stream
+        overrideHardwareTimestamps = true; // main stream overrides hardware timestamps
     }
     else
     {
@@ -354,51 +354,55 @@ void Synchronizer::reset()
 void Synchronizer::prepareForUpdate()
 {
     previousMainStreamKey = mainStreamKey;
-
+    mainStreamKey = String();
+    dataStreamObjects.clear();
+    streams.clear();
     streamCount = 0;
-
-    for (auto [id, stream] : streams)
-        stream->isActive = false;
 }
 
 void Synchronizer::finishedUpdate()
 {
+    if (mainStreamKey.isEmpty() && streamCount > 0)
+    {
+        // if no main stream is set, set the first non-hardware-synced stream as the main stream
+        for (auto stream : dataStreamObjects)
+        {
+            if (! streamGeneratesTimestamps (stream->streamKey))
+            {
+                mainStreamKey = stream->streamKey;
+                LOGD ("No main stream set, setting ", mainStreamKey, " as the main stream");
+                break;
+            }
+        }
+    }
 }
 
 void Synchronizer::addDataStream (String streamKey, float expectedSampleRate, bool generatesTimestamps)
 {
     LOGD ("Synchronizer adding ", streamKey, " with sample rate ", expectedSampleRate);
-    // if this is the first stream, make it the main one
-    if (mainStreamKey == "")
-        mainStreamKey = streamKey;
 
     //std::cout << "Main stream ID: " << mainStreamId << std::endl;
 
     // if there's a stored value, and it appears again,
     // re-instantiate this as the main stream
-    if (mainStreamKey == previousMainStreamKey)
+    if (streamKey == previousMainStreamKey)
         mainStreamKey = previousMainStreamKey;
 
-    // if there's no Stream object yet, create a new one
-    if (streams.count (streamKey) == 0)
-    {
-        //std::cout << "Creating new Stream object" << std::endl;
-        dataStreamObjects.add (new SyncStream (streamKey, expectedSampleRate, this, generatesTimestamps));
-        streams[streamKey] = dataStreamObjects.getLast();
-        setSyncLine (streamKey, generatesTimestamps ? -1 : 0); // if the stream generates its own timestamps, set sync line to -1 (no sync line), otherwise set it to 0
-    }
-    else
-    {
-        // otherwise, indicate that the stream is currently active and update sample rate
-        streams[streamKey]->isActive = true;
-        streams[streamKey]->expectedSampleRate = expectedSampleRate;
-    }
+    //std::cout << "Creating new Stream object" << std::endl;
+    dataStreamObjects.add (new SyncStream (streamKey, expectedSampleRate, this, generatesTimestamps));
+    streams[streamKey] = dataStreamObjects.getLast();
+    setSyncLine (streamKey, generatesTimestamps ? -1 : 0); // if the stream generates its own timestamps, set sync line to -1 (no sync line), otherwise set it to 0
 
     streamCount++;
 }
 
 void Synchronizer::setMainDataStream (String streamKey)
 {
+    if (streams.count (streamKey) == 0)
+    {
+        LOGD ("Cannot set ", streamKey, " as main data stream. Stream not found.");
+        return;
+    }
     LOGD ("Synchronizer setting mainDataStream to ", streamKey);
     mainStreamKey = streamKey;
     reset();
@@ -516,6 +520,9 @@ bool Synchronizer::isStreamSynced (String streamKey)
 
 bool Synchronizer::streamGeneratesTimestamps (String streamKey)
 {
+    if (streams.count (streamKey) == 0)
+        return false;
+
     return streams[streamKey]->generatesTimestamps && ! streams[streamKey]->overrideHardwareTimestamps;
 }
 
@@ -535,12 +542,14 @@ SyncStatus Synchronizer::getStatus (String streamKey)
 
 void Synchronizer::hiResTimerCallback()
 {
+    if (mainStreamKey.isEmpty())
+        return;
 
     const ScopedLock sl (synchronizerLock);
 
     for (auto [key, stream] : streams)
     {
-        if (key != mainStreamKey)
+        if (key != mainStreamKey && ! streamGeneratesTimestamps (key))
         {
             stream->syncWith (streams[mainStreamKey]);
         }