fix: fix incorrect bypass behaviour

Author: zsliu98

source/PluginProcessor.cpp

@@ -125,8 +125,32 @@ bool PluginProcessor::isBusesLayoutSupported(const BusesLayout &layouts) const {
     return true;
 }
 
-void PluginProcessor::processBlock(juce::AudioBuffer<float> &buffer,
-                                   juce::MidiBuffer &) {
+void PluginProcessor::processBlock(juce::AudioBuffer<float> &buffer, juce::MidiBuffer &) {
+    if (bypass_ref_.load(std::memory_order::relaxed) < .5f) {
+        processBlockInternal<false>(buffer);
+    } else {
+        processBlockInternal<true>(buffer);
+    }
+}
+
+void PluginProcessor::processBlock(juce::AudioBuffer<double> &buffer, juce::MidiBuffer &) {
+    if (bypass_ref_.load(std::memory_order::relaxed) < .5f) {
+        processBlockInternal<false>(buffer);
+    } else {
+        processBlockInternal<true>(buffer);
+    }
+}
+
+void PluginProcessor::processBlockBypassed(juce::AudioBuffer<float> &buffer, juce::MidiBuffer &) {
+    processBlockInternal<true>(buffer);
+}
+
+void PluginProcessor::processBlockBypassed(juce::AudioBuffer<double> &buffer, juce::MidiBuffer &) {
+    processBlockInternal<true>(buffer);
+}
+
+template<bool IsBypassed>
+void PluginProcessor::processBlockInternal(juce::AudioBuffer<float> &buffer) {
     juce::ScopedNoDenormals no_denormals;
     double_in_pointers[0] = double_in_buffer[0].data();
     double_in_pointers[1] = double_in_buffer[1].data();
@@ -143,20 +167,25 @@ void PluginProcessor::processBlock(juce::AudioBuffer<float> &buffer,
                                    static_cast<size_t>(buffer.getNumSamples()));
     }
 
-    if (bypass_ref_.load(std::memory_order::relaxed) < .5f) {
+    if constexpr (!IsBypassed) {
         for (size_t chan = 0; chan < static_cast<size_t>(std::min(4, buffer.getNumChannels())); ++chan) {
             zldsp::vector::copy(buffer.getWritePointer(static_cast<int>(chan)),
                                 double_out_pointers1[chan], static_cast<size_t>(buffer.getNumSamples()));
         }
     } else {
+        double_controller_.processBypassDelay(double_in_pointers, static_cast<size_t>(buffer.getNumSamples()));
+        for (size_t chan = 0; chan < 2; ++chan) {
+            zldsp::vector::copy(buffer.getWritePointer(static_cast<int>(chan)),
+                                double_in_pointers[chan], static_cast<size_t>(buffer.getNumSamples()));
+        }
         for (auto i = getTotalNumInputChannels(); i < getTotalNumOutputChannels(); ++i) {
             buffer.clear(i, 0, buffer.getNumSamples());
         }
     }
 }
 
-void PluginProcessor::processBlock(juce::AudioBuffer<double> &buffer,
-                                   juce::MidiBuffer &) {
+template<bool IsBypassed>
+void PluginProcessor::processBlockInternal(juce::AudioBuffer<double> &buffer) {
     juce::ScopedNoDenormals no_denormals;
     double_in_pointers[0] = buffer.getWritePointer(0);
     double_in_pointers[1] = buffer.getWritePointer(1);
@@ -169,12 +198,13 @@ void PluginProcessor::processBlock(juce::AudioBuffer<double> &buffer,
                                    static_cast<size_t>(buffer.getNumSamples()));
     }
 
-    if (bypass_ref_.load(std::memory_order::relaxed) < .5f) {
+    if constexpr (!IsBypassed) {
         for (size_t chan = 0; chan < static_cast<size_t>(std::min(4, buffer.getNumChannels())); ++chan) {
             zldsp::vector::copy(buffer.getWritePointer(static_cast<int>(chan)),
                                 double_out_pointers1[chan], static_cast<size_t>(buffer.getNumSamples()));
         }
     } else {
+        double_controller_.processBypassDelay(double_in_pointers, static_cast<size_t>(buffer.getNumSamples()));
         for (auto i = getTotalNumInputChannels(); i < getTotalNumOutputChannels(); ++i) {
             buffer.clear(i, 0, buffer.getNumSamples());
         }

source/PluginProcessor.hpp

@@ -40,6 +40,10 @@ class PluginProcessor : public juce::AudioProcessor {
 
     void processBlock(juce::AudioBuffer<double> &, juce::MidiBuffer &) override;
 
+    void processBlockBypassed(juce::AudioBuffer<float> &, juce::MidiBuffer &) override;
+
+    void processBlockBypassed(juce::AudioBuffer<double> &, juce::MidiBuffer &) override;
+
     juce::AudioProcessorEditor *createEditor() override;
 
     bool hasEditor() const override;
@@ -74,7 +78,7 @@ class PluginProcessor : public juce::AudioProcessor {
         return double_controller_;
     }
 
-    double getAtomicSampleRate() const  {
+    double getAtomicSampleRate() const {
         return sample_rate_.load(std::memory_order::relaxed);
     }
 
@@ -86,12 +90,18 @@ class PluginProcessor : public juce::AudioProcessor {
 
     std::array<std::vector<double>, 2> double_in_buffer;
     std::array<std::vector<double>, 4> double_out_buffer;
-    std::array<double*, 2> double_in_pointers{};
-    std::array<double*, 4> double_out_pointers1{};
-    std::array<double*, 4> double_out_pointers2{};
+    std::array<double *, 2> double_in_pointers{};
+    std::array<double *, 4> double_out_pointers1{};
+    std::array<double *, 4> double_out_pointers2{};
 
     zlp::Controller<double> double_controller_;
     zlp::ControllerAttach<double> double_controller_attach_;
 
+    template<bool IsBypassed>
+    void processBlockInternal(juce::AudioBuffer<float> &);
+
+    template<bool IsBypassed>
+    void processBlockInternal(juce::AudioBuffer<double> &);
+
     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(PluginProcessor)
 };

source/dsp/delay/integer_delay.hpp

@@ -74,9 +74,9 @@ namespace zldsp::delay {
         }
 
         void setDelay(const FloatType delay_seconds) {
-            const auto delay_samples = static_cast<int>(std::round(delay_seconds * sample_rate_));
+            delay_samples_ = static_cast<int>(std::round(delay_seconds * sample_rate_));
             const auto pre_delay_samples = static_cast<int>(std::round(delay_seconds_ * sample_rate_));
-            const auto delta = delay_samples - pre_delay_samples;
+            const auto delta = delay_samples_ - pre_delay_samples;
             delay_seconds_ = delay_seconds;
             if (delta < 0) {
                 tail_ += delta;
@@ -96,12 +96,13 @@ namespace zldsp::delay {
         }
 
         [[nodiscard]] int getDelayInSamples() const {
-            return static_cast<int>(std::round(delay_seconds_ * sample_rate_));
+            return delay_samples_;
         }
 
     private:
         double sample_rate_{48000.0};
         FloatType delay_seconds_{0};
+        int delay_samples_{0};
         int capacity_{0}, head_{0}, tail_{0};
         std::vector<std::vector<FloatType> > states_;
     };

source/dsp/splitter/lh_splitter/lh_fir_splitter.hpp

@@ -152,6 +152,10 @@ namespace zldsp::splitter {
             }
         }
 
+        int getMaxLatency() const {
+            return static_cast<int>(1 << (kSecondOrderNumStage + extra_stage_ + 2)) + 2;
+        }
+
     private:
         inline static constexpr size_t kFirstOrderNumStage = 9;
         inline static constexpr size_t kSecondOrderNumStage = 11;

source/dsp/splitter/ts_splitter/ts_splitter.hpp

@@ -40,9 +40,9 @@ namespace zldsp::splitter {
             delay_span_[0] = steady_buffer;
             delay_.process(delay_span_, num_samples);
             // transient split
-            fft_span_[0] = in_buffer;
-            zldsp::filter::FIRBase<FloatType, 10>::process(fft_span_, num_samples);
             zldsp::vector::copy(transient_buffer, in_buffer, num_samples);
+            fft_span_[0] = transient_buffer;
+            zldsp::filter::FIRBase<FloatType, 10>::process(fft_span_, num_samples);
             // subtract transient buffer from steady buffer
             auto transient_v = kfr::make_univector(transient_buffer, num_samples);
             auto steady_v = kfr::make_univector(steady_buffer, num_samples);

source/zlp/controller.cpp

@@ -29,6 +29,10 @@ namespace zlp {
 
         fft_analyzer_.prepare(sample_rate, {2, 2});
         mag_analyzer_.prepare(sample_rate, max_num_samples);
+
+        const auto max_latency = std::max(lh_fir_splitter_.getMaxLatency(), ts_splitter_[0].getTSLatency());
+        bypass_delay_.prepare(sample_rate, max_num_samples, 2,
+                              static_cast<FloatType>(max_latency + 1) / static_cast<FloatType>(sample_rate));
     }
 
     template<typename FloatType>
@@ -156,11 +160,22 @@ namespace zlp {
         }
     }
 
+    template<typename FloatType>
+    void Controller<FloatType>::processBypassDelay(std::array<FloatType *, 2> &in_buffer, size_t num_samples) {
+        if (bypass_delay_.getDelayInSamples() == 0) {
+            return;
+        }
+        bypass_delay_.process(in_buffer, num_samples);
+    }
+
     template<typename FloatType>
     void Controller<FloatType>::checkUpdateLatency() {
+        bypass_delay_.reset();
+        bypass_delay_.setDelayInSamples(latency_.load(std::memory_order::relaxed));
         if (latency_.load(std::memory_order::relaxed) != p_ref_.getLatencySamples()) {
             triggerAsyncUpdate();
         }
+        mag_analyzer_.setToReset();
     }
 
     template<typename FloatType>

source/zlp/controller.hpp

@@ -35,6 +35,8 @@ namespace zlp {
                      std::array<FloatType *, 4> &out_buffer,
                      size_t num_samples);
 
+        void processBypassDelay(std::array<FloatType *, 2> &in_buffer, size_t num_samples);
+
         void setSplitType(zlp::PSplitType::SplitType split_type) {
             split_type_.store(split_type, std::memory_order::relaxed);
             to_update_split_type_.store(true, std::memory_order::release);
@@ -120,6 +122,8 @@ namespace zlp {
         std::atomic<bool> is_mag_on_{false};
         zldsp::analyzer::MultipleMagAnalyzer<FloatType, 2, kAnalyzerPointNum> mag_analyzer_;
 
+        zldsp::delay::IntegerDelay<FloatType> bypass_delay_;
+
         void checkUpdateLatency();
 
         void handleAsyncUpdate() override;