Finalizing the menu integration and wiring to UI

src/fx_flanger.h

@@ -54,8 +54,8 @@ private:
     float32_t lfo_phase_;
     float32_t lfo_phase_increment_;
 
-    float32_t delay_time_ms_;   // Delay time in milliseconds
+    float32_t delay_time_ms_;   // Delay time in milliseconds (0.0 - 10.0)
     float32_t frequency_;       // LFO frequency in HZ (0.1 - 10.0)
-    float32_t depth_;           // Depth of the flanger effect in milliseconds
+    float32_t depth_;           // Depth of the flanger effect in milliseconds (0.0 - 10.0)
     float32_t feedback_;        // Amount of feedback to apply to the delay line
 };

src/fx_orbitone.h

@@ -35,7 +35,7 @@ public:
     inline float32_t getFeedback() const;
 
 private:
-    float32_t feedback_;        // Amount of feedback to apply to the stage's input
+    float32_t feedback_;        // Amount of feedback to apply to the stage's input (0.0 - 1.0)
 };
 
 class OrbitoneStage : public FXElement

src/fx_phaser.cpp

@@ -2,10 +2,10 @@
 
 #include <cmath>
 
-PhaserParameter::PhaserParameter(float32_t sampling_rate, float32_t frequency, float32_t q) :
+PhaserParameter::PhaserParameter(float32_t sampling_rate, float32_t frequency, float32_t resonance) :
     FXBase(sampling_rate),
     frequency_(frequency),
-    q_(q)
+    resonance_(resonance)
 {
     this->computeCoefficients();
 }
@@ -17,7 +17,7 @@ PhaserParameter::~PhaserParameter()
 void PhaserParameter::computeCoefficients()
 {
     float32_t w0 = 2.0f * PI * this->getFrequency() / this->getSamplingRate();
-    float32_t alpha = sin(w0) / (2.0f * this->q_);
+    float32_t alpha = sin(w0) / (2.0f * this->resonance_);
     this->a0 = 1.0f + alpha;
     this->a1 = -2.0f * cos(w0);
     this->a2 = 1.0f - alpha;
@@ -36,15 +36,15 @@ float32_t PhaserParameter::getFrequency() const
     return this->frequency_;
 }
 
-void PhaserParameter::setQ(float32_t q)
+void PhaserParameter::setResonance(float32_t resonance)
 {
-    this->q_ = constrain(q, 0.5f, 10.0f);
+    this->resonance_ = constrain(resonance, 0.5f, 10.0f);
     this->computeCoefficients();
 }
 
-float32_t PhaserParameter::getQ() const
+float32_t PhaserParameter::getResonance() const
 {
-    return this->q_;
+    return this->resonance_;
 }
 
 
@@ -125,12 +125,12 @@ inline float32_t Phaser::getFrequency() const
     return this->params_.getFrequency();
 }
 
-void Phaser::setQ(float32_t q)
+void Phaser::setResonance(float32_t q)
 {
-    this->params_.setQ(q);
+    this->params_.setResonance(q);
 }
 
-inline float32_t Phaser::getQ() const
+inline float32_t Phaser::getResonance() const
 {
-    return this->params_.getQ();
+    return this->params_.getResonance();
 }

src/fx_phaser.h

@@ -34,14 +34,14 @@ public:
     void setFrequency(float32_t frequency);
     inline float32_t getFrequency() const;
 
-    void setQ(float32_t q);
-    inline float32_t getQ() const;
+    void setResonance(float32_t q);
+    inline float32_t getResonance() const;
 
 private:
     void computeCoefficients();
 
-    float32_t frequency_;           // LFO frequency in Hz
-    float32_t q_;                   // Q factor for the filters
+    float32_t frequency_;           // LFO frequency in Hz (0.01 - 5.0)
+    float32_t resonance_;           // Resonance factor for the filters (0.5 - 10.0)
 
     float32_t a0, a1, a2, b1, b2;   // Coefficients for the stage's filter
 };
@@ -67,7 +67,7 @@ class Phaser : public FXElement
     DISALLOW_COPY_AND_ASSIGN(Phaser);
 
 public:
-    Phaser(float32_t sampling_rate, float32_t frequency = 0.5f, float32_t q = 1.0f);
+    Phaser(float32_t sampling_rate, float32_t frequency = 0.5f, float32_t resonance = 1.0f);
     virtual ~Phaser();
 
     virtual void processSample(float32_t inL, float32_t inR, float32_t& outL, float32_t& outR) override;
@@ -75,12 +75,12 @@ public:
     void setFrequency(float32_t frequency);
     float32_t getFrequency() const;
 
-    void setQ(float32_t q);
-    float32_t getQ() const;
+    void setResonance(float32_t resonance);
+    float32_t getResonance() const;
 
 private:
     PhaserParameter params_;
-    float32_t phase_;           // Current phase of the LFO
+    float32_t phase_;           // Current phase of the LFO (0.01 - 5.0)
     float32_t phase_increment_; // Amount to increment the phase at each sample
     PhaserStage* stages_[NUM_PHASER_STAGES];
 };

src/fx_rack.cpp

@@ -2,10 +2,11 @@
 
 #include <cassert>
 
-FXRack::FXRack(float32_t sampling_rate, bool enable) :
+FXRack::FXRack(float32_t sampling_rate, bool enable, float32_t wet) :
     FX(sampling_rate),
     FXElement(sampling_rate),
     enable_(enable),
