perf: switch voice mixing to block render paths

Author: tucktuckg00se

src/PluginProcessor.cpp

@@ -532,10 +532,10 @@ bool IntersectProcessor::isBusesLayoutSupported (const BusesLayout& layouts) con
     return true;
 }
 
-void IntersectProcessor::prepareToPlay (double sampleRate, int /*samplesPerBlock*/)
+void IntersectProcessor::prepareToPlay (double sampleRate, int samplesPerBlock)
 {
     currentSampleRate = sampleRate;
-    voicePool.setSampleRate (sampleRate);
+    voicePool.prepareToPlay (sampleRate, samplesPerBlock);
     std::fill (std::begin (heldNotes), std::end (heldNotes), false);
 
     auto sampleSnap = sampleData.getSnapshot();
@@ -2050,53 +2050,34 @@ void IntersectProcessor::processBlock (juce::AudioBuffer<float>& buffer,
 
     buffer.clear();
 
+    const int numSamples = buffer.getNumSamples();
+
     if (numActiveBuses <= 1)
     {
-        // Fast path: single stereo output
-        for (int i = 0; i < buffer.getNumSamples(); ++i)
-        {
-            float sL = 0.0f, sR = 0.0f;
-            voicePool.processSample (sampleData, currentSampleRate, sL, sR);
-            if (busL[0]) busL[0][i] = sanitiseSample (sL);
-            if (busR[0]) busR[0][i] = sanitiseSample (sR);
-        }
+        // Fast path: single stereo output — voice-first block render
+        voicePool.renderMainBusBlock (sampleData, busL[0], busR[0], numSamples);
+
+        // Sanitise once after all voices have been mixed
+        if (busL[0])
+            for (int i = 0; i < numSamples; ++i)
+                busL[0][i] = sanitiseSample (busL[0][i]);
+        if (busR[0])
+            for (int i = 0; i < numSamples; ++i)
+                busR[0][i] = sanitiseSample (busR[0][i]);
     }
     else
     {
-        // Multi-out: route each voice to its assigned bus
-        constexpr int previewIdx = VoicePool::kPreviewVoiceIndex;
-        for (int i = 0; i < buffer.getNumSamples(); ++i)
-        {
-            for (int vi = 0; vi < voicePool.getMaxActiveVoices(); ++vi)
-            {
-                float vL = 0.0f, vR = 0.0f;
-                voicePool.processVoiceSample (vi, sampleData, currentSampleRate, vL, vR);
+        // Multi-out: voice-first block render with per-voice bus routing
+        voicePool.renderRoutedBlock (sampleData, busL.data(), busR.data(), numActiveBuses, numSamples);
 
-                int bus = voicePool.getVoice (vi).outputBus;
-                if (bus < 0 || bus >= numActiveBuses || busL[bus] == nullptr) bus = 0;
-                if (busL[bus]) busL[bus][i] += vL;
-                if (busR[bus]) busR[bus][i] += vR;
-            }
-
-            // Always process preview voice (LazyChopEngine) on main bus
-            if (previewIdx >= voicePool.getMaxActiveVoices()
-                && juce::isPositiveAndBelow (previewIdx, VoicePool::kMaxVoices)
-                && voicePool.getVoice (previewIdx).active)
-            {
-                float vL = 0.0f, vR = 0.0f;
-                voicePool.processVoiceSample (previewIdx, sampleData, currentSampleRate, vL, vR);
-                if (busL[0]) busL[0][i] += vL;
-                if (busR[0]) busR[0][i] += vR;
-            }
-        }
         // Clamp / NaN-guard every active bus after accumulation
         for (int b = 0; b < numActiveBuses; ++b)
         {
             if (busL[b])
-                for (int i = 0; i < buffer.getNumSamples(); ++i)
+                for (int i = 0; i < numSamples; ++i)
                     busL[b][i] = sanitiseSample (busL[b][i]);
             if (busR[b])
-                for (int i = 0; i < buffer.getNumSamples(); ++i)
+                for (int i = 0; i < numSamples; ++i)
                     busR[b][i] = sanitiseSample (busR[b][i]);
         }
     }

src/audio/VoicePool.cpp

@@ -210,6 +210,14 @@ VoicePool::VoicePool()
     updateBungeePingPongFadeLength();
 }
 
+void VoicePool::prepareToPlay (double sr, int maxBlockSize)
+{
+    setSampleRate (sr);
+    const int scratchSize = juce::jmax (1, maxBlockSize);
+    scratchL.resize ((size_t) scratchSize, 0.0f);
+    scratchR.resize ((size_t) scratchSize, 0.0f);
+}
+
 void VoicePool::setSampleRate (double sr)
 {
     sampleRate = sr;
@@ -1110,6 +1118,87 @@ void VoicePool::processSample (const SampleData& sample, double sr,
     }
 }
 
+void VoicePool::renderMainBusBlock (const SampleData& sample,
+                                     float* destL, float* destR, int numSamples)
+{
+    // Zero destination
+    if (destL) std::fill_n (destL, numSamples, 0.0f);
+    if (destR) std::fill_n (destR, numSamples, 0.0f);
+
+    auto renderVoiceBlock = [&] (int vi)
+    {
+        for (int s = 0; s < numSamples; ++s)
+        {
+            float vL = 0.0f, vR = 0.0f;
+            processVoiceSample (vi, sample, sampleRate, vL, vR);
+            if (destL) destL[s] += vL;
+            if (destR) destR[s] += vR;
+        }
+    };
+
+    for (int vi = 0; vi < maxActive; ++vi)
+    {
+        if (voices[vi].active)
+            renderVoiceBlock (vi);
+    }
+
+    // Preview voice (LazyChopEngine / shift preview) — always on main bus
+    constexpr int previewIdx = kPreviewVoiceIndex;
+    if (previewIdx >= maxActive && voices[previewIdx].active)
+        renderVoiceBlock (previewIdx);
+}
+
+void VoicePool::renderRoutedBlock (const SampleData& sample,
+                                    float* busL[], float* busR[], int numBuses, int numSamples)
+{
+    const int scratchSize = (int) std::min (scratchL.size(), scratchR.size());
+    jassert (scratchSize > 0);
+    if (scratchSize <= 0 || numSamples <= 0)
+        return;
+
+    auto renderVoiceToScratch = [&] (int vi, int chunkSamples)
+    {
+        for (int s = 0; s < chunkSamples; ++s)
+            processVoiceSample (vi, sample, sampleRate, scratchL[s], scratchR[s]);
+    };
+
+    auto accumulateScratchToBus = [&] (float* dstL, float* dstR, int chunkStart, int chunkSamples)
+    {
+        for (int s = 0; s < chunkSamples; ++s)
+        {
+            if (dstL) dstL[chunkStart + s] += scratchL[s];
+            if (dstR) dstR[chunkStart + s] += scratchR[s];
+        }
+    };
+
+    for (int chunkStart = 0; chunkStart < numSamples; chunkStart += scratchSize)
+    {
+        const int chunkSamples = std::min (scratchSize, numSamples - chunkStart);
+
+        for (int vi = 0; vi < maxActive; ++vi)
+        {
+            if (! voices[vi].active)
+                continue;
+
+            renderVoiceToScratch (vi, chunkSamples);
+
+            int bus = voices[vi].outputBus;
+            if (bus < 0 || bus >= numBuses || busL[bus] == nullptr)
+                bus = 0;
+
+            accumulateScratchToBus (busL[bus], busR[bus], chunkStart, chunkSamples);
+        }
+
+        // Preview voice — always to bus 0
+        constexpr int previewIdx = kPreviewVoiceIndex;
+        if (previewIdx >= maxActive && voices[previewIdx].active)
+        {
+            renderVoiceToScratch (previewIdx, chunkSamples);
+            accumulateScratchToBus (busL[0], busR[0], chunkStart, chunkSamples);
+        }
+    }
+}
+
 void VoicePool::startShiftPreview (int startSample, int bufferSize,
                                     const PreviewStretchParams& p)
 {

src/audio/VoicePool.h

@@ -88,6 +88,13 @@ class VoicePool
     void processSample (const SampleData& sample, double sampleRate,
                         float& outL, float& outR);
 
+    // Block-based render APIs — preferred entry points from processBlock()
+    void renderMainBusBlock (const SampleData& sample,
+                             float* destL, float* destR, int numSamples);
+    void renderRoutedBlock (const SampleData& sample,
+                            float* busL[], float* busR[], int numBuses, int numSamples);
+
+    void prepareToPlay (double sampleRate, int maxBlockSize);
     void setSampleRate (double sr);
     double getSampleRate() const { return sampleRate; }
 
@@ -134,4 +141,8 @@ class VoicePool
     std::array<Voice, kMaxVoices> voices;
     int maxActive = 16; // playable voices, excluding preview voice
     double sampleRate = 44100.0;
+
+    // Preallocated scratch buffers for block rendering (sized to maxBlockSize)
+    std::vector<float> scratchL;
+    std::vector<float> scratchR;
 };