Adding the Dry FX and adding the reset method called on bypass

src/fx.h

@@ -37,6 +37,8 @@ protected:
 public:
     float32_t getSamplingRate() const;
 
+    virtual void reset() = 0;
+
 private:
     const float32_t SamplingRate;
 };

src/fx_chorus.cpp

@@ -15,10 +15,10 @@ Chorus::Chorus(float32_t sampling_rate) :
     fullscale_depth_(0.0f),
     feedback_(0.0f)
 {
-    this->lfo_[LFO_Index::Sin1] = new LFO(sampling_rate, LFO::Waveform::Sine, 0.0f, LFO1_MAX_FREQ);
-    this->lfo_[LFO_Index::Cos1] = new LFO(sampling_rate, LFO::Waveform::Sine, 0.0f, LFO1_MAX_FREQ, Constants::MPI_2);
-    this->lfo_[LFO_Index::Sin2] = new LFO(sampling_rate, LFO::Waveform::Sine, 0.0f, LFO2_MAX_FREQ);
-    this->lfo_[LFO_Index::Cos2] = new LFO(sampling_rate, LFO::Waveform::Sine, 0.0f, LFO2_MAX_FREQ, Constants::MPI_2);
+    this->lfo_[LFOIndex::Sin1] = new LFO(sampling_rate, LFO::Waveform::Sine, 0.0f, LFO1_MAX_FREQ);
+    this->lfo_[LFOIndex::Cos1] = new LFO(sampling_rate, LFO::Waveform::Sine, 0.0f, LFO1_MAX_FREQ, Constants::MPI_2);
+    this->lfo_[LFOIndex::Sin2] = new LFO(sampling_rate, LFO::Waveform::Sine, 0.0f, LFO2_MAX_FREQ);
+    this->lfo_[LFOIndex::Cos2] = new LFO(sampling_rate, LFO::Waveform::Sine, 0.0f, LFO2_MAX_FREQ, Constants::MPI_2);
 
     this->setRate(0.1f);
     this->setDepth(0.15f);
@@ -32,6 +32,15 @@ Chorus::~Chorus()
     }
 }
 