+    wet_level_(wet),
     fx_chain_(sampling_rate)
 {
     this->fxTube_ = new FXUnit<Tube>(sampling_rate);
@@ -27,10 +28,6 @@ FXRack::FXRack(float32_t sampling_rate, bool enable) :
 
 FXRack::~FXRack()
 {
-    for(FXChain::iterator it = this->fx_chain_.begin(); it != this->fx_chain_.end(); it++)
-    {
-        delete *it;
-    }
     this->fx_chain_.clear();
 
     delete this->fxTube_;
@@ -100,6 +97,16 @@ bool FXRack::isEnable() const
     return this->enable_;
 }
 
+void FXRack::setWetLevel(float32_t wet_level)
+{
+    this->wet_level_ = constrain(wet_level, 0.0f, 1.0f);
+}
+
+float32_t FXRack::getWetLevel() const
+{
+    return this->wet_level_;
+}
+
 void FXRack::registerFX(FXElement* fx)
 {
     assert(fx);

src/fx_rack.h

@@ -95,7 +95,7 @@ class FXRack : virtual public FX, virtual public FXElement
     DISALLOW_COPY_AND_ASSIGN(FXRack);
 
 public:
-    FXRack(float32_t sampling_rate, bool enable = true);
+    FXRack(float32_t sampling_rate, bool enable = true, float32_t wet = 1.0f);
     virtual ~FXRack();
 
     virtual void processSample(float32_t inL, float32_t inR, float32_t& outL, float32_t& outR) override;
@@ -104,6 +104,9 @@ public:
     void setEnable(bool enable = true);
     bool isEnable() const;
 
+    void setWetLevel(float32_t wet_level);
+    float32_t getWetLevel() const;
+
     FXUnit<Tube>* getTube();
     FXUnit<Chorus>* getChorus();
     FXUnit<Flanger>* getFlanger();
@@ -116,6 +119,7 @@ private:
     void registerFX(FXElement* fx);
 
     bool enable_;
+    float32_t wet_level_;
 
     FXChain fx_chain_;
     FXUnit<Tube>* fxTube_;

src/fx_shimmer_reverb.cpp

@@ -9,7 +9,7 @@ ShimmerReverb::ShimmerReverb(float32_t sampling_rate,
                              float32_t shimmer_frequency,
                              float32_t shimmer_amplitude,
                              float32_t decay_time) : FXElement(sampling_rate),
-                                                     DelayLineLength(static_cast<unsigned>(SHIMMER_MAX_DELAY_TIME * sampling_rate)),
+                                                     DelayLineLength(static_cast<unsigned>(2.0f * SHIMMER_MAX_DELAY_TIME * sampling_rate)),
                                                      write_pos_L_(0),
                                                      write_pos_R_(0),
                                                      shimmer_phase_(0.0f)
@@ -40,12 +40,8 @@ void ShimmerReverb::processSample(float32_t inL, float32_t inR, float32_t& outL,
     float32_t shimmerOffsetR = this->getShimmerAmplitude() * cos(this->shimmer_phase_ * 2.0f * PI);
 
     // Calculate read position for left and right channel delay lines
-    int readPosL = this->write_pos_L_ - (int)(this->delay_time_L_ * this->getSamplingRate()) - (int)(shimmerOffsetL * this->getSamplingRate());
-    int readPosR = this->write_pos_R_ - (int)(this->delay_time_R_ * this->getSamplingRate()) - (int)(shimmerOffsetR * this->getSamplingRate());
-
-    // Wrap read position around the end of the delay line if necessary
-    if(readPosL < 0) readPosL += this->DelayLineLength;
-    if(readPosR < 0) readPosR += this->DelayLineLength;
+    unsigned readPosL = static_cast<unsigned>(this->DelayLineLength + this->write_pos_L_ - (this->delay_time_L_ + shimmerOffsetL) * this->getSamplingRate()) % this->DelayLineLength;
+    unsigned readPosR = static_cast<unsigned>(this->DelayLineLength + this->write_pos_R_ - (this->delay_time_R_ + shimmerOffsetR) * this->getSamplingRate()) % this->DelayLineLength;
 
     // Read32_t left and right channel delay line samples
     float32_t delaySampleL = this->delay_line_L_[readPosL];

src/fx_tape_delay.cpp

@@ -5,14 +5,15 @@
 
 TapeDelay::TapeDelay(const float32_t sampling_rate, float32_t default_delay_time, float32_t default_flutter_level, float32_t default_feedback_level) :
     FXElement(sampling_rate),
-    MaxSampleDelayTime(sampling_rate * MAX_DELAY_TIME),
+    MaxSampleDelayTime(2.0f * sampling_rate * MAX_DELAY_TIME),
     left_read_pos_(0),
     right_read_pos_(0)
 {
     this->left_buffer_ = new float32_t[this->MaxSampleDelayTime];
     this->right_buffer_ = new float32_t[this->MaxSampleDelayTime];
 
-    this->setDelayTime(default_delay_time);
+    this->setLeftDelayTime(default_delay_time);
+    this->setRightDelayTime(default_delay_time);
     this->setFlutterLevel(default_flutter_level);
     this->setFeedbakLevel(default_feedback_level);
 }
@@ -26,20 +27,14 @@ TapeDelay::~TapeDelay()
 void TapeDelay::processSample(float32_t inL, float32_t inR, float32_t& outL, float32_t& outR)
 {
     // calculate the fluttered delay time
-    float32_t fluttered_delay_time = this->getDelayTime() + this->getFlutteredDelayTime();
-
+    float32_t fluttered_delay_time_L = (MAX_DELAY_TIME * this->getLeftDelayTime() + this->getFlutteredDelayTime()) * this->getSamplingRate();
     // Calculate write positions
-    int left_write_pos = this->left_read_pos_ - static_cast<int>(fluttered_delay_time);
-    while(left_write_pos < 0)
-    {
-        left_write_pos += this->MaxSampleDelayTime;
-    }
+    int left_write_pos = (this->MaxSampleDelayTime + this->left_read_pos_ - static_cast<int>(fluttered_delay_time_L)) % this->MaxSampleDelayTime;
 
-    int right_write_pos = this->right_read_pos_ - static_cast<int>(fluttered_delay_time);
-    while(right_write_pos < 0)
-    {
-        right_write_pos += this->MaxSampleDelayTime;
-    }
+    // calculate the fluttered delay time
+    float32_t fluttered_delay_time_R = (MAX_DELAY_TIME * this->getRightDelayTime() + this->getFlutteredDelayTime()) * this->getSamplingRate();
+    // Calculate write positions
+    int right_write_pos = (this->MaxSampleDelayTime + this->right_read_pos_ - static_cast<int>(fluttered_delay_time_R)) % this->MaxSampleDelayTime;
 
     // Write input to delay buffers
     this->left_buffer_[left_write_pos] = inL;
@@ -64,19 +59,29 @@ void TapeDelay::processSample(float32_t inL, float32_t inR, float32_t& outL, flo
     }
 }
 
-void TapeDelay::setDelayTime(float32_t delay_time)
+void TapeDelay::setLeftDelayTime(float32_t delay_time)
+{
+    this->left_delay_time_ = constrain(delay_time, 0.0f, 1.0f);
+}
+
+float32_t TapeDelay::getLeftDelayTime() const
+{
+    return this->left_delay_time_;
+}
+
+void TapeDelay::setRightDelayTime(float32_t delay_time)
 {
-    this->delay_time_ = constrain(delay_time, 0.0f, 1.0f);
+    this->right_delay_time_ = constrain(delay_time, 0.0f, 1.0f);
 }
 
-float32_t TapeDelay::getDelayTime() const
+float32_t TapeDelay::getRightDelayTime() const
 {
-    return this->delay_time_;
+    return this->right_delay_time_;
 }
 
 void TapeDelay::setFlutterLevel(float32_t flutter_level)
 {
-    this->flutter_level_ = constrain(flutter_level, 0.0f, 1.0f); 
+    this->flutter_level_ = constrain(flutter_level, 0.0f, 0.1f); 
 }
 
 float32_t TapeDelay::getFlutterLevel() const

src/fx_tape_delay.h

@@ -23,7 +23,7 @@
 
 #include <random>
 
-#define MAX_DELAY_TIME 2
+#define MAX_DELAY_TIME 2.0f
 
 class TapeDelay : public FXElement
 {
@@ -35,8 +35,11 @@ public:
 
     virtual void processSample(float32_t inL, float32_t inR, float32_t& outL, float32_t& outR) override;
 
-    void setDelayTime(float32_t delay_time);
-    float32_t getDelayTime() const;
+    void setLeftDelayTime(float32_t delay_time);
+    float32_t getLeftDelayTime() const;
+
+    void setRightDelayTime(float32_t delay_time);
+    float32_t getRightDelayTime() const;
 
     void setFlutterLevel(float32_t flutter_level);
     float32_t getFlutterLevel() const;
@@ -53,8 +56,9 @@ private:
     size_t right_read_pos_;
     float32_t* left_buffer_;
     float32_t* right_buffer_;
-    float32_t delay_time_;
-    float32_t flutter_level_;
-    float32_t feedback_;
+    float32_t left_delay_time_;         // Left delay time in seconds (0.0 - 2.0)
+    float32_t right_delay_time_;        // Right delay time in seconds (0.0 - 2.0)
+    float32_t flutter_level_;           // Flutter level (0.0 - 0.1)
+    float32_t feedback_;                // Feedback (0.0 - 1.0)
     std::mt19937 random_generator_;
 };

src/minidexed.cpp

@@ -156,13 +156,65 @@ CMiniDexed::CMiniDexed (CConfig *pConfig, CInterruptSystem *pInterrupt,
 	SetParameter (ParameterReverbLevel, 99);
 	// END setup reverb
 
+	SetParameter (ParameterCompressorEnable, 1);
+
 	// BEGIN setup FXRack
 #ifdef ARM_ALLOW_MULTI_CORE
 	this->fx_rack = new FXRack(static_cast<float32_t>(pConfig->GetSampleRate()));
+
+	// FXChain parameters
+	this->SetParameter(ParameterFXChainEnable, 1);
+	this->SetParameter(ParameterFXChainWet, 99);
+
+	// FXChain > Tube parameters
+	this->SetParameter(ParameterFXChainTubeEnable, 1);
+	this->SetParameter(ParameterFXChainTubeWet, 50);
+	this->SetParameter(ParameterFXChainTubeOverdrive, 10);
+
+	// FXChain > Chorus parameters
+	this->SetParameter(ParameterFXChainChorusEnable, 1);
+	this->SetParameter(ParameterFXChainChorusWet, 50);
+	this->SetParameter(ParameterFXChainChorusRate, 15);
+	this->SetParameter(ParameterFXChainChorusDepth, 10);
+	this->SetParameter(ParameterFXChainChorusFeedback, 20);
+	
+	// FXChain > Flanger parameters
+	this->SetParameter(ParameterFXChainFlangerEnable, 1);
+	this->SetParameter(ParameterFXChainFlangerWet, 50);
+	this->SetParameter(ParameterFXChainFlangerDelayTime, 10);
+	this->SetParameter(ParameterFXChainFlangerRate, 15);
+	this->SetParameter(ParameterFXChainFlangerDepth, 10);
+	this->SetParameter(ParameterFXChainFlangerFeedback, 20);
+
+	// FXChain > Orbitone parameters
+	this->SetParameter(ParameterFXChainOrbitoneEnable, 1);
+	this->SetParameter(ParameterFXChainOrbitoneWet, 50);
+	this->SetParameter(ParameterFXChainOrbitoneFeedback, 65);
+
+	// FXChain > Phaser parameters
+	this->SetParameter(ParameterFXChainPhaserEnable, 1);
+	this->SetParameter(ParameterFXChainPhaserWet, 50);
+	this->SetParameter(ParameterFXChainPhaserRate, 5);
+	this->SetParameter(ParameterFXChainPhaserResonance, 45);
+
+	// FXChain > TapeDelay parameters
+	this->SetParameter(ParameterFXChainTapeDelayEnable, 1);
+	this->SetParameter(ParameterFXChainTapeDelayWet, 50);
+	this->SetParameter(ParameterFXChainTapeDelayLeftDelayTime, 15);
+	this->SetParameter(ParameterFXChainTapeDelayRightDelayTime, 22);
+	this->SetParameter(ParameterFXChainTapeDelayFlutter, 7);
+	this->SetParameter(ParameterFXChainTapeDelayFeedback, 35);
+
+	// FXChain > ShimmerReverb parameters
+	this->SetParameter(ParameterFXChainShimmerReverbEnable, 1);
+	this->SetParameter(ParameterFXChainShimmerReverbWet, 70);
+	this->SetParameter(ParameterFXChainShimmerReverbDelayTimeLeft, 15);
+	this->SetParameter(ParameterFXChainShimmerReverbDelayTimeRight, 22);
+	this->SetParameter(ParameterFXChainShimmerReverbFrequency, 20);
+	this->SetParameter(ParameterFXChainShimmerReverbAmplitude, 15);
+	this->SetParameter(ParameterFXChainShimmerReverbDecayTime,	65);
 #endif
 	// END setup FXRack
-
-	SetParameter (ParameterCompressorEnable, 1);
 };
 
 bool CMiniDexed::Initialize (void)
@@ -205,16 +257,20 @@ bool CMiniDexed::Initialize (void)
 		reverb_send_mixer->pan(i,mapfloat(m_nPan[i],0,127,0.0f,1.0f));
 		reverb_send_mixer->gain(i,mapfloat(m_nReverbSend[i],0,99,0.0f,1.0f));
 	}
+this->m_UI.LCDWrite("Initialize: before perf loading");
 
 	if (m_PerformanceConfig.Load ())
 	{
+this->m_UI.LCDWrite("Initialize: load perf");
 		LoadPerformanceParameters(); 
+this->m_UI.LCDWrite("Initialize: load perf done");
 	}
 	else
 	{
 		SetMIDIChannel (CMIDIDevice::OmniMode, 0);
 	}
-	
+this->m_UI.LCDWrite("Initialize: done");
+
 	// load performances file list, and attempt to create the performance folder
 	if (!m_PerformanceConfig.ListPerformances()) 
 	{
@@ -632,6 +688,7 @@ void CMiniDexed::SetParameter (TParameter Parameter, int nValue)
 
 	assert (Parameter < ParameterUnknown);
 	m_nParameter[Parameter] = nValue;
+	float32_t fValue = 0.0f;
 
 	switch (Parameter)
 	{
@@ -645,169 +702,312 @@ void CMiniDexed::SetParameter (TParameter Parameter, int nValue)
 
 	case ParameterReverbEnable:
 		nValue=constrain((int)nValue,0,1);
-		m_ReverbSpinLock.Acquire ();
+		m_FXSpinLock.Acquire ();
 		reverb->set_bypass (!nValue);
-		m_ReverbSpinLock.Release ();
+		m_FXSpinLock.Release ();
 		break;
 
 	case ParameterReverbSize:
 		nValue=constrain((int)nValue,0,99);
-		m_ReverbSpinLock.Acquire ();
+		m_FXSpinLock.Acquire ();
 		reverb->size (nValue / 99.0f);
-		m_ReverbSpinLock.Release ();
+		m_FXSpinLock.Release ();
 		break;
 
 	case ParameterReverbHighDamp:
 		nValue=constrain((int)nValue,0,99);
-		m_ReverbSpinLock.Acquire ();
+		m_FXSpinLock.Acquire ();
 		reverb->hidamp (nValue / 99.0f);
-		m_ReverbSpinLock.Release ();
+		m_FXSpinLock.Release ();
 		break;
 
 	case ParameterReverbLowDamp:
 		nValue=constrain((int)nValue,0,99);
-		m_ReverbSpinLock.Acquire ();
+		m_FXSpinLock.Acquire ();
 		reverb->lodamp (nValue / 99.0f);
-		m_ReverbSpinLock.Release ();
+		m_FXSpinLock.Release ();
 		break;
 
 	case ParameterReverbLowPass:
 		nValue=constrain((int)nValue,0,99);
-		m_ReverbSpinLock.Acquire ();
+		m_FXSpinLock.Acquire ();
 		reverb->lowpass (nValue / 99.0f);
-		m_ReverbSpinLock.Release ();
+		m_FXSpinLock.Release ();
 		break;
 
 	case ParameterReverbDiffusion:
 		nValue=constrain((int)nValue,0,99);
-		m_ReverbSpinLock.Acquire ();
+		m_FXSpinLock.Acquire ();
 		reverb->diffusion (nValue / 99.0f);
-		m_ReverbSpinLock.Release ();
+		m_FXSpinLock.Release ();
 		break;
 
 	case ParameterReverbLevel:
 		nValue=constrain((int)nValue,0,99);
-		m_ReverbSpinLock.Acquire ();
+		m_FXSpinLock.Acquire ();
 		reverb->level (nValue / 99.0f);
-		m_ReverbSpinLock.Release ();
+		m_FXSpinLock.Release ();
 		break;
 
 #ifdef ARM_ALLOW_MULTI_CORE
 	// BEGIN FXChain parameters
 	case ParameterFXChainEnable: 
+		nValue = constrain((int)nValue, 0, 1);
+		this->m_FXSpinLock.Acquire();
+		this->setFXChainEnable(!!nValue);
+		this->m_FXSpinLock.Release();
+		break;
+	case ParameterFXChainWet: 
+		nValue = constrain((int)nValue, 0, 99);
+		fValue = mapfloat(nValue, 0, 99, 0.0f, 1.0f);
+		this->m_FXSpinLock.Acquire();
+		this->setFXChainWet(fValue);
+		this->m_FXSpinLock.Release();
 		break;
 	
 	// FXChain > Tube parameters
 	case ParameterFXChainTubeEnable: 
-		this->setFXChainTubeEnable(0);
+		nValue = constrain((int)nValue, 0, 1);
+		this->m_FXSpinLock.Acquire();
+		this->setFXChainTubeEnable(!!nValue);
+		this->m_FXSpinLock.Release();
 		break;
 	case ParameterFXChainTubeWet: 
-		this->setFXChainTubeWet(0);
+		nValue = constrain((int)nValue, 0, 99);
+		fValue = mapfloat(nValue, 0, 99, 0.0f, 1.0f);
+		this->m_FXSpinLock.Acquire();
+		this->setFXChainTubeWet(fValue);
+		this->m_FXSpinLock.Release();
 		break;
 	case ParameterFXChainTubeOverdrive: 
-		this->setFXChainTubeOverdrive(0);
+		nValue = constrain((int)nValue, 0, 99);
+		fValue = mapfloat(nValue, 0, 99, 0.0f, 1.0f);
+		this->m_FXSpinLock.Acquire();
+		this->setFXChainTubeOverdrive(fValue);
+		this->m_FXSpinLock.Release();
 		break;
 	
 	// FXChain > Chorus parameters
 	case ParameterFXChainChorusEnable: 
-		this->setFXChainChorusEnable(0);
+		nValue = constrain((int)nValue, 0, 1);
+		this->m_FXSpinLock.Acquire();
+		this->setFXChainChorusEnable(!!nValue);
+		this->m_FXSpinLock.Release();
 		break;
 	case ParameterFXChainChorusWet: 
-		this->setFXChainChorusWet(0);
+		nValue = constrain((int)nValue, 0, 99);
+		fValue = mapfloat(nValue, 0, 99, 0.0f, 1.0f);
+		this->m_FXSpinLock.Acquire();
+		this->setFXChainChorusWet(fValue);
+		this->m_FXSpinLock.Release();
 		break;
 	case ParameterFXChainChorusRate: 
-		this->setFXChainChorusRate(0);
+		nValue = constrain((int)nValue, 0, 99);
+		fValue = mapfloat(nValue, 0, 99, 0.1f, 1.0f);
+		this->m_FXSpinLock.Acquire();
+		this->setFXChainChorusRate(fValue);
+		this->m_FXSpinLock.Release();
 		break;
 	case ParameterFXChainChorusDepth: 
-		this->setFXChainChorusDepth(0);
+		nValue = constrain((int)nValue, 0, 99);
+		fValue = mapfloat(nValue, 0, 99, 0.0f, 10.0f);
+		this->m_FXSpinLock.Acquire();
+		this->setFXChainChorusDepth(fValue);
+		this->m_FXSpinLock.Release();
 		break;
 	case ParameterFXChainChorusFeedback: 
-		this->setFXChainChorusFeedback(0);
+		nValue = constrain((int)nValue, 0, 99);
+		fValue = mapfloat(nValue, 0, 99, 0.0f, 1.0f);
+		this->m_FXSpinLock.Acquire();
+		this->setFXChainChorusFeedback(fValue);
+		this->m_FXSpinLock.Release();
 		break;
 	
 	// FXChain > Flanger parameters
 	case ParameterFXChainFlangerEnable: 
-		this->setFXChainFlangerEnable(0);
+		nValue = constrain((int)nValue, 0, 1);
+		this->m_FXSpinLock.Acquire();
+		this->setFXChainFlangerEnable(!!nValue);
+		this->m_FXSpinLock.Release();
 		break;
 	case ParameterFXChainFlangerWet: 
-		this->setFXChainFlangerWet(0);
+		nValue = constrain((int)nValue, 0, 99);
+		fValue = mapfloat(nValue, 0, 99, 0.0f, 1.0f);
+		this->m_FXSpinLock.Acquire();
+		this->setFXChainFlangerWet(fValue);
+		this->m_FXSpinLock.Release();
 		break;
 	case ParameterFXChainFlangerDelayTime: 
-		this->setFXChainFlangerDelayTime(0);
+		nValue = constrain((int)nValue, 0, 99);
+		fValue = mapfloat(nValue, 0, 99, 0.0f, 10.0f);
+		this->m_FXSpinLock.Acquire();
+		this->setFXChainFlangerDelayTime(fValue);
+		this->m_FXSpinLock.Release();
 		break;
 	case ParameterFXChainFlangerRate: 
-		this->setFXChainFlangerRate(0);
+		nValue = constrain((int)nValue, 0, 99);
+		fValue = mapfloat(nValue, 0, 99, 0.1f, 10.0f);
+		this->m_FXSpinLock.Acquire();
+		this->setFXChainFlangerRate(fValue);
+		this->m_FXSpinLock.Release();
 		break;
 	case ParameterFXChainFlangerDepth: 
-		this->setFXChainFlangerDepth(0);
+		nValue = constrain((int)nValue, 0, 99);
+		fValue = mapfloat(nValue, 0, 99, 0.0f, 10.0f);
+		this->m_FXSpinLock.Acquire();
+		this->setFXChainFlangerDepth(fValue);
+		this->m_FXSpinLock.Release();
 		break;
 	case ParameterFXChainFlangerFeedback: 
-		this->setFXChainFlangerFeedback(0);
+		nValue = constrain((int)nValue, 0, 99);
+		fValue = mapfloat(nValue, 0, 99, 0.0f, 1.0f);
+		this->m_FXSpinLock.Acquire();
+		this->setFXChainFlangerFeedback(fValue);
+		this->m_FXSpinLock.Release();
 		break;
 	
 	// FXChain > Orbitone parameters
 	case ParameterFXChainOrbitoneEnable: 
-		this->setFXChainOrbitoneEnable(0);
+		nValue = constrain((int)nValue, 0, 1);
+		this->m_FXSpinLock.Acquire();
+		this->setFXChainOrbitoneEnable(!!nValue);
+		this->m_FXSpinLock.Release();
 		break;
 	case ParameterFXChainOrbitoneWet: 
-		this->setFXChainOrbitoneWet(0);
+		nValue = constrain((int)nValue, 0, 99);
+		fValue = mapfloat(nValue, 0, 99, 0.0f, 1.0f);
+		this->m_FXSpinLock.Acquire();
+		this->setFXChainOrbitoneWet(fValue);
+		this->m_FXSpinLock.Release();
 		break;
 	case ParameterFXChainOrbitoneFeedback: 
-		this->setFXChainOrbitoneFeedback(0);
+		nValue = constrain((int)nValue, 0, 99);
+		fValue = mapfloat(nValue, 0, 99, 0.0f, 1.0f);
+		this->m_FXSpinLock.Acquire();
+		this->setFXChainOrbitoneFeedback(fValue);
+		this->m_FXSpinLock.Release();
 		break;
 	
 	// FXChain > Phaser parameters
 	case ParameterFXChainPhaserEnable: 
-		this->setFXChainPhaserEnable(0);
+		nValue = constrain((int)nValue, 0, 1);
+		this->m_FXSpinLock.Acquire();
+		this->setFXChainPhaserEnable(!!nValue);
+		this->m_FXSpinLock.Release();
 		break;
 	case ParameterFXChainPhaserWet: 
-		this->setFXChainPhaserWet(0);
+		nValue = constrain((int)nValue, 0, 99);
+		fValue = mapfloat(nValue, 0, 99, 0.0f, 1.0f);
+		this->m_FXSpinLock.Acquire();
+		this->setFXChainPhaserWet(fValue);
+		this->m_FXSpinLock.Release();
 		break;
 	case ParameterFXChainPhaserRate: 
-		this->setFXChainPhaserRate(0);
+		nValue = constrain((int)nValue, 0, 99);
+		fValue = mapfloat(nValue, 0, 99, 0.01f, 5.0f);
+		this->m_FXSpinLock.Acquire();
+		this->setFXChainPhaserRate(fValue);
+		this->m_FXSpinLock.Release();
 		break;
-	case ParameterFXChainPhaserQ: 
-		this->setFXChainPhaserQ(0);
+	case ParameterFXChainPhaserResonance: 
+		nValue = constrain((int)nValue, 0, 99);
+		fValue = mapfloat(nValue, 0, 99, 0.5f, 10.0f);
+		this->m_FXSpinLock.Acquire();
+		this->setFXChainPhaserResonance(fValue);
+		this->m_FXSpinLock.Release();
 		break;
 	
 	// FXChain > TapeDelay parameters
 	case ParameterFXChainTapeDelayEnable: 
-		this->setFXChainTapeDelayEnable(0);
+		nValue = constrain((int)nValue, 0, 1);
+		this->m_FXSpinLock.Acquire();
+		this->setFXChainTapeDelayEnable(!!nValue);
+		this->m_FXSpinLock.Release();
 		break;
 	case ParameterFXChainTapeDelayWet: 
-		this->setFXChainTapeDelayWet(0);
+		nValue = constrain((int)nValue, 0, 99);
+		fValue = mapfloat(nValue, 0, 99, 0.0f, 1.0f);
+		this->m_FXSpinLock.Acquire();
+		this->setFXChainTapeDelayWet(fValue);
+		this->m_FXSpinLock.Release();
+		break;
+	case ParameterFXChainTapeDelayLeftDelayTime: 
+		nValue = constrain((int)nValue, 0, 99);
+		fValue = mapfloat(nValue, 0, 99, 0.0f, 1.0f);
+		this->m_FXSpinLock.Acquire();
+		this->setFXChainTapeDelayLeftDelayTime(0);
+		this->m_FXSpinLock.Release();
 		break;
-	case ParameterFXChainTapeDelayDelayTime: 
-		this->setFXChainTapeDelayDelayTime(0);
+	case ParameterFXChainTapeDelayRightDelayTime: 
+		nValue = constrain((int)nValue, 0, 99);
+		fValue = mapfloat(nValue, 0, 99, 0.0f, 1.0f);
+		this->m_FXSpinLock.Acquire();
+		this->setFXChainTapeDelayRightDelayTime(0);
+		this->m_FXSpinLock.Release();
 		break;
 	case ParameterFXChainTapeDelayFlutter: 
-		this->setFXChainTapeDelayFlutter(0);
+		nValue = constrain((int)nValue, 0, 99);
+		fValue = mapfloat(nValue, 0, 99, 0.0f, 0.1f);
+		this->m_FXSpinLock.Acquire();
+		this->setFXChainTapeDelayFlutter(fValue);
+		this->m_FXSpinLock.Release();
 		break;
 	case ParameterFXChainTapeDelayFeedback: 
-		this->setFXChainTapeDelayFeedback(0);
+		nValue = constrain((int)nValue, 0, 99);
+		fValue = mapfloat(nValue, 0, 99, 0.0f, 1.0f);
+		this->m_FXSpinLock.Acquire();
+		this->setFXChainTapeDelayFeedback(fValue);
+		this->m_FXSpinLock.Release();
 		break;
 	
 	// FXChain > ShimmerReverb parameters
 	case ParameterFXChainShimmerReverbEnable: 
-		this->setFXChainShimmerReverbEnable(0);
+		nValue = constrain((int)nValue, 0, 1);
+		this->m_FXSpinLock.Acquire();
+		this->setFXChainShimmerReverbEnable(!!nValue);
+		this->m_FXSpinLock.Release();
 		break;
 	case ParameterFXChainShimmerReverbWet: 
-		this->setFXChainShimmerReverbWet(0);
+		nValue = constrain((int)nValue, 0, 99);
+		fValue = mapfloat(nValue, 0, 99, 0.0f, 1.0f);
+		this->m_FXSpinLock.Acquire();
+		this->setFXChainShimmerReverbWet(fValue);
+		this->m_FXSpinLock.Release();
 		break;
 	case ParameterFXChainShimmerReverbDelayTimeLeft: 
-		this->setFXChainShimmerReverbDelayTimeLeft(0);
+		nValue = constrain((int)nValue, 0, 99);
+		fValue = mapfloat(nValue, 0, 99, 0.0f, 2.0f);
+		this->m_FXSpinLock.Acquire();
+		this->setFXChainShimmerReverbDelayTimeLeft(fValue);
+		this->m_FXSpinLock.Release();
 		break;
 	case ParameterFXChainShimmerReverbDelayTimeRight: 
-		this->setFXChainShimmerReverbDelayTimeRight(0);
+		nValue = constrain((int)nValue, 0, 99);
+		fValue = mapfloat(nValue, 0, 99, 0.0f, 2.0f);
+		this->m_FXSpinLock.Acquire();
+		this->setFXChainShimmerReverbDelayTimeRight(fValue);
+		this->m_FXSpinLock.Release();
 		break;
 	case ParameterFXChainShimmerReverbFrequency: 
-		this->setFXChainShimmerReverbFrequency(0);
+		nValue = constrain((int)nValue, 0, 99);
+		fValue = mapfloat(nValue, 0, 99, 0.0f, static_cast<float32_t>(this->m_pConfig->GetSampleRate() >> 1));
+		this->m_FXSpinLock.Acquire();
+		this->setFXChainShimmerReverbFrequency(fValue);
+		this->m_FXSpinLock.Release();
 		break;
 	case ParameterFXChainShimmerReverbAmplitude: 
-		this->setFXChainShimmerReverbAmplitude(0);
+		nValue = constrain((int)nValue, 0, 99);
+		fValue = mapfloat(nValue, 0, 99, 0.0f, 1.0f);
+		this->m_FXSpinLock.Acquire();
+		this->setFXChainShimmerReverbAmplitude(fValue);
+		this->m_FXSpinLock.Release();
 		break;
 	case ParameterFXChainShimmerReverbDecayTime: 
-		this->setFXChainShimmerReverbDecayTime(0);
+		nValue = constrain((int)nValue, 0, 99);
+		fValue = mapfloat(nValue, 0, 99, 0.0f, 2.0f);
+		this->m_FXSpinLock.Acquire();
+		this->setFXChainShimmerReverbDecayTime(fValue);
+		this->m_FXSpinLock.Release();
 		break;
 	// END FXChain parameters
 #endif
@@ -1113,9 +1313,9 @@ void CMiniDexed::ProcessSound (void)
 				arm_fill_f32(0.0f, ReverbSendBuffer[indexR], nFrames);
 				arm_fill_f32(0.0f, ReverbSendBuffer[indexL], nFrames);
 	
-				m_ReverbSpinLock.Acquire ();
+				m_FXSpinLock.Acquire ();
 	
-       		         	reverb_send_mixer->getMix(ReverbSendBuffer[indexL], ReverbSendBuffer[indexR]);
+				reverb_send_mixer->getMix(ReverbSendBuffer[indexL], ReverbSendBuffer[indexR]);
 				reverb->doReverb(ReverbSendBuffer[indexL],ReverbSendBuffer[indexR],ReverbBuffer[indexL], ReverbBuffer[indexR],nFrames);
 	
 				// scale down and add left reverb buffer by reverb level 
@@ -1125,23 +1325,45 @@ void CMiniDexed::ProcessSound (void)
 				arm_scale_f32(ReverbBuffer[indexR], reverb->get_level(), ReverbBuffer[indexR], nFrames);
 				arm_add_f32(SampleBuffer[indexR], ReverbBuffer[indexR], SampleBuffer[indexR], nFrames);
 	
-				m_ReverbSpinLock.Release ();
+				m_FXSpinLock.Release ();
 			}
 			// END adding reverb
 	
 			// BEGIN adding FXRack
-			if(this->fx_rack->isEnable())
+			if(this->fx_rack->isEnable() && this->fx_rack->getWetLevel() > 0.0f) 
 			{
-				float32_t FXRackBuffer[2][nFrames];
-				float32_t FXRackSendBuffer[2][nFrames];
+				// scale down and add left FXRack buffer by reverb level 
+				if(this->fx_rack->getWetLevel() == 1.0f)
+				{
+					this->m_FXSpinLock.Acquire();
+					this->fx_rack->process(SampleBuffer[indexL], SampleBuffer[indexR], SampleBuffer[indexL], SampleBuffer[indexR], nFrames);
+					this->m_FXSpinLock.Release();
+				}
+				else
+				{
+					float32_t DryFXRackSendBuffer[2][nFrames];
+					float32_t WetFXRackBuffer[2][nFrames];
+					arm_fill_f32(0.0f, DryFXRackSendBuffer[indexR], nFrames);
+					arm_fill_f32(0.0f, DryFXRackSendBuffer[indexL], nFrames);
+					arm_fill_f32(0.0f, WetFXRackBuffer[indexL], nFrames);
+					arm_fill_f32(0.0f, WetFXRackBuffer[indexR], nFrames);
+
+					this->m_FXSpinLock.Acquire();
+
+					this->fx_rack->process(SampleBuffer[indexL], SampleBuffer[indexR], WetFXRackBuffer[indexL], WetFXRackBuffer[indexR], nFrames);
 
-				arm_fill_f32(0.0f, FXRackBuffer[indexL], nFrames);
-				arm_fill_f32(0.0f, FXRackBuffer[indexR], nFrames);
-				arm_fill_f32(0.0f, FXRackSendBuffer[indexR], nFrames);
-				arm_fill_f32(0.0f, FXRackSendBuffer[indexL], nFrames);
+					// scale down and add left FXRack buffer by reverb level 
+					arm_scale_f32(WetFXRackBuffer[indexL], this->fx_rack->getWetLevel(), WetFXRackBuffer[indexL], nFrames);
+					arm_scale_f32(SampleBuffer[indexL], 1.0f - this->fx_rack->getWetLevel(), DryFXRackSendBuffer[indexL], nFrames);
+					arm_add_f32(DryFXRackSendBuffer[indexL], WetFXRackBuffer[indexL], SampleBuffer[indexL], nFrames);
 
-				this->reverb_send_mixer->getMix(FXRackSendBuffer[indexL], FXRackSendBuffer[indexR]);
-				this->fx_rack->process(FXRackSendBuffer[indexL], FXRackSendBuffer[indexR], FXRackBuffer[indexL], FXRackBuffer[indexR], nFrames);
+					// scale down and add right FXRack buffer by reverb level 
+					arm_scale_f32(WetFXRackBuffer[indexR], this->fx_rack->getWetLevel(), WetFXRackBuffer[indexR], nFrames);
+					arm_scale_f32(SampleBuffer[indexR], 1.0f - this->fx_rack->getWetLevel(), DryFXRackSendBuffer[indexR], nFrames);
+					arm_add_f32(DryFXRackSendBuffer[indexR], WetFXRackBuffer[indexR], SampleBuffer[indexR], nFrames);
+
+					this->m_FXSpinLock.Release();
+				}
 			}
 			// END adding FXRack
 
@@ -1232,6 +1454,47 @@ bool CMiniDexed::DoSavePerformance (void)
 	m_PerformanceConfig.SetReverbDiffusion (m_nParameter[ParameterReverbDiffusion]);
 	m_PerformanceConfig.SetReverbLevel (m_nParameter[ParameterReverbLevel]);
 
+	// BEGIN FXRack parameters
+#ifdef ARM_ALLOW_MULTI_CORE
+	this->m_PerformanceConfig.SetFXChainEnable(!!this->m_nParameter[ParameterFXChainEnable]);
+	this->m_PerformanceConfig.SetFXChainWet(this->m_nParameter[ParameterFXChainWet]);
+	this->m_PerformanceConfig.SetFXChainTubeEnable(!!this->m_nParameter[ParameterFXChainTubeEnable]);
+	this->m_PerformanceConfig.SetFXChainTubeWet(this->m_nParameter[ParameterFXChainTubeWet]);
+	this->m_PerformanceConfig.SetFXChainTubeOverdrive(this->m_nParameter[ParameterFXChainTubeOverdrive]);
+	this->m_PerformanceConfig.SetFXChainChorusEnable(!!this->m_nParameter[ParameterFXChainChorusEnable]);
+	this->m_PerformanceConfig.SetFXChainChorusWet(this->m_nParameter[ParameterFXChainChorusWet]);
+	this->m_PerformanceConfig.SetFXChainChorusRate(this->m_nParameter[ParameterFXChainChorusRate]);
+	this->m_PerformanceConfig.SetFXChainChorusDepth(this->m_nParameter[ParameterFXChainChorusDepth]);
+	this->m_PerformanceConfig.SetFXChainChorusFeedback(this->m_nParameter[ParameterFXChainChorusFeedback]);
+	this->m_PerformanceConfig.SetFXChainFlangerEnable(!!this->m_nParameter[ParameterFXChainFlangerEnable]);
+	this->m_PerformanceConfig.SetFXChainFlangerWet(this->m_nParameter[ParameterFXChainFlangerWet]);
+	this->m_PerformanceConfig.SetFXChainFlangerDelayTime(this->m_nParameter[ParameterFXChainFlangerDelayTime]);
+	this->m_PerformanceConfig.SetFXChainFlangerRate(this->m_nParameter[ParameterFXChainFlangerRate]);
+	this->m_PerformanceConfig.SetFXChainFlangerDepth(this->m_nParameter[ParameterFXChainFlangerDepth]);
+	this->m_PerformanceConfig.SetFXChainFlangerFeedback(this->m_nParameter[ParameterFXChainFlangerFeedback]);
+	this->m_PerformanceConfig.SetFXChainOrbitoneEnable(!!this->m_nParameter[ParameterFXChainOrbitoneEnable]);
+	this->m_PerformanceConfig.SetFXChainOrbitoneWet(this->m_nParameter[ParameterFXChainOrbitoneWet]);
+	this->m_PerformanceConfig.SetFXChainOrbitoneFeedback(this->m_nParameter[ParameterFXChainOrbitoneFeedback]);
+	this->m_PerformanceConfig.SetFXChainPhaserEnable(!!this->m_nParameter[ParameterFXChainPhaserEnable]);
+	this->m_PerformanceConfig.SetFXChainPhaserWet(this->m_nParameter[ParameterFXChainPhaserWet]);
+	this->m_PerformanceConfig.SetFXChainPhaserRate(this->m_nParameter[ParameterFXChainPhaserRate]);
+	this->m_PerformanceConfig.SetFXChainPhaserResonance(this->m_nParameter[ParameterFXChainPhaserResonance]);
+	this->m_PerformanceConfig.SetFXChainTapeDelayEnable(!!this->m_nParameter[ParameterFXChainTapeDelayEnable]);
+	this->m_PerformanceConfig.SetFXChainTapeDelayWet(this->m_nParameter[ParameterFXChainTapeDelayWet]);
+	this->m_PerformanceConfig.SetFXChainTapeDelayLeftDelayTime(this->m_nParameter[ParameterFXChainTapeDelayLeftDelayTime]);
+	this->m_PerformanceConfig.SetFXChainTapeDelayRightDelayTime(this->m_nParameter[ParameterFXChainTapeDelayRightDelayTime]);
+	this->m_PerformanceConfig.SetFXChainTapeDelayFlutter(this->m_nParameter[ParameterFXChainTapeDelayFlutter]);
+	this->m_PerformanceConfig.SetFXChainTapeDelayFeedback(this->m_nParameter[ParameterFXChainTapeDelayFeedback]);
+	this->m_PerformanceConfig.SetFXChainShimmerReverbEnable(!!this->m_nParameter[ParameterFXChainShimmerReverbEnable]);
+	this->m_PerformanceConfig.SetFXChainShimmerReverbWet(this->m_nParameter[ParameterFXChainShimmerReverbWet]);
+	this->m_PerformanceConfig.SetFXChainShimmerReverbDelayTimeLeft(this->m_nParameter[ParameterFXChainShimmerReverbDelayTimeLeft]);
+	this->m_PerformanceConfig.SetFXChainShimmerReverbDelayTimeRight(this->m_nParameter[ParameterFXChainShimmerReverbDelayTimeRight]);
+	this->m_PerformanceConfig.SetFXChainShimmerReverbFrequency(this->m_nParameter[ParameterFXChainShimmerReverbFrequency]);
+	this->m_PerformanceConfig.SetFXChainShimmerReverbAmplitude(this->m_nParameter[ParameterFXChainShimmerReverbAmplitude]);
+	this->m_PerformanceConfig.SetFXChainShimmerReverbDecayTime(this->m_nParameter[ParameterFXChainShimmerReverbDecayTime]);
+#endif
+	// END FXRqck pqrqmeters
+
 	if(m_bSaveAsDeault)
 	{
 		m_PerformanceConfig.SetNewPerformance(0);
@@ -1810,6 +2073,11 @@ void CMiniDexed::setFXChainEnable(bool value)
     this->fx_rack->setEnable(value);
 }
 
+void CMiniDexed::setFXChainWet(float32_t value)
+{
+    this->fx_rack->setWetLevel(value);
+}
+
 void CMiniDexed::setFXChainTubeEnable(bool value)
 {
     this->fx_rack->getTube()->setEnable(value);
@@ -1910,9 +2178,9 @@ void CMiniDexed::setFXChainPhaserRate(float32_t value)
     this->fx_rack->getPhaser()->setFrequency(value);
 }
 
-void CMiniDexed::setFXChainPhaserQ(float32_t value)
+void CMiniDexed::setFXChainPhaserResonance(float32_t value)
 {
-    this->fx_rack->getPhaser()->setQ(value);
+    this->fx_rack->getPhaser()->setResonance(value);
 }
 
 void CMiniDexed::setFXChainTapeDelayEnable(bool value)
@@ -1925,9 +2193,14 @@ void CMiniDexed::setFXChainTapeDelayWet(float32_t value)
     this->fx_rack->getTapeDelay()->setWetLevel(value);
 }
 
-void CMiniDexed::setFXChainTapeDelayDelayTime(float32_t value)
+void CMiniDexed::setFXChainTapeDelayLeftDelayTime(float32_t value)
+{
+    this->fx_rack->getTapeDelay()->setLeftDelayTime(value);
+}
+
+void CMiniDexed::setFXChainTapeDelayRightDelayTime(float32_t value)
 {
-    this->fx_rack->getTapeDelay()->setDelayTime(value);
+    this->fx_rack->getTapeDelay()->setRightDelayTime(value);
 }
 
 void CMiniDexed::setFXChainTapeDelayFlutter(float32_t value)

src/minidexed.h

@@ -139,8 +139,11 @@ public:
 		ParameterReverbDiffusion,
 		ParameterReverbLevel,
 
+		// BEGIN FXRack global parameters definition
+#ifdef ARM_ALLOW_MULTI_CORE
 		// FXChain parameters
 		ParameterFXChainEnable,
+		ParameterFXChainWet,
 
 		// FXChain > Tube parameters
 		ParameterFXChainTubeEnable,
@@ -171,12 +174,13 @@ public:
 		ParameterFXChainPhaserEnable,
 		ParameterFXChainPhaserWet,
 		ParameterFXChainPhaserRate,
-		ParameterFXChainPhaserQ,
+		ParameterFXChainPhaserResonance,
 
 		// FXChain > TapeDelay parameters
 		ParameterFXChainTapeDelayEnable,
 		ParameterFXChainTapeDelayWet,
-		ParameterFXChainTapeDelayDelayTime,
+		ParameterFXChainTapeDelayLeftDelayTime,
+		ParameterFXChainTapeDelayRightDelayTime,
 		ParameterFXChainTapeDelayFlutter,
 		ParameterFXChainTapeDelayFeedback,
 
@@ -188,6 +192,8 @@ public:
 		ParameterFXChainShimmerReverbFrequency,
 		ParameterFXChainShimmerReverbAmplitude,
 		ParameterFXChainShimmerReverbDecayTime,
+#endif
+		// END FXRack global parameters definition
 
 		ParameterUnknown
 	};
@@ -260,6 +266,7 @@ public:
 	// BEGIN FXRack parameters setters
 #ifdef ARM_ALLOW_MULTI_CORE
 	void setFXChainEnable(bool value);
+	void setFXChainWet(float32_t value);
 	void setFXChainTubeEnable(bool value);
 	void setFXChainTubeWet(float32_t value);
 	void setFXChainTubeOverdrive(float32_t value);
@@ -280,10 +287,11 @@ public:
 	void setFXChainPhaserEnable(bool value);
 	void setFXChainPhaserWet(float32_t value);
 	void setFXChainPhaserRate(float32_t value);
-	void setFXChainPhaserQ(float32_t value);
+	void setFXChainPhaserResonance(float32_t value);
 	void setFXChainTapeDelayEnable(bool value);
 	void setFXChainTapeDelayWet(float32_t value);
-	void setFXChainTapeDelayDelayTime(float32_t value);
+	void setFXChainTapeDelayLeftDelayTime(float32_t value);
+	void setFXChainTapeDelayRightDelayTime(float32_t value);
 	void setFXChainTapeDelayFlutter(float32_t value);
 	void setFXChainTapeDelayFeedback(float32_t value);
 	void setFXChainShimmerReverbEnable(bool value);
@@ -382,7 +390,7 @@ private:
 	AudioStereoMixer<CConfig::ToneGenerators>* tg_mixer;
 	AudioStereoMixer<CConfig::ToneGenerators>* reverb_send_mixer;
 
-	CSpinLock m_ReverbSpinLock;
+	CSpinLock m_FXSpinLock;
 
 	FXRack* fx_rack;
 

src/performanceconfig.cpp

@@ -159,6 +159,45 @@ bool CPerformanceConfig::Load (void)
 	m_nReverbDiffusion = m_Properties.GetNumber ("ReverbDiffusion", 65);
 	m_nReverbLevel = m_Properties.GetNumber ("ReverbLevel", 99);
 
+#ifdef ARM_ALLOW_MULTI_CORE
+	this->m_bFXChainEnable = this->m_Properties.GetNumber("FXChainEnable", 1);
+	this->m_nFXChainWet = this->m_Properties.GetNumber("FXChainWet", 99);
+	this->m_bFXChainTubeEnable = this->m_Properties.GetNumber("FXChainTubeEnable", 1);
+	this->m_nFXChainTubeWet = this->m_Properties.GetNumber("FXChainTubeWet", 50);
+	this->m_nFXChainTubeOverdrive = this->m_Properties.GetNumber("FXChainTubeOverdrive", 10);
+	this->m_bFXChainChorusEnable = this->m_Properties.GetNumber("FXChainChorusEnable", 1);
+	this->m_nFXChainChorusWet = this->m_Properties.GetNumber("FXChainChorusWet", 50);
+	this->m_nFXChainChorusRate = this->m_Properties.GetNumber("FXChainChorusRate", 15);
+	this->m_nFXChainChorusDepth = this->m_Properties.GetNumber("FXChainChorusDepth", 10);
+	this->m_nFXChainChorusFeedback = this->m_Properties.GetNumber("FXChainChorusFeedback", 20);
+	this->m_bFXChainFlangerEnable = this->m_Properties.GetNumber("FXChainFlangerEnable", 1);
+	this->m_nFXChainFlangerWet = this->m_Properties.GetNumber("FXChainFlangerWet", 		50);
+	this->m_nFXChainFlangerDelayTime = this->m_Properties.GetNumber("FXChainFlangerDelayTime", 10);
+	this->m_nFXChainFlangerRate = this->m_Properties.GetNumber("FXChainFlangerRate", 15);
+	this->m_nFXChainFlangerDepth = this->m_Properties.GetNumber("FXChainFlangerDepth", 10);
+	this->m_nFXChainFlangerFeedback = this->m_Properties.GetNumber("FXChainFlangerFeedback", 20);
+	this->m_bFXChainOrbitoneEnable = this->m_Properties.GetNumber("FXChainOrbitoneEnable", 1);
+	this->m_nFXChainOrbitoneWet = this->m_Properties.GetNumber("FXChainOrbitoneWet", 50);
+	this->m_nFXChainOrbitoneFeedback = this->m_Properties.GetNumber("FXChainOrbitoneFeedback", 65);
+	this->m_bFXChainPhaserEnable = this->m_Properties.GetNumber("FXChainPhaserEnable", 1);
+	this->m_nFXChainPhaserWet = this->m_Properties.GetNumber("FXChainPhaserWet", 50);
+	this->m_nFXChainPhaserRate = this->m_Properties.GetNumber("FXChainPhaserRate", 5);
+	this->m_nFXChainPhaserResonance = this->m_Properties.GetNumber("FXChainPhaserResonance", 45);
+	this->m_bFXChainTapeDelayEnable = this->m_Properties.GetNumber("FXChainTapeDelayEnable", 1);
+	this->m_nFXChainTapeDelayWet = this->m_Properties.GetNumber("FXChainTapeDelayWet", 50);
+	this->m_nFXChainTapeDelayLeftDelayTime = this->m_Properties.GetNumber("FXChainTapeDelayLeftDelayTime", 15);
+	this->m_nFXChainTapeDelayRightDelayTime = this->m_Properties.GetNumber("FXChainTapeDelayRightDelayTime", 22);
+	this->m_nFXChainTapeDelayFlutter = this->m_Properties.GetNumber("FXChainTapeDelayFlutter", 7);
+	this->m_nFXChainTapeDelayFeedback = this->m_Properties.GetNumber("FXChainTapeDelayFeedback", 35);
+	this->m_bFXChainShimmerReverbEnable = this->m_Properties.GetNumber("FXChainShimmerReverbEnable", 1);
+	this->m_nFXChainShimmerReverbWet = this->m_Properties.GetNumber("FXChainShimmerReverbWet", 70);
+	this->m_nFXChainShimmerReverbDelayTimeLeft = this->m_Properties.GetNumber("FXChainShimmerReverbDelayTimeLeft", 15);
+	this->m_nFXChainShimmerReverbDelayTimeRight = this->m_Properties.GetNumber("FXChainShimmerReverbDelayTimeRight", 22);
+	this->m_nFXChainShimmerReverbFrequency = this->m_Properties.GetNumber("FXChainShimmerReverbFrequency", 20);
+	this->m_nFXChainShimmerReverbAmplitude = this->m_Properties.GetNumber("FXChainShimmerReverbAmplitude", 15);
+	this->m_nFXChainShimmerReverbDecayTime = this->m_Properties.GetNumber("FXChainShimmerReverbDecayTime", 65);
+#endif
+
 	return bResult;
 }
 
