Rename ShimmerReverb into Reverberator

src/fx.h

@@ -25,6 +25,10 @@
 #include "debug.hpp"
 #include "fx_base.h"
 
+#define MAKE_INTEGRAL_FRACTIONAL(x) \
+    size_t x ## _integral = static_cast<size_t>(x); \
+    float32_t x ## _fractional = x - static_cast<float32_t>(x ## _integral)
+
 class INSPECTABLE(FXBase)
 {
     DISALLOW_COPY_AND_ASSIGN(FXBase);

src/fx_engine.hpp

@@ -338,8 +338,7 @@ public:
         {
             assert((D::base + D::length) <= size);
 
-            int32_t offset_integral = static_cast<int32_t>(offset);
-            float32_t offset_fractional = offset - static_cast<float32_t>(offset_integral);
+            MAKE_INTEGRAL_FRACTIONAL(offset);
 
             int32_t index = this->write_ptr_ + offset_integral + D::base;
             float32_t a = DataType<format>::decompress(this->buffer_[index & MASK]);

src/fx_rack.cpp

@@ -15,7 +15,7 @@ FXRack::FXRack(float32_t sampling_rate, bool enable, float32_t wet) :
     this->fxOrbitone_ = new FXUnit<Orbitone>(sampling_rate);
     this->fxPhaser_ = new FXUnit<Phaser>(sampling_rate);
     this->fxDelay_ = new FXUnit<Delay>(sampling_rate);
-    this->fxShimmerReverb_ = new FXUnit<ShimmerReverb>(sampling_rate);
+    this->fxReverberator_ = new FXUnit<Reverberator>(sampling_rate);
 
     this->registerFX(this->fxTube_);
     this->registerFX(this->fxChorus_);
@@ -23,7 +23,7 @@ FXRack::FXRack(float32_t sampling_rate, bool enable, float32_t wet) :
     this->registerFX(this->fxOrbitone_);
     this->registerFX(this->fxPhaser_);
     this->registerFX(this->fxDelay_);
-    this->registerFX(this->fxShimmerReverb_);
+    this->registerFX(this->fxReverberator_);
 }
 
 FXRack::~FXRack()
@@ -36,7 +36,7 @@ FXRack::~FXRack()
     delete this->fxOrbitone_;
     delete this->fxPhaser_;
     delete this->fxDelay_;
-    delete this->fxShimmerReverb_;
+    delete this->fxReverberator_;
 }
 
 inline void FXRack::reset()
@@ -147,7 +147,7 @@ FXUnit<Delay>* FXRack::getDelay()
     return this->fxDelay_;
 }
 
-FXUnit<ShimmerReverb>* FXRack::getShimmerReverb()
+FXUnit<Reverberator>* FXRack::getReverberator()
 {
-    return this->fxShimmerReverb_;
+    return this->fxReverberator_;
 }

src/fx_rack.h

@@ -25,7 +25,7 @@
 #include "fx_orbitone.h"
 #include "fx_phaser.h"
 #include "fx_delay.h"
-#include "fx_shimmer_reverb.h"
+#include "fx_reverberator.h"
 #include "fx_unit.hpp"
 
 #include <vector>
@@ -56,7 +56,7 @@ public:
     FXUnit<Orbitone>* getOrbitone();
     FXUnit<Phaser>* getPhaser();
     FXUnit<Delay>* getDelay();
-    FXUnit<ShimmerReverb>* getShimmerReverb();
+    FXUnit<Reverberator>* getReverberator();
 
 private:
     void registerFX(FXElement* fx);
@@ -71,7 +71,7 @@ private:
     FXUnit<Orbitone>* fxOrbitone_;
     FXUnit<Phaser>* fxPhaser_;
     FXUnit<Delay>* fxDelay_;
-    FXUnit<ShimmerReverb>* fxShimmerReverb_;
+    FXUnit<Reverberator>* fxReverberator_;
 
     IMPLEMENT_DUMP(
         const size_t space = 10;
@@ -104,7 +104,7 @@ private:
             this->fxOrbitone_->dump(out, deepInspection, tag + ".fxOrbitone_");
             this->fxPhaser_->dump(out, deepInspection, tag + ".fxPhaser_");
             this->fxDelay_->dump(out, deepInspection, tag + ".fxDelay_");
-            this->fxShimmerReverb_->dump(out, deepInspection, tag + ".fxShimmerReverb_");
+            this->fxReverberator_->dump(out, deepInspection, tag + ".fxReverberator_");
         }
 
         out << "END " << tag << "(" << typeid(*this).name() << ") dump" << std::endl << std::endl;
@@ -124,7 +124,7 @@ private:
             nb_errors += this->fxOrbitone_->inspect(inspector, deepInspection, tag + ".fxOrbitone_");
             nb_errors += this->fxPhaser_->inspect(inspector, deepInspection, tag + ".fxPhaser_");
             nb_errors += this->fxDelay_->inspect(inspector, deepInspection, tag + ".fxDelay_");
-            nb_errors += this->fxShimmerReverb_->inspect(inspector, deepInspection, tag + ".fxShimmerReverb_");
+            nb_errors += this->fxReverberator_->inspect(inspector, deepInspection, tag + ".fxReverberator_");
         }
 
         return nb_errors;

src/fx_reverberator.cpp

@@ -0,0 +1,160 @@
+#include "fx_reverberator.h"
+
+#define TAIL , -1
+
+Reverberator::Reverberator(float32_t sampling_rate) : 
+    FXElement(sampling_rate),
+    engine_(sampling_rate),
+    input_gain_(-1.0f),
+    reverb_time_(0.0f),
+    diffusion_(-1.0f),
+    lp_(-1.0f),
+    lp_decay_1_(0.0f),
+    lp_decay_2_(0.0f)
+{
+    this->engine_.setLFOFrequency(Engine::LFOIndex::LFO_1, 0.5f);
+    this->engine_.setLFOFrequency(Engine::LFOIndex::LFO_2, 0.3f);
+    
+    this->setInputGain(1.0f);
+    this->setTime(0.7f);
+    this->setDiffusion(0.625f);
+    this->setLP(0.7f);
+
+    this->reset();
+}
+
+Reverberator::~Reverberator()
+{
+}
+
+void Reverberator::reset()
+{
+    this->engine_.reset();
+    this->lp_decay_1_ = 0.0f;
+    this->lp_decay_2_ = 0.0f;
+}
+
+void Reverberator::processSample(float32_t inL, float32_t inR, float32_t& outL, float32_t& outR)
+{
+    // This is the Griesinger topology described in the Dattorro paper
+    // (4 AP diffusers on the input, then a loop of 2x 2AP+1Delay).
+    // Modulation is applied in the loop of the first diffuser AP for additional
+    // smearing; and to the two long delays for a slow shimmer/chorus effect.
+    typedef Engine::Reserve< 113,
+            Engine::Reserve< 162,
+            Engine::Reserve< 241,
+            Engine::Reserve< 399,
+            Engine::Reserve<1653,
+            Engine::Reserve<2038,
+            Engine::Reserve<3411,
+            Engine::Reserve<1913,
+            Engine::Reserve<1663,
+            Engine::Reserve<4782> > > > > > > > > > Memory;
+    Engine::DelayLine<Memory, 0> ap1;
+    Engine::DelayLine<Memory, 1> ap2;
+    Engine::DelayLine<Memory, 2> ap3;
+    Engine::DelayLine<Memory, 3> ap4;
+    Engine::DelayLine<Memory, 4> dap1a;
+    Engine::DelayLine<Memory, 5> dap1b;
+    Engine::DelayLine<Memory, 6> del1;
+    Engine::DelayLine<Memory, 7> dap2a;
+    Engine::DelayLine<Memory, 8> dap2b;
+    Engine::DelayLine<Memory, 9> del2;
+    Engine::Context c;
+
+    const float32_t kap = this->diffusion_;
+    const float32_t klp = this->lp_;
+    const float32_t krt = this->reverb_time_;
+    const float32_t gain = this->input_gain_;
+
+    float32_t lp_1 = this->lp_decay_1_;
+    float32_t lp_2 = this->lp_decay_2_;
+
+    float32_t wet = 0.0f;
+    float32_t apout = 0.0f;
+    engine_.start(&c);
+    
+    // Smear AP1 inside the loop.
+    c.interpolate(ap1, 10.0f, Engine::LFOIndex::LFO_1, 60.0f, 1.0f);
+    c.writeAndLoad(ap1, 100, 0.0f);
+    c.read(inL + inR, gain);
+
+    // Diffuse through 4 allpasses.
+    c.read(ap1 TAIL, kap);
+    c.writeAllPass(ap1, -kap);
+    c.read(ap2 TAIL, kap);
+    c.writeAllPass(ap2, -kap);
+    c.read(ap3 TAIL, kap);
+    c.writeAllPass(ap3, -kap);
+    c.read(ap4 TAIL, kap);
+    c.writeAllPass(ap4, -kap);
+    c.write(apout);
+      
+    // Main reverb loop.
+    c.load(apout);
+    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);
+    c.read(dap1b TAIL, kap);
+    c.writeAllPass(dap1b, -kap);
+    c.write(del1, 2.0f);
+    c.writeAndLoad(wet, 0.0f);
+
+    outL = wet;
+
+    c.load(apout);
+    c.read(del1 TAIL, krt);
+    c.lp(lp_2, klp);
+    c.read(dap2a TAIL, kap);
+    c.writeAllPass(dap2a, -kap);
+    c.read(dap2b TAIL, -kap);
+    c.writeAllPass(dap2b, kap);
+    c.write(del2, 2.0f);
+    c.writeAndLoad(wet, 0.0f);
+
+    outR = wet;
+
+    this->lp_decay_1_ = lp_1;
+    this->lp_decay_2_ = lp_2;
+}
+
+void Reverberator::setInputGain(float32_t gain)
+{
+    this->input_gain_ = constrain(gain, 0.0f, 1.0f);
+}
+
+float32_t Reverberator::getInputGain() const
+{
+    return this->input_gain_;
+}
+
+void Reverberator::setTime(float32_t time)
+{
+    this->reverb_time_ = constrain(time, 0.0f, 1.0f);
+}
+
+float32_t Reverberator::getTime() const
+{
+    return this->reverb_time_;
+}
+
+void Reverberator::setDiffusion(float32_t diffusion)
+{
+    this->diffusion_ = constrain(diffusion, 0.0f, 1.0f);
+}
+
+float32_t Reverberator::getDiffusion() const
+{
+    return this->diffusion_;
+}
+
+void Reverberator::setLP(float32_t lp)
+{
+    this->lp_ = constrain(lp, 0.0f, 1.0f);
+}
+
+float32_t Reverberator::getLP() const
+{
+    return this->lp_;
+}

src/fx_reverberator.h