+void Chorus::reset()
+{
+    this->engine_.reset();
+    for(unsigned i = 0; i < 4; ++i)
+    {
+        this->lfo_[i]->reset();
+    }
+}
+
 void Chorus::processSample(float32_t inL, float32_t inR, float32_t& outL, float32_t& outR)
 {
     typedef Engine::Reserve<2047> Memory;
@@ -41,10 +50,10 @@ void Chorus::processSample(float32_t inL, float32_t inR, float32_t& outL, float3
     this->engine_.start(&c);
     
     // Update LFO.
-    float32_t sin_1 = this->lfo_[LFO_Index::Sin1]->process();
-    float32_t cos_1 = this->lfo_[LFO_Index::Cos1]->process();
-    float32_t sin_2 = this->lfo_[LFO_Index::Sin2]->process();
-    float32_t cos_2 = this->lfo_[LFO_Index::Cos2]->process();
+    float32_t sin_1 = this->lfo_[LFOIndex::Sin1]->process();
+    float32_t cos_1 = this->lfo_[LFOIndex::Cos1]->process();
+    float32_t sin_2 = this->lfo_[LFOIndex::Sin2]->process();
+    float32_t cos_2 = this->lfo_[LFOIndex::Cos2]->process();
 
     float32_t wet;
 

src/fx_chorus.h

@@ -27,7 +27,7 @@ class Chorus : public FXElement
     DISALLOW_COPY_AND_ASSIGN(Chorus);
 
 public:
-    enum LFO_Index
+    enum LFOIndex
     {
         Sin1 = 0,
         Sin2,
@@ -38,6 +38,7 @@ public:
     Chorus(float32_t sampling_rate);
     virtual ~Chorus();
 
+    virtual void reset() override;
     virtual void processSample(float32_t inL, float32_t inR, float32_t& outL, float32_t& outR) override;
 
     void setDepth(float32_t depth);

src/fx_components.cpp

@@ -14,6 +14,7 @@ const float32_t Constants::M1_PI = 1.0f / PI;
 /////////////////////////
 LFO::LFO(float32_t sampling_rate, Waveform waveform, float32_t min_frequency, float32_t max_frequency, float32_t initial_phase) :
     FXBase(sampling_rate),
+    InitialPhase(initial_phase),
     min_frequency_(min_frequency),
     max_frequency_(max_frequency),
     waveform_(waveform),
@@ -78,6 +79,12 @@ float32_t LFO::getFrequency() const
     return this->frequency_;
 }
 
+void LFO::reset()
+{
+    this->phase_ = this->InitialPhase;
+    this->current_sample_ = 0.0f;
+}
+
 float32_t LFO::process()
 {
     float32_t out = 0.0f;
@@ -173,6 +180,11 @@ float32_t JitterGenerator::getMagnitude() const
     return this->magnitude_;
 }
 
+void JitterGenerator::reset()
+{
+    this->phase_ = 0.0f;
+}
+
 float32_t JitterGenerator::process()
 {
     float32_t out = std::sin(this->phase_);

src/fx_components.h

@@ -56,10 +56,12 @@ public:
     void setFrequency(float32_t frequency);
     float32_t getFrequency() const;
 
+    virtual void reset() override;
     float32_t process();
     float32_t current() const;
 
 private:
+    const float32_t                             InitialPhase;
     const float32_t                             min_frequency_;
     const float32_t                             max_frequency_;
     Waveform                                    waveform_;
@@ -245,6 +247,7 @@ public:
     void setMagnitude(float32_t magnitude);
     float32_t getMagnitude() const;
 
+    virtual void reset() override;
     float32_t process();
 
 private:

src/fx_delay.cpp

@@ -28,6 +28,12 @@ void Delay::LowHighPassFilter::setCutoffChangeRatio(float32_t ratio)
     this->hpf_.setCutoff(HPF_CUTOFF_REF * ratio);
 }
 
+void Delay::LowHighPassFilter::reset()
+{
+    this->lpf_.reset();
+    this->hpf_.reset();
+}
+
 void Delay::LowHighPassFilter::processSample(float32_t inL, float32_t inR, float32_t& outL, float32_t& outR)
 {
     this->lpf_.processSample(inL, inR, outL, outR);
@@ -44,12 +50,11 @@ Delay::Delay(const float32_t sampling_rate, float32_t default_delay_time, float3
     this->buffer_L_ = new float32_t[this->MaxSampleDelayTime];
     this->buffer_R_ = new float32_t[this->MaxSampleDelayTime];
 
-    memset(this->buffer_L_, 0, this->MaxSampleDelayTime * sizeof(float32_t));
-    memset(this->buffer_R_, 0, this->MaxSampleDelayTime * sizeof(float32_t));
-
     this->setLeftDelayTime(default_delay_time);
     this->setRightDelayTime(default_delay_time);
     this->setFeedbak(default_feedback_level);
+    
+    this->reset();
 }
 
 Delay::~Delay()
@@ -58,6 +63,15 @@ Delay::~Delay()
     delete[] this->buffer_R_;
 }
 
+void Delay::reset()
+{
+    memset(this->buffer_L_, 0, this->MaxSampleDelayTime * sizeof(float32_t));
+    memset(this->buffer_R_, 0, this->MaxSampleDelayTime * sizeof(float32_t));
+    this->read_pos_L_ = 0;
+    this->read_pos_R_ = 0;
+    this->filter_.reset();
+}
+
 void Delay::processSample(float32_t inL, float32_t inR, float32_t& outL, float32_t& outR)
 {
     float32_t delay_time_L = (MAX_DELAY_TIME * this->getLeftDelayTime() ) * this->getSamplingRate();

src/fx_delay.h

@@ -36,6 +36,7 @@ class Delay : public FXElement
         LowHighPassFilter(float32_t sampling_rate);
         virtual ~LowHighPassFilter();
 
+        virtual void reset() override;
         virtual void processSample(float32_t inL, float32_t inR, float32_t& outL, float32_t& outR) override;
 
         void setCutoffChangeRatio(float32_t ratio);
@@ -49,7 +50,8 @@ class Delay : public FXElement
 public:
     Delay(const float32_t sampling_rate, float32_t default_delay_time = 0.25f, float32_t default_flutter_level = 1.0f, float32_t default_wet_level = 0.5f);
     virtual ~Delay();
-
+    
+    virtual void reset() override;
     virtual void processSample(float32_t inL, float32_t inR, float32_t& outL, float32_t& outR) override;
 
     void setLeftDelayTime(float32_t delay_time);
@@ -63,8 +65,8 @@ public:
 
 private:
     const size_t MaxSampleDelayTime;
-    size_t read_pos_L_;
-    size_t read_pos_R_;
+    unsigned read_pos_L_;
+    unsigned read_pos_R_;
     float32_t* buffer_L_;
     float32_t* buffer_R_;
     float32_t delay_time_L_;        // Left delay time in seconds (0.0 - 2.0)

src/fx_dry.cpp

@@ -0,0 +1,21 @@
+#include "fx_dry.h"
+
+Dry::Dry(float32_t samplingRate) :
+    FXElement(samplingRate)
+{
+}
+
+Dry::~Dry()
+{
+}
+
+void Dry::reset()
+{
+    // does nothing
+}
+
+void Dry::processSample(float32_t inL, float32_t inR, float32_t& outL, float32_t& outR)
+{
+    outL = inL;
+    outR = inR;
+}

src/fx_dry.h

@@ -0,0 +1,33 @@
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+//
+// fx_tube.h
+//
+// Stereo Tube overdrive audio effects proposed in the context of the MiniDexed project
+//
+#pragma once
+
+#include "fx_components.h"
+
+class Dry : public FXElement
+{
+    DISALLOW_COPY_AND_ASSIGN(Dry);
+
+public:
+    Dry(float32_t sampling_rate);
+    virtual ~Dry();
+
+    virtual void reset() override;
+    virtual void processSample(float32_t inL, float32_t inR, float32_t& outL, float32_t& outR) override;
+};

src/fx_engine.hpp

@@ -17,12 +17,6 @@ enum Format
     FORMAT_32_BIT
 };
 
-enum LFOIndex
-{
-    LFO_1,
-    LFO_2
-};
-
 template <Format format>
 struct DataType
 {
@@ -70,12 +64,18 @@ class FxEngine : public FXBase
 public:
     typedef typename DataType<format>::T T;
 
+    enum LFOIndex
+    {
+        LFO_1 = 0,
+        LFO_2
+    };
+
     FxEngine(float32_t sampling_rate, float32_t max_lfo1_frequency = 1.0f, float32_t max_lfo2_frequency = 1.0f) :
         FXBase(sampling_rate)
     {
         this->buffer_ = new uint16_t[size];
-        this->lfo_[LFO_1] = enable_lfo ? new LFO(sampling_rate, LFO::Waveform::Sine, 0.0f, max_lfo1_frequency) : nullptr;
-        this->lfo_[LFO_2] = enable_lfo ? new LFO(sampling_rate, LFO::Waveform::Sine, 0.0f, max_lfo2_frequency) : nullptr;
+        this->lfo_[LFOIndex::LFO_1] = enable_lfo ? new LFO(sampling_rate, LFO::Waveform::Sine, 0.0f, max_lfo1_frequency) : nullptr;
+        this->lfo_[LFOIndex::LFO_2] = enable_lfo ? new LFO(sampling_rate, LFO::Waveform::Sine, 0.0f, max_lfo2_frequency) : nullptr;
         this->clear();
     }
 
@@ -95,6 +95,13 @@ public:
         this->write_ptr_ = 0;
     }
 
+    virtual void reset() override
+    {
+        this->clear();
+        this->lfo_[LFOIndex::LFO_1]->reset();
+        this->lfo_[LFOIndex::LFO_2]->reset();
+    }
+
     struct Empty
     {
     };

src/fx_flanger.cpp

@@ -10,16 +10,14 @@ Flanger::Flanger(float32_t sampling_rate, float32_t rate, float32_t depth, float
     this->delay_lineL_ = new float32_t[this->MaxDelayLineSize];
     this->delay_lineR_ = new float32_t[this->MaxDelayLineSize];
 
-    memset(this->delay_lineL_, 0, this->MaxDelayLineSize * sizeof(float32_t));
-    memset(this->delay_lineR_, 0, this->MaxDelayLineSize * sizeof(float32_t));
-    memset(this->feedback_samples_, 0, 2 * sizeof(float32_t));
-
-    this->lfo_[LFO_Index::LFO_L] = new LFO(sampling_rate, LFO::Waveform::Sine, 0.1f, 5.0f);
-    this->lfo_[LFO_Index::LFO_R] = new LFO(sampling_rate, LFO::Waveform::Sine, 0.1f, 5.0f, Constants::MPI_2);
+    this->lfo_[LFOIndex::LFO_L] = new LFO(sampling_rate, LFO::Waveform::Sine, 0.1f, 5.0f);
+    this->lfo_[LFOIndex::LFO_R] = new LFO(sampling_rate, LFO::Waveform::Sine, 0.1f, 5.0f, Constants::MPI_2);
 
     this->setRate(rate);
     this->setDepth(depth);
     this->setFeedback(feedback);
+
+    this->reset();
 }
 
 Flanger::~Flanger()
@@ -27,8 +25,8 @@ Flanger::~Flanger()
     delete[] this->delay_lineL_;
     delete[] this->delay_lineR_;
 
-    delete this->lfo_[LFO_Index::LFO_L];
-    delete this->lfo_[LFO_Index::LFO_R];
+    delete this->lfo_[LFOIndex::LFO_L];
+    delete this->lfo_[LFOIndex::LFO_R];
 }
 
 inline float32_t linearIterpolationnterp(float32_t inX, float32_t inY, float32_t inPhase)
@@ -36,6 +34,17 @@ inline float32_t linearIterpolationnterp(float32_t inX, float32_t inY, float32_t
 	return (1.0f - inPhase) * inX + inPhase * inY;
 }
 
+void Flanger::reset()
+{
+    memset(this->delay_lineL_, 0, this->MaxDelayLineSize * sizeof(float32_t));
+    memset(this->delay_lineR_, 0, this->MaxDelayLineSize * sizeof(float32_t));
+    memset(this->feedback_samples_, 0, 2 * sizeof(float32_t));
+    this->write_index_ = 0;
+
+    this->lfo_[LFOIndex::LFO_L]->reset();
+    this->lfo_[LFOIndex::LFO_R]->reset();
+}
+
 void Flanger::processSample(float32_t inL, float32_t inR, float32_t& outL, float32_t& outR)
 {
     // Write sample and any feedback into delay buffers
@@ -104,13 +113,13 @@ void Flanger::processSample(float32_t inL, float32_t inR, float32_t& outL, float
 
 void Flanger::setRate(float32_t rate)
 {
-    this->lfo_[LFO_Index::LFO_L]->setNormalizedFrequency(rate);
-    this->lfo_[LFO_Index::LFO_R]->setNormalizedFrequency(rate);
+    this->lfo_[LFOIndex::LFO_L]->setNormalizedFrequency(rate);
+    this->lfo_[LFOIndex::LFO_R]->setNormalizedFrequency(rate);
 }
 
 float32_t Flanger::getRate() const
 {
-    return this->lfo_[LFO_Index::LFO_L]->getNormalizedFrequency();
+    return this->lfo_[LFOIndex::LFO_L]->getNormalizedFrequency();
 }
 
 void Flanger::setDepth(float32_t depth)

src/fx_flanger.h

@@ -27,7 +27,7 @@ class Flanger : public FXElement
     DISALLOW_COPY_AND_ASSIGN(Flanger);
 
 public:
-    enum LFO_Index
+    enum LFOIndex
     {
         LFO_L = 0,
         LFO_R
@@ -36,6 +36,7 @@ public:
     Flanger(float32_t sampling_rate, float32_t rate = 0.5f, float32_t depth = 0.5f, float32_t feedback = 0.0f);
     virtual ~Flanger();
 
+    virtual void reset() override;
     virtual void processSample(float32_t inL, float32_t inR, float32_t& outL, float32_t& outR) override;
 
     void setRate(float32_t rate);

src/fx_orbitone.cpp

@@ -13,13 +13,13 @@ Orbitone::Orbitone(float32_t sampling_rate, float32_t rate, float32_t depth) :
     depth_(0.0f),
     fullscale_depth_(0.0f)
 {
-    this->lfo_[LFO_Index::Slow0  ] = new LFO(sampling_rate, LFO::Waveform::Sine, 0.0f, LFO_SLOW_MAX_FREQUENCY, 0.0f);
-    this->lfo_[LFO_Index::Slow120] = new LFO(sampling_rate, LFO::Waveform::Sine, 0.0f, LFO_SLOW_MAX_FREQUENCY, 2.0f * PI / 3.0);
-    this->lfo_[LFO_Index::Slow240] = new LFO(sampling_rate, LFO::Waveform::Sine, 0.0f, LFO_SLOW_MAX_FREQUENCY, 4.0f * PI / 3.0);
+    this->lfo_[LFOIndex::Slow0  ] = new LFO(sampling_rate, LFO::Waveform::Sine, 0.0f, LFO_SLOW_MAX_FREQUENCY, 0.0f);
+    this->lfo_[LFOIndex::Slow120] = new LFO(sampling_rate, LFO::Waveform::Sine, 0.0f, LFO_SLOW_MAX_FREQUENCY, 2.0f * PI / 3.0);
+    this->lfo_[LFOIndex::Slow240] = new LFO(sampling_rate, LFO::Waveform::Sine, 0.0f, LFO_SLOW_MAX_FREQUENCY, 4.0f * PI / 3.0);
 
-    this->lfo_[LFO_Index::Fast0  ] = new LFO(sampling_rate, LFO::Waveform::Sine, 0.0f, LFO_FAST_MAX_FREQUENCY, 0.0f);
-    this->lfo_[LFO_Index::Fast120] = new LFO(sampling_rate, LFO::Waveform::Sine, 0.0f, LFO_FAST_MAX_FREQUENCY, 2.0f * PI / 3.0);
-    this->lfo_[LFO_Index::Fast240] = new LFO(sampling_rate, LFO::Waveform::Sine, 0.0f, LFO_FAST_MAX_FREQUENCY, 4.0f * PI / 3.0);
+    this->lfo_[LFOIndex::Fast0  ] = new LFO(sampling_rate, LFO::Waveform::Sine, 0.0f, LFO_FAST_MAX_FREQUENCY, 0.0f);
+    this->lfo_[LFOIndex::Fast120] = new LFO(sampling_rate, LFO::Waveform::Sine, 0.0f, LFO_FAST_MAX_FREQUENCY, 2.0f * PI / 3.0);
+    this->lfo_[LFOIndex::Fast240] = new LFO(sampling_rate, LFO::Waveform::Sine, 0.0f, LFO_FAST_MAX_FREQUENCY, 4.0f * PI / 3.0);
 
     for(unsigned i = 0; i < 6; ++i)
     {
@@ -37,6 +37,15 @@ Orbitone::~Orbitone()
     }
 }
 
+void Orbitone::reset()
+{
+    this->engine_.reset();
+    for(unsigned i = 0; i < 6; ++i)
+    {
+        this->lfo_[i]->reset();
+    }
+}
+
 void Orbitone::processSample(float32_t inL, float32_t inR, float32_t& outL, float32_t& outR)
 {
     typedef Engine::Reserve<2047, Engine::Reserve<2047> > Memory;
@@ -46,13 +55,13 @@ void Orbitone::processSample(float32_t inL, float32_t inR, float32_t& outL, floa
 
     this->engine_.start(&c);
     
-    float32_t slow_0   = this->lfo_[LFO_Index::Slow0  ]->process();
-    float32_t slow_120 = this->lfo_[LFO_Index::Slow120]->process();
-    float32_t slow_240 = this->lfo_[LFO_Index::Slow240]->process();
+    float32_t slow_0   = this->lfo_[LFOIndex::Slow0  ]->process();
+    float32_t slow_120 = this->lfo_[LFOIndex::Slow120]->process();
+    float32_t slow_240 = this->lfo_[LFOIndex::Slow240]->process();
 
-    float32_t fast_0   = this->lfo_[LFO_Index::Fast0  ]->process();
-    float32_t fast_120 = this->lfo_[LFO_Index::Fast120]->process();
-    float32_t fast_240 = this->lfo_[LFO_Index::Fast240]->process();
+    float32_t fast_0   = this->lfo_[LFOIndex::Fast0  ]->process();
+    float32_t fast_120 = this->lfo_[LFOIndex::Fast120]->process();
+    float32_t fast_240 = this->lfo_[LFOIndex::Fast240]->process();
       
     float32_t a = this->fullscale_depth_ * 1.0f;
     float32_t b = this->fullscale_depth_ * 0.1f;
@@ -85,7 +94,7 @@ void Orbitone::processSample(float32_t inL, float32_t inR, float32_t& outL, floa
 void Orbitone::setRate(float32_t rate)
 {
     rate = constrain(rate, 0.0f, 1.0f);
-    if(this->lfo_[LFO_Index::Slow0]->getNormalizedFrequency() != rate)
+    if(this->lfo_[LFOIndex::Slow0]->getNormalizedFrequency() != rate)
     {
         for(unsigned i = 0; i < 6; ++i)
         {
@@ -96,7 +105,7 @@ void Orbitone::setRate(float32_t rate)
 
 float32_t Orbitone::getRate() const
 {
-    return this->lfo_[LFO_Index::Slow0]->getNormalizedFrequency();
+    return this->lfo_[LFOIndex::Slow0]->getNormalizedFrequency();
 }
 
 void Orbitone::setDepth(float32_t depth)

src/fx_orbitone.h

@@ -27,7 +27,7 @@ class Orbitone : public FXElement
     DISALLOW_COPY_AND_ASSIGN(Orbitone);
 
 public:
-    enum LFO_Index
+    enum LFOIndex
     {
         Slow0 = 0,
         Slow120,
@@ -40,6 +40,7 @@ public:
     Orbitone(float32_t sampling_rate, float32_t rate = 0.5f, float32_t depth = 0.5f);
     virtual ~Orbitone();
 
+    virtual void reset() override;
     virtual void processSample(float32_t inL, float32_t inR, float32_t& outL, float32_t& outR) override;
 
     void setRate(float32_t rate);

src/fx_phaser.cpp

@@ -3,17 +3,22 @@
 #include <algorithm>
 #include <cmath>
 
-AllpassDelay::AllpassDelay() :
+Phaser::AllpassDelay::AllpassDelay() :
     a1_(0.0f)
 {
-    memset(this->z_, 0, 2 * sizeof(float32_t));
+    this->reset();
 }
 
-AllpassDelay::~AllpassDelay()
+Phaser::AllpassDelay::~AllpassDelay()
 {
 }
 
-void AllpassDelay::processSample(float32_t inL, float32_t inR, float32_t& outL, float32_t& outR)
+void Phaser::AllpassDelay::reset()
+{
+    memset(this->z_, 0, 2 * sizeof(float32_t));
+}
+
+void Phaser::AllpassDelay::processSample(float32_t inL, float32_t inR, float32_t& outL, float32_t& outR)
 {
     outL = inL * -this->a1_ + this->z_[0];
     this->z_[0] = outL * this->a1_ + inL;
@@ -22,7 +27,7 @@ void AllpassDelay::processSample(float32_t inL, float32_t inR, float32_t& outL,
     this->z_[1] = outR * this->a1_ + inR;
 }
 
-void AllpassDelay::setDelay(float32_t delay)
+void Phaser::AllpassDelay::setDelay(float32_t delay)
 {
     this->a1_ = (1.0f - delay) / (1.0f + delay);
 }
@@ -41,13 +46,24 @@ Phaser::Phaser(float32_t sampling_rate, float32_t rate, float32_t depth, float32
     this->setFeedback(feedback);
     this->setFrequencyRange(440.0f, 1600.0f);
 
-    memset(this->z_, 0, 2 * sizeof(float32_t));
+    this->reset();
 }
 
 Phaser::~Phaser()
 {
 }
 
+void Phaser::reset()
+{
+    memset(this->z_, 0, 2 * sizeof(float32_t));
+
+    for(unsigned i = 0; i < this->nb_stages_; ++i)
+    {
+        this->stages_[i].reset();
+    }
+    this->lfo_.reset();
+}
+
 void Phaser::processSample(float32_t inL, float32_t inR, float32_t& outL, float32_t& outR)
 {
     float32_t d = this->dmin_ + (this->dmax_ - this->dmin_) * ((1.0f + this->lfo_.process()) / 2.0f);

src/fx_phaser.h

@@ -20,34 +20,35 @@
 
 #include "fx_components.h"
 
-class AllpassDelay
+#define MAX_NB_PHASES 24
+
+class Phaser : public FXElement
 {
-    DISALLOW_COPY_AND_ASSIGN(AllpassDelay);
+    DISALLOW_COPY_AND_ASSIGN(Phaser);
 
 public:
-    AllpassDelay();
-    virtual ~AllpassDelay();
+    class AllpassDelay
+    {
+        DISALLOW_COPY_AND_ASSIGN(AllpassDelay);
 
-    virtual void processSample(float32_t inL, float32_t inR, float32_t& outL, float32_t& outR);
+    public:
+        AllpassDelay();
+        virtual ~AllpassDelay();
 
-    void setDelay(float32_t delay);
+        virtual void reset();
+        virtual void processSample(float32_t inL, float32_t inR, float32_t& outL, float32_t& outR);
 
-private:
-    float32_t a1_;
-    float32_t z_[2];
-};
+        void setDelay(float32_t delay);
 
+    private:
+        float32_t a1_;
+        float32_t z_[2];
+    };
 
-#define MAX_NB_PHASES 24
-
-class Phaser : public FXElement
-{
-    DISALLOW_COPY_AND_ASSIGN(Phaser);
-
-public:
     Phaser(float32_t sampling_rate, float32_t rate = 0.5f, float32_t depth = 1.0f, float32_t feedback = 0.7f);
     virtual ~Phaser();
 
+    virtual void reset() override;
     virtual void processSample(float32_t inL, float32_t inR, float32_t& outL, float32_t& outR) override;
 
     void setFrequencyRange(float32_t min_frequency, float32_t max_frequency);

src/fx_rack.cpp

@@ -50,6 +50,14 @@ inline void FXRack::processSample(float32_t inL, float32_t inR, float32_t& outL,
     }
 }
 
+void FXRack::reset()
+{
+    for(FXChain::iterator it = this->fx_chain_.begin(); it != this->fx_chain_.end(); it++)
+    {
+        (*it)->reset();;
+    }
+}
+
 void FXRack::process(float32_t* left_input, float32_t* right_input, float32_t* left_output, float32_t* right_output, size_t nSamples)
 {
     float32_t sampleInL;

src/fx_rack.h

@@ -40,6 +40,7 @@ public:
     FXRack(float32_t sampling_rate, bool enable = true, float32_t wet = 1.0f);
     virtual ~FXRack();
 
+    virtual void reset() override;
     virtual inline void processSample(float32_t inL, float32_t inR, float32_t& outL, float32_t& outR) override;
     virtual void process(float32_t* left_input, float32_t* right_input, float32_t* left_output, float32_t* right_output, size_t nSamples) override;
 

src/fx_shimmer_reverb.cpp

@@ -5,7 +5,6 @@
 
 #define TAIL , -1
 
-
 ShimmerReverb::ShimmerReverb(float32_t sampling_rate) : 
     FXElement(sampling_rate),
     engine_(sampling_rate),
@@ -13,8 +12,9 @@ ShimmerReverb::ShimmerReverb(float32_t sampling_rate) :
     diffusion_(-1.0f),
     lp_(-1.0f)
 {
-    this->engine_.setLFOFrequency(LFO_1, 0.5f);
-    this->engine_.setLFOFrequency(LFO_2, 0.3f);
+    this->engine_.setLFOFrequency(Engine::LFOIndex::LFO_1, 0.5f);
+    this->engine_.setLFOFrequency(Engine::LFOIndex::LFO_2, 0.3f);
+    
     this->setInputGain(1.0f);
     this->setLP(0.7f);
     this->setDiffusion(0.625f);
@@ -24,6 +24,11 @@ ShimmerReverb::~ShimmerReverb()
 {
 }
 
+void ShimmerReverb::reset()
+{
+    this->engine_.reset();
+}
+
 void ShimmerReverb::processSample(float32_t inL, float32_t inR, float32_t& outL, float32_t& outR)
 {
     // This is the Griesinger topology described in the Dattorro paper
@@ -65,7 +70,7 @@ void ShimmerReverb::processSample(float32_t inL, float32_t inR, float32_t& outL,
     engine_.start(&c);
     
     // Smear AP1 inside the loop.
-    c.interpolate(ap1, 10.0f, LFO_1, 60.0f, 1.0f);
+    c.interpolate(ap1, 10.0f, Engine::LFOIndex::LFO_1, 60.0f, 1.0f);
     c.write(ap1, 100, 0.0f);
     
     c.read(inL + inR, gain);
@@ -83,7 +88,7 @@ void ShimmerReverb::processSample(float32_t inL, float32_t inR, float32_t& outL,
       
     // Main reverb loop.
     c.load(apout);
-    c.interpolate(del2, 4680.0f, LFO_2, 100.0f, krt);
+    c.interpolate(del2, 4680.0f, Engine::LFOIndex::LFO_2, 100.0f, krt);
     c.lp(lp_1, klp);
     c.read(dap1a TAIL, -kap);
     c.writeAllPass(dap1a, kap);

src/fx_shimmer_reverb.h

@@ -29,9 +29,9 @@ class ShimmerReverb : public FXElement
 
 public:
     ShimmerReverb(float32_t sampling_rate);
-
     virtual ~ShimmerReverb();
 
+    virtual void reset() override;
     virtual void processSample(float32_t inL, float32_t inR, float32_t& outL, float32_t& outR) override;
 
     void setInputGain(float32_t gain);

src/fx_svf.cpp

@@ -9,12 +9,11 @@ StateVariableFilter::StateVariableFilter(float32_t sampling_rate, Type type, flo
     resonance_(0.0f),
     peak_gain_(0.0f)
 {
-    memset(this->z1_, 0, 2 * sizeof(float32_t));
-    memset(this->z2_, 0, 2 * sizeof(float32_t));
-
     this->setPeakGainDB(1.0f);
     this->setCutoff(cutoff);
     this->setResonance(0.0f);
+
+    this->reset();
 }
 
 StateVariableFilter::~StateVariableFilter()
@@ -171,6 +170,12 @@ void StateVariableFilter::updateCoefficients()
     }
 }
 
+void StateVariableFilter::reset()
+{
+    memset(this->z1_, 0, 2 * sizeof(float32_t));
+    memset(this->z2_, 0, 2 * sizeof(float32_t));
+}
+
 void StateVariableFilter::processSample(float32_t inL, float32_t inR, float32_t& outL, float32_t& outR)
 {
     const float32_t gain = 10.0f;

src/fx_svf.h

@@ -44,6 +44,7 @@ public:
     void setResonance(float32_t resonance);
     void setPeakGainDB(float32_t gainDB);
 
+    virtual void reset() override;
     virtual void processSample(float32_t inL, float32_t inR, float32_t& outL, float32_t& outR) override;
 
 private:

src/fx_tube.cpp

@@ -14,6 +14,11 @@ Tube::~Tube()
 {
 }
 
+void Tube::reset()
+{
+    // does nothing
+}
+
 void Tube::processSample(float32_t inL, float32_t inR, float32_t& outL, float32_t& outR)
 {
     outL = softSaturator2(inL, this->saturation_);

src/fx_tube.h

@@ -28,6 +28,7 @@ public:
     Tube(float32_t sampling_rate);
     virtual ~Tube();
 
+    virtual void reset() override;
     virtual void processSample(float32_t inL, float32_t inR, float32_t& outL, float32_t& outR) override;
 
     void setOverdrive(float32_t overdrive);

src/fx_unit.hpp

@@ -70,7 +70,8 @@ class FXUnit : public virtual FXUnitModule, public virtual _FXElement
 public:
     FXUnit(float32_t sampling_rate, bool enable = true, float32_t wet_level = 0.5f) :
         FXUnitModule(),
-        _FXElement(sampling_rate)
+        _FXElement(sampling_rate),
+        is_reset_(false)
     {
         this->setEnable(enable);
         this->setWetLevel(wet_level);
@@ -80,15 +81,30 @@ public:
     {
     }
 
+    void reset()
+    {
+        if(!this->is_reset_)
+        {
+            _FXElement::reset();
+            this->is_reset_ = true;
+        }
+    }
+
     void processSample(float32_t inL, float32_t inR, float32_t& outL, float32_t& outR)
     {
         if(!this->isEnable() || this->getWetLevel() == 0.0f)
         {
+            if(!this->isEnable())
+            {
+                _FXElement::reset();
+            }
+
             outL = inL;
             outR = inR;
         }
         else
         {
+            this->is_reset_ = false;
             _FXElement::processSample(inL, inR, outL, outR);
 
             float32_t dry = 1.0f - this->getWetLevel();
@@ -96,4 +112,7 @@ public:
             outR = this->getWetLevel() * outR + dry * inR;
         }
     }
+
+private:
+    bool is_reset_;
 };