Ensure Channel Map settings persist when input changes

Author: jsiegle

Plugins/ChannelMappingNode/ChannelMappingEditor.cpp

@@ -251,6 +251,10 @@ void ChannelMappingEditor::mouseDown(const MouseEvent& e)
 
             displayString += String(button->getChannelNum());
 
+            menu.addItem(2,     // index
+                "Reset stream settings",  // message
+                true);          // isSelectable
+
             menu.addItem(1,     // index
                 displayString,  // message
                 true);          // isSelectable
@@ -259,11 +263,25 @@ void ChannelMappingEditor::mouseDown(const MouseEvent& e)
 
             PopupMenu::dismissAllActiveMenus();
 
-            if (result > 0)
+            if (result == 1)
             {
                 processor->setChannelEnabled(getCurrentStream(), buttonIndex, !isActive);
                 CoreServices::updateSignalChain(this);
             }
+            else if (result == 2)
+            {
+                bool response = AlertWindow::showOkCancelBox(AlertWindow::NoIcon,
+                    "Reset Channel Map",
+                    "Are you sure you want to reset the channel map for the current stream?",
+                    "OK", "Cancel", 0, 0);
+
+                if (response)
+                {
+                    processor->resetStream(getCurrentStream());
+                    CoreServices::updateSignalChain(this);
+                }
+                
+            }
 
         }
 

Plugins/ChannelMappingNode/ChannelMappingNode.cpp

@@ -59,6 +59,8 @@ void ChannelMapSettings::updateNumChannels(int newChannelCount)
         isEnabled.add(true);
     }
 
+    numChannels = newChannelCount;
+
 }
 
 void ChannelMapSettings::toXml(XmlElement* xml)
@@ -108,6 +110,27 @@ void ChannelMapSettings::fromJson(File filename)
     PrbFormat::read(filename, this);
 }
 
+void ChannelMapSettings::setStream(const DataStream* stream)
+{
+    numChannels = stream->getChannelCount();
+    sampleRate = stream->getSampleRate();
+    streamName = stream->getName();
+    streamId = stream->getStreamId();
+    sourceNodeId = stream->getSourceNodeId();
+}
+
+void ChannelMapSettings::reset()
+{
+    channelOrder.clear();
+    isEnabled.clear();
+
+    for (int i = 0; i < numChannels; i++)
+    {
+        channelOrder.add(i);
+        isEnabled.add(true);
+    }
+}
+
 // =====================================================
 
 ChannelMappingNode::ChannelMappingNode()
@@ -124,14 +147,54 @@ AudioProcessorEditor* ChannelMappingNode::createEditor()
 }
 
 
+ChannelMapSettings* ChannelMappingNode::findMatchingStreamSettings(ChannelMapSettings* s)
+{
+    for (auto streamId : previousStreamIds)
+    {
+        if ((s->sourceNodeId == settings[streamId]->sourceNodeId) &&
+            (s->streamName == settings[streamId]->streamName))
+        {
+            // perfect match
+            return settings[streamId];
+        }
+
+        if ((s->streamName == settings[streamId]->streamName))
+        {
+            // matching name
+            return settings[streamId];
+        }
+    }
+
+    return nullptr;
+}
+
 void ChannelMappingNode::updateSettings()
 {
 
     settings.update(getDataStreams());
 
     for (auto stream : getDataStreams())
     {
-        settings[stream->getStreamId()]->updateNumChannels(stream->getChannelCount());
+
+        const uint16 streamId = stream->getStreamId();
+
+        if ( settings[streamId]->sourceNodeId == -1) // no stream applied yet
+        {
+            settings[streamId]->setStream(stream);
+
+            ChannelMapSettings* s = findMatchingStreamSettings(settings[streamId]);
+
+            if (s != nullptr)
+            {
+                settings[streamId]->channelOrder = s->channelOrder;
+                settings[streamId]->isEnabled = s->isEnabled;
+            }
+
+            previousStreamIds.add(streamId);
+
+        }
+        
+        settings[streamId]->updateNumChannels(stream->getChannelCount());
 
         if ((*stream)["enable_stream"])
         {
@@ -140,19 +203,19 @@ void ChannelMappingNode::updateSettings()
             for (int ch = 0; ch < stream->getChannelCount(); ch++)
             {
 
-                int localIndex = settings[stream->getStreamId()]->channelOrder[ch];
+                int localIndex = settings[streamId]->channelOrder[ch];
                 Array<ContinuousChannel*> channelsForStream = stream->getContinuousChannels();
 
                 int globalIndex = channelsForStream[localIndex]->getGlobalIndex();
 
-                if (settings[stream->getStreamId()]->isEnabled[ch])
+                if (settings[streamId]->isEnabled[ch])
                 {
                     newChannelOrder.add(channelsForStream[localIndex]);
                 }
 
             }
 
-            DataStream* currentStream = getDataStream(stream->getStreamId());
+            DataStream* currentStream = getDataStream(streamId);
 
             currentStream->clearContinuousChannels();
 
@@ -164,7 +227,6 @@ void ChannelMappingNode::updateSettings()
 
 }
 
-
 void ChannelMappingNode::setChannelEnabled(uint16 streamId, int channelNum, int isEnabled)
 {
     settings[streamId]->isEnabled.set(channelNum, isEnabled);
@@ -175,6 +237,11 @@ void ChannelMappingNode::setChannelOrder(uint16 streamId, Array<int> order)
     settings[streamId]->channelOrder = order;
 }
 
+void ChannelMappingNode::resetStream(uint16 streamId)
+{
+    settings[streamId]->reset();
+}
+
 Array<int> ChannelMappingNode::getChannelOrder(uint16 streamId)
 {
     return settings[streamId]->channelOrder;

Plugins/ChannelMappingNode/ChannelMappingNode.h

@@ -57,6 +57,18 @@ class ChannelMapSettings
     /** Reads settings from JSON (.prb format)*/
     void fromJson(File file);
 
+    /** Sets the stream info */
+    void setStream(const DataStream* stream);
+
+    /** Reset to defaults */
+    void reset();
+
+    int sourceNodeId = -1;
+    String streamName = "";
+    int numChannels = 0;
+    float sampleRate = 0.0f;
+    uint16 streamId = 0;
+
 };
 
 /**
@@ -92,6 +104,9 @@ class ChannelMappingNode : public GenericProcessor
     /** Sets the channel order*/
     void setChannelOrder(uint16 streamId, Array<int> order);
 
+    /** Resets to default settings*/
+    void resetStream(uint16 streamId);
+
     /** Gets the channel order */
     Array<int> getChannelOrder(uint16 streamId);
 
@@ -112,9 +127,15 @@ class ChannelMappingNode : public GenericProcessor
 
 private:
 
+    /** Find previously saved settings from similar streams */
+    ChannelMapSettings* findMatchingStreamSettings(ChannelMapSettings* s);
+
     /** Holds settings for individual streams*/
     StreamSettings<ChannelMapSettings> settings;
 
+    /** Previous stream IDs*/
+    Array<uint16> previousStreamIds;
+
     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (ChannelMappingNode);
 };