Relax vocals gate thresholds and explicitly write main bus output (#4)

Author: axeldelafosse

plugin/include/StemgenRT/Constants.h

@@ -43,19 +43,19 @@ constexpr float kSoftGateFloor = 0.000016f;     // -96dB in linear (16-bit noise
 // On instrumental tracks, the model often outputs spurious low-level content in the vocals stem.
 // This gate detects when vocals energy is very low relative to the mix and transfers it to "other".
 // Two criteria: (1) ratio of vocals to total energy, (2) absolute vocals level.
-// Real vocals are typically above -25dB; be aggressive about gating quiet content.
+// Keep gating conservative enough to avoid suppressing quiet but valid vocals.
 //
 // Ratio-based gating: when vocals are a tiny fraction of the mix, they're likely noise
-constexpr float kVocalsGateRatioThreshold = 0.01f;   // Below 1% of mix energy, start gating
-constexpr float kVocalsGateRatioFloor = 0.003f;      // Below 0.3%, fully gate (transfer to other)
+constexpr float kVocalsGateRatioThreshold = 0.0040f;  // Below 0.40% of mix energy, start gating
+constexpr float kVocalsGateRatioFloor = 0.0008f;      // Below 0.08%, fully gate (transfer to other)
 //
 // Level-based gating: absolute vocals level threshold (real vocals are rarely this quiet)
 // Uses peak amplitude (max of L/R) rather than RMS for faster response
-constexpr float kVocalsGateLevelThresholdDb = -28.0f;  // Above this, vocals pass through
-constexpr float kVocalsGateLevelFloorDb = -32.0f;      // Below this, fully gate
+constexpr float kVocalsGateLevelThresholdDb = -39.0f;  // Above this, vocals pass through
+constexpr float kVocalsGateLevelFloorDb = -50.0f;      // Below this, fully gate
 // Precomputed linear values: 10^(dB/20)
-constexpr float kVocalsGateLevelThreshold = 0.04f;     // -28dB in linear
-constexpr float kVocalsGateLevelFloor = 0.025f;        // -32dB in linear
+constexpr float kVocalsGateLevelThreshold = 0.0112f;   // -39dB in linear
+constexpr float kVocalsGateLevelFloor = 0.0032f;       // -50dB in linear
 //
 // Asymmetric attack/release time constants for vocals gate (in seconds)
 // Fast attack so vocals come in quickly, slow release to avoid pumping on gaps

plugin/include/StemgenRT/OverlapAddProcessor.h

@@ -96,6 +96,10 @@ class OverlapAddProcessor {
     // Advance dry delay positions (call once per sample after reading)
     void advanceDryDelayPos();
 
+    // Dry delay priming helpers
+    bool isDryDelayPrimed() const { return dryDelayPrimed_; }
+    void primeDryDelayFromInput(const float* inputPointers[kNumChannels], int numSamples);
+
     // === Chunk boundary crossfade state ===
 
     // Previous chunk's overlap tail for crossfading at chunk boundaries.
@@ -135,6 +139,7 @@ class OverlapAddProcessor {
     std::array<std::vector<float>, kNumChannels> dryDelayLine_;
     size_t dryDelayWritePos_{0};
     size_t dryDelayReadPos_{0};
+    bool dryDelayPrimed_{false};
 
     // Chunk boundary crossfade state
     std::array<std::array<std::vector<float>, kNumChannels>, kNumStems> prevOverlapTail_;

plugin/source/OutputWriter.cpp

@@ -57,8 +57,8 @@ void OutputWriter::writeBlock(
             dry[ch] = overlapAdd.readDryDelaySample(ch);
         }
 
-        // Main bus: don't write — input passes through unmodified via
-        // JUCE in-place buffer sharing.
+        // Main bus is copied from live input in PluginProcessor before this call.
+        // Keep it untouched here so bus 0 remains true dry passthrough.
 
         // Stem buses (if enabled)
         // During underrun, output dry/4 to each stem (approximate equal split)

plugin/source/OverlapAddProcessor.cpp

@@ -64,6 +64,7 @@ void OverlapAddProcessor::reset() {
     // Initialize dry delay positions so readPos lags behind writePos by kOutputChunkSize
     dryDelayWritePos_ = static_cast<size_t>(kOutputChunkSize);
     dryDelayReadPos_ = 0;
+    dryDelayPrimed_ = false;
 }
 
 void OverlapAddProcessor::resetIndices() {
@@ -79,6 +80,7 @@ void OverlapAddProcessor::resetIndices() {
     // Initialize dry delay positions so readPos lags behind writePos by kOutputChunkSize
     dryDelayWritePos_ = static_cast<size_t>(kOutputChunkSize);
     dryDelayReadPos_ = 0;
+    dryDelayPrimed_ = false;
 }
 
 void OverlapAddProcessor::pushInputSample(int channel, float hpSample, float lpSample, float drySample) {
@@ -161,4 +163,28 @@ void OverlapAddProcessor::advanceDryDelayPos() {
     dryDelayReadPos_ = (dryDelayReadPos_ + 1) % dryDelaySize;
 }
 
+void OverlapAddProcessor::primeDryDelayFromInput(
+    const float* inputPointers[kNumChannels], int numSamples) {
+    if (numSamples <= 0)
+        return;
+
+    const size_t targetFill = static_cast<size_t>(kOutputChunkSize);
+    const size_t inputCount = static_cast<size_t>(numSamples);
+    const size_t copyCount = std::min(targetFill, inputCount);
+    const size_t srcOffset = inputCount - copyCount;
+
+    for (int ch = 0; ch < kNumChannels; ++ch) {
+        auto& dryDelay = dryDelayLine_[static_cast<size_t>(ch)];
+        std::fill_n(dryDelay.begin(), targetFill, 0.0f);
+
+        if (inputPointers[ch] != nullptr) {
+            std::memcpy(dryDelay.data(),
+                        inputPointers[ch] + srcOffset,
+                        copyCount * sizeof(float));
+        }
+    }
+
+    dryDelayPrimed_ = true;
+}
+
 }  // namespace audio_plugin

plugin/source/PluginProcessor.cpp

@@ -707,6 +707,12 @@ void AudioPluginAudioProcessor::processBlock(juce::AudioBuffer<float>& buffer,
       }
     }
 
+    // Prime dry delay line before main output takes a sample so the first block
+    // isn't silent due to the initial zeroed buffer.
+    if (!overlapAdd_.isDryDelayPrimed()) {
+      overlapAdd_.primeDryDelayFromInput(inputChannelPtrs, numSamples);
+    }
+
     // ===== Write separated stems to output buses =====
     const int numOutputBuses = getBusCount(false /* isInput */);
 

test/CMakeLists.txt

@@ -6,7 +6,10 @@ project(AudioPluginTest)
 enable_testing()
 
 # Creates the test console application.
-set(SOURCE_FILES source/AudioProcessorTest.cpp)
+set(SOURCE_FILES
+  source/AudioProcessorTest.cpp
+  source/OverlapAddProcessorTest.cpp
+)
 add_executable(${PROJECT_NAME} ${SOURCE_FILES})
 
 # Sets the necessary include directories of googletest.

test/source/OverlapAddProcessorTest.cpp

@@ -0,0 +1,97 @@
+#include <StemgenRT/Constants.h>
+#include <StemgenRT/OverlapAddProcessor.h>
+#include <gtest/gtest.h>
+#include <vector>
+
+namespace audio_plugin_test {
+
+namespace {
+
+void pushDryBlock(audio_plugin::OverlapAddProcessor& processor,
+                  const std::vector<float>& left,
+                  const std::vector<float>& right) {
+  ASSERT_EQ(left.size(), right.size());
+  for (size_t i = 0; i < left.size(); ++i) {
+    processor.pushInputSample(0, 0.0f, 0.0f, left[i]);
+    processor.pushInputSample(1, 0.0f, 0.0f, right[i]);
+  }
+}
+
+std::vector<float> readDrySamples(audio_plugin::OverlapAddProcessor& processor,
+                                  int channel,
+                                  size_t count) {
+  std::vector<float> out(count);
+  for (size_t i = 0; i < count; ++i) {
+    out[i] = processor.readDryDelaySample(channel);
+    processor.advanceDryDelayPos();
+  }
+  return out;
+}
+
+}  // namespace
+
+TEST(OverlapAddProcessorTest, PrimeDryDelayDoesNotTileShortHostBlock) {
+  audio_plugin::OverlapAddProcessor processor;
+  processor.allocate();
+
+  // Simulate RT reset behavior: indices are reset but dry delay storage is retained.
+  std::vector<float> stale(audio_plugin::kOutputChunkSize * 2, -1.0f);
+  pushDryBlock(processor, stale, stale);
+  processor.resetIndices();
+
+  constexpr int kHostBlockSize = 64;
+  std::vector<float> input(static_cast<size_t>(kHostBlockSize));
+  for (int i = 0; i < kHostBlockSize; ++i) {
+    input[static_cast<size_t>(i)] = static_cast<float>(i + 1);
+  }
+
+  pushDryBlock(processor, input, input);
+
+  const float* inputPointers[audio_plugin::kNumChannels] = {
+      input.data(), input.data()};
+  processor.primeDryDelayFromInput(inputPointers, kHostBlockSize);
+
+  auto primed = readDrySamples(processor, 0, audio_plugin::kOutputChunkSize);
+
+  for (int i = 0; i < kHostBlockSize; ++i) {
+    EXPECT_FLOAT_EQ(primed[static_cast<size_t>(i)], input[static_cast<size_t>(i)]);
+  }
+  for (int i = kHostBlockSize; i < audio_plugin::kOutputChunkSize; ++i) {
+    EXPECT_FLOAT_EQ(primed[static_cast<size_t>(i)], 0.0f);
+  }
+}
+
+TEST(OverlapAddProcessorTest, PrimeDryDelayKeepsNewestWrappedSamplesForLargeHostBlock) {
+  audio_plugin::OverlapAddProcessor withPriming;
+  withPriming.allocate();
+  withPriming.resetIndices();
+
+  audio_plugin::OverlapAddProcessor withoutPriming;
+  withoutPriming.allocate();
+  withoutPriming.resetIndices();
+
+  constexpr int kHostBlockSize = 1024;
+  static_assert(kHostBlockSize > audio_plugin::kOutputChunkSize);
+  std::vector<float> input(static_cast<size_t>(kHostBlockSize));
+  for (int i = 0; i < kHostBlockSize; ++i) {
+    input[static_cast<size_t>(i)] = static_cast<float>(i + 1);
+  }
+
+  pushDryBlock(withPriming, input, input);
+  pushDryBlock(withoutPriming, input, input);
+
+  const float* inputPointers[audio_plugin::kNumChannels] = {
+      input.data(), input.data()};
+  withPriming.primeDryDelayFromInput(inputPointers, kHostBlockSize);
+
+  auto primed = readDrySamples(withPriming, 0, audio_plugin::kOutputChunkSize);
+  auto baseline = readDrySamples(withoutPriming, 0, audio_plugin::kOutputChunkSize);
+
+  for (int i = 0; i < audio_plugin::kOutputChunkSize; ++i) {
+    EXPECT_FLOAT_EQ(primed[static_cast<size_t>(i)], baseline[static_cast<size_t>(i)]);
+    EXPECT_FLOAT_EQ(primed[static_cast<size_t>(i)],
+                    input[static_cast<size_t>(i + audio_plugin::kOutputChunkSize)]);
+  }
+}
+
+}  // namespace audio_plugin_test