#4 Trigger or release voices depending on the stop enablement based on the current state of the keys.

Author: Archie3d

Source/aeolus/division.cpp

@@ -44,6 +44,7 @@ Division::Division(Engine& engine, const String& name)
     , _swellFilterStateR{}
     , _stops{}
     , _activeVoices{}
+    , _keysState{}
     , _triggerFlag{}
     , _volumeLevel{}
 {
@@ -327,28 +328,10 @@ void Division::noteOn(int note, int midiChannel)
 
     _triggerFlag = true;
 
-    for (const auto& stop : _stops) {
-        if (!stop.isEnabled())
-            continue;
-
-        for (const auto& zone : stop.getZones()) {
-            if (zone.isForKey(note)) {
-                for (auto* rw : zone.rankwaves) {
-                    auto state = rw->trigger(note);
+    for (int stopIndex = 0; stopIndex < (int)_stops.size(); ++stopIndex)
+        triggerVoicesForStop(stopIndex, note);
 
-                    // Rankwave may be in the middle of construction, in this case
-                    // we don't trigger a voice.
-                    if (state.isTriggered()) {
-                        state.gain = stop.getGain();
-                        state.chiffGain = stop.getChiffGain();
-
-                        if (auto* voice = _engine.getVoicePool().trigger(state))
-                            _activeVoices.append(voice);
-                    }
-                }
-            }
-        }
-    }
+    _keysState.set(note);
 
     // Forward to the linked divisions
     for (auto& link : _linkedDivisions) {
@@ -377,6 +360,8 @@ void Division::noteOff(int note, int midiChannel)
         voice = voice->next();
     }
 
+    _keysState.reset(note);
+
     // Forward to the linked divisions
     for (auto& link : _linkedDivisions) {
         if (link.enabled) {
@@ -387,6 +372,8 @@ void Division::noteOff(int note, int midiChannel)
 
 void Division::allNotesOff()
 {
+    _keysState.reset();
+
     auto* voice = _activeVoices.first();
 
     while (voice != nullptr) {
@@ -400,6 +387,9 @@ bool Division::process(AudioBuffer<float>& targetBuffer, AudioBuffer<float>& voi
     jassert(targetBuffer.getNumSamples() == SUB_FRAME_LENGTH);
     jassert(voiceBuffer.getNumSamples() == SUB_FRAME_LENGTH);
 
+    releaseVoicesOfDisabledStops();
+    triggerVoicesOfEnabledStops();
+
     auto* voice = _activeVoices.first();
 
     if (voice == nullptr)
@@ -500,4 +490,90 @@ void Division::modulate(juce::AudioBuffer<float>& targetBuffer, const juce::Audi
 #endif
 }
 
+void Division::releaseVoicesOfDisabledStops()
+{
+    auto* voice = _activeVoices.first();
+
+    while (voice != nullptr) {
+        if (voice->isActive()) {
+            const int stopIndex = voice->stopIndex();
+
+            if (isPositiveAndBelow(stopIndex, _stops.size())) {
+                const auto& stop = _stops[stopIndex];
+
+                if (!stop.isEnabled())
+                    voice->release();
+            }
+        }
+
+        voice = voice->next();
+    }
+}
+
+void Division::triggerVoicesOfEnabledStops()
+{
+    for (int stopIndex = 0; stopIndex < _stops.size(); ++stopIndex) {
+        auto& stop = _stops[stopIndex];
+
+        if (!stop.isEnabled())
+            continue;
+
+        bool hasVoices = false;
+
+        auto* voice = _activeVoices.first();
+
+        while (voice != nullptr) {
+            if (voice->stopIndex() == stopIndex) {
+                hasVoices = true;
+                break;
+            }
+
+            voice = voice->next();
+        }
+
+        // Trigger voices for enabled stops
+        if (!hasVoices) {
+            for (int note = 0; note < _keysState.size(); ++note) {
+                if (_keysState[note])
+                    triggerVoicesForStop(stopIndex, note);
+            }
+        }
+    }
+}
+
+bool Division::triggerVoicesForStop(int stopIndex, int note)
+{
+    jassert(isPositiveAndBelow(stopIndex, _stops.size()));
+
+    const auto& stop = _stops[stopIndex];
+
+    if (!stop.isEnabled())
+        return false;
+
+    bool voiceTriggered = false;
+
+    for (const auto& zone : stop.getZones()) {
+        if (zone.isForKey(note)) {
+            for (auto* rw : zone.rankwaves) {
+                auto state = rw->trigger(note);
+
+                // Rankwave may be in the middle of construction, in this case
+                // we don't trigger a voice.
+                if (state.isTriggered()) {
+                    state.gain = stop.getGain();
+                    state.chiffGain = stop.getChiffGain();
+
+                    if (auto* voice = _engine.getVoicePool().trigger(state)) {
+                        voice->setStopIndex(stopIndex);
+                        _activeVoices.append(voice);
+                        voiceTriggered = true;
+                    }
+                }
+            }
+        }
+    }
+
+    return voiceTriggered;
+}
+
 AEOLUS_NAMESPACE_END

Source/aeolus/division.h

@@ -29,6 +29,7 @@
 
 #include <atomic>
 #include <vector>
+#include <bitset>
 
 AEOLUS_NAMESPACE_BEGIN
 
@@ -141,6 +142,9 @@ class Division
     bool process(juce::AudioBuffer<float>& targetBuffer, juce::AudioBuffer<float>& voiceBuffer);
     void modulate(juce::AudioBuffer<float>& targetBuffer, const juce::AudioBuffer<float>& tremulantBuffer);
 
+    void releaseVoicesOfDisabledStops();
+    void triggerVoicesOfEnabledStops();
+
     List<Voice>& getActiveVoices() noexcept { return _activeVoices; }
 
     /**
@@ -158,6 +162,8 @@ class Division
 
 private:
 
+    bool triggerVoicesForStop(int stopIndex, int note);
+
     Engine& _engine;
 
     juce::String _name;     ///< The division name.
@@ -190,6 +196,8 @@ class Division
 
     List<Voice> _activeVoices;  ///< Active voices on this division.
 
+    std::bitset<128> _keysState; ///< MIDI keys state 1 = on, 0 = off.
+
     /// Tells whether this division has been triggered.
     /// This is used to avoid a division to be triggered multiple
     /// times by the same not on/off even, which is the case

Source/aeolus/engine.h

@@ -232,6 +232,7 @@ class Engine
      */
     void process(float* outL, float* outR, int numFrames, bool isNonRealtime = false);
 
+    // Multibus version of the processing (does not include the convolver).
     void process(juce::AudioBuffer<float>& out, bool isNonRealtime = false);
 
     /**

Source/aeolus/globals.h

@@ -66,6 +66,9 @@ constexpr static int NOTE_MIN = 36;
 /// Highest possible note.
 constexpr static int NOTE_MAX = 96;
 
+/// Total number of MIDI notes.
+constexpr static int TOTAL_NOTES = 128;
+
 /// Maxumim number of pipes in combined stops (like mixtures)
 constexpr static int MAX_RANK = 5;
 

Source/aeolus/voice.cpp

@@ -27,6 +27,7 @@ AEOLUS_NAMESPACE_BEGIN
 Voice::Voice(Engine& engine)
     : _engine(engine)
     , _state{}
+    , _stopIndex{-1}
     , _buffer{0}
     , _delayLine{SAMPLE_RATE}
     , _delay{0.0f}
@@ -93,6 +94,7 @@ void Voice::release()
 void Voice::reset()
 {
     _state.reset();
+    _stopIndex = -1;
 
     memset(_buffer, 0, sizeof(float) * SUB_FRAME_LENGTH);
 
@@ -140,6 +142,11 @@ bool Voice::isOver() const noexcept
     return (_state.env == Pipewave::Over) && _postReleaseCounter == 0;
 }
 
+bool Voice::isActive() const noexcept
+{
+    return _state.env == Pipewave::Attack;
+}
+
 bool Voice::isForNote(int note) const noexcept
 {
     if (_state.pipewave != nullptr)

Source/aeolus/voice.h

@@ -48,15 +48,23 @@ class Voice : public ListItem<Voice>
     void reset();
     void process(float* outL, float* outR);
     bool isOver() const noexcept;
+    bool isActive() const noexcept;
     bool isForNote(int note) const noexcept;
 
+    void setStopIndex(int idx) noexcept { _stopIndex = idx; }
+    int stopIndex() const noexcept { return _stopIndex; }
+
     void resetAndReturnToPool();
 
     float getPanPosition() const noexcept { return _panPosition; }
 
 private:
     Engine& _engine;
     Pipewave::State _state; ///< Pipe state associated with this voice.
+    
+    /// Index of the stop associated with this voice.
+    /// This is used to tell which stops are voiced.
+    int _stopIndex;
 
     float _buffer[SUB_FRAME_LENGTH];