Fix bypass delay #3

Author: jurihock

src/StftPitchShiftPlugin/Core.h

@@ -20,7 +20,9 @@ class Core
 
   virtual int latency() const = 0;
   virtual bool compatible(const int blocksize) const = 0;
-  virtual void process(const std::span<const float> input, const std::span<float> output) = 0;
+
+  virtual void dry(const std::span<const float> input, const std::span<float> output) = 0;
+  virtual void wet(const std::span<const float> input, const std::span<float> output) = 0;
 
 protected:
 

src/StftPitchShiftPlugin/Core/DelayedCore.cpp

@@ -25,7 +25,24 @@ bool DelayedCore::compatible(const int blocksize) const
   return static_cast<size_t>(blocksize) <= synthesis_window_size;
 }
 
-void DelayedCore::process(const std::span<const float> input, const std::span<float> output)
+void DelayedCore::dry(const std::span<const float> input, const std::span<float> output)
+{
+  process(input, output, [&](std::span<float> x, std::span<float> y)
+  {
+    InstantCore::dry(x, y);
+  });
+}
+
+void DelayedCore::wet(const std::span<const float> input, const std::span<float> output)
+{
+  process(input, output, [&](std::span<float> x, std::span<float> y)
+  {
+    InstantCore::wet(x, y);
+  });
+}
+
+void DelayedCore::process(const std::span<const float> input, const std::span<float> output,
+                          std::function<void(std::span<float> x, std::span<float> y)> callback)
 {
   const auto minsamples = input.size();
   const auto maxsamples = synthesis_window_size;
@@ -48,7 +65,7 @@ void DelayedCore::process(const std::span<const float> input, const std::span<fl
     const auto x = buffer.input.data() + buffer.input.size();
     const auto y = buffer.output.data() + buffer.output.size();
 
-    InstantCore::process(
+    callback(
       std::span(x - samples, maxsamples),
       std::span(y - samples, maxsamples));
 

src/StftPitchShiftPlugin/Core/DelayedCore.h

@@ -12,7 +12,9 @@ class DelayedCore : public InstantCore
 
   int latency() const override;
   bool compatible(const int blocksize) const override;
-  void process(const std::span<const float> input, const std::span<float> output) override;
+
+  void dry(const std::span<const float> input, const std::span<float> output) override;
+  void wet(const std::span<const float> input, const std::span<float> output) override;
 
 private:
 
@@ -22,4 +24,7 @@ class DelayedCore : public InstantCore
 
   size_t samples;
 
+  void process(const std::span<const float> input, const std::span<float> output,
+               std::function<void(std::span<float> x, std::span<float> y)> callback);
+
 };

src/StftPitchShiftPlugin/Core/InstantCore.cpp

@@ -23,7 +23,24 @@ bool InstantCore::compatible(const int blocksize) const
   return static_cast<size_t>(blocksize) == synthesis_window_size;
 }
 
-void InstantCore::process(const std::span<const float> input, const std::span<float> output)
+void InstantCore::dry(const std::span<const float> input, const std::span<float> output)
+{
+  process(input, output, [](std::span<double> x, std::span<double> y)
+  {
+    std::copy(x.begin(), x.end(), y.begin());
+  });
+}
+
+void InstantCore::wet(const std::span<const float> input, const std::span<float> output)
+{
+  process(input, output, [&](std::span<double> x, std::span<double> y)
+  {
+    stft_pitch_shift(x, y);
+  });
+}
+
+void InstantCore::process(const std::span<const float> input, const std::span<float> output,
+                          std::function<void(std::span<double> x, std::span<double> y)> callback)
 {
   // shift input buffer
   std::copy(
@@ -38,8 +55,8 @@ void InstantCore::process(const std::span<const float> input, const std::span<fl
     buffer.input.begin() + analysis_window_size,
     transform<float, double>);
 
-  // apply pitch shifting within the built-in STFT routine
-  stft_pitch_shift(buffer.input, buffer.output);
+  // start processing
+  callback(buffer.input, buffer.output);
 
   // copy new output samples back
   std::transform(

src/StftPitchShiftPlugin/Core/InstantCore.h

@@ -12,7 +12,9 @@ class InstantCore : public Core
 
   int latency() const override;
   bool compatible(const int blocksize) const override;
-  void process(const std::span<const float> input, const std::span<float> output) override;
+
+  void dry(const std::span<const float> input, const std::span<float> output) override;
+  void wet(const std::span<const float> input, const std::span<float> output) override;
 
 private:
 
@@ -21,4 +23,7 @@ class InstantCore : public Core
   template<typename X, typename Y>
   static Y transform(const X x) { return static_cast<Y>(x); }
 
+  void process(const std::span<const float> input, const std::span<float> output,
+               std::function<void(std::span<double> x, std::span<double> y)> callback);
+
 };

src/StftPitchShiftPlugin/Processor.cpp

@@ -182,7 +182,14 @@ void Processor::processBlock(juce::AudioBuffer<float>& audio, juce::MidiBuffer&
       audio.getWritePointer(0),
       static_cast<size_t>(channel_samples));
 
-    core->process(input, output);
+    if (parameters->bypass())
+    {
+      core->dry(input, output);
+    }
+    else
+    {
+      core->wet(input, output);
+    }
   };
 
   const auto process_stereo_output = [&](const std::string& error = "")
@@ -200,11 +207,7 @@ void Processor::processBlock(juce::AudioBuffer<float>& audio, juce::MidiBuffer&
 
   TIC();
 
-  if (parameters->bypass() || (channel_samples < 4))
-  {
-    process_stereo_output();
-  }
-  else if (!state)
+  if (!state)
   {
     process_stereo_output("state is not initialized");
   }