@@ -0,0 +1,121 @@
+// 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_reverberator.h
+//
+// Stereo Reverberator proposed in the context of the MiniDexed project 
+// It is adapted from the Reverb that could be found on Cloud EuroRack module from Mutable Instrruments
+//
+#pragma once
+
+#include "fx_components.h"
+#include "fx_engine.hpp"
+
+#define REVERBERATOR_BUFFER_SIZE 16384
+
+class Reverberator : public FXElement
+{
+    DISALLOW_COPY_AND_ASSIGN(Reverberator);
+
+public:
+    Reverberator(float32_t sampling_rate);
+    virtual ~Reverberator();
+
+    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);
+    float32_t getInputGain() const;
+
+    void setTime(float32_t time);
+    float32_t getTime() const;
+
+    void setDiffusion(float32_t diffusion);
+    float32_t getDiffusion() const;
+
+    void setLP(float32_t lp);
+    float32_t getLP() const;
+
+private:
+    typedef FxEngine<REVERBERATOR_BUFFER_SIZE, Format::FORMAT_FLOAT32, true> Engine;
+    Engine engine_;
+
+    float32_t input_gain_;
+    float32_t reverb_time_;
+    float32_t diffusion_;
+    float32_t lp_;
+
+    float32_t lp_decay_1_;
+    float32_t lp_decay_2_;
+
+    IMPLEMENT_DUMP(
+        const size_t space = 12;
+        const size_t precision = 6;
+
+        std::stringstream ss;
+
+        out << "START " << tag << "(" << typeid(*this).name() << ") dump" << std::endl << std::endl;
+
+        SS_RESET(ss, precision, std::left);
+        SS__TEXT(ss, ' ', space, std::left, '|', "input_gain_");
+        SS__TEXT(ss, ' ', space, std::left, '|', "reverb_time_");
+        SS__TEXT(ss, ' ', space, std::left, '|', "diffusion_");
+        SS__TEXT(ss, ' ', space, std::left, '|', "lp_");
+        SS__TEXT(ss, ' ', space, std::left, '|', "lp_decay_1_");
+        SS__TEXT(ss, ' ', space, std::left, '|', "lp_decay_2_");
+        out << "\t" << ss.str() << std::endl;
+
+        SS_RESET(ss, precision, std::left);
+        SS_SPACE(ss, '-', space, std::left, '+');
+        SS_SPACE(ss, '-', space, std::left, '+');
+        SS_SPACE(ss, '-', space, std::left, '+');
+        SS_SPACE(ss, '-', space, std::left, '+');
+        SS_SPACE(ss, '-', space, std::left, '+');
+        SS_SPACE(ss, '-', space, std::left, '+');
+        out << "\t" << ss.str() << std::endl;
+
+        SS_RESET(ss, precision, std::left);
+        SS__TEXT(ss, ' ', space - 1, std::right, " |", this->input_gain_);
+        SS__TEXT(ss, ' ', space - 1, std::right, " |", this->reverb_time_);
+        SS__TEXT(ss, ' ', space - 1, std::right, " |", this->diffusion_);
+        SS__TEXT(ss, ' ', space - 1, std::right, " |", this->lp_);
+        SS__TEXT(ss, ' ', space - 1, std::right, " |", this->lp_decay_1_);
+        SS__TEXT(ss, ' ', space - 1, std::right, " |", this->lp_decay_2_);
+        out << "\t" << ss.str() << std::endl;
+
+        if(deepInspection)
+        {
+            this->engine.dump(out, deepInspection, tag + ".engine_");
+        }
+    )
+
+    IMPLEMENT_INSPECT(
+        size_t nb_errors = 0u;
+
+        nb_errors += inspector(tag + ".input_gain_", this->input_gain_, 0.0f, 1.0f, deepInspection);
+        nb_errors += inspector(tag + ".reverb_time_", this->reverb_time_, 0.0f, 1.0f, deepInspection);
+        nb_errors += inspector(tag + ".diffusion_", this->diffusion_, 0.0f, 1.0f, deepInspection);
+        nb_errors += inspector(tag + ".lp_", this->lp_, 0.0f, 1.0f, deepInspection);
+        nb_errors += inspector(tag + ".lp_decay_1_", this->lp_decay_1_, 0.0f, 1.0f, deepInspection);
+        nb_errors += inspector(tag + ".lp_decay_2_", this->lp_decay_2_, 0.0f, 1.0f, deepInspection);
+
+        if(deepInspection)
+        {
+            nb_errors += this->engine_.inspect(inspector, deepInspection, tag + ".engine_");
+        }
+
+        return nb_errors;
+    )
+};

src/fx_shimmer_helper.cpp

@@ -0,0 +1,137 @@
+#pragma once
+
+#include "fx_shimmer_helper.h"
+
+const float lut_pitch_ratio_high[] = {
+   6.151958251e-04,  6.517772725e-04,  6.905339660e-04,  7.315952524e-04,
+   7.750981699e-04,  8.211879055e-04,  8.700182794e-04,  9.217522585e-04,
+   9.765625000e-04,  1.034631928e-03,  1.096154344e-03,  1.161335073e-03,
+   1.230391650e-03,  1.303554545e-03,  1.381067932e-03,  1.463190505e-03,
+   1.550196340e-03,  1.642375811e-03,  1.740036559e-03,  1.843504517e-03,
+   1.953125000e-03,  2.069263856e-03,  2.192308688e-03,  2.322670146e-03,
+   2.460783301e-03,  2.607109090e-03,  2.762135864e-03,  2.926381010e-03,
+   3.100392680e-03,  3.284751622e-03,  3.480073118e-03,  3.687009034e-03,
+   3.906250000e-03,  4.138527712e-03,  4.384617376e-03,  4.645340293e-03,
+   4.921566601e-03,  5.214218180e-03,  5.524271728e-03,  5.852762019e-03,
+   6.200785359e-03,  6.569503244e-03,  6.960146235e-03,  7.374018068e-03,
+   7.812500000e-03,  8.277055425e-03,  8.769234752e-03,  9.290680586e-03,
+   9.843133202e-03,  1.042843636e-02,  1.104854346e-02,  1.170552404e-02,
+   1.240157072e-02,  1.313900649e-02,  1.392029247e-02,  1.474803614e-02,
+   1.562500000e-02,  1.655411085e-02,  1.753846950e-02,  1.858136117e-02,
+   1.968626640e-02,  2.085687272e-02,  2.209708691e-02,  2.341104808e-02,
+   2.480314144e-02,  2.627801298e-02,  2.784058494e-02,  2.949607227e-02,
+   3.125000000e-02,  3.310822170e-02,  3.507693901e-02,  3.716272234e-02,
+   3.937253281e-02,  4.171374544e-02,  4.419417382e-02,  4.682209615e-02,
+   4.960628287e-02,  5.255602595e-02,  5.568116988e-02,  5.899214454e-02,
+   6.250000000e-02,  6.621644340e-02,  7.015387802e-02,  7.432544469e-02,
+   7.874506562e-02,  8.342749089e-02,  8.838834765e-02,  9.364419230e-02,
+   9.921256575e-02,  1.051120519e-01,  1.113623398e-01,  1.179842891e-01,
+   1.250000000e-01,  1.324328868e-01,  1.403077560e-01,  1.486508894e-01,
+   1.574901312e-01,  1.668549818e-01,  1.767766953e-01,  1.872883846e-01,
+   1.984251315e-01,  2.102241038e-01,  2.227246795e-01,  2.359685782e-01,
+   2.500000000e-01,  2.648657736e-01,  2.806155121e-01,  2.973017788e-01,
+   3.149802625e-01,  3.337099635e-01,  3.535533906e-01,  3.745767692e-01,
+   3.968502630e-01,  4.204482076e-01,  4.454493591e-01,  4.719371563e-01,
+   5.000000000e-01,  5.297315472e-01,  5.612310242e-01,  5.946035575e-01,
+   6.299605249e-01,  6.674199271e-01,  7.071067812e-01,  7.491535384e-01,
+   7.937005260e-01,  8.408964153e-01,  8.908987181e-01,  9.438743127e-01,
+   1.000000000e+00,  1.059463094e+00,  1.122462048e+00,  1.189207115e+00,
+   1.259921050e+00,  1.334839854e+00,  1.414213562e+00,  1.498307077e+00,
+   1.587401052e+00,  1.681792831e+00,  1.781797436e+00,  1.887748625e+00,
+   2.000000000e+00,  2.118926189e+00,  2.244924097e+00,  2.378414230e+00,
+   2.519842100e+00,  2.669679708e+00,  2.828427125e+00,  2.996614154e+00,
+   3.174802104e+00,  3.363585661e+00,  3.563594873e+00,  3.775497251e+00,
+   4.000000000e+00,  4.237852377e+00,  4.489848193e+00,  4.756828460e+00,
+   5.039684200e+00,  5.339359417e+00,  5.656854249e+00,  5.993228308e+00,
+   6.349604208e+00,  6.727171322e+00,  7.127189745e+00,  7.550994501e+00,
+   8.000000000e+00,  8.475704755e+00,  8.979696386e+00,  9.513656920e+00,
+   1.007936840e+01,  1.067871883e+01,  1.131370850e+01,  1.198645662e+01,
+   1.269920842e+01,  1.345434264e+01,  1.425437949e+01,  1.510198900e+01,
+   1.600000000e+01,  1.695140951e+01,  1.795939277e+01,  1.902731384e+01,
+   2.015873680e+01,  2.135743767e+01,  2.262741700e+01,  2.397291323e+01,
+   2.539841683e+01,  2.690868529e+01,  2.850875898e+01,  3.020397801e+01,
+   3.200000000e+01,  3.390281902e+01,  3.591878555e+01,  3.805462768e+01,
+   4.031747360e+01,  4.271487533e+01,  4.525483400e+01,  4.794582646e+01,
+   5.079683366e+01,  5.381737058e+01,  5.701751796e+01,  6.040795601e+01,
+   6.400000000e+01,  6.780563804e+01,  7.183757109e+01,  7.610925536e+01,
+   8.063494719e+01,  8.542975067e+01,  9.050966799e+01,  9.589165292e+01,
+   1.015936673e+02,  1.076347412e+02,  1.140350359e+02,  1.208159120e+02,
+   1.280000000e+02,  1.356112761e+02,  1.436751422e+02,  1.522185107e+02,
+   1.612698944e+02,  1.708595013e+02,  1.810193360e+02,  1.917833058e+02,
+   2.031873347e+02,  2.152694823e+02,  2.280700718e+02,  2.416318240e+02,
+   2.560000000e+02,  2.712225522e+02,  2.873502844e+02,  3.044370214e+02,
+   3.225397888e+02,  3.417190027e+02,  3.620386720e+02,  3.835666117e+02,
+   4.063746693e+02,  4.305389646e+02,  4.561401437e+02,  4.832636481e+02,
+   5.120000000e+02,  5.424451043e+02,  5.747005687e+02,  6.088740429e+02,
+   6.450795775e+02,  6.834380053e+02,  7.240773439e+02,  7.671332234e+02,
+   8.127493386e+02,  8.610779292e+02,  9.122802874e+02,  9.665272962e+02,
+   1.024000000e+03,  1.084890209e+03,  1.149401137e+03,  1.217748086e+03,
+   1.290159155e+03,  1.366876011e+03,  1.448154688e+03,  1.534266447e+03,
+};
+
+const float lut_pitch_ratio_low[] = {
+   1.000000000e+00,  1.000225659e+00,  1.000451370e+00,  1.000677131e+00,
+   1.000902943e+00,  1.001128806e+00,  1.001354720e+00,  1.001580685e+00,
+   1.001806701e+00,  1.002032768e+00,  1.002258886e+00,  1.002485055e+00,
+   1.002711275e+00,  1.002937546e+00,  1.003163868e+00,  1.003390242e+00,
+   1.003616666e+00,  1.003843141e+00,  1.004069668e+00,  1.004296246e+00,
+   1.004522874e+00,  1.004749554e+00,  1.004976285e+00,  1.005203068e+00,
+   1.005429901e+00,  1.005656786e+00,  1.005883722e+00,  1.006110709e+00,
+   1.006337747e+00,  1.006564836e+00,  1.006791977e+00,  1.007019169e+00,
+   1.007246412e+00,  1.007473707e+00,  1.007701053e+00,  1.007928450e+00,
+   1.008155898e+00,  1.008383398e+00,  1.008610949e+00,  1.008838551e+00,
+   1.009066205e+00,  1.009293910e+00,  1.009521667e+00,  1.009749475e+00,
+   1.009977334e+00,  1.010205245e+00,  1.010433207e+00,  1.010661221e+00,
+   1.010889286e+00,  1.011117403e+00,  1.011345571e+00,  1.011573790e+00,
+   1.011802061e+00,  1.012030384e+00,  1.012258758e+00,  1.012487183e+00,
+   1.012715661e+00,  1.012944189e+00,  1.013172770e+00,  1.013401401e+00,
+   1.013630085e+00,  1.013858820e+00,  1.014087607e+00,  1.014316445e+00,
+   1.014545335e+00,  1.014774277e+00,  1.015003270e+00,  1.015232315e+00,
+   1.015461411e+00,  1.015690560e+00,  1.015919760e+00,  1.016149011e+00,
+   1.016378315e+00,  1.016607670e+00,  1.016837077e+00,  1.017066536e+00,
+   1.017296046e+00,  1.017525609e+00,  1.017755223e+00,  1.017984889e+00,
+   1.018214607e+00,  1.018444376e+00,  1.018674198e+00,  1.018904071e+00,
+   1.019133996e+00,  1.019363973e+00,  1.019594002e+00,  1.019824083e+00,
+   1.020054216e+00,  1.020284401e+00,  1.020514637e+00,  1.020744926e+00,
+   1.020975266e+00,  1.021205659e+00,  1.021436104e+00,  1.021666600e+00,
+   1.021897149e+00,  1.022127749e+00,  1.022358402e+00,  1.022589107e+00,
+   1.022819863e+00,  1.023050672e+00,  1.023281533e+00,  1.023512446e+00,
+   1.023743411e+00,  1.023974428e+00,  1.024205498e+00,  1.024436619e+00,
+   1.024667793e+00,  1.024899019e+00,  1.025130297e+00,  1.025361627e+00,
+   1.025593009e+00,  1.025824444e+00,  1.026055931e+00,  1.026287470e+00,
+   1.026519061e+00,  1.026750705e+00,  1.026982401e+00,  1.027214149e+00,
+   1.027445949e+00,  1.027677802e+00,  1.027909707e+00,  1.028141664e+00,
+   1.028373674e+00,  1.028605736e+00,  1.028837851e+00,  1.029070017e+00,
+   1.029302237e+00,  1.029534508e+00,  1.029766832e+00,  1.029999209e+00,
+   1.030231638e+00,  1.030464119e+00,  1.030696653e+00,  1.030929239e+00,
+   1.031161878e+00,  1.031394569e+00,  1.031627313e+00,  1.031860109e+00,
+   1.032092958e+00,  1.032325859e+00,  1.032558813e+00,  1.032791820e+00,
+   1.033024879e+00,  1.033257991e+00,  1.033491155e+00,  1.033724372e+00,
+   1.033957641e+00,  1.034190964e+00,  1.034424338e+00,  1.034657766e+00,
+   1.034891246e+00,  1.035124779e+00,  1.035358364e+00,  1.035592003e+00,
+   1.035825694e+00,  1.036059437e+00,  1.036293234e+00,  1.036527083e+00,
+   1.036760985e+00,  1.036994940e+00,  1.037228947e+00,  1.037463008e+00,
+   1.037697121e+00,  1.037931287e+00,  1.038165506e+00,  1.038399777e+00,
+   1.038634102e+00,  1.038868479e+00,  1.039102910e+00,  1.039337393e+00,
+   1.039571929e+00,  1.039806518e+00,  1.040041160e+00,  1.040275855e+00,
+   1.040510603e+00,  1.040745404e+00,  1.040980258e+00,  1.041215165e+00,
+   1.041450125e+00,  1.041685138e+00,  1.041920204e+00,  1.042155323e+00,
+   1.042390495e+00,  1.042625720e+00,  1.042860998e+00,  1.043096329e+00,
+   1.043331714e+00,  1.043567151e+00,  1.043802642e+00,  1.044038185e+00,
+   1.044273782e+00,  1.044509433e+00,  1.044745136e+00,  1.044980892e+00,
+   1.045216702e+00,  1.045452565e+00,  1.045688481e+00,  1.045924450e+00,
+   1.046160473e+00,  1.046396549e+00,  1.046632678e+00,  1.046868860e+00,
+   1.047105096e+00,  1.047341385e+00,  1.047577727e+00,  1.047814123e+00,
+   1.048050572e+00,  1.048287074e+00,  1.048523630e+00,  1.048760239e+00,
+   1.048996902e+00,  1.049233618e+00,  1.049470387e+00,  1.049707210e+00,
+   1.049944086e+00,  1.050181015e+00,  1.050417999e+00,  1.050655035e+00,
+   1.050892125e+00,  1.051129269e+00,  1.051366466e+00,  1.051603717e+00,
+   1.051841021e+00,  1.052078378e+00,  1.052315790e+00,  1.052553255e+00,
+   1.052790773e+00,  1.053028345e+00,  1.053265971e+00,  1.053503650e+00,
+   1.053741383e+00,  1.053979169e+00,  1.054217010e+00,  1.054454903e+00,
+   1.054692851e+00,  1.054930852e+00,  1.055168907e+00,  1.055407016e+00,
+   1.055645178e+00,  1.055883395e+00,  1.056121664e+00,  1.056359988e+00,
+   1.056598366e+00,  1.056836797e+00,  1.057075282e+00,  1.057313821e+00,
+   1.057552413e+00,  1.057791060e+00,  1.058029760e+00,  1.058268515e+00,
+   1.058507323e+00,  1.058746185e+00,  1.058985101e+00,  1.059224071e+00,
+};

src/fx_shimmer_helper.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "fx.h"
+
+extern const float lut_pitch_ratio_high[257];
+extern const float lut_pitch_ratio_low[257];
+
+inline float32_t SemitonesToRatio(float32_t semitones)
+{
+    float32_t pitch = semitones + 128.0f;
+    MAKE_INTEGRAL_FRACTIONAL(pitch)
+
+    return lut_pitch_ratio_high[pitch_integral] * lut_pitch_ratio_low[static_cast<int32_t>(pitch_fractional * 256.0f)];
+}

src/fx_shimmer_reverb.h

@@ -13,10 +13,10 @@
 //
 
 //
-// fx_shimmer_reverb3.h
+// fx_shimmer_reverb.h
 //
-// Stereo Shimmer Reverb proposed in the context of the MiniDexed project 
-// It is adapted from the Shimmer Reverb that could be found on Cloud EuroRack module from Mutable Instrruments
+// Stereo ShimmerReverb Reverb proposed in the context of the MiniDexed project 
+// It is adapted from the ShimmerReverb Reverb that could be found on Cloud EuroRack module from Mutable Instrruments
 //
 #pragma once
 

src/minidexed.cpp

@@ -199,12 +199,12 @@ CMiniDexed::CMiniDexed (CConfig *pConfig, CInterruptSystem *pInterrupt,
 	this->SetParameter(ParameterReverbDiffusion, 65);
 	this->SetParameter(ParameterReverbLevel, 99);
 
-	// ShimmerReverb parameters
-	this->SetParameter(ParameterFXShimmerReverbEnable, 1);
-	this->SetParameter(ParameterFXShimmerReverbInputGain, 99);
-	this->SetParameter(ParameterFXShimmerReverbTime, 80);
-	this->SetParameter(ParameterFXShimmerReverbDiffusion, 80);
-	this->SetParameter(ParameterFXShimmerReverbLP, 70);
+	// Reverberator parameters
+	this->SetParameter(ParameterFXReverberatorEnable, 1);
+	this->SetParameter(ParameterFXReverberatorInputGain, 99);
+	this->SetParameter(ParameterFXReverberatorTime, 80);
+	this->SetParameter(ParameterFXReverberatorDiffusion, 80);
+	this->SetParameter(ParameterFXReverberatorLP, 70);
 
 #endif
 
@@ -958,35 +958,35 @@ void CMiniDexed::SetParameter (TParameter Parameter, int nValue)
 		m_FXSpinLock.Release ();
 		break;
 
-	// ShimmerReverb parameters
-	case ParameterFXShimmerReverbEnable: 
+	// Reverberator parameters
+	case ParameterFXReverberatorEnable: 
 		nValue = constrain((int)nValue, 0, 1);
 		this->m_FXSpinLock.Acquire();
-		this->mixing_console_->getShimmerReverb()->setMute(!nValue);
+		this->mixing_console_->getReverberator()->setMute(!nValue);
 		this->m_FXSpinLock.Release();
 		break;
-	case ParameterFXShimmerReverbInputGain: 
+	case ParameterFXReverberatorInputGain: 
 		nValue = constrain((int)nValue, 0, 99);
 		this->m_FXSpinLock.Acquire();
-		this->mixing_console_->getShimmerReverb()->setInputGain(nValue / 99.0f);
+		this->mixing_console_->getReverberator()->setInputGain(nValue / 99.0f);
 		this->m_FXSpinLock.Release();
 		break;
-	case ParameterFXShimmerReverbTime: 
+	case ParameterFXReverberatorTime: 
 		nValue = constrain((int)nValue, 0, 99);
 		this->m_FXSpinLock.Acquire();
-		this->mixing_console_->getShimmerReverb()->setTime(nValue / 99.0f);
+		this->mixing_console_->getReverberator()->setTime(nValue / 99.0f);
 		this->m_FXSpinLock.Release();
 		break;
-	case ParameterFXShimmerReverbDiffusion: 
+	case ParameterFXReverberatorDiffusion: 
 		nValue = constrain((int)nValue, 0, 99);
 		this->m_FXSpinLock.Acquire();
-		this->mixing_console_->getShimmerReverb()->setDiffusion(nValue / 99.0f);
+		this->mixing_console_->getReverberator()->setDiffusion(nValue / 99.0f);
 		this->m_FXSpinLock.Release();
 		break;
-	case ParameterFXShimmerReverbLP: 
+	case ParameterFXReverberatorLP: 
 		nValue = constrain((int)nValue, 0, 99);
 		this->m_FXSpinLock.Acquire();
-		this->mixing_console_->getShimmerReverb()->setLP(nValue / 99.0f);
+		this->mixing_console_->getReverberator()->setLP(nValue / 99.0f);
 		this->m_FXSpinLock.Release();
 		break;
 
@@ -1110,7 +1110,7 @@ void CMiniDexed::SetTGParameter (TTGParameter Parameter, int nValue, unsigned nT
 	case TGParameterMixingSendFXPhaser:			this->setMixingConsoleSendLevel(nTG, MixerOutput::FX_Phaser, 		nValue); break;
 	case TGParameterMixingSendFXDelay:			this->setMixingConsoleSendLevel(nTG, MixerOutput::FX_Delay, 			nValue); break;
 	case TGParameterMixingSendFXPlateReverb:	this->setMixingConsoleSendLevel(nTG, MixerOutput::FX_PlateReverb, 	nValue); break;
-	case TGParameterMixingSendFXShimmerReverb:	this->setMixingConsoleSendLevel(nTG, MixerOutput::FX_ShimmerReverb, 	nValue); break;
+	case TGParameterMixingSendFXReverberator:	this->setMixingConsoleSendLevel(nTG, MixerOutput::FX_Reverberator, 	nValue); break;
 	case TGParameterMixingSendFXMainOutput:		this->setMixingConsoleSendLevel(nTG, MixerOutput::MainOutput, 		nValue); break;
 #else
 	case TGParameterReverbSend:	SetReverbSend (nValue, nTG);	break;
@@ -1558,11 +1558,11 @@ bool CMiniDexed::DoSavePerformance (void)
 	this->m_PerformanceConfig.SetFXDelayLeftDelayTime(this->m_nParameter[ParameterFXDelayLeftDelayTime]);
 	this->m_PerformanceConfig.SetFXDelayRightDelayTime(this->m_nParameter[ParameterFXDelayRightDelayTime]);
 	this->m_PerformanceConfig.SetFXDelayFeedback(this->m_nParameter[ParameterFXDelayFeedback]);
-	this->m_PerformanceConfig.SetFXShimmerReverbEnable(!!this->m_nParameter[ParameterFXShimmerReverbEnable]);
-	this->m_PerformanceConfig.SetFXShimmerReverbInputGain(this->m_nParameter[ParameterFXShimmerReverbInputGain]);
-	this->m_PerformanceConfig.SetFXShimmerReverbTime(this->m_nParameter[ParameterFXShimmerReverbTime]);
-	this->m_PerformanceConfig.SetFXShimmerReverbDiffusion(this->m_nParameter[ParameterFXShimmerReverbDiffusion]);
-	this->m_PerformanceConfig.SetFXShimmerReverbLP(this->m_nParameter[ParameterFXShimmerReverbLP]);
+	this->m_PerformanceConfig.SetFXReverberatorEnable(!!this->m_nParameter[ParameterFXReverberatorEnable]);
+	this->m_PerformanceConfig.SetFXReverberatorInputGain(this->m_nParameter[ParameterFXReverberatorInputGain]);
+	this->m_PerformanceConfig.SetFXReverberatorTime(this->m_nParameter[ParameterFXReverberatorTime]);
+	this->m_PerformanceConfig.SetFXReverberatorDiffusion(this->m_nParameter[ParameterFXReverberatorDiffusion]);
+	this->m_PerformanceConfig.SetFXReverberatorLP(this->m_nParameter[ParameterFXReverberatorLP]);
 
 	size_t end = MixerOutput::kFXCount - 1;
 	for(size_t ret = 0; ret < end; ++ret)
@@ -1981,11 +1981,11 @@ void CMiniDexed::LoadPerformanceParameters(void)
 	this->SetParameter(ParameterFXDelayLeftDelayTime, this->m_PerformanceConfig.GetFXDelayLeftDelayTime());
 	this->SetParameter(ParameterFXDelayRightDelayTime, this->m_PerformanceConfig.GetFXDelayRightDelayTime());
 	this->SetParameter(ParameterFXDelayFeedback, this->m_PerformanceConfig.GetFXDelayFeedback());
-	this->SetParameter(ParameterFXShimmerReverbEnable, this->m_PerformanceConfig.GetFXShimmerReverbEnable());
-	this->SetParameter(ParameterFXShimmerReverbInputGain, this->m_PerformanceConfig.GetFXShimmerReverbInputGain());
-	this->SetParameter(ParameterFXShimmerReverbTime, this->m_PerformanceConfig.GetFXShimmerReverbTime());
-	this->SetParameter(ParameterFXShimmerReverbDiffusion, this->m_PerformanceConfig.GetFXShimmerReverbDiffusion());
-	this->SetParameter(ParameterFXShimmerReverbLP, this->m_PerformanceConfig.GetFXShimmerReverbLP());
+	this->SetParameter(ParameterFXReverberatorEnable, this->m_PerformanceConfig.GetFXReverberatorEnable());
+	this->SetParameter(ParameterFXReverberatorInputGain, this->m_PerformanceConfig.GetFXReverberatorInputGain());
+	this->SetParameter(ParameterFXReverberatorTime, this->m_PerformanceConfig.GetFXReverberatorTime());
+	this->SetParameter(ParameterFXReverberatorDiffusion, this->m_PerformanceConfig.GetFXReverberatorDiffusion());
+	this->SetParameter(ParameterFXReverberatorLP, this->m_PerformanceConfig.GetFXReverberatorLP());
 
 	size_t end = MixerOutput::kFXCount - 1;
 	for(size_t ret = 0; ret < end; ++ret)

src/minidexed.h

@@ -189,12 +189,12 @@ public:
 		ParameterFXDelayFlutterRate,
 		ParameterFXDelayFlutterAmount,
 
-		// ShimmerReverb parameters
-		ParameterFXShimmerReverbEnable,
-		ParameterFXShimmerReverbInputGain,
-		ParameterFXShimmerReverbTime,
-		ParameterFXShimmerReverbDiffusion,
-		ParameterFXShimmerReverbLP,
+		// Reverberator parameters
+		ParameterFXReverberatorEnable,
+		ParameterFXReverberatorInputGain,
+		ParameterFXReverberatorTime,
+		ParameterFXReverberatorDiffusion,
+		ParameterFXReverberatorLP,
 
 		// Tube Return parameters
 		ParameterFXTube_ChorusReturn,
@@ -203,7 +203,7 @@ public:
 		ParameterFXTube_PhaserReturn,
 		ParameterFXTube_DelayReturn,
 		ParameterFXTube_ReverbReturn,
-		ParameterFXTube_ShimmerReturn,
+		ParameterFXTube_ReverberatorReturn,
 		ParameterFXTube_MainOutput,
 
 		// Chorus Return parameters
@@ -213,7 +213,7 @@ public:
 		ParameterFXChorus_PhaserReturn,
 		ParameterFXChorus_DelayReturn,
 		ParameterFXChorus_ReverbReturn,
-		ParameterFXChorus_ShimmerReturn,
+		ParameterFXChorus_ReverberatorReturn,
 		ParameterFXChorus_MainOutput,
 
 		// Flanger Return parameters
@@ -223,7 +223,7 @@ public:
 		ParameterFXFlanger_PhaserReturn,
 		ParameterFXFlanger_DelayReturn,
 		ParameterFXFlanger_ReverbReturn,
-		ParameterFXFlanger_ShimmerReturn,
+		ParameterFXFlanger_ReverberatorReturn,
 		ParameterFXFlanger_MainOutput,
 
 		// Orbitone Return parameters
@@ -233,7 +233,7 @@ public:
 		ParameterFXOrbitone_PhaserReturn,
 		ParameterFXOrbitone_DelayReturn,
 		ParameterFXOrbitone_ReverbReturn,
-		ParameterFXOrbitone_ShimmerReturn,
+		ParameterFXOrbitone_ReverberatorReturn,
 		ParameterFXOrbitone_MainOutput,
 
 		// Phaser Return parameters
@@ -243,7 +243,7 @@ public:
 		ParameterFXPhaser_OrbitoneReturn,
 		ParameterFXPhaser_DelayReturn,
 		ParameterFXPhaser_ReverbReturn,
-		ParameterFXPhaser_ShimmerReturn,
+		ParameterFXPhaser_ReverberatorReturn,
 		ParameterFXPhaser_MainOutput,
 
 		// Delay Return parameters
@@ -253,7 +253,7 @@ public:
 		ParameterFXDelay_OrbitoneReturn,
 		ParameterFXDelay_PhaserReturn,
 		ParameterFXDelay_ReverbReturn,
-		ParameterFXDelay_ShimmerReturn,
+		ParameterFXDelay_ReverberatorReturn,
 		ParameterFXDelay_MainOutput,
 
 		// Reverb Return parameters
@@ -263,18 +263,18 @@ public:
 		ParameterFXReverb_OrbitoneReturn,
 		ParameterFXReverb_PhaserReturn,
 		ParameterFXReverb_DelayReturn,
-		ParameterFXReverb_ShimmerReturn,
+		ParameterFXReverb_ReverberatorReturn,
 		ParameterFXReverb_MainOutput,
 
-		// Shimmer Return parameters
-		ParameterFXShimmer_TubeReturn,
-		ParameterFXShimmer_ChorusReturn,
-		ParameterFXShimmer_FlangerReturn,
-		ParameterFXShimmer_OrbitoneReturn,
-		ParameterFXShimmer_PhaserReturn,
-		ParameterFXShimmer_DelayReturn,
-		ParameterFXShimmer_ReverbReturn,
-		ParameterFXShimmer_MainOutput,
+		// Reverberator Return parameters
+		ParameterFXReverberator_TubeReturn,
+		ParameterFXReverberator_ChorusReturn,
+		ParameterFXReverberator_FlangerReturn,
+		ParameterFXReverberator_OrbitoneReturn,
+		ParameterFXReverberator_PhaserReturn,
+		ParameterFXReverberator_DelayReturn,
+		ParameterFXReverberator_ReverbReturn,
+		ParameterFXReverberator_MainOutput,
 
 		// END FX global parameters definition
 	#endif
@@ -339,7 +339,7 @@ public:
 		TGParameterMixingSendFXPhaser,
 		TGParameterMixingSendFXDelay,
 		TGParameterMixingSendFXPlateReverb,
-		TGParameterMixingSendFXShimmerReverb,
+		TGParameterMixingSendFXReverberator,
 		TGParameterMixingSendFXMainOutput,
 #endif // MIXING_CONSOLE_ENABLE
 

src/mixing_console.hpp

@@ -29,7 +29,7 @@
 #include "fx_phaser.h"
 #include "fx_delay.h"
 #include "effect_platervbstereo.h"
-#include "fx_shimmer_reverb.h"
+#include "fx_reverberator.h"
 #include "fx_dry.h"
 #include "fx_unit2.hpp"
 
@@ -63,7 +63,7 @@ public:
     inline FXUnit2<Phaser>* getPhaser();
     inline FXUnit2<Delay>* getDelay();
     inline FXUnit2<AudioEffectPlateReverb>* getPlateReverb();
-    inline FXUnit2<ShimmerReverb>* getShimmerReverb();
+    inline FXUnit2<Reverberator>* getReverberator();
     inline FXUnit2<Dry>* getDry();
 
     // Processing
@@ -94,7 +94,7 @@ private:
     FXUnit2<Phaser>* phaser_;
     FXUnit2<Delay>* delay_;
     FXUnit2<AudioEffectPlateReverb>* plate_reverb_;
-    FXUnit2<ShimmerReverb>* shimmer_reverb_;
+    FXUnit2<Reverberator>* shimmer_reverb_;
     FXUnit2<Dry>* dry_;
 
     IMPLEMENT_DUMP(
@@ -332,7 +332,7 @@ MixingConsole<nb_inputs>::MixingConsole(float32_t sampling_rate, size_t buffer_s
     this->fx_[MixerOutput::FX_Phaser] = this->phaser_ = new FXUnit2<Phaser>(sampling_rate);
     this->fx_[MixerOutput::FX_Delay] = this->delay_  = new FXUnit2<Delay>(sampling_rate);
     this->fx_[MixerOutput::FX_PlateReverb] = this->plate_reverb_ = new FXUnit2<AudioEffectPlateReverb>(sampling_rate);
-    this->fx_[MixerOutput::FX_ShimmerReverb] = this->shimmer_reverb_ = new FXUnit2<ShimmerReverb>(sampling_rate);
+    this->fx_[MixerOutput::FX_Reverberator] = this->shimmer_reverb_ = new FXUnit2<Reverberator>(sampling_rate);
     this->fx_[MixerOutput::MainOutput] = this->dry_ = new FXUnit2<Dry>(sampling_rate);
 
     this->init();
@@ -511,7 +511,7 @@ FXUnit2<AudioEffectPlateReverb>* MixingConsole<nb_inputs>::getPlateReverb()
 }
 
 template<size_t nb_inputs>
-FXUnit2<ShimmerReverb>* MixingConsole<nb_inputs>::getShimmerReverb()
+FXUnit2<Reverberator>* MixingConsole<nb_inputs>::getReverberator()
 {
     return this->shimmer_reverb_;
 }

src/mixing_console_constants.h

@@ -16,7 +16,7 @@ enum MixerOutput
     FX_Phaser,
     FX_Delay,
     FX_PlateReverb,
-    FX_ShimmerReverb,
+    FX_Reverberator,
     MainOutput,
     kFXCount
 };
@@ -32,7 +32,7 @@ inline std::string toString(MixerOutput enum_val)
         "Phaser",
         "Delay",
         "PlateReverb",
-        "ShimmerReverb",
+        "Reverberator",
         "MainOutput"
     };
     static_assert(names.size() == MixerOutput::kFXCount, "Enum MixerOutput and string array size mismatch");
@@ -51,7 +51,7 @@ inline MixerOutput toIndex(const char* str)
     TO_INDEX_CHECK(str, MixerOutput::FX_Phaser);
     TO_INDEX_CHECK(str, MixerOutput::FX_Delay);
     TO_INDEX_CHECK(str, MixerOutput::FX_PlateReverb);
-    TO_INDEX_CHECK(str, MixerOutput::FX_ShimmerReverb);
+    TO_INDEX_CHECK(str, MixerOutput::FX_Reverberator);
     TO_INDEX_CHECK(str, MixerOutput::MainOutput);
 
     throw std::invalid_argument("Invalid MixerOutput string");

src/performance.ini

@@ -313,9 +313,9 @@ FXChainDelayWet=50
 FXChainDelayLeftDelayTime=15
 FXChainDelayRightDelayTime=22
 FXChainDelayFeedback=35
-FXChainShimmerReverbEnable=1
-FXChainShimmerReverbWet=70
-FXChainShimmerReverbInputGain=55
-FXChainShimmerReverbTime=75
-FXChainShimmerReverbDiffusion=75
-FXChainShimmerReverbLP=80
+FXChainReverberatorEnable=1
+FXChainReverberatorWet=70
+FXChainReverberatorInputGain=55
+FXChainReverberatorTime=75
+FXChainReverberatorDiffusion=75
+FXChainReverberatorLP=80

src/performanceconfig.cpp

@@ -182,11 +182,11 @@ bool CPerformanceConfig::Load (void)
 	this->m_nFXDelayLeftDelayTime = this->m_Properties.GetNumber("FXDelayLeftDelayTime", 15);
 	this->m_nFXDelayRightDelayTime = this->m_Properties.GetNumber("FXDelayRightDelayTime", 22);
 	this->m_nFXDelayFeedback = this->m_Properties.GetNumber("FXDelayFeedback", 35);
-	this->m_bFXShimmerReverbEnable = this->m_Properties.GetNumber("FXShimmerReverbEnable", 1);
-	this->m_nFXShimmerReverbInputGain = this->m_Properties.GetNumber("FXShimmerReverbInputGain", 30);
-	this->m_nFXShimmerReverbTime = this->m_Properties.GetNumber("FXShimmerReverbTime", 30);
-	this->m_nFXShimmerReverbDiffusion = this->m_Properties.GetNumber("FXShimmerReverbDiffusion", 30);
-	this->m_nFXShimmerReverbLP = this->m_Properties.GetNumber("FXShimmerReverbLP", 99);
+	this->m_bFXReverberatorEnable = this->m_Properties.GetNumber("FXReverberatorEnable", 1);
+	this->m_nFXReverberatorInputGain = this->m_Properties.GetNumber("FXReverberatorInputGain", 30);
+	this->m_nFXReverberatorTime = this->m_Properties.GetNumber("FXReverberatorTime", 30);
+	this->m_nFXReverberatorDiffusion = this->m_Properties.GetNumber("FXReverberatorDiffusion", 30);
+	this->m_nFXReverberatorLP = this->m_Properties.GetNumber("FXReverberatorLP", 99);
 
 	for(unsigned in = 0; in < CConfig::ToneGenerators; ++in)
 	{
@@ -355,11 +355,11 @@ bool CPerformanceConfig::Save (void)
 	this->m_Properties.SetNumber("FXDelayLeftDelayTime", m_nFXDelayLeftDelayTime);
 	this->m_Properties.SetNumber("FXDelayRightDelayTime", m_nFXDelayRightDelayTime);
 	this->m_Properties.SetNumber("FXDelayFeedback", m_nFXDelayFeedback);
-	this->m_Properties.SetNumber("FXShimmerReverbEnable", m_bFXShimmerReverbEnable ? 1 : 0);
-	this->m_Properties.SetNumber("FXShimmerReverbInputGain", m_nFXShimmerReverbInputGain);
-	this->m_Properties.SetNumber("FXShimmerReverbTime", m_nFXShimmerReverbTime);
-	this->m_Properties.SetNumber("FXShimmerReverbDiffusion", m_nFXShimmerReverbDiffusion);
-	this->m_Properties.SetNumber("FXShimmerReverbLP", m_nFXShimmerReverbLP);
+	this->m_Properties.SetNumber("FXReverberatorEnable", m_bFXReverberatorEnable ? 1 : 0);
+	this->m_Properties.SetNumber("FXReverberatorInputGain", m_nFXReverberatorInputGain);
+	this->m_Properties.SetNumber("FXReverberatorTime", m_nFXReverberatorTime);
+	this->m_Properties.SetNumber("FXReverberatorDiffusion", m_nFXReverberatorDiffusion);
+	this->m_Properties.SetNumber("FXReverberatorLP", m_nFXReverberatorLP);
 
 	for(unsigned in = 0; in < CConfig::ToneGenerators; ++in)
 	{
@@ -1137,29 +1137,29 @@ unsigned CPerformanceConfig::GetFXDelayFeedback(void) const
 	return this->m_nFXDelayFeedback;
 }
 
-bool CPerformanceConfig::GetFXShimmerReverbEnable(void) const
+bool CPerformanceConfig::GetFXReverberatorEnable(void) const
 {
-	return this->m_bFXShimmerReverbEnable;
+	return this->m_bFXReverberatorEnable;
 }
 
-unsigned CPerformanceConfig::GetFXShimmerReverbInputGain(void) const
+unsigned CPerformanceConfig::GetFXReverberatorInputGain(void) const
 {
-	return this->m_nFXShimmerReverbInputGain;
+	return this->m_nFXReverberatorInputGain;
 }
 
-unsigned CPerformanceConfig::GetFXShimmerReverbTime(void) const
+unsigned CPerformanceConfig::GetFXReverberatorTime(void) const
 {
-	return this->m_nFXShimmerReverbTime;
+	return this->m_nFXReverberatorTime;
 }
 
-unsigned CPerformanceConfig::GetFXShimmerReverbDiffusion(void) const
+unsigned CPerformanceConfig::GetFXReverberatorDiffusion(void) const
 {
-	return this->m_nFXShimmerReverbDiffusion;
+	return this->m_nFXReverberatorDiffusion;
 }
 
-unsigned CPerformanceConfig::GetFXShimmerReverbLP(void) const
+unsigned CPerformanceConfig::GetFXReverberatorLP(void) const
 {
-	return this->m_nFXShimmerReverbLP;
+	return this->m_nFXReverberatorLP;
 }
 
 unsigned CPerformanceConfig::GetFXSendLevel(unsigned in, MixerOutput fx) const
@@ -1281,29 +1281,29 @@ void CPerformanceConfig::SetFXDelayFeedback(unsigned nValue)
 	this->m_nFXDelayFeedback = nValue;
 }
 
-void CPerformanceConfig::SetFXShimmerReverbEnable(unsigned bValue)
+void CPerformanceConfig::SetFXReverberatorEnable(unsigned bValue)
 {
-	this->m_bFXShimmerReverbEnable = bValue;
+	this->m_bFXReverberatorEnable = bValue;
 }
 
-void CPerformanceConfig::SetFXShimmerReverbInputGain(unsigned nValue)
+void CPerformanceConfig::SetFXReverberatorInputGain(unsigned nValue)
 {
-	this->m_nFXShimmerReverbInputGain = nValue;
+	this->m_nFXReverberatorInputGain = nValue;
 }
 
-void CPerformanceConfig::SetFXShimmerReverbTime(unsigned nValue)
+void CPerformanceConfig::SetFXReverberatorTime(unsigned nValue)
 {
-	this->m_nFXShimmerReverbTime = nValue;
+	this->m_nFXReverberatorTime = nValue;
 }
 
-void CPerformanceConfig::SetFXShimmerReverbDiffusion(unsigned nValue)
+void CPerformanceConfig::SetFXReverberatorDiffusion(unsigned nValue)
 {
-	this->m_nFXShimmerReverbDiffusion = nValue;
+	this->m_nFXReverberatorDiffusion = nValue;
 }
 
-void CPerformanceConfig::SetFXShimmerReverbLP(unsigned nValue)
+void CPerformanceConfig::SetFXReverberatorLP(unsigned nValue)
 {
-	this->m_nFXShimmerReverbLP = nValue;
+	this->m_nFXReverberatorLP = nValue;
 }
 
 void CPerformanceConfig::SetFXSendLevel(unsigned in, MixerOutput fx, unsigned nValue)

src/performanceconfig.h

@@ -140,11 +140,11 @@ public:
 	unsigned GetFXDelayLeftDelayTime(void) const;
 	unsigned GetFXDelayRightDelayTime(void) const;
 	unsigned GetFXDelayFeedback(void) const;
-	bool GetFXShimmerReverbEnable(void) const;
-	unsigned GetFXShimmerReverbInputGain(void) const;
-	unsigned GetFXShimmerReverbTime(void) const;
-	unsigned GetFXShimmerReverbDiffusion(void) const;
-	unsigned GetFXShimmerReverbLP(void) const;
+	bool GetFXReverberatorEnable(void) const;
+	unsigned GetFXReverberatorInputGain(void) const;
+	unsigned GetFXReverberatorTime(void) const;
+	unsigned GetFXReverberatorDiffusion(void) const;
+	unsigned GetFXReverberatorLP(void) const;
 	unsigned GetFXSendLevel(unsigned in, MixerOutput fx) const;
 	unsigned GetFXReturnLevel(MixerOutput ret, MixerOutput fx) const;
 
@@ -169,11 +169,11 @@ public:
 	void SetFXDelayLeftDelayTime(unsigned nValue);
 	void SetFXDelayRightDelayTime(unsigned nValue);
 	void SetFXDelayFeedback(unsigned nValue);
-	void SetFXShimmerReverbEnable(unsigned nValue);
-	void SetFXShimmerReverbInputGain(unsigned nValue);
-	void SetFXShimmerReverbTime(unsigned nValue);
-	void SetFXShimmerReverbDiffusion(unsigned nValue);
-	void SetFXShimmerReverbLP(unsigned nValue);
+	void SetFXReverberatorEnable(unsigned nValue);
+	void SetFXReverberatorInputGain(unsigned nValue);
+	void SetFXReverberatorTime(unsigned nValue);
+	void SetFXReverberatorDiffusion(unsigned nValue);
+	void SetFXReverberatorLP(unsigned nValue);
 	void SetFXSendLevel(unsigned in, MixerOutput fx, unsigned nValue);
 	void SetFXReturnLevel(MixerOutput ret, MixerOutput fx, unsigned nValue);
 #endif
@@ -268,11 +268,11 @@ private:
 	unsigned m_nFXDelayLeftDelayTime;
 	unsigned m_nFXDelayRightDelayTime;
 	unsigned m_nFXDelayFeedback;
-	bool m_bFXShimmerReverbEnable;
-	unsigned m_nFXShimmerReverbInputGain;
-	unsigned m_nFXShimmerReverbTime;
-	unsigned m_nFXShimmerReverbDiffusion;
-	unsigned m_nFXShimmerReverbLP;
+	bool m_bFXReverberatorEnable;
+	unsigned m_nFXReverberatorInputGain;
+	unsigned m_nFXReverberatorTime;
+	unsigned m_nFXReverberatorDiffusion;
+	unsigned m_nFXReverberatorLP;
 
 	unsigned m_nFXSendLevel[CConfig::ToneGenerators][MixerOutput::kFXCount];
 	unsigned m_nFXReturnLevel[MixerOutput::kFXCount - 1][MixerOutput::kFXCount];

src/test/beta.cpp

@@ -62,7 +62,7 @@ TEST(BetaTest, MixingConsoleShortBuffer)
     delete mixer;
 }
 
-TEST(BetaTest, MixingConsoleShimmerShortBuffer)
+TEST(BetaTest, MixingConsoleReverberatorShortBuffer)
 {
     const testing::TestInfo* test_info = testing::UnitTest::GetInstance()->current_test_info();
     std::string full_test_name = test_info->test_case_name();
@@ -75,14 +75,14 @@ TEST(BetaTest, MixingConsoleShimmerShortBuffer)
     mixer->setChannelLevel(0, 1.0f);
     mixer->setPan(0, 0.5f);
 
-    mixer->getShimmerReverb()->setInputGain(0.35f);
-    mixer->getShimmerReverb()->setTime(0.69f);
-    mixer->getShimmerReverb()->setDiffusion(0.7f);
-    mixer->getShimmerReverb()->setLP(0.8f);
+    mixer->getReverberator()->setInputGain(0.35f);
+    mixer->getReverberator()->setTime(0.69f);
+    mixer->getReverberator()->setDiffusion(0.7f);
+    mixer->getReverberator()->setLP(0.8f);
 
     mixer->setSendLevel(0, MixerOutput::MainOutput, 0.4f);
-    mixer->setSendLevel(0, MixerOutput::FX_ShimmerReverb, 1.0f);
-    mixer->setReturnLevel(MixerOutput::FX_ShimmerReverb, MixerOutput::MainOutput, 0.6f);
+    mixer->setSendLevel(0, MixerOutput::FX_Reverberator, 1.0f);
+    mixer->setReturnLevel(MixerOutput::FX_Reverberator, MixerOutput::MainOutput, 0.6f);
 
     float32_t inSamples[size];
     for(size_t s = 0; s < size; ++s) inSamples[s] = getRandomValue();
@@ -146,7 +146,7 @@ TEST(BetaTest, MixingConsoleDrySamplesBoundariesTest)
     delete mixer;
 }
 
-TEST(BetaTest, MixingConsoleShimmerSamplesBoundariesTest)
+TEST(BetaTest, MixingConsoleReverberatorSamplesBoundariesTest)
 {
     const testing::TestInfo* test_info = testing::UnitTest::GetInstance()->current_test_info();
     std::string full_test_name = test_info->test_case_name();
@@ -168,14 +168,14 @@ TEST(BetaTest, MixingConsoleShimmerSamplesBoundariesTest)
     mixer->setPan(0, 0.5f);
 
     mixer->setSendLevel(0, MixerOutput::MainOutput, 0.4f);
-    mixer->setSendLevel(0, MixerOutput::FX_ShimmerReverb, 1.0f);
-    mixer->setReturnLevel(MixerOutput::FX_ShimmerReverb, MixerOutput::MainOutput, 0.6f);
-
-    mixer->getShimmerReverb()->setMute(false);
-    mixer->getShimmerReverb()->setInputGain(0.35);
-    mixer->getShimmerReverb()->setTime(0.65);
-    mixer->getShimmerReverb()->setDiffusion(0.8);
-    mixer->getShimmerReverb()->setLP(0.7f);
+    mixer->setSendLevel(0, MixerOutput::FX_Reverberator, 1.0f);
+    mixer->setReturnLevel(MixerOutput::FX_Reverberator, MixerOutput::MainOutput, 0.6f);
+
+    mixer->getReverberator()->setMute(false);
+    mixer->getReverberator()->setInputGain(0.35);
+    mixer->getReverberator()->setTime(0.65);
+    mixer->getReverberator()->setDiffusion(0.8);
+    mixer->getReverberator()->setLP(0.7f);
 
     mixer->setInputSampleBuffer(0, inSamples[0]);
     mixer->process(outSamples[0], outSamples[1]);

src/test/beta_lowlevel.cpp

@@ -25,7 +25,7 @@
 
 typedef FxEngine<16384, Format::FORMAT_FLOAT32, true> Engine;
 
-void processDebugShimmerSample(
+void processDebugReverberatorSample(
     Engine& engine_, size_t index, 
     float32_t& lp_decay_1_, float32_t& lp_decay_2_, 
     float32_t inL, float32_t inR, 
@@ -120,7 +120,7 @@ void processDebugShimmerSample(
     std::cout << std::endl << "***********************************************************************************************************" << std::endl << std::endl;
 }
 
-TEST(LowLevel, TestDiracShimmerAlgo)
+TEST(LowLevel, TestDiracReverberatorAlgo)
 {
     const testing::TestInfo* test_info = testing::UnitTest::GetInstance()->current_test_info();
     std::string full_test_name = test_info->test_case_name();
@@ -147,7 +147,7 @@ TEST(LowLevel, TestDiracShimmerAlgo)
 
     for(size_t i = 0; i < size; ++i)
     {
-        processDebugShimmerSample(engine_, i, lp1, lp2, inSamples[i], inSamples[i], outSamplesL[i], outSamplesR[i]);
+        processDebugReverberatorSample(engine_, i, lp1, lp2, inSamples[i], inSamples[i], outSamplesL[i], outSamplesR[i]);
     }
 
     saveWaveFile(getResultFile(full_test_name + ".wav", true), outSamplesL, outSamplesR, size, SAMPLING_FREQUENCY, 16);
@@ -158,7 +158,7 @@ TEST(LowLevel, TestDiracShimmerAlgo)
     delete[] inSamples;
 }
 
-void processShimmerSample(
+void processReverberatorSample(
     Engine& engine_L_, Engine& engine_R_, size_t index, 
     float32_t& lp_decay_1_, float32_t& lp_decay_2_, 
     float32_t inL, float32_t inR, 
@@ -269,7 +269,7 @@ void processShimmerSample(
     lp_decay_2_ = lp_2;
 }
 
-TEST(LowLevel, TestStereoShimmerAlgo)
+TEST(LowLevel, TestStereoReverberatorAlgo)
 {
     const testing::TestInfo* test_info = testing::UnitTest::GetInstance()->current_test_info();
     std::string full_test_name = test_info->test_case_name();
@@ -298,7 +298,7 @@ TEST(LowLevel, TestStereoShimmerAlgo)
 
     for(size_t i = 0; i < size; ++i)
     {
-        processShimmerSample(engine_L_, engine_R_, i, lp1, lp2, inSamples[0][i], inSamples[1][i], outSamplesL[i], outSamplesR[i]);
+        processReverberatorSample(engine_L_, engine_R_, i, lp1, lp2, inSamples[0][i], inSamples[1][i], outSamplesL[i], outSamplesR[i]);
     }
 
     saveWaveFile(getResultFile(full_test_name + ".wav", true), outSamplesL, outSamplesR, size, SAMPLING_FREQUENCY, 16);
@@ -311,7 +311,7 @@ TEST(LowLevel, TestStereoShimmerAlgo)
     delete[] inSamples;
 }
 
-void processShimmerSample(
+void processReverberatorSample(
     Engine& engine_, size_t index, 
     float32_t& lp_decay_1_, float32_t& lp_decay_2_, 
     float32_t inL, float32_t inR, 
@@ -401,7 +401,7 @@ void processShimmerSample(
     lp_decay_2_ = lp_2;
 }
 
-TEST(LowLevel, TestMonoShimmerAlgo)
+TEST(LowLevel, TestMonoReverberatorAlgo)
 {
     const testing::TestInfo* test_info = testing::UnitTest::GetInstance()->current_test_info();
     std::string full_test_name = test_info->test_case_name();
@@ -426,7 +426,7 @@ TEST(LowLevel, TestMonoShimmerAlgo)
 
     for(size_t i = 0; i < size; ++i)
     {
-        processShimmerSample(engine_, i, lp1, lp2, inSamples[0][i], inSamples[1][i], outSamplesL[i], outSamplesR[i]);
+        processReverberatorSample(engine_, i, lp1, lp2, inSamples[0][i], inSamples[1][i], outSamplesL[i], outSamplesR[i]);
     }
 
     saveWaveFile(getResultFile(full_test_name + ".wav", true), outSamplesL, outSamplesR, size, SAMPLING_FREQUENCY, 16);

src/test/test_fxLevelTuning.cpp

@@ -7,7 +7,7 @@
 #include "../fx_phaser.h"
 #include "../fx_delay.h"
 #include "../effect_platervbstereo.h"
-#include "../fx_shimmer_reverb.h"
+#include "../fx_reverberator.h"
 
 TEST(LevelTuning, Tube)
 {
@@ -241,9 +241,9 @@ TEST(LevelTuning, PlateReverb)
     EXPECT_LE(1.0f / ratio, 1.1f);
 }
 
-TEST(LevelTuning, ShimmerReverb)
+TEST(LevelTuning, Reverberator)
 {
-    ShimmerReverb fx(SAMPLING_FREQUENCY);
+    Reverberator fx(SAMPLING_FREQUENCY);
     fx.reset();
     fx.setInputGain(0.35f);
     fx.setTime(0.89f);
@@ -269,7 +269,7 @@ TEST(LevelTuning, ShimmerReverb)
 
     float32_t ratio = std::sqrt(sumOut / sumIn);
 
-    ASSERT_EQ(nb_errors, 0) << "Sample value error for ShimmerReverb";
+    ASSERT_EQ(nb_errors, 0) << "Sample value error for Reverberator";
     EXPECT_GE(ratio, 0.9f);
     EXPECT_LE(1.0f / ratio, 1.1f);
 }

src/test/test_fx_helper.cpp

@@ -12,7 +12,7 @@ std::string getScenarioName(int scenario)
     bool fxOrbitone = Active(scenario, FXSwitch::FX__Orbitone);
     bool fxFlanger = Active(scenario, FXSwitch::FX__Flanger);
     bool fxDelay = Active(scenario, FXSwitch::FX__Delay);
-    bool fxShimmer = Active(scenario, FXSwitch::FX__ShimmerReverb);
+    bool fxReverberator = Active(scenario, FXSwitch::FX__Reverberator);
     bool fxReverb = Active(scenario, FXSwitch::FX__PlateReverb);
     bool first = true;
 
@@ -67,7 +67,7 @@ std::string getScenarioName(int scenario)
         first = false;
     }
 
-    if(fxShimmer) 
+    if(fxReverberator) 
     {
         if(!first) ss << ", ";
         ss << "Shim";

src/test/test_fx_helper.h

@@ -57,7 +57,7 @@ enum FXSwitch
     FX__Orbitone,
     FX__Phaser,
     FX__Delay,
-    FX__ShimmerReverb,
+    FX__Reverberator,
     FX__PlateReverb,
     __kFXCount
 };

src/test/test_fx_mixing_console.cpp

@@ -60,11 +60,11 @@ void setupMixingConsoleFX(Mixer* mixer)
     mixer->getPlateReverb()->diffusion(0.65f);
     mixer->getPlateReverb()->level(1.0f);
 
-    mixer->getShimmerReverb()->setMute(false);
-    mixer->getShimmerReverb()->setInputGain(0.65f);
-    mixer->getShimmerReverb()->setTime(0.89f);
-    mixer->getShimmerReverb()->setDiffusion(0.75f);
-    mixer->getShimmerReverb()->setLP(0.8f);
+    mixer->getReverberator()->setMute(false);
+    mixer->getReverberator()->setInputGain(0.65f);
+    mixer->getReverberator()->setTime(0.89f);
+    mixer->getReverberator()->setDiffusion(0.75f);
+    mixer->getReverberator()->setLP(0.8f);
 }
 
 #define ACTIVE_FX(scenarioId, fx) const bool b ## fx = ((scenarioId & MixerOutput::fx) == MixerOutput::fx)
@@ -78,7 +78,7 @@ void setupMixingConsoleFX(Mixer* mixer, int scenarioId)
     ACTIVE_FX(scenarioId, FX_Phaser);
     ACTIVE_FX(scenarioId, FX_Delay);
     ACTIVE_FX(scenarioId, FX_PlateReverb);
-    ACTIVE_FX(scenarioId, FX_ShimmerReverb);
+    ACTIVE_FX(scenarioId, FX_Reverberator);
 
     mixer->setChannelLevel(0, 1.0f);
     mixer->setPan(0, 0.5f);
@@ -184,17 +184,17 @@ void setupMixingConsoleFX(Mixer* mixer, int scenarioId)
         }
     }
 
-    if(bFX_ShimmerReverb)
+    if(bFX_Reverberator)
     {
         nbActiveFX++;
         if(nbActiveFX == 1)
         {
-            mixer->setSendLevel(0, MixerOutput::FX_ShimmerReverb, 1.0f);
-            previousActivatedFX = MixerOutput::FX_ShimmerReverb;
+            mixer->setSendLevel(0, MixerOutput::FX_Reverberator, 1.0f);
+            previousActivatedFX = MixerOutput::FX_Reverberator;
         }
         else
         {
-            mixer->setReturnLevel(previousActivatedFX, MixerOutput::FX_ShimmerReverb, 1.0f);
+            mixer->setReturnLevel(previousActivatedFX, MixerOutput::FX_Reverberator, 1.0f);
         }
     }
 
@@ -257,7 +257,7 @@ TEST(MixingConsole, DryProcessing)
     mixer.setSendLevel(0, MixerOutput::FX_Phaser, 0.0f);
     mixer.setSendLevel(0, MixerOutput::FX_Delay, 0.0f);
     mixer.setSendLevel(0, MixerOutput::FX_PlateReverb, 0.0f);
-    mixer.setSendLevel(0, MixerOutput::FX_ShimmerReverb, 0.0f);
+    mixer.setSendLevel(0, MixerOutput::FX_Reverberator, 0.0f);
 
     for(size_t i = MixerOutput::OutputStart; i < (MixerOutput::kFXCount - 1); ++i)
     {
@@ -288,7 +288,7 @@ TEST(MixingConsole, DryProcessing)
     EXPECT_NEAR(out[StereoChannels::Left ][1], sqrt(2.0f) / 10.0f, epsilon);
 }
 
-TEST(MixingConsole, ShimmerProcessing)
+TEST(MixingConsole, ReverberatorProcessing)
 {
     const float32_t epsilon = 1e-7;
     const size_t length = 2;
@@ -297,8 +297,8 @@ TEST(MixingConsole, ShimmerProcessing)
     mixer.reset();
 
     mixer.setSendLevel(0, MixerOutput::MainOutput, 0.0f);
-    mixer.setSendLevel(0, MixerOutput::FX_ShimmerReverb, 1.0f);
-    mixer.setReturnLevel(MixerOutput::FX_ShimmerReverb, MixerOutput::MainOutput, 1.0f);
+    mixer.setSendLevel(0, MixerOutput::FX_Reverberator, 1.0f);
+    mixer.setReturnLevel(MixerOutput::FX_Reverberator, MixerOutput::MainOutput, 1.0f);
     mixer.setChannelLevel(0, 1.0f);
     mixer.setPan(0, 0.5f);
     ASSERT_EQ(0, INSPECT((&mixer), fullInspector));
@@ -335,7 +335,7 @@ TEST(MixingConsole, ShimmerProcessing)
     EXPECT_NEAR(out1[StereoChannels::Right][1], out2[StereoChannels::Right][1], epsilon);
 }
 
-TEST(MixingConsole, ShimmerNoiseProcessing)
+TEST(MixingConsole, ReverberatorNoiseProcessing)
 {
     const size_t length = 1024;
 
@@ -343,8 +343,8 @@ TEST(MixingConsole, ShimmerNoiseProcessing)
     mixer.reset();
 
     mixer.setSendLevel(0, MixerOutput::MainOutput, 0.0f);
-    mixer.setSendLevel(0, MixerOutput::FX_ShimmerReverb, 1.0f);
-    mixer.setReturnLevel(MixerOutput::FX_ShimmerReverb, MixerOutput::MainOutput, 1.0f);
+    mixer.setSendLevel(0, MixerOutput::FX_Reverberator, 1.0f);
+    mixer.setReturnLevel(MixerOutput::FX_Reverberator, MixerOutput::MainOutput, 1.0f);
     mixer.setChannelLevel(0, 1.0f);
     mixer.setPan(0, 0.5f);
     ASSERT_EQ(0, INSPECT((&mixer), fullInspector));
@@ -378,15 +378,15 @@ TEST(MixingConsole, StandardUsageProcessing)
     mixer.setSendLevel(0, MixerOutput::FX_Phaser, 1.0f);
     // mixer.setReturnLevel(MixerOutput::FX_Tube, MixerOutput::MainOutput, 1.0f);
     // mixer.setSendLevel(0, MixerOutput::FX_Chorus, 1.0f);
-    // mixer.setSendLevel(0, MixerOutput::FX_ShimmerReverb, 1.0f);
+    // mixer.setSendLevel(0, MixerOutput::FX_Reverberator, 1.0f);
     mixer.setReturnLevel(MixerOutput::FX_Tube, MixerOutput::FX_Chorus, 1.0f);
-    mixer.setReturnLevel(MixerOutput::FX_Chorus, MixerOutput::FX_ShimmerReverb, 1.0f);
+    mixer.setReturnLevel(MixerOutput::FX_Chorus, MixerOutput::FX_Reverberator, 1.0f);
     mixer.setReturnLevel(MixerOutput::FX_Phaser, MixerOutput::FX_Delay, 1.0f);
 
     mixer.setSendLevel(0, MixerOutput::MainOutput, 0.25f);
     mixer.setReturnLevel(MixerOutput::FX_Tube, MixerOutput::MainOutput, 0.1f);
     mixer.setReturnLevel(MixerOutput::FX_Chorus, MixerOutput::MainOutput, 0.15f);
-    mixer.setReturnLevel(MixerOutput::FX_ShimmerReverb, MixerOutput::MainOutput, 0.3f);
+    mixer.setReturnLevel(MixerOutput::FX_Reverberator, MixerOutput::MainOutput, 0.3f);
     mixer.setReturnLevel(MixerOutput::FX_Delay, MixerOutput::MainOutput, 0.3f);
 
     mixer.setInputSampleBuffer(0, inSamples[0], inSamples[1]);

src/test/test_fx_rack.cpp

@@ -46,12 +46,12 @@ void setupRack(FXRack* rack, int scenario)
     rack->getDelay()->setFlutterRate(0.0f);
     rack->getDelay()->setFlutterAmount(0.0f);
 
-    rack->getShimmerReverb()->setEnable(Active(scenario, FXSwitch::FX__ShimmerReverb));
-    rack->getShimmerReverb()->setWetLevel(0.5f);
-    rack->getShimmerReverb()->setInputGain(0.35f);
-    rack->getShimmerReverb()->setTime(0.89f);
-    rack->getShimmerReverb()->setDiffusion(0.75f);
-    rack->getShimmerReverb()->setLP(0.8f);
+    rack->getReverberator()->setEnable(Active(scenario, FXSwitch::FX__Reverberator));
+    rack->getReverberator()->setWetLevel(0.5f);
+    rack->getReverberator()->setInputGain(0.35f);
+    rack->getReverberator()->setTime(0.89f);
+    rack->getReverberator()->setDiffusion(0.75f);
+    rack->getReverberator()->setLP(0.8f);
 }
 
 TEST_P(FXScenarioTest, FXRackResetAllScenarios)
@@ -84,4 +84,4 @@ TEST_P(FXScenarioTest, ScenarioProcessing)
     CLEANUP_AUDIO_TEST(inSamples, outSamples);
 }
 
-INSTANTIATE_TEST_SUITE_P(FXRack, FXScenarioTest, testing::Range(0, 1 << (FXSwitch::FX__ShimmerReverb + 1)));
+INSTANTIATE_TEST_SUITE_P(FXRack, FXScenarioTest, testing::Range(0, 1 << (FXSwitch::FX__Reverberator + 1)));

src/test/test_fx_shimmer_reverb.cpp

@@ -1,9 +1,9 @@
 #include <gtest/gtest.h>
 
 #include "test_fx_helper.h"
-#include "../fx_shimmer_reverb.h"
+#include "../fx_reverberator.h"
 
-TEST(FXShimmerReverb, TransientSilence)
+TEST(FXReverberator, TransientSilence)
 {
     const testing::TestInfo* test_info = testing::UnitTest::GetInstance()->current_test_info();
     std::string full_test_name = test_info->test_case_name();
@@ -19,7 +19,7 @@ TEST(FXShimmerReverb, TransientSilence)
     memset(outSamplesL, 0, size * sizeof(float32_t));
     memset(outSamplesR, 0, size * sizeof(float32_t));
 
-    ShimmerReverb* shimmer = new ShimmerReverb(SAMPLING_FREQUENCY);
+    Reverberator* shimmer = new Reverberator(SAMPLING_FREQUENCY);
 
     shimmer->setInputGain(0.55f);
     shimmer->setTime(0.75f);
@@ -47,7 +47,7 @@ TEST(FXShimmerReverb, TransientSilence)
     delete[] outSamplesR;
 }
 
-TEST(FXShimmerReverb, TransientSilenceWithDirac)
+TEST(FXReverberator, TransientSilenceWithDirac)
 {
     const testing::TestInfo* test_info = testing::UnitTest::GetInstance()->current_test_info();
     std::string full_test_name = test_info->test_case_name();
@@ -64,7 +64,7 @@ TEST(FXShimmerReverb, TransientSilenceWithDirac)
     memset(outSamplesL, 0, size * sizeof(float32_t));
     memset(outSamplesR, 0, size * sizeof(float32_t));
 
-    ShimmerReverb* shimmer = new ShimmerReverb(SAMPLING_FREQUENCY);
+    Reverberator* shimmer = new Reverberator(SAMPLING_FREQUENCY);
 
     shimmer->setInputGain(0.55f);
     shimmer->setTime(0.75f);
@@ -92,7 +92,7 @@ TEST(FXShimmerReverb, TransientSilenceWithDirac)
     delete[] outSamplesR;
 }
 
-TEST(FXShimmerReverb, TransientNoise)
+TEST(FXReverberator, TransientNoise)
 {
     const testing::TestInfo* test_info = testing::UnitTest::GetInstance()->current_test_info();
     std::string full_test_name = test_info->test_case_name();
@@ -108,7 +108,7 @@ TEST(FXShimmerReverb, TransientNoise)
     memset(outSamplesL, 0, size * sizeof(float32_t));
     memset(outSamplesR, 0, size * sizeof(float32_t));
 
-    ShimmerReverb* shimmer = new ShimmerReverb(SAMPLING_FREQUENCY);
+    Reverberator* shimmer = new Reverberator(SAMPLING_FREQUENCY);
 
     shimmer->setInputGain(0.55f);
     shimmer->setTime(0.75f);
@@ -136,7 +136,7 @@ TEST(FXShimmerReverb, TransientNoise)
     delete[] outSamplesR;
 }
 
-TEST(FXShimmerReverb, TransientMusic)
+TEST(FXReverberator, TransientMusic)
 {
     const testing::TestInfo* test_info = testing::UnitTest::GetInstance()->current_test_info();
     std::string full_test_name = test_info->test_case_name();
@@ -151,7 +151,7 @@ TEST(FXShimmerReverb, TransientMusic)
     memset(outSamplesL, 0, size * sizeof(float32_t));
     memset(outSamplesR, 0, size * sizeof(float32_t));
 
-    ShimmerReverb* shimmer = new ShimmerReverb(SAMPLING_FREQUENCY);
+    Reverberator* shimmer = new Reverberator(SAMPLING_FREQUENCY);
 
     shimmer->setInputGain(0.55f);
     shimmer->setTime(0.75f);

src/test/test_unitFXTuning.cpp

@@ -8,7 +8,7 @@
 #include "../fx_phaser.h"
 #include "../fx_delay.h"
 #include "../effect_platervbstereo.h"
-#include "../fx_shimmer_reverb.h"
+#include "../fx_reverberator.h"
 
 TEST(UnitFXTuning, Dry)
 {
@@ -114,9 +114,9 @@ TEST(UnitFXTuning, PlateReverb)
     CLEANUP_AUDIO_TEST(inSamples, outSamples);
 }
 
-TEST(UnitFXTuning, ShimmerReverb)
+TEST(UnitFXTuning, Reverberator)
 {
-    ShimmerReverb fx(SAMPLING_FREQUENCY);
+    Reverberator fx(SAMPLING_FREQUENCY);
     fx.setInputGain(0.65f);
     fx.setTime(0.89f);
     fx.setDiffusion(0.75f);

src/uimenu.cpp

@@ -72,7 +72,7 @@ const CUIMenu::TMenuItem CUIMenu::s_TGMenu[] =
 	{"Phaser-Send", EditTGParameter, 	0, CMiniDexed::TGParameterMixingSendFXPhaser},
 	{"Delay-Send", 	EditTGParameter, 	0, CMiniDexed::TGParameterMixingSendFXDelay},
 	{"Reverb-Send", EditTGParameter, 	0, CMiniDexed::TGParameterMixingSendFXPlateReverb},
-	{"ShimmR-Send", EditTGParameter, 	0, CMiniDexed::TGParameterMixingSendFXShimmerReverb},
+	{"ShimmR-Send", EditTGParameter, 	0, CMiniDexed::TGParameterMixingSendFXReverberator},
 	{"Main Out", 	EditTGParameter, 	0, CMiniDexed::TGParameterMixingSendFXMainOutput},
 #endif
 #ifdef PLATE_REVERB_ENABLE
@@ -105,7 +105,7 @@ const CUIMenu::TMenuItem CUIMenu::s_EffectsMenu[] =
 	{"Reverb",		MenuHandler, CUIMenu::s_FXPlateReverb},
 #endif
 #ifdef MIXING_CONSOLE_ENABLE
-	{"Shimmer", MenuHandler, CUIMenu::s_FXShimmerReverb},
+	{"Reverberator", MenuHandler, CUIMenu::s_FXReverberator},
 #endif
 	{0}
 };
@@ -223,14 +223,14 @@ const CUIMenu::TMenuItem CUIMenu::s_FXDelay[] =
 	{0}
 };
 
-const CUIMenu::TMenuItem CUIMenu::s_FXShimmerReverb[] =
+const CUIMenu::TMenuItem CUIMenu::s_FXReverberator[] =
 {
-	{"Enable", 	EditGlobalParameter, 	0, CMiniDexed::ParameterFXShimmerReverbEnable},
-	{"Gain",	EditGlobalParameter,	0, CMiniDexed::ParameterFXShimmerReverbInputGain},
-	{"Time",	EditGlobalParameter,	0, CMiniDexed::ParameterFXShimmerReverbTime},
-	{"Diffus",	EditGlobalParameter,	0, CMiniDexed::ParameterFXShimmerReverbDiffusion},
-	{"LowPass",	EditGlobalParameter,	0, CMiniDexed::ParameterFXShimmerReverbLP},
-	{"Return", 	MenuHandler, 			CUIMenu::s_FXShimmerReverbReturn},
+	{"Enable", 	EditGlobalParameter, 	0, CMiniDexed::ParameterFXReverberatorEnable},
+	{"Gain",	EditGlobalParameter,	0, CMiniDexed::ParameterFXReverberatorInputGain},
+	{"Time",	EditGlobalParameter,	0, CMiniDexed::ParameterFXReverberatorTime},
+	{"Diffus",	EditGlobalParameter,	0, CMiniDexed::ParameterFXReverberatorDiffusion},
+	{"LowPass",	EditGlobalParameter,	0, CMiniDexed::ParameterFXReverberatorLP},
+	{"Return", 	MenuHandler, 			CUIMenu::s_FXReverberatorReturn},
 	{0}
 };
 
@@ -242,7 +242,7 @@ const CUIMenu::TMenuItem CUIMenu::s_FXTubeReturn[] =
 	{"PhR Rtn", EditGlobalParameter, 	0, CMiniDexed::ParameterFXTube_PhaserReturn},
 	{"Del Rtn", EditGlobalParameter, 	0, CMiniDexed::ParameterFXTube_DelayReturn},
 	{"Rev Rtn", EditGlobalParameter, 	0, CMiniDexed::ParameterFXTube_ReverbReturn},
-	{"ShR Rtn", EditGlobalParameter, 	0, CMiniDexed::ParameterFXTube_ShimmerReturn},
+	{"ShR Rtn", EditGlobalParameter, 	0, CMiniDexed::ParameterFXTube_ReverberatorReturn},
 	{"MainOut", EditGlobalParameter, 	0, CMiniDexed::ParameterFXTube_MainOutput},
 	{0}
 };
@@ -255,7 +255,7 @@ const CUIMenu::TMenuItem CUIMenu::s_FXChorusReturn[] =
 	{"PhR Rtn", EditGlobalParameter, 	0, CMiniDexed::ParameterFXChorus_PhaserReturn},
 	{"Del Rtn", EditGlobalParameter, 	0, CMiniDexed::ParameterFXChorus_DelayReturn},
 	{"Rev Rtn", EditGlobalParameter, 	0, CMiniDexed::ParameterFXChorus_ReverbReturn},
-	{"ShR Rtn", EditGlobalParameter, 	0, CMiniDexed::ParameterFXChorus_ShimmerReturn},
+	{"ShR Rtn", EditGlobalParameter, 	0, CMiniDexed::ParameterFXChorus_ReverberatorReturn},
 	{"MainOut", EditGlobalParameter, 	0, CMiniDexed::ParameterFXChorus_MainOutput},
 	{0}
 };
@@ -268,7 +268,7 @@ const CUIMenu::TMenuItem CUIMenu::s_FXFlangerReturn[] =
 	{"PhR Rtn", EditGlobalParameter, 	0, CMiniDexed::ParameterFXFlanger_PhaserReturn},
 	{"Del Rtn", EditGlobalParameter, 	0, CMiniDexed::ParameterFXFlanger_DelayReturn},
 	{"Rev Rtn", EditGlobalParameter, 	0, CMiniDexed::ParameterFXFlanger_ReverbReturn},
-	{"ShR Rtn", EditGlobalParameter, 	0, CMiniDexed::ParameterFXFlanger_ShimmerReturn},
+	{"ShR Rtn", EditGlobalParameter, 	0, CMiniDexed::ParameterFXFlanger_ReverberatorReturn},
 	{"MainOut", EditGlobalParameter, 	0, CMiniDexed::ParameterFXFlanger_MainOutput},
 	{0}
 };
@@ -281,7 +281,7 @@ const CUIMenu::TMenuItem CUIMenu::s_FXOrbitoneReturn[] =
 	{"PhR Rtn", EditGlobalParameter, 	0, CMiniDexed::ParameterFXOrbitone_PhaserReturn},
 	{"Del Rtn", EditGlobalParameter, 	0, CMiniDexed::ParameterFXOrbitone_DelayReturn},
 	{"Rev Rtn", EditGlobalParameter, 	0, CMiniDexed::ParameterFXOrbitone_ReverbReturn},
-	{"ShR Rtn", EditGlobalParameter, 	0, CMiniDexed::ParameterFXOrbitone_ShimmerReturn},
+	{"ShR Rtn", EditGlobalParameter, 	0, CMiniDexed::ParameterFXOrbitone_ReverberatorReturn},
 	{"MainOut", EditGlobalParameter, 	0, CMiniDexed::ParameterFXOrbitone_MainOutput},
 	{0}
 };
@@ -294,7 +294,7 @@ const CUIMenu::TMenuItem CUIMenu::s_FXPhaserReturn[] =
 	{"Orb Rtn", EditGlobalParameter, 	0, CMiniDexed::ParameterFXPhaser_OrbitoneReturn},
 	{"Del Rtn", EditGlobalParameter, 	0, CMiniDexed::ParameterFXPhaser_DelayReturn},
 	{"Rev Rtn", EditGlobalParameter, 	0, CMiniDexed::ParameterFXPhaser_ReverbReturn},
-	{"ShR Rtn", EditGlobalParameter, 	0, CMiniDexed::ParameterFXPhaser_ShimmerReturn},
+	{"ShR Rtn", EditGlobalParameter, 	0, CMiniDexed::ParameterFXPhaser_ReverberatorReturn},
 	{"MainOut", EditGlobalParameter, 	0, CMiniDexed::ParameterFXPhaser_MainOutput},
 	{0}
 };
@@ -307,7 +307,7 @@ const CUIMenu::TMenuItem CUIMenu::s_FXDelayReturn[] =
 	{"Orb Rtn", EditGlobalParameter, 	0, CMiniDexed::ParameterFXDelay_OrbitoneReturn},
 	{"PhR Rtn", EditGlobalParameter, 	0, CMiniDexed::ParameterFXDelay_PhaserReturn},
 	{"Rev Rtn", EditGlobalParameter, 	0, CMiniDexed::ParameterFXDelay_ReverbReturn},
-	{"ShR Rtn", EditGlobalParameter, 	0, CMiniDexed::ParameterFXDelay_ShimmerReturn},
+	{"ShR Rtn", EditGlobalParameter, 	0, CMiniDexed::ParameterFXDelay_ReverberatorReturn},
 	{"MainOut", EditGlobalParameter, 	0, CMiniDexed::ParameterFXDelay_MainOutput},
 	{0}
 };
@@ -320,21 +320,21 @@ const CUIMenu::TMenuItem CUIMenu::s_FXPlateReverbReturn[] =
 	{"Orb Rtn", EditGlobalParameter, 	0, CMiniDexed::ParameterFXReverb_OrbitoneReturn},
 	{"PhR Rtn", EditGlobalParameter, 	0, CMiniDexed::ParameterFXReverb_PhaserReturn},
 	{"Del Rtn", EditGlobalParameter, 	0, CMiniDexed::ParameterFXReverb_DelayReturn},
-	{"ShR Rtn", EditGlobalParameter, 	0, CMiniDexed::ParameterFXReverb_ShimmerReturn},
+	{"ShR Rtn", EditGlobalParameter, 	0, CMiniDexed::ParameterFXReverb_ReverberatorReturn},
 	{"MainOut", EditGlobalParameter, 	0, CMiniDexed::ParameterFXReverb_MainOutput},
 	{0}
 };
 
-const CUIMenu::TMenuItem CUIMenu::s_FXShimmerReverbReturn[] =
+const CUIMenu::TMenuItem CUIMenu::s_FXReverberatorReturn[] =
 {
-	{"Tub Rtn", EditGlobalParameter, 	0, CMiniDexed::ParameterFXShimmer_TubeReturn},
-	{"ChR Rtn", EditGlobalParameter, 	0, CMiniDexed::ParameterFXShimmer_ChorusReturn},
-	{"FlR Rtn", EditGlobalParameter, 	0, CMiniDexed::ParameterFXShimmer_FlangerReturn},
-	{"Orb Rtn", EditGlobalParameter, 	0, CMiniDexed::ParameterFXShimmer_OrbitoneReturn},
-	{"PhR Rtn", EditGlobalParameter, 	0, CMiniDexed::ParameterFXShimmer_PhaserReturn},
-	{"Del Rtn", EditGlobalParameter, 	0, CMiniDexed::ParameterFXShimmer_DelayReturn},
-	{"Rev Rtn", EditGlobalParameter, 	0, CMiniDexed::ParameterFXShimmer_ReverbReturn},
-	{"MainOut", EditGlobalParameter, 	0, CMiniDexed::ParameterFXShimmer_MainOutput},
+	{"Tub Rtn", EditGlobalParameter, 	0, CMiniDexed::ParameterFXReverberator_TubeReturn},
+	{"ChR Rtn", EditGlobalParameter, 	0, CMiniDexed::ParameterFXReverberator_ChorusReturn},
+	{"FlR Rtn", EditGlobalParameter, 	0, CMiniDexed::ParameterFXReverberator_FlangerReturn},
+	{"Orb Rtn", EditGlobalParameter, 	0, CMiniDexed::ParameterFXReverberator_OrbitoneReturn},
+	{"PhR Rtn", EditGlobalParameter, 	0, CMiniDexed::ParameterFXReverberator_PhaserReturn},
+	{"Del Rtn", EditGlobalParameter, 	0, CMiniDexed::ParameterFXReverberator_DelayReturn},
+	{"Rev Rtn", EditGlobalParameter, 	0, CMiniDexed::ParameterFXReverberator_ReverbReturn},
+	{"MainOut", EditGlobalParameter, 	0, CMiniDexed::ParameterFXReverberator_MainOutput},
 	{0}
 };
 
@@ -458,12 +458,12 @@ const CUIMenu::TParameter CUIMenu::s_GlobalParameter[CMiniDexed::ParameterUnknow
 	{0,	99,	1},				// ParameterFXDelayFlutterRate
 	{0,	99,	1},				// ParameterFXDelayFlutterAmount
 
-	// FX > ShimmerReverb parameters
-	{0,	1,	1,	ToOnOff},	// ParameterFXShimmerReverbEnable
-	{0,	99,	1},				// ParameterFXShimmerReverbInputGain
-	{0,	99,	1},				// ParameterFXShimmerReverbTime
-	{0,	99,	1},				// ParameterFXShimmerReverbDiffusion
-	{0,	99,	1},				// ParameterFXShimmerReverbLP
+	// FX > Reverberator parameters
+	{0,	1,	1,	ToOnOff},	// ParameterFXReverberatorEnable
+	{0,	99,	1},				// ParameterFXReverberatorInputGain
+	{0,	99,	1},				// ParameterFXReverberatorTime
+	{0,	99,	1},				// ParameterFXReverberatorDiffusion
+	{0,	99,	1},				// ParameterFXReverberatorLP
 
 	// FX > Tube Return parameters
 	{0, 99, 1},				// ParameterFXTube_ChorusReturn,
@@ -472,7 +472,7 @@ const CUIMenu::TParameter CUIMenu::s_GlobalParameter[CMiniDexed::ParameterUnknow
 	{0, 99, 1},				// ParameterFXTube_PhaserReturn,
 	{0, 99, 1},				// ParameterFXTube_DelayReturn,
 	{0, 99, 1},				// ParameterFXTube_ReverbReturn,
-	{0, 99, 1},				// ParameterFXTube_ShimmerReturn,
+	{0, 99, 1},				// ParameterFXTube_ReverberatorReturn,
 	{0, 99, 1},				// ParameterFXTube_MainOutput,
 
 	// FX > Chorus Return parameters
@@ -482,7 +482,7 @@ const CUIMenu::TParameter CUIMenu::s_GlobalParameter[CMiniDexed::ParameterUnknow
 	{0, 99, 1},				// ParameterFXChorus_PhaserReturn,
 	{0, 99, 1},				// ParameterFXChorus_DelayReturn,
 	{0, 99, 1},				// ParameterFXChorus_ReverbReturn,
-	{0, 99, 1},				// ParameterFXChorus_ShimmerReturn,
+	{0, 99, 1},				// ParameterFXChorus_ReverberatorReturn,
 	{0, 99, 1},				// ParameterFXChorus_MainOutput,
 
 	// FX > Flanger Return parameters
@@ -492,7 +492,7 @@ const CUIMenu::TParameter CUIMenu::s_GlobalParameter[CMiniDexed::ParameterUnknow
 	{0, 99, 1},				// ParameterFXFlanger_PhaserReturn,
 	{0, 99, 1},				// ParameterFXFlanger_DelayReturn,
 	{0, 99, 1},				// ParameterFXFlanger_ReverbReturn,
-	{0, 99, 1},				// ParameterFXFlanger_ShimmerReturn,
+	{0, 99, 1},				// ParameterFXFlanger_ReverberatorReturn,
 	{0, 99, 1},				// ParameterFXFlanger_MainOutput,
 
 	// FX > Orbitone Return parameters
@@ -502,7 +502,7 @@ const CUIMenu::TParameter CUIMenu::s_GlobalParameter[CMiniDexed::ParameterUnknow
 	{0, 99, 1},				// ParameterFXOrbitone_PhaserReturn,
 	{0, 99, 1},				// ParameterFXOrbitone_DelayReturn,
 	{0, 99, 1},				// ParameterFXOrbitone_ReverbReturn,
-	{0, 99, 1},				// ParameterFXOrbitone_ShimmerReturn,
+	{0, 99, 1},				// ParameterFXOrbitone_ReverberatorReturn,
 	{0, 99, 1},				// ParameterFXOrbitone_MainOutput,
 
 	// FX > Phaser Return parameters
@@ -512,7 +512,7 @@ const CUIMenu::TParameter CUIMenu::s_GlobalParameter[CMiniDexed::ParameterUnknow
 	{0, 99, 1},				// ParameterFXPhaser_OrbitoneReturn,
 	{0, 99, 1},				// ParameterFXPhaser_DelayReturn,
 	{0, 99, 1},				// ParameterFXPhaser_ReverbReturn,
-	{0, 99, 1},				// ParameterFXPhaser_ShimmerReturn,
+	{0, 99, 1},				// ParameterFXPhaser_ReverberatorReturn,
 	{0, 99, 1},				// ParameterFXPhaser_MainOutput,
 
 	// FX > Delay Return parameters
@@ -522,7 +522,7 @@ const CUIMenu::TParameter CUIMenu::s_GlobalParameter[CMiniDexed::ParameterUnknow
 	{0, 99, 1},				// ParameterFXDelay_OrbitoneReturn,
 	{0, 99, 1},				// ParameterFXDelay_PhaserReturn,
 	{0, 99, 1},				// ParameterFXDelay_ReverbReturn,
-	{0, 99, 1},				// ParameterFXDelay_ShimmerReturn,
+	{0, 99, 1},				// ParameterFXDelay_ReverberatorReturn,
 	{0, 99, 1},				// ParameterFXDelay_MainOutput,
 
 	// FX > Reverb Return parameters
@@ -532,18 +532,18 @@ const CUIMenu::TParameter CUIMenu::s_GlobalParameter[CMiniDexed::ParameterUnknow
 	{0, 99, 1},				// ParameterFXReverb_OrbitoneReturn,
 	{0, 99, 1},				// ParameterFXReverb_PhaserReturn,
 	{0, 99, 1},				// ParameterFXReverb_DelayReturn,
-	{0, 99, 1},				// ParameterFXReverb_ShimmerReturn,
+	{0, 99, 1},				// ParameterFXReverb_ReverberatorReturn,
 	{0, 99, 1},				// ParameterFXReverb_MainOutput,
 
-	// FX > Shimmer Return parameters
-	{0, 99, 1},				// ParameterFXShimmer_TubeReturn,
-	{0, 99, 1},				// ParameterFXShimmer_ChorusReturn,
-	{0, 99, 1},				// ParameterFXShimmer_FlangerReturn,
-	{0, 99, 1},				// ParameterFXShimmer_OrbitoneReturn,
-	{0, 99, 1},				// ParameterFXShimmer_PhaserReturn,
-	{0, 99, 1},				// ParameterFXShimmer_DelayReturn,
-	{0, 99, 1},				// ParameterFXShimmer_ReverbReturn,
-	{0, 99, 1},				// ParameterFXShimmer_MainOutput,
+	// FX > Reverberator Return parameters
+	{0, 99, 1},				// ParameterFXReverberator_TubeReturn,
+	{0, 99, 1},				// ParameterFXReverberator_ChorusReturn,
+	{0, 99, 1},				// ParameterFXReverberator_FlangerReturn,
+	{0, 99, 1},				// ParameterFXReverberator_OrbitoneReturn,
+	{0, 99, 1},				// ParameterFXReverberator_PhaserReturn,
+	{0, 99, 1},				// ParameterFXReverberator_DelayReturn,
+	{0, 99, 1},				// ParameterFXReverberator_ReverbReturn,
+	{0, 99, 1},				// ParameterFXReverberator_MainOutput,
 
 	#endif
 	// END FX global parameters mapping definition

src/uimenu.h

@@ -158,8 +158,8 @@ private:
 #endif
 #ifdef MIXING_CONSOLE_ENABLE
 	static const TMenuItem s_FXPlateReverbReturn[];
-	static const TMenuItem s_FXShimmerReverb[];
-	static const TMenuItem s_FXShimmerReverbReturn[];
+	static const TMenuItem s_FXReverberator[];
+	static const TMenuItem s_FXReverberatorReturn[];
 #endif
 	static const TMenuItem s_EditVoiceMenu[];
 	static const TMenuItem s_OperatorMenu[];