#38 Update pipes on tuning change.

Author: Archie3d

Source/PluginEditor.cpp

@@ -149,11 +149,8 @@ AeolusAudioProcessorEditor::AeolusAudioProcessorEditor (AeolusAudioProcessor& p)
 
             const bool scaleChanged = (g->getTuningFrequency() != freq) || (g->getScale().getType() != scaleType);
 
-            if (mtsChanged) {
+            if (mtsChanged || scaleChanged) {
                 g->setMTSEnabled(contentPtr->isMTSTuningEnabled());
-            }
-
-            if (scaleChanged) {
                 g->setTuningFrequency(freq);
                 g->setScaleType(scaleType);
                 g->rebuildRankwaves();

Source/aeolus/engine.cpp

@@ -79,6 +79,8 @@ EngineGlobal::EngineGlobal()
 
     loadRankwaves();
     loadIRs();
+
+    startTimer(100);
 }
 
 EngineGlobal::~EngineGlobal()
@@ -190,14 +192,14 @@ String EngineGlobal::getMTSScaleName()
     return String(MTS_GetScaleName(_mtsClient));
 }
 
-double EngineGlobal::getMTSNoteToFrequency(int midiNote, int midiChannel)
+float EngineGlobal::getMTSNoteToFrequency(int midiNote, int midiChannel)
 {
     if (_mtsClient == nullptr || !isConnectedToMTSMaster())
     {
         return _scale.getFrequencyForMidoNote(midiNote);
     }
 
-    return MTS_NoteToFrequency(_mtsClient, (char)midiNote, (char)midiChannel);
+    return (float)MTS_NoteToFrequency(_mtsClient, (char)midiNote, (char)midiChannel);
 }
 
 
@@ -211,22 +213,22 @@ void EngineGlobal::rebuildRankwaves()
     // Kill all the active voices
     int numActiveVoices = 0;
 
-    for (auto* processor : _processors) {
-        processor->killAllVoices();
-        numActiveVoices += processor->getNumberOfActiveVoices();
-    }
+    do {
+        for (auto* processor : _processors) {
+            const auto numVoices{ processor->getNumberOfActiveVoices() };
 
-    Thread::sleep(100);
+            if (numVoices > 0) {
+                processor->killAllVoices();
+                numActiveVoices += numVoices;
+            }
+        }
 
-    // Wait for the voices to release
-    while (numActiveVoices > 0) {
-        numActiveVoices = 0;
-        for (auto* processor : _processors) {
-            processor->killAllVoices();
-            numActiveVoices += processor->getNumberOfActiveVoices();
-            Thread::sleep(100);
+        // Wait for the voices to release
+        if (numActiveVoices > 0) {
+            Thread::sleep(10);
         }
-    }
+
+    } while (numActiveVoices > 0);
 
     updateStops(_sampleRate);
 }
@@ -361,6 +363,33 @@ void EngineGlobal::loadIRs()
 
 }
 
+bool EngineGlobal::updateMTSTuningCache()
+{
+    bool changed{};
+
+    for (int midiNote = 0; midiNote < _mtsTuningCache.size(); ++midiNote) {
+        const float f{ getMTSNoteToFrequency(midiNote, 0) };
+        if (_mtsTuningCache[midiNote] != f) {
+            _mtsTuningCache[midiNote] = f;
+            changed = true;
+        }
+    }
+
+  return changed;
+}
+
+void EngineGlobal::timerCallback()
+{
+    if (!_mtsEnabled) return;
+
+    auto changed{ updateMTSTuningCache() };
+
+    if (changed) {
+        rebuildRankwaves();
+    }
+}
+
+
 JUCE_IMPLEMENT_SINGLETON(EngineGlobal)
 
 //==============================================================================

Source/aeolus/engine.h

@@ -46,7 +46,8 @@ class Engine;
  *
  * This class in a singleton which is shared among all the plugin instances.
  */
-class EngineGlobal : public juce::DeletedAtShutdown
+class EngineGlobal : public juce::DeletedAtShutdown,
+                     private juce::Timer
 {
 public:
 
@@ -100,7 +101,7 @@ class EngineGlobal : public juce::DeletedAtShutdown
 
     bool isConnectedToMTSMaster();
     juce::String getMTSScaleName();
-    double getMTSNoteToFrequency(int midiNote, int midiChannel);
+    float getMTSNoteToFrequency(int midiNote, int midiChannel);
 
     bool isMTSEnabled() const { return _mtsEnabled; }
     void setMTSEnabled(bool shouldBeEnabled) { _mtsEnabled = shouldBeEnabled; }
@@ -116,6 +117,15 @@ class EngineGlobal : public juce::DeletedAtShutdown
     void loadRankwaves();
     void loadIRs();
 
+    /**
+     * Refresh MTS tuning table for all MIDI notes.
+     * Returns true if there was a change to the tuning.
+     */
+    bool updateMTSTuningCache();
+
+    // juce::Timer
+    void timerCallback() override;
+
     juce::Array<ProcessorProxy*> _processors;
 
     juce::OwnedArray<Rankwave> _rankwaves;
@@ -130,6 +140,7 @@ class EngineGlobal : public juce::DeletedAtShutdown
 
     MTSClient* _mtsClient{};
     bool _mtsEnabled{};
+    std::array<float, 128> _mtsTuningCache{};
 
     juce::ApplicationProperties _globalProperties;
 };

Source/aeolus/rankwave.cpp

@@ -426,15 +426,32 @@ void Rankwave::createPipes(const Scale& scale, float tuningFrequency)
 
 void Rankwave::retunePipes(const Scale& scale, float tuningFrequency)
 {
-    const auto fn = _model.getFn();
-    const auto fd = _model.getFd();
+    auto* g = aeolus::EngineGlobal::getInstance();
 
-    float fbase = tuningFrequency * fn / fd;
+    const float fnd = (float)_model.getFn() / (float)_model.getFd();
+    jassert(fnd > 0.0f);
 
-    for (int i = _noteMin; i <= _noteMax; ++i) {
-        Pipewave* pipe = _pipes[i - _noteMin];
-        pipe->setFrequency(scale.getFrequencyForMidoNote(i, fbase));
-        pipe->setNeedsToBeRebuilt(true);
+    if (g->isMTSEnabled()) {
+        // Use MTS provided tuning
+        for (int i = _noteMin; i <= _noteMax; ++i) {
+            Pipewave* pipe = _pipes[i - _noteMin];
+            const float f{ g->getMTSNoteToFrequency(i, 0) * fnd };
+
+            if (pipe->getPipeFrequency() != f) {
+                pipe->setFrequency(f);
+                pipe->setNeedsToBeRebuilt(true);
+            }
+        }
+
+    } else {
+        // Use local scale
+        float fbase = tuningFrequency * fnd;
+
+        for (int i = _noteMin; i <= _noteMax; ++i) {
+            Pipewave* pipe = _pipes[i - _noteMin];
+            pipe->setFrequency(scale.getFrequencyForMidoNote(i, fbase));
+            pipe->setNeedsToBeRebuilt(true);
+        }
     }
 }