@@ -277,6 +316,45 @@ bool CPerformanceConfig::Save (void)
 	m_Properties.SetNumber ("ReverbDiffusion", m_nReverbDiffusion);
 	m_Properties.SetNumber ("ReverbLevel", m_nReverbLevel);
 
+#ifdef ARM_ALLOW_MULTI_CORE
+	this->m_Properties.SetNumber("FXChainEnable", m_bFXChainEnable ? 1 : 0);
+	this->m_Properties.SetNumber("FXChainWet", m_nFXChainWet);
+	this->m_Properties.SetNumber("FXChainTubeEnable", m_bFXChainTubeEnable ? 1 : 0);
+	this->m_Properties.SetNumber("FXChainTubeWet", m_nFXChainTubeWet);
+	this->m_Properties.SetNumber("FXChainTubeOverdrive", m_nFXChainTubeOverdrive);
+	this->m_Properties.SetNumber("FXChainChorusEnable", m_bFXChainChorusEnable ? 1 : 0);
+	this->m_Properties.SetNumber("FXChainChorusWet", m_nFXChainChorusWet);
+	this->m_Properties.SetNumber("FXChainChorusRate", m_nFXChainChorusRate);
+	this->m_Properties.SetNumber("FXChainChorusDepth", m_nFXChainChorusDepth);
+	this->m_Properties.SetNumber("FXChainChorusFeedback", m_nFXChainChorusFeedback);
+	this->m_Properties.SetNumber("FXChainFlangerEnable", m_bFXChainFlangerEnable ? 1 : 0);
+	this->m_Properties.SetNumber("FXChainFlangerWet", m_nFXChainFlangerWet);
+	this->m_Properties.SetNumber("FXChainFlangerDelayTime", m_nFXChainFlangerDelayTime);
+	this->m_Properties.SetNumber("FXChainFlangerRate", m_nFXChainFlangerRate);
+	this->m_Properties.SetNumber("FXChainFlangerDepth", m_nFXChainFlangerDepth);
+	this->m_Properties.SetNumber("FXChainFlangerFeedback", m_nFXChainFlangerFeedback);
+	this->m_Properties.SetNumber("FXChainOrbitoneEnable", m_bFXChainOrbitoneEnable ? 1 : 0);
+	this->m_Properties.SetNumber("FXChainOrbitoneWet", m_nFXChainOrbitoneWet);
+	this->m_Properties.SetNumber("FXChainOrbitoneFeedback", m_nFXChainOrbitoneFeedback ? 1 : 0);
+	this->m_Properties.SetNumber("FXChainPhaserEnable", m_bFXChainPhaserEnable);
+	this->m_Properties.SetNumber("FXChainPhaserWet", m_nFXChainPhaserWet);
+	this->m_Properties.SetNumber("FXChainPhaserRate", m_nFXChainPhaserRate);
+	this->m_Properties.SetNumber("FXChainPhaserResonance", m_nFXChainPhaserResonance);
+	this->m_Properties.SetNumber("FXChainTapeDelayEnable", m_bFXChainTapeDelayEnable ? 1 : 0);
+	this->m_Properties.SetNumber("FXChainTapeDelayWet", m_nFXChainTapeDelayWet);
+	this->m_Properties.SetNumber("FXChainTapeDelayLeftDelayTime", m_nFXChainTapeDelayLeftDelayTime);
+	this->m_Properties.SetNumber("FXChainTapeDelayRightDelayTime", m_nFXChainTapeDelayRightDelayTime);
+	this->m_Properties.SetNumber("FXChainTapeDelayFlutter", m_nFXChainTapeDelayFlutter);
+	this->m_Properties.SetNumber("FXChainTapeDelayFeedback", m_nFXChainTapeDelayFeedback);
+	this->m_Properties.SetNumber("FXChainShimmerReverbEnable", m_bFXChainShimmerReverbEnable ? 1 : 0);
+	this->m_Properties.SetNumber("FXChainShimmerReverbWet", m_nFXChainShimmerReverbWet);
+	this->m_Properties.SetNumber("FXChainShimmerReverbDelayTimeLeft", m_nFXChainShimmerReverbDelayTimeLeft);
+	this->m_Properties.SetNumber("FXChainShimmerReverbDelayTimeRight", m_nFXChainShimmerReverbDelayTimeRight);
+	this->m_Properties.SetNumber("FXChainShimmerReverbFrequency", m_nFXChainShimmerReverbFrequency);
+	this->m_Properties.SetNumber("FXChainShimmerReverbAmplitude", m_nFXChainShimmerReverbAmplitude);
+	this->m_Properties.SetNumber("FXChainShimmerReverbDecayTime", m_nFXChainShimmerReverbDecayTime);
+#endif
+
 	return m_Properties.Save ();
 }
 
@@ -923,3 +1001,366 @@ bool CPerformanceConfig::DeletePerformance(unsigned nID)
 	}
 	return bOK;
 }
+
+#ifdef ARM_ALLOW_MULTI_CORE
+bool CPerformanceConfig::GetFXChainEnable(void) const
+{
+	return this->m_bFXChainEnable;
+}
+
+unsigned CPerformanceConfig::GetFXChainWet(void) const
+{
+	return this->m_nFXChainWet;
+}
+
+bool CPerformanceConfig::GetFXChainTubeEnable(void) const
+{
+	return this->m_bFXChainTubeEnable;
+}
+
+unsigned CPerformanceConfig::GetFXChainTubeWet(void) const
+{
+	return this->m_nFXChainTubeWet;
+}
+
+unsigned CPerformanceConfig::GetFXChainTubeOverdrive(void) const
+{
+	return this->m_nFXChainTubeOverdrive;
+}
+
+bool CPerformanceConfig::GetFXChainChorusEnable(void) const
+{
+	return this->m_bFXChainChorusEnable;
+}
+
+unsigned CPerformanceConfig::GetFXChainChorusWet(void) const
+{
+	return this->m_nFXChainChorusWet;
+}
+
+unsigned CPerformanceConfig::GetFXChainChorusRate(void) const
+{
+	return this->m_nFXChainChorusRate;
+}
+
+unsigned CPerformanceConfig::GetFXChainChorusDepth(void) const
+{
+	return this->m_nFXChainChorusDepth;
+}
+
+unsigned CPerformanceConfig::GetFXChainChorusFeedback(void) const
+{
+	return this->m_nFXChainChorusFeedback;
+}
+
+bool CPerformanceConfig::GetFXChainFlangerEnable(void) const
+{
+	return this->m_bFXChainFlangerEnable;
+}
+
+unsigned CPerformanceConfig::GetFXChainFlangerWet(void) const
+{
+	return this->m_nFXChainFlangerWet;
+}
+
+unsigned CPerformanceConfig::GetFXChainFlangerDelayTime(void) const
+{
+	return this->m_nFXChainFlangerDelayTime;
+}
+
+unsigned CPerformanceConfig::GetFXChainFlangerRate(void) const
+{
+	return this->m_nFXChainFlangerRate;
+}
+
+unsigned CPerformanceConfig::GetFXChainFlangerDepth(void) const
+{
+	return this->m_nFXChainFlangerDepth;
+}
+
+unsigned CPerformanceConfig::GetFXChainFlangerFeedback(void) const
+{
+	return this->m_nFXChainFlangerFeedback;
+}
+
+bool CPerformanceConfig::GetFXChainOrbitoneEnable(void) const
+{
+	return this->m_bFXChainOrbitoneEnable;
+}
+
+unsigned CPerformanceConfig::GetFXChainOrbitoneWet(void) const
+{
+	return this->m_nFXChainOrbitoneWet;
+}
+
+unsigned CPerformanceConfig::GetFXChainOrbitoneFeedback(void) const
+{
+	return this->m_nFXChainOrbitoneFeedback;
+}
+
+bool CPerformanceConfig::GetFXChainPhaserEnable(void) const
+{
+	return this->m_bFXChainPhaserEnable;
+}
+
+unsigned CPerformanceConfig::GetFXChainPhaserWet(void) const
+{
+	return this->m_nFXChainPhaserWet;
+}
+
+unsigned CPerformanceConfig::GetFXChainPhaserRate(void) const
+{
+	return this->m_nFXChainPhaserRate;
+}
+
+unsigned CPerformanceConfig::GetFXChainPhaserResonance(void) const
+{
+	return this->m_nFXChainPhaserResonance;
+}
+
+bool CPerformanceConfig::GetFXChainTapeDelayEnable(void) const
+{
+	return this->m_bFXChainTapeDelayEnable;
+}
+
+unsigned CPerformanceConfig::GetFXChainTapeDelayWet(void) const
+{
+	return this->m_nFXChainTapeDelayWet;
+}
+
+unsigned CPerformanceConfig::GetFXChainTapeDelayLeftDelayTime(void) const
+{
+	return this->m_nFXChainTapeDelayLeftDelayTime;
+}
+
+unsigned CPerformanceConfig::GetFXChainTapeDelayRightDelayTime(void) const
+{
+	return this->m_nFXChainTapeDelayRightDelayTime;
+}
+
+unsigned CPerformanceConfig::GetFXChainTapeDelayFlutter(void) const
+{
+	return this->m_nFXChainTapeDelayFlutter;
+}
+
+unsigned CPerformanceConfig::GetFXChainTapeDelayFeedback(void) const
+{
+	return this->m_nFXChainTapeDelayFeedback;
+}
+
+bool CPerformanceConfig::GetFXChainShimmerReverbEnable(void) const
+{
+	return this->m_bFXChainShimmerReverbEnable;
+}
+
+unsigned CPerformanceConfig::GetFXChainShimmerReverbWet(void) const
+{
+	return this->m_nFXChainShimmerReverbWet;
+}
+
+unsigned CPerformanceConfig::GetFXChainShimmerReverbDelayTimeLeft(void) const
+{
+	return this->m_nFXChainShimmerReverbDelayTimeLeft;
+}
+
+unsigned CPerformanceConfig::GetFXChainShimmerReverbDelayTimeRight(void) const
+{
+	return this->m_nFXChainShimmerReverbDelayTimeRight;
+}
+
+unsigned CPerformanceConfig::GetFXChainShimmerReverbFrequency(void) const
+{
+	return this->m_nFXChainShimmerReverbFrequency;
+}
+
+unsigned CPerformanceConfig::GetFXChainShimmerReverbAmplitude(void) const
+{
+	return this->m_nFXChainShimmerReverbAmplitude;
+}
+
+unsigned CPerformanceConfig::GetFXChainShimmerReverbDecayTime(void) const
+{
+	return this->m_nFXChainShimmerReverbDecayTime;
+}
+
+void CPerformanceConfig::SetFXChainEnable(bool bValue)
+{
+	this->m_bFXChainEnable = bValue;
+}
+
+void CPerformanceConfig::SetFXChainWet(unsigned nValue)
+{
+	this->m_nFXChainWet = nValue;
+}
+
+void CPerformanceConfig::SetFXChainTubeEnable(bool bValue)
+{
+	this->m_bFXChainTubeEnable = bValue;
+}
+
+void CPerformanceConfig::SetFXChainTubeWet(unsigned nValue)
+{
+	this->m_nFXChainTubeWet = nValue;
+}
+
+void CPerformanceConfig::SetFXChainTubeOverdrive(unsigned nValue)
+{
+	this->m_nFXChainTubeOverdrive = nValue;
+}
+
+void CPerformanceConfig::SetFXChainChorusEnable(bool bValue)
+{
+	this->m_bFXChainChorusEnable = bValue;
+}
+
+void CPerformanceConfig::SetFXChainChorusWet(unsigned nValue)
+{
+	this->m_nFXChainChorusWet = nValue;
+}
+
+void CPerformanceConfig::SetFXChainChorusRate(unsigned nValue)
+{
+	this->m_nFXChainChorusRate = nValue;
+}
+
+void CPerformanceConfig::SetFXChainChorusDepth(unsigned nValue)
+{
+	this->m_nFXChainChorusDepth = nValue;
+}
+
+void CPerformanceConfig::SetFXChainChorusFeedback(unsigned nValue)
+{
+	this->m_nFXChainChorusFeedback = nValue;
+}
+
+void CPerformanceConfig::SetFXChainFlangerEnable(bool bValue)
+{
+	this->m_bFXChainFlangerEnable = bValue;
+}
+
+void CPerformanceConfig::SetFXChainFlangerWet(unsigned nValue)
+{
+	this->m_nFXChainFlangerWet = nValue;
+}
+
+void CPerformanceConfig::SetFXChainFlangerDelayTime(unsigned nValue)
+{
+	this->m_nFXChainFlangerDelayTime = nValue;
+}
+
+void CPerformanceConfig::SetFXChainFlangerRate(unsigned nValue)
+{
+	this->m_nFXChainFlangerRate = nValue;
+}
+
+void CPerformanceConfig::SetFXChainFlangerDepth(unsigned nValue)
+{
+	this->m_nFXChainFlangerDepth = nValue;
+}
+
+void CPerformanceConfig::SetFXChainFlangerFeedback(unsigned nValue)
+{
+	this->m_nFXChainFlangerFeedback = nValue;
+}
+
+void CPerformanceConfig::SetFXChainOrbitoneEnable(bool bValue)
+{
+	this->m_bFXChainOrbitoneEnable = bValue;
+}
+
+void CPerformanceConfig::SetFXChainOrbitoneWet(unsigned nValue)
+{
+	this->m_nFXChainOrbitoneWet = nValue;
+}
+
+void CPerformanceConfig::SetFXChainOrbitoneFeedback(unsigned nValue)
+{
+	this->m_nFXChainOrbitoneFeedback = nValue;
+}
+
+void CPerformanceConfig::SetFXChainPhaserEnable(bool bValue)
+{
+	this->m_bFXChainPhaserEnable = bValue;
+}
+
+void CPerformanceConfig::SetFXChainPhaserWet(unsigned nValue)
+{
+	this->m_nFXChainPhaserWet = nValue;
+}
+
+void CPerformanceConfig::SetFXChainPhaserRate(unsigned nValue)
+{
+	this->m_nFXChainPhaserRate = nValue;
+}
+
+void CPerformanceConfig::SetFXChainPhaserResonance(unsigned nValue)
+{
+	this->m_nFXChainPhaserResonance = nValue;
+}
+
+void CPerformanceConfig::SetFXChainTapeDelayEnable(unsigned bValue)
+{
+	this->m_bFXChainTapeDelayEnable = bValue;
+}
+
+void CPerformanceConfig::SetFXChainTapeDelayWet(unsigned nValue)
+{
+	this->m_nFXChainTapeDelayWet = nValue;
+}
+
+void CPerformanceConfig::SetFXChainTapeDelayLeftDelayTime(unsigned nValue)
+{
+	this->m_nFXChainTapeDelayLeftDelayTime = nValue;
+}
+
+void CPerformanceConfig::SetFXChainTapeDelayRightDelayTime(unsigned nValue)
+{
+	this->m_nFXChainTapeDelayRightDelayTime = nValue;
+}
+
+void CPerformanceConfig::SetFXChainTapeDelayFlutter(unsigned nValue)
+{
+	this->m_nFXChainTapeDelayFlutter = nValue;
+}
+
+void CPerformanceConfig::SetFXChainTapeDelayFeedback(unsigned nValue)
+{
+	this->m_nFXChainTapeDelayFeedback = nValue;
+}
+
+void CPerformanceConfig::SetFXChainShimmerReverbEnable(unsigned bValue)
+{
+	this->m_bFXChainShimmerReverbEnable = bValue;
+}
+
+void CPerformanceConfig::SetFXChainShimmerReverbWet(unsigned nValue)
+{
+	this->m_nFXChainShimmerReverbWet = nValue;
+}
+
+void CPerformanceConfig::SetFXChainShimmerReverbDelayTimeLeft(unsigned nValue)
+{
+	this->m_nFXChainShimmerReverbDelayTimeLeft = nValue;
+}
+
+void CPerformanceConfig::SetFXChainShimmerReverbDelayTimeRight(unsigned nValue)
+{
+	this->m_nFXChainShimmerReverbDelayTimeRight = nValue;
+}
+
+void CPerformanceConfig::SetFXChainShimmerReverbFrequency(unsigned nValue)
+{
+	this->m_nFXChainShimmerReverbFrequency = nValue;
+}
+
+void CPerformanceConfig::SetFXChainShimmerReverbAmplitude(unsigned nValue)
+{
+	this->m_nFXChainShimmerReverbAmplitude = nValue;
+}
+
+void CPerformanceConfig::SetFXChainShimmerReverbDecayTime(unsigned nValue)
+{
+	this->m_nFXChainShimmerReverbDecayTime = nValue;
+}
+
+#endif

src/performanceconfig.h

@@ -117,6 +117,82 @@ public:
 	void SetReverbDiffusion (unsigned nValue);
 	void SetReverbLevel (unsigned nValue);
 
+#ifdef ARM_ALLOW_MULTI_CORE
+	bool GetFXChainEnable(void) const;
+	unsigned GetFXChainWet(void) const;
+	bool GetFXChainTubeEnable(void) const;
+	unsigned GetFXChainTubeWet(void) const;
+	unsigned GetFXChainTubeOverdrive(void) const;
+	bool GetFXChainChorusEnable(void) const;
+	unsigned GetFXChainChorusWet(void) const;
+	unsigned GetFXChainChorusRate(void) const;
+	unsigned GetFXChainChorusDepth(void) const;
+	unsigned GetFXChainChorusFeedback(void) const;
+	bool GetFXChainFlangerEnable(void) const;
+	unsigned GetFXChainFlangerWet(void) const;
+	unsigned GetFXChainFlangerDelayTime(void) const;
+	unsigned GetFXChainFlangerRate(void) const;
+	unsigned GetFXChainFlangerDepth(void) const;
+	unsigned GetFXChainFlangerFeedback(void) const;
+	bool GetFXChainOrbitoneEnable(void) const;
+	unsigned GetFXChainOrbitoneWet(void) const;
+	unsigned GetFXChainOrbitoneFeedback(void) const;
+	bool GetFXChainPhaserEnable(void) const;
+	unsigned GetFXChainPhaserWet(void) const;
+	unsigned GetFXChainPhaserRate(void) const;
+	unsigned GetFXChainPhaserResonance(void) const;
+	bool GetFXChainTapeDelayEnable(void) const;
+	unsigned GetFXChainTapeDelayWet(void) const;
+	unsigned GetFXChainTapeDelayLeftDelayTime(void) const;
+	unsigned GetFXChainTapeDelayRightDelayTime(void) const;
+	unsigned GetFXChainTapeDelayFlutter(void) const;
+	unsigned GetFXChainTapeDelayFeedback(void) const;
+	bool GetFXChainShimmerReverbEnable(void) const;
+	unsigned GetFXChainShimmerReverbWet(void) const;
+	unsigned GetFXChainShimmerReverbDelayTimeLeft(void) const;
+	unsigned GetFXChainShimmerReverbDelayTimeRight(void) const;
+	unsigned GetFXChainShimmerReverbFrequency(void) const;
+	unsigned GetFXChainShimmerReverbAmplitude(void) const;
+	unsigned GetFXChainShimmerReverbDecayTime(void) const;
+
+	void SetFXChainEnable(bool bValue);
+	void SetFXChainWet(unsigned nValue);
+	void SetFXChainTubeEnable(bool bValue);
+	void SetFXChainTubeWet(unsigned nValue);
+	void SetFXChainTubeOverdrive(unsigned nValue);
+	void SetFXChainChorusEnable(bool bValue);
+	void SetFXChainChorusWet(unsigned nValue);
+	void SetFXChainChorusRate(unsigned nValue);
+	void SetFXChainChorusDepth(unsigned nValue);
+	void SetFXChainChorusFeedback(unsigned nValue);
+	void SetFXChainFlangerEnable(bool bValue);
+	void SetFXChainFlangerWet(unsigned nValue);
+	void SetFXChainFlangerDelayTime(unsigned nValue);
+	void SetFXChainFlangerRate(unsigned nValue);
+	void SetFXChainFlangerDepth(unsigned nValue);
+	void SetFXChainFlangerFeedback(unsigned nValue);
+	void SetFXChainOrbitoneEnable(bool bValue);
+	void SetFXChainOrbitoneWet(unsigned nValue);
+	void SetFXChainOrbitoneFeedback(unsigned nValue);
+	void SetFXChainPhaserEnable(bool bValue);
+	void SetFXChainPhaserWet(unsigned nValue);
+	void SetFXChainPhaserRate(unsigned nValue);
+	void SetFXChainPhaserResonance(unsigned nValue);
+	void SetFXChainTapeDelayEnable(unsigned nValue);
+	void SetFXChainTapeDelayWet(unsigned nValue);
+	void SetFXChainTapeDelayLeftDelayTime(unsigned nValue);
+	void SetFXChainTapeDelayRightDelayTime(unsigned nValue);
+	void SetFXChainTapeDelayFlutter(unsigned nValue);
+	void SetFXChainTapeDelayFeedback(unsigned nValue);
+	void SetFXChainShimmerReverbEnable(unsigned nValue);
+	void SetFXChainShimmerReverbWet(unsigned nValue);
+	void SetFXChainShimmerReverbDelayTimeLeft(unsigned nValue);
+	void SetFXChainShimmerReverbDelayTimeRight(unsigned nValue);
+	void SetFXChainShimmerReverbFrequency(unsigned nValue);
+	void SetFXChainShimmerReverbAmplitude(unsigned nValue);
+	void SetFXChainShimmerReverbDecayTime(unsigned nValue);
+#endif
+
 	bool VoiceDataFilled(unsigned nTG);
 	bool ListPerformances(); 
 	//std::string m_DirName;
@@ -183,6 +259,45 @@ private:
 	unsigned m_nReverbLowPass;
 	unsigned m_nReverbDiffusion;
 	unsigned m_nReverbLevel;
+
+#ifdef ARM_ALLOW_MULTI_CORE
+	bool m_bFXChainEnable;
+	unsigned m_nFXChainWet;
+	bool m_bFXChainTubeEnable;
+	unsigned m_nFXChainTubeWet;
+	unsigned m_nFXChainTubeOverdrive;
+	bool m_bFXChainChorusEnable;
+	unsigned m_nFXChainChorusWet;
+	unsigned m_nFXChainChorusRate;
+	unsigned m_nFXChainChorusDepth;
+	unsigned m_nFXChainChorusFeedback;
+	bool m_bFXChainFlangerEnable;
+	unsigned m_nFXChainFlangerWet;
+	unsigned m_nFXChainFlangerDelayTime;
+	unsigned m_nFXChainFlangerRate;
+	unsigned m_nFXChainFlangerDepth;
+	unsigned m_nFXChainFlangerFeedback;
+	bool m_bFXChainOrbitoneEnable;
+	unsigned m_nFXChainOrbitoneWet;
+	unsigned m_nFXChainOrbitoneFeedback;
+	bool m_bFXChainPhaserEnable;
+	unsigned m_nFXChainPhaserWet;
+	unsigned m_nFXChainPhaserRate;
+	unsigned m_nFXChainPhaserResonance;
+	bool m_bFXChainTapeDelayEnable;
+	unsigned m_nFXChainTapeDelayWet;
+	unsigned m_nFXChainTapeDelayLeftDelayTime;
+	unsigned m_nFXChainTapeDelayRightDelayTime;
+	unsigned m_nFXChainTapeDelayFlutter;
+	unsigned m_nFXChainTapeDelayFeedback;
+	bool m_bFXChainShimmerReverbEnable;
+	unsigned m_nFXChainShimmerReverbWet;
+	unsigned m_nFXChainShimmerReverbDelayTimeLeft;
+	unsigned m_nFXChainShimmerReverbDelayTimeRight;
+	unsigned m_nFXChainShimmerReverbFrequency;
+	unsigned m_nFXChainShimmerReverbAmplitude;
+	unsigned m_nFXChainShimmerReverbDecayTime;
+#endif
 };
 
 #endif

src/uimenu.cpp

@@ -138,6 +138,7 @@ const CUIMenu::TMenuItem CUIMenu::s_FXChainMenu[] =
 {
 	// FXChain
 	{"Enable",			EditGlobalParameter,	0,	CMiniDexed::ParameterFXChainEnable},
+	{"Wet Level",		EditGlobalParameter,	0,	CMiniDexed::ParameterFXChainEnable},
 
 	{"Tube", 			MenuHandler, s_FXChainTube},
 	{"Chorus", 			MenuHandler, s_FXChainChorus},
@@ -191,7 +192,7 @@ const CUIMenu::TMenuItem CUIMenu::s_FXChainPhaser[] =
 	{"Enable", 		EditGlobalParameter, 	0, CMiniDexed::ParameterFXChainPhaserEnable},
 	{"Wet Level", 	EditGlobalParameter,	0, CMiniDexed::ParameterFXChainPhaserWet},
 	{"LFO Rate",	EditGlobalParameter,	0, CMiniDexed::ParameterFXChainPhaserRate},
-	{"Q", 			EditGlobalParameter,	0, CMiniDexed::ParameterFXChainPhaserQ},
+	{"Resonance", 	EditGlobalParameter,	0, CMiniDexed::ParameterFXChainPhaserResonance},
 	{0}
 };
 
@@ -199,7 +200,8 @@ const CUIMenu::TMenuItem CUIMenu::s_FXChainTapeDelay[] =
 {
 	{"Enable", 		EditGlobalParameter, 	0, CMiniDexed::ParameterFXChainTapeDelayEnable},
 	{"Wet Level", 	EditGlobalParameter,	0, CMiniDexed::ParameterFXChainTapeDelayWet},
-	{"Delay Time",	EditGlobalParameter,	0, CMiniDexed::ParameterFXChainTapeDelayDelayTime},
+	{"Left Delay",	EditGlobalParameter,	0, CMiniDexed::ParameterFXChainTapeDelayLeftDelayTime},
+	{"Right Delay",	EditGlobalParameter,	0, CMiniDexed::ParameterFXChainTapeDelayRightDelayTime},
 	{"Flutter",		EditGlobalParameter,	0, CMiniDexed::ParameterFXChainTapeDelayFlutter},
 	{"Feedback", 	EditGlobalParameter,	0, CMiniDexed::ParameterFXChainTapeDelayFeedback},
 	{0}
@@ -289,14 +291,72 @@ const CUIMenu::TMenuItem CUIMenu::s_SaveMenu[] =
 // must match CMiniDexed::TParameter
 const CUIMenu::TParameter CUIMenu::s_GlobalParameter[CMiniDexed::ParameterUnknown] =
 {
-	{0,	1,	1,	ToOnOff},		// ParameterCompessorEnable
-	{0,	1,	1,	ToOnOff},		// ParameterReverbEnable
+	{0,	1,	1,	ToOnOff},	// ParameterCompessorEnable
+	{0,	1,	1,	ToOnOff},	// ParameterReverbEnable
 	{0,	99,	1},				// ParameterReverbSize
 	{0,	99,	1},				// ParameterReverbHighDamp
 	{0,	99,	1},				// ParameterReverbLowDamp
 	{0,	99,	1},				// ParameterReverbLowPass
 	{0,	99,	1},				// ParameterReverbDiffusion
 	{0,	99,	1}				// ParameterReverbLevel
+
+	// BEGIN FXRack global parameters mapping definition
+#ifdef ARM_ALLOW_MULTI_CORE
+	,
+	// FXChain parameters
+	{0,	1,	1,	ToOnOff},	// ParameterFXChainEnable
+	{0,	99,	1},				// ParameterFXChainWet
+
+	// FXChain > Tube parameters
+	{0,	1,	1,	ToOnOff},	// ParameterFXChainTubeEnable
+	{0,	99,	1},				// ParameterFXChainTubeWet
+	{0,	99,	1},				// ParameterFXChainTubeOverdrive
+
+	// FXChain > Chorus parameters
+	{0,	1,	1,	ToOnOff},	// ParameterFXChainChorusEnable
+	{0,	99,	1},				// ParameterFXChainChorusWet
+	{0,	99,	1},				// ParameterFXChainChorusRate
+	{0,	99,	1},				// ParameterFXChainChorusDepth
+	{0,	99,	1},				// ParameterFXChainChorusFeedback
+
+	// FXChain > Flanger parameters
+	{0,	1,	1,	ToOnOff},	// ParameterFXChainFlangerEnable
+	{0,	99,	1},				// ParameterFXChainFlangerWet
+	{0,	99,	1},				// ParameterFXChainFlangerDelayTime
+	{0,	99,	1},				// ParameterFXChainFlangerRate
+	{0,	99,	1},				// ParameterFXChainFlangerDepth
+	{0,	99,	1},				// ParameterFXChainFlangerFeedback
+
+	// FXChain > Orbitone parameters
+	{0,	1,	1,	ToOnOff},	// ParameterFXChainOrbitoneEnable
+	{0,	99,	1},				// ParameterFXChainOrbitoneWet
+	{0,	99,	1},				// ParameterFXChainOrbitoneFeedback
+
+	// FXChain > Phaser parameters
+	{0,	1,	1,	ToOnOff},	// ParameterFXChainPhaserEnable
+	{0,	99,	1},				// ParameterFXChainPhaserWet
+	{0,	99,	1},				// ParameterFXChainPhaserRate
+	{0,	99,	1},				// ParameterFXChainPhaserResonance
+
+	// FXChain > TapeDelay parameters
+	{0,	1,	1,	ToOnOff},	// ParameterFXChainTapeDelayEnable
+	{0,	99,	1},				// ParameterFXChainTapeDelayWet
+	{0,	99,	1},				// ParameterFXChainTapeDelayLeftDelayTime
+	{0,	99,	1},				// ParameterFXChainTapeDelayRightDelayTime
+	{0,	99,	1},				// ParameterFXChainTapeDelayFlutter
+	{0,	99,	1},				// ParameterFXChainTapeDelayFeedback
+
+	// FXChain > ShimmerReverb parameters
+	{0,	1,	1,	ToOnOff},	// ParameterFXChainShimmerReverbEnable
+	{0,	99,	1},				// ParameterFXChainShimmerReverbWet
+	{0,	99,	1},				// ParameterFXChainShimmerReverbDelayTimeLeft
+	{0,	99,	1},				// ParameterFXChainShimmerReverbDelayTimeRight
+	{0,	99,	1},				// ParameterFXChainShimmerReverbFrequency
+	{0,	99,	1},				// ParameterFXChainShimmerReverbAmplitude
+	{0,	99,	1},				// ParameterFXChainShimmerReverbDecayTime
+#endif
+	// END FXRack global parameters mapping definition
+
 };
 
 // must match CMiniDexed::TTGParameter

src/userinterface.h

@@ -55,8 +55,8 @@ public:
 	// To be called from the MIDI device on reception of a MIDI CC message
 	void UIMIDICmdHandler (unsigned nMidiCh, unsigned nMidiCmd, unsigned nMidiData1, unsigned nMidiData2);
 
-private:
 	void LCDWrite (const char *pString);		// Print to optional HD44780 display
+private:
 
 	void EncoderEventHandler (CKY040::TEvent Event);
 	static void EncoderEventStub (CKY040::TEvent Event, void *pParam);