Start FXRack parameter integration

src/Makefile

@@ -6,11 +6,12 @@ CIRCLE_STDLIB_DIR = ../circle-stdlib
 SYNTH_DEXED_DIR = ../Synth_Dexed/src
 CMSIS_DIR = ../CMSIS_5/CMSIS
 
-OBJS = main.o kernel.o minidexed.o config.o userinterface.o uimenu.o \
+OBJS = main.o kernel.o minidexed.o minidexed_ext.o config.o userinterface.o uimenu.o \
        mididevice.o midikeyboard.o serialmididevice.o pckeyboard.o \
        sysexfileloader.o performanceconfig.o perftimer.o \
        effect_compressor.o effect_platervbstereo.o \
-       fx.o fx_flanger.o fx_orbitone.o fx_phaser.o fx_tape_delay.o fx_shimmer_reverb.o fx_rack.o \
+       fx.o fx_tube.o fx_chorus.o fx_flanger.o fx_orbitone.o fx_phaser.o \
+       fx_tape_delay.o fx_shimmer_reverb.o fx_rack.o \
        uibuttons.o midipin.o
 
 OPTIMIZE = -O3

src/fx_chorus.h

@@ -31,13 +31,13 @@ public:
     virtual void processSample(float32_t inL, float32_t inR, float32_t& outL, float32_t& outR) override;
 
     void setDepth(float32_t depth);
-    inline float32_t getDepth() const;
+    float32_t getDepth() const;
 
     void setRate(float32_t rate);
-    inline float32_t getRate() const;
+    float32_t getRate() const;
 
     void setFeedback(float32_t feedback);
-    inline float32_t getFeedback() const;
+    float32_t getFeedback() const;
 
 private:
     const unsigned NumVoices;   // Number of voices in the chorus

src/fx_flanger.h

@@ -31,16 +31,16 @@ public:
     virtual void processSample(float32_t inL, float32_t inR, float32_t& outL, float32_t& outR) override;
 
     void setDelayTime(float32_t delayMS);
-    inline float32_t getDelayTime() const;
+    float32_t getDelayTime() const;
 
     void setFrequency(float32_t frequency);
-    inline float32_t getFrequency() const;
+    float32_t getFrequency() const;
 
     void setDepth(float32_t depth);
-    inline float32_t getDepth() const;
+    float32_t getDepth() const;
 
     void setFeedback(float32_t feedback);
-    inline float32_t getFeedback() const;
+    float32_t getFeedback() const;
 
 private:
     inline void adjustDelayCofficients();

src/fx_orbitone.cpp

@@ -17,7 +17,7 @@ void OrbitoneParameter::setFeedback(float32_t feedback)
     this->feedback_ = constrain(feedback, 0.0f, 1.0f);
 }
 
-float32_t OrbitoneParameter::getFeedback() const
+inline float32_t OrbitoneParameter::getFeedback() const
 {
     return this->feedback_;
 }

src/fx_orbitone.h

@@ -67,7 +67,7 @@ public:
     virtual void processSample(float32_t inL, float32_t inR, float32_t& outL, float32_t& outR) override;
 
     void setFeedback(float32_t feedback);
-    inline float32_t getFeedback() const;
+    float32_t getFeedback() const;
 
 private:
     OrbitoneParameter params_;

src/fx_phaser.cpp

@@ -120,7 +120,7 @@ void Phaser::setFrequency(float32_t frequency)
     this->phase_increment_ = 2.0f * PI * frequency / this->getSamplingRate();
 }
 
-float32_t Phaser::getFrequency() const
+inline float32_t Phaser::getFrequency() const
 {
     return this->params_.getFrequency();
 }
@@ -130,7 +130,7 @@ void Phaser::setQ(float32_t q)
     this->params_.setQ(q);
 }
 
-float32_t Phaser::getQ() const
+inline float32_t Phaser::getQ() const
 {
     return this->params_.getQ();
 }

src/fx_phaser.h

@@ -73,10 +73,10 @@ public:
     virtual void processSample(float32_t inL, float32_t inR, float32_t& outL, float32_t& outR) override;
 
     void setFrequency(float32_t frequency);
-    inline float32_t getFrequency() const;
+    float32_t getFrequency() const;
 
     void setQ(float32_t q);
-    inline float32_t getQ() const;
+    float32_t getQ() const;
 
 private:
     PhaserParameter params_;

src/fx_rack.cpp

@@ -1,8 +1,12 @@
 #include "fx_rack.h"
 
-FXRack::FXRack(float32_t sampling_rate) :
+#include <cassert>
+
+FXRack::FXRack(float32_t sampling_rate, bool enable) :
     FX(sampling_rate),
-    fx_chain_()
+    FXElement(sampling_rate),
+    enable_(enable),
+    fx_chain_(sampling_rate)
 {
     this->fxTube_ = new FXUnit<Tube>(sampling_rate);
     this->fxChorus_ = new FXUnit<Chorus>(sampling_rate);
@@ -38,6 +42,17 @@ FXRack::~FXRack()
     delete this->fxShimmerReverb_;
 }
 
+void FXRack::processSample(float32_t inL, float32_t inR, float32_t& outL, float32_t& outR)
+{
+    for(FXChain::iterator it = this->fx_chain_.begin(); it != this->fx_chain_.end(); it++)
+    {
+        (*it)->processSample(inL, inR, outL, outR);
+
+        inL = outL;
+        inR = outR;
+    }
+}
+
 void FXRack::process(float32_t* left_input, float32_t* right_input, float32_t* left_output, float32_t* right_output, size_t nSamples)
 {
     float32_t sampleInL;
@@ -52,12 +67,14 @@ void FXRack::process(float32_t* left_input, float32_t* right_input, float32_t* l
         sampleOutL = 0.0f;
         sampleOutR = 0.0f;
 
-        for(FXChain::iterator it = this->fx_chain_.begin(); it != this->fx_chain_.end(); it++)
+        if(this->isEnable()) 
         {
-            (*it)->processSample(sampleInL, sampleInR, sampleOutL, sampleOutR);
+            this->processSample(sampleInL, sampleInR, sampleOutL, sampleOutR);
-
+        }
-            sampleInL = sampleOutL;
+        else
-            sampleInR = sampleOutR;
+        {
+            sampleOutL = sampleInL;
+            sampleOutR = sampleInR;
         }
 
         *left_output = sampleOutL;
@@ -73,7 +90,53 @@ void FXRack::process(float32_t* left_input, float32_t* right_input, float32_t* l
     }
 }
 
+void FXRack::setEnable(bool enable)
+{
+    this->enable_ = enable;
+}
+
+bool FXRack::isEnable() const
+{
+    return this->enable_;
+}
+
 void FXRack::registerFX(FXElement* fx)
 {
+    assert(fx);
     this->fx_chain_.push_back(fx);
 }
+
+FXUnit<Tube>* FXRack::getTube()
+{
+    return this->fxTube_;
+}
+
+FXUnit<Chorus>* FXRack::getChorus()
+{
+    return this->fxChorus_;
+}
+
+FXUnit<Flanger>* FXRack::getFlanger()
+{
+    return this->fxFlanger_;
+}
+
+FXUnit<Orbitone>* FXRack::getOrbitone()
+{
+    return this->fxOrbitone_;
+}
+
+FXUnit<Phaser>* FXRack::getPhaser()
+{
+    return this->fxPhaser_;
+}
+
+FXUnit<TapeDelay>* FXRack::getTapeDelay()
+{
+    return this->fxTapeDelay_;
+}
+
+FXUnit<ShimmerReverb>* FXRack::getShimmerReverb()
+{
+    return this->fxShimmerReverb_;
+}

src/fx_rack.h

@@ -36,10 +36,11 @@ class FXUnit : public virtual _FXElement
     DISALLOW_COPY_AND_ASSIGN(FXUnit);
 
 public:
-    FXUnit(float32_t sampling_rate, float32_t wet_level = 0.5f) :
+    FXUnit(float32_t sampling_rate, bool enable = true, float32_t wet_level = 0.5f) :
-        _FXElement(sampling_rate),
+        _FXElement(sampling_rate)
-        wet_level_(wet_level)
     {
+        this->setEnable(enable);
+        this->setWetLevel(wet_level);
     }
 
     virtual ~FXUnit()
@@ -48,7 +49,7 @@ public:
 
     void processSample(float32_t inL, float32_t inR, float32_t& outL, float32_t& outR)
     {
-        if(this->getWetLevel() == 0.0f)
+        if(!this->isEnable() || this->getWetLevel() == 0.0f)
         {
             outL = inL;
             outR = inR;
@@ -62,6 +63,16 @@ public:
         }
     }
 
+    void setEnable(bool enable = true)
+    {
+        this->enable_ = enable;
+    }
+
+    inline bool isEnable() const
+    {
+        return this->enable_;
+    }
+
     void setWetLevel(float32_t wet_level)
     {
         this->wet_level_ = constrain(wet_level, 0.0f, 1.0f);
@@ -73,24 +84,39 @@ public:
     }
 
 private:
+    bool enable_;
     float32_t wet_level_;   // How much the signal is affected by the inner FX (0.0 - 1.0)
 };
 
 typedef std::vector<FXElement*> FXChain;
 
-class FXRack : public FX
+class FXRack : virtual public FX, virtual public FXElement
 {
     DISALLOW_COPY_AND_ASSIGN(FXRack);
 
 public:
-    FXRack(float32_t sampling_rate);
+    FXRack(float32_t sampling_rate, bool enable = true);
     virtual ~FXRack();
 
+    virtual void processSample(float32_t inL, float32_t inR, float32_t& outL, float32_t& outR) override;
     virtual void process(float32_t* left_input, float32_t* right_input, float32_t* left_output, float32_t* right_output, size_t nSamples) override;
 
+    void setEnable(bool enable = true);
+    bool isEnable() const;
+
+    FXUnit<Tube>* getTube();
+    FXUnit<Chorus>* getChorus();
+    FXUnit<Flanger>* getFlanger();
+    FXUnit<Orbitone>* getOrbitone();
+    FXUnit<Phaser>* getPhaser();
+    FXUnit<TapeDelay>* getTapeDelay();
+    FXUnit<ShimmerReverb>* getShimmerReverb();
+
 private:
     void registerFX(FXElement* fx);
 
+    bool enable_;
+
     FXChain fx_chain_;
     FXUnit<Tube>* fxTube_;
     FXUnit<Chorus>* fxChorus_;

src/fx_shimmer_reverb.cpp

@@ -120,4 +120,3 @@ float32_t ShimmerReverb::getDecayTime() const
 {
     return this->decay_time_;
 }
-

src/fx_shimmer_reverb.h

@@ -40,19 +40,19 @@ public:
     virtual void processSample(float32_t inL, float32_t inR, float32_t& outL, float32_t& outR) override;
 
     void setLeftDelayTime(float32_t delay_time_L);
-    inline float32_t getLeftDelayTime() const;
+    float32_t getLeftDelayTime() const;
 
     void setRightDelayTime(float32_t delay_time_R);
-    inline float32_t getRightDelayTime() const;
+    float32_t getRightDelayTime() const;
 
     void setShimmerFrequency(float32_t frequency);
-    inline float32_t getShimmerFrequency() const;
+    float32_t getShimmerFrequency() const;
 
     void setShimmerAmplitude(float32_t amplitude);
-    inline float32_t getShimmerAmplitude() const;
+    float32_t getShimmerAmplitude() const;
 
     void setDecayTime(float32_t decay_time);
-    inline float32_t getDecayTime() const;
+    float32_t getDecayTime() const;
 
 private:
     const unsigned DelayLineLength;

src/fx_tape_delay.cpp

@@ -69,7 +69,7 @@ void TapeDelay::setDelayTime(float32_t delay_time)
     this->delay_time_ = constrain(delay_time, 0.0f, 1.0f);
 }
 
-inline float32_t TapeDelay::getDelayTime() const
+float32_t TapeDelay::getDelayTime() const
 {
     return this->delay_time_;
 }
@@ -79,7 +79,7 @@ void TapeDelay::setFlutterLevel(float32_t flutter_level)
     this->flutter_level_ = constrain(flutter_level, 0.0f, 1.0f); 
 }
 
-inline float32_t TapeDelay::getFlutterLevel() const
+float32_t TapeDelay::getFlutterLevel() const
 {
     return this->flutter_level_;
 }
@@ -89,12 +89,12 @@ void TapeDelay::setFeedbakLevel(float32_t feedback)
     this->feedback_ = constrain(feedback, 0.0, 1.0);
 }
 
-inline float32_t TapeDelay::getFeedbackLevel() const
+float32_t TapeDelay::getFeedbackLevel() const
 {
     return this->feedback_;
 }
 
-inline float32_t TapeDelay::getFlutteredDelayTime()
+float32_t TapeDelay::getFlutteredDelayTime()
 {
     // Genarate a random number in the range [-1.0 , 1.0]
     float32_t r = 

src/fx_tape_delay.h

@@ -36,13 +36,13 @@ public:
     virtual void processSample(float32_t inL, float32_t inR, float32_t& outL, float32_t& outR) override;
 
     void setDelayTime(float32_t delay_time);
-    inline float32_t getDelayTime() const;
+    float32_t getDelayTime() const;
 
     void setFlutterLevel(float32_t flutter_level);
-    inline float32_t getFlutterLevel() const;
+    float32_t getFlutterLevel() const;
 
     void setFeedbakLevel(float32_t feedback);
-    inline float32_t getFeedbackLevel() const;
+    float32_t getFeedbackLevel() const;
 
 private:
     inline float32_t getFlutteredDelayTime();

src/fx_tube.h

@@ -31,7 +31,7 @@ public:
     virtual void processSample(float32_t inL, float32_t inR, float32_t& outL, float32_t& outR) override;
 
     void setOverdrive(float32_t overdrive);
-    inline float32_t getOverdrive() const;
+    float32_t getOverdrive() const;
 
 private:
     const float32_t TubeCurve;

src/minidexed.cpp

@@ -156,6 +156,12 @@ CMiniDexed::CMiniDexed (CConfig *pConfig, CInterruptSystem *pInterrupt,
 	SetParameter (ParameterReverbLevel, 99);
 	// END setup reverb
 
+	// BEGIN setup FXRack
+#ifdef ARM_ALLOW_MULTI_CORE
+	this->fx_rack = new FXRack(static_cast<float32_t>(pConfig->GetSampleRate()));
+#endif
+	// END setup FXRack
+
 	SetParameter (ParameterCompressorEnable, 1);
 };
 
@@ -686,6 +692,126 @@ void CMiniDexed::SetParameter (TParameter Parameter, int nValue)
 		m_ReverbSpinLock.Release ();
 		break;
 
+#ifdef ARM_ALLOW_MULTI_CORE
+	// BEGIN FXChain parameters
+	case ParameterFXChainEnable: 
+		break;
+	
+	// FXChain > Tube parameters
+	case ParameterFXChainTubeEnable: 
+		this->setFXChainTubeEnable(0);
+		break;
+	case ParameterFXChainTubeWet: 
+		this->setFXChainTubeWet(0);
+		break;
+	case ParameterFXChainTubeOverdrive: 
+		this->setFXChainTubeOverdrive(0);
+		break;
+	
+	// FXChain > Chorus parameters
+	case ParameterFXChainChorusEnable: 
+		this->setFXChainChorusEnable(0);
+		break;
+	case ParameterFXChainChorusWet: 
+		this->setFXChainChorusWet(0);
+		break;
+	case ParameterFXChainChorusRate: 
+		this->setFXChainChorusRate(0);
+		break;
+	case ParameterFXChainChorusDepth: 
+		this->setFXChainChorusDepth(0);
+		break;
+	case ParameterFXChainChorusFeedback: 
+		this->setFXChainChorusFeedback(0);
+		break;
+	
+	// FXChain > Flanger parameters
+	case ParameterFXChainFlangerEnable: 
+		this->setFXChainFlangerEnable(0);
+		break;
+	case ParameterFXChainFlangerWet: 
+		this->setFXChainFlangerWet(0);
+		break;
+	case ParameterFXChainFlangerDelayTime: 
+		this->setFXChainFlangerDelayTime(0);
+		break;
+	case ParameterFXChainFlangerRate: 
+		this->setFXChainFlangerRate(0);
+		break;
+	case ParameterFXChainFlangerDepth: 
+		this->setFXChainFlangerDepth(0);
+		break;
+	case ParameterFXChainFlangerFeedback: 
+		this->setFXChainFlangerFeedback(0);
+		break;
+	
+	// FXChain > Orbitone parameters
+	case ParameterFXChainOrbitoneEnable: 
+		this->setFXChainOrbitoneEnable(0);
+		break;
+	case ParameterFXChainOrbitoneWet: 
+		this->setFXChainOrbitoneWet(0);
+		break;
+	case ParameterFXChainOrbitoneFeedback: 
+		this->setFXChainOrbitoneFeedback(0);
+		break;
+	
+	// FXChain > Phaser parameters
+	case ParameterFXChainPhaserEnable: 
+		this->setFXChainPhaserEnable(0);
+		break;
+	case ParameterFXChainPhaserWet: 
+		this->setFXChainPhaserWet(0);
+		break;
+	case ParameterFXChainPhaserRate: 
+		this->setFXChainPhaserRate(0);
+		break;
+	case ParameterFXChainPhaserQ: 
+		this->setFXChainPhaserQ(0);
+		break;
+	
+	// FXChain > TapeDelay parameters
+	case ParameterFXChainTapeDelayEnable: 
+		this->setFXChainTapeDelayEnable(0);
+		break;
+	case ParameterFXChainTapeDelayWet: 
+		this->setFXChainTapeDelayWet(0);
+		break;
+	case ParameterFXChainTapeDelayDelayTime: 
+		this->setFXChainTapeDelayDelayTime(0);
+		break;
+	case ParameterFXChainTapeDelayFlutter: 
+		this->setFXChainTapeDelayFlutter(0);
+		break;
+	case ParameterFXChainTapeDelayFeedback: 
+		this->setFXChainTapeDelayFeedback(0);
+		break;
+	
+	// FXChain > ShimmerReverb parameters
+	case ParameterFXChainShimmerReverbEnable: 
+		this->setFXChainShimmerReverbEnable(0);
+		break;
+	case ParameterFXChainShimmerReverbWet: 
+		this->setFXChainShimmerReverbWet(0);
+		break;
+	case ParameterFXChainShimmerReverbDelayTimeLeft: 
+		this->setFXChainShimmerReverbDelayTimeLeft(0);
+		break;
+	case ParameterFXChainShimmerReverbDelayTimeRight: 
+		this->setFXChainShimmerReverbDelayTimeRight(0);
+		break;
+	case ParameterFXChainShimmerReverbFrequency: 
+		this->setFXChainShimmerReverbFrequency(0);
+		break;
+	case ParameterFXChainShimmerReverbAmplitude: 
+		this->setFXChainShimmerReverbAmplitude(0);
+		break;
+	case ParameterFXChainShimmerReverbDecayTime: 
+		this->setFXChainShimmerReverbDecayTime(0);
+		break;
+	// END FXChain parameters
+#endif
+
 	default:
 		assert (0);
 		break;
@@ -1003,6 +1129,22 @@ void CMiniDexed::ProcessSound (void)
 			}
 			// END adding reverb
 	
+			// BEGIN adding FXRack
+			if(this->fx_rack->isEnable())
+			{
+				float32_t FXRackBuffer[2][nFrames];
+				float32_t FXRackSendBuffer[2][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);
+
+				this->reverb_send_mixer->getMix(FXRackSendBuffer[indexL], FXRackSendBuffer[indexR]);
+				this->fx_rack->process(FXRackSendBuffer[indexL], FXRackSendBuffer[indexR], FXRackBuffer[indexL], FXRackBuffer[indexR], nFrames);
+			}
+			// END adding FXRack
+
 			// Convert dual float array (left, right) to single int16 array (left/right)
 			for(uint16_t i=0; i<nFrames;i++)
 			{

src/minidexed.h

@@ -44,6 +44,10 @@
 #include "effect_platervbstereo.h"
 #include "effect_compressor.h"
 
+#ifdef ARM_ALLOW_MULTI_CORE
+#include "fx_rack.h"
+#endif
+
 class CMiniDexed
 #ifdef ARM_ALLOW_MULTI_CORE
 :	public CMultiCoreSupport
@@ -134,6 +138,57 @@ public:
 		ParameterReverbLowPass,
 		ParameterReverbDiffusion,
 		ParameterReverbLevel,
+
+		// FXChain parameters
+		ParameterFXChainEnable,
+
+		// FXChain > Tube parameters
+		ParameterFXChainTubeEnable,
+		ParameterFXChainTubeWet,
+		ParameterFXChainTubeOverdrive,
+
+		// FXChain > Chorus parameters
+		ParameterFXChainChorusEnable,
+		ParameterFXChainChorusWet,
+		ParameterFXChainChorusRate,
+		ParameterFXChainChorusDepth,
+		ParameterFXChainChorusFeedback,
+		
+		// FXChain > Flanger parameters
+		ParameterFXChainFlangerEnable,
+		ParameterFXChainFlangerWet,
+		ParameterFXChainFlangerDelayTime,
+		ParameterFXChainFlangerRate,
+		ParameterFXChainFlangerDepth,
+		ParameterFXChainFlangerFeedback,
+
+		// FXChain > Orbitone parameters
+		ParameterFXChainOrbitoneEnable,
+		ParameterFXChainOrbitoneWet,
+		ParameterFXChainOrbitoneFeedback,
+
+		// FXChain > Phaser parameters
+		ParameterFXChainPhaserEnable,
+		ParameterFXChainPhaserWet,
+		ParameterFXChainPhaserRate,
+		ParameterFXChainPhaserQ,
+
+		// FXChain > TapeDelay parameters
+		ParameterFXChainTapeDelayEnable,
+		ParameterFXChainTapeDelayWet,
+		ParameterFXChainTapeDelayDelayTime,
+		ParameterFXChainTapeDelayFlutter,
+		ParameterFXChainTapeDelayFeedback,
+
+		// FXChain > ShimmerReverb parameters
+		ParameterFXChainShimmerReverbEnable,
+		ParameterFXChainShimmerReverbWet,
+		ParameterFXChainShimmerReverbDelayTimeLeft,
+		ParameterFXChainShimmerReverbDelayTimeRight,
+		ParameterFXChainShimmerReverbFrequency,
+		ParameterFXChainShimmerReverbAmplitude,
+		ParameterFXChainShimmerReverbDecayTime,
+
 		ParameterUnknown
 	};
 
@@ -202,6 +257,45 @@ public:
 
 	void setMasterVolume (float32_t vol);
 
+	// BEGIN FXRack parameters setters
+#ifdef ARM_ALLOW_MULTI_CORE
+	void setFXChainEnable(bool value);
+	void setFXChainTubeEnable(bool value);
+	void setFXChainTubeWet(float32_t value);
+	void setFXChainTubeOverdrive(float32_t value);
+	void setFXChainChorusEnable(bool value);
+	void setFXChainChorusWet(float32_t value);
+	void setFXChainChorusRate(float32_t value);
+	void setFXChainChorusDepth(float32_t value);
+	void setFXChainChorusFeedback(float32_t value);
+	void setFXChainFlangerEnable(bool value);
+	void setFXChainFlangerWet(float32_t value);
+	void setFXChainFlangerDelayTime(float32_t value);
+	void setFXChainFlangerRate(float32_t value);
+	void setFXChainFlangerDepth(float32_t value);
+	void setFXChainFlangerFeedback(float32_t value);
+	void setFXChainOrbitoneEnable(bool value);
+	void setFXChainOrbitoneWet(float32_t value);
+	void setFXChainOrbitoneFeedback(float32_t value);
+	void setFXChainPhaserEnable(bool value);
+	void setFXChainPhaserWet(float32_t value);
+	void setFXChainPhaserRate(float32_t value);
+	void setFXChainPhaserQ(float32_t value);
+	void setFXChainTapeDelayEnable(bool value);
+	void setFXChainTapeDelayWet(float32_t value);
+	void setFXChainTapeDelayDelayTime(float32_t value);
+	void setFXChainTapeDelayFlutter(float32_t value);
+	void setFXChainTapeDelayFeedback(float32_t value);
+	void setFXChainShimmerReverbEnable(bool value);
+	void setFXChainShimmerReverbWet(float32_t value);
+	void setFXChainShimmerReverbDelayTimeLeft(float32_t value);
+	void setFXChainShimmerReverbDelayTimeRight(float32_t value);
+	void setFXChainShimmerReverbFrequency(float32_t value);
+	void setFXChainShimmerReverbAmplitude(float32_t value);
+	void setFXChainShimmerReverbDecayTime(float32_t value);
+#endif
+	// END FXRack parameters setters
+
 private:
 	int16_t ApplyNoteLimits (int16_t pitch, unsigned nTG);	// returns < 0 to ignore note
 	uint8_t m_uchOPMask[CConfig::ToneGenerators];
@@ -290,6 +384,8 @@ private:
 
 	CSpinLock m_ReverbSpinLock;
 
+	FXRack* fx_rack;
+
 	bool m_bSavePerformance;
 	bool m_bSavePerformanceNewFile;
 	bool m_bSetNewPerformance;

src/uimenu.cpp

@@ -82,6 +82,7 @@ const CUIMenu::TMenuItem CUIMenu::s_EffectsMenu[] =
 	{"Compress",	EditGlobalParameter,	0,	CMiniDexed::ParameterCompressorEnable},
 #ifdef ARM_ALLOW_MULTI_CORE
 	{"Reverb",	MenuHandler,		s_ReverbMenu},
+	{"FX Chain", MenuHandler,		s_FXChainMenu},
 #endif
 	{0}
 };
@@ -89,14 +90,14 @@ const CUIMenu::TMenuItem CUIMenu::s_EffectsMenu[] =
 const CUIMenu::TMenuItem CUIMenu::s_EditPitchBendMenu[] =
 {
 	{"Bend Range",	EditTGParameter2,	0,	CMiniDexed::TGParameterPitchBendRange},
-	{"Bend Step",		EditTGParameter2,	0,	CMiniDexed::TGParameterPitchBendStep},
+	{"Bend Step",	EditTGParameter2,	0,	CMiniDexed::TGParameterPitchBendStep},
 	{0}
 };
 
 const CUIMenu::TMenuItem CUIMenu::s_EditPortamentoMenu[] =
 {
 	{"Mode",		EditTGParameter2,	0,	CMiniDexed::TGParameterPortamentoMode},
-	{"Glissando",		EditTGParameter2,	0,	CMiniDexed::TGParameterPortamentoGlissando},
+	{"Glissando",	EditTGParameter2,	0,	CMiniDexed::TGParameterPortamentoGlissando},
 	{"Time",		EditTGParameter2,	0,	CMiniDexed::TGParameterPortamentoTime},
 	{0}
 };
@@ -106,7 +107,7 @@ const CUIMenu::TMenuItem CUIMenu::s_ModulationMenu[] =
 	{"Mod. Wheel",		MenuHandler,	s_ModulationMenuParameters,	CMiniDexed::TGParameterMWRange},
 	{"Foot Control",	MenuHandler,	s_ModulationMenuParameters,	CMiniDexed::TGParameterFCRange},
 	{"Breath Control",	MenuHandler,	s_ModulationMenuParameters,	CMiniDexed::TGParameterBCRange},
-	{"Aftertouch",	MenuHandler,	s_ModulationMenuParameters,	CMiniDexed::TGParameterATRange},
+	{"Aftertouch",		MenuHandler,	s_ModulationMenuParameters,	CMiniDexed::TGParameterATRange},
 	{0}
 };
 
@@ -123,13 +124,96 @@ const CUIMenu::TMenuItem CUIMenu::s_ModulationMenuParameters[] =
 
 const CUIMenu::TMenuItem CUIMenu::s_ReverbMenu[] =
 {
-	{"Enable",	EditGlobalParameter,	0,	CMiniDexed::ParameterReverbEnable},
+	{"Enable",		EditGlobalParameter,	0,	CMiniDexed::ParameterReverbEnable},
-	{"Size",	EditGlobalParameter,	0,	CMiniDexed::ParameterReverbSize},
+	{"Size",		EditGlobalParameter,	0,	CMiniDexed::ParameterReverbSize},
 	{"High damp",	EditGlobalParameter,	0,	CMiniDexed::ParameterReverbHighDamp},
 	{"Low damp",	EditGlobalParameter,	0,	CMiniDexed::ParameterReverbLowDamp},
 	{"Low pass",	EditGlobalParameter,	0,	CMiniDexed::ParameterReverbLowPass},
 	{"Diffusion",	EditGlobalParameter,	0,	CMiniDexed::ParameterReverbDiffusion},
-	{"Level",	EditGlobalParameter,	0,	CMiniDexed::ParameterReverbLevel},
+	{"Level",		EditGlobalParameter,	0,	CMiniDexed::ParameterReverbLevel},
+	{0}
+};
+
+const CUIMenu::TMenuItem CUIMenu::s_FXChainMenu[] = 
+{
+	// FXChain
+	{"Enable",			EditGlobalParameter,	0,	CMiniDexed::ParameterFXChainEnable},
+
+	{"Tube", 			MenuHandler, s_FXChainTube},
+	{"Chorus", 			MenuHandler, s_FXChainChorus},
+	{"Flanger", 		MenuHandler, s_FXChainFlanger},
+	{"Orbitone", 		MenuHandler, s_FXChainOrbitone},
+	{"Phaser", 			MenuHandler, s_FXChainPhaser},
+	{"TapeDelay", 		MenuHandler, s_FXChainTapeDelay},
+	{"ShimmerReverb", 	MenuHandler, s_FXChainShimmerReverb},
+	{0}
+};
+
+const CUIMenu::TMenuItem CUIMenu::s_FXChainTube[] =
+{
+	{"Enable", 		EditGlobalParameter, 	0, CMiniDexed::ParameterFXChainTubeEnable},
+	{"Wet Level", 	EditGlobalParameter,	0, CMiniDexed::ParameterFXChainTubeWet},
+	{"Overdrive",	EditGlobalParameter,	0, CMiniDexed::ParameterFXChainTubeOverdrive},
+	{0}
+};
+
+const CUIMenu::TMenuItem CUIMenu::s_FXChainChorus[] =
+{
+	{"Enable", 		EditGlobalParameter, 	0, CMiniDexed::ParameterFXChainChorusEnable},
+	{"Wet Level", 	EditGlobalParameter,	0, CMiniDexed::ParameterFXChainChorusWet},
+	{"LFO Rate",	EditGlobalParameter,	0, CMiniDexed::ParameterFXChainChorusRate},
+	{"Depth", 		EditGlobalParameter,	0, CMiniDexed::ParameterFXChainChorusDepth},
+	{"Feedback", 	EditGlobalParameter,	0, CMiniDexed::ParameterFXChainChorusFeedback},
+	{0}
+};
+
+const CUIMenu::TMenuItem CUIMenu::s_FXChainFlanger[] =
+{
+	{"Enable", 		EditGlobalParameter, 	0, CMiniDexed::ParameterFXChainFlangerEnable},
+	{"Wet Level", 	EditGlobalParameter,	0, CMiniDexed::ParameterFXChainFlangerWet},
+	{"Delay Time", 	EditGlobalParameter,	0, CMiniDexed::ParameterFXChainFlangerDelayTime},
+	{"LFO Rate",	EditGlobalParameter,	0, CMiniDexed::ParameterFXChainFlangerRate},
+	{"Depth",		EditGlobalParameter,	0, CMiniDexed::ParameterFXChainFlangerDepth},
+	{"Feedback", 	EditGlobalParameter,	0, CMiniDexed::ParameterFXChainFlangerFeedback},
+	{0}
+};
+
+const CUIMenu::TMenuItem CUIMenu::s_FXChainOrbitone[] =
+{
+	{"Enable", 		EditGlobalParameter, 	0, CMiniDexed::ParameterFXChainOrbitoneEnable},
+	{"Wet Level", 	EditGlobalParameter,	0, CMiniDexed::ParameterFXChainOrbitoneWet},
+	{"Feedback", 	EditGlobalParameter,	0, CMiniDexed::ParameterFXChainOrbitoneFeedback},
+	{0}
+};
+
+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},
+	{0}
+};
+
+const CUIMenu::TMenuItem CUIMenu::s_FXChainTapeDelay[] =
+{
+	{"Enable", 		EditGlobalParameter, 	0, CMiniDexed::ParameterFXChainTapeDelayEnable},
+	{"Wet Level", 	EditGlobalParameter,	0, CMiniDexed::ParameterFXChainTapeDelayWet},
+	{"Delay Time",	EditGlobalParameter,	0, CMiniDexed::ParameterFXChainTapeDelayDelayTime},
+	{"Flutter",		EditGlobalParameter,	0, CMiniDexed::ParameterFXChainTapeDelayFlutter},
+	{"Feedback", 	EditGlobalParameter,	0, CMiniDexed::ParameterFXChainTapeDelayFeedback},
+	{0}
+};
+
+const CUIMenu::TMenuItem CUIMenu::s_FXChainShimmerReverb[] =
+{
+	{"Enable", 		EditGlobalParameter, 	0, CMiniDexed::ParameterFXChainShimmerReverbEnable},
+	{"Wet Level", 	EditGlobalParameter,	0, CMiniDexed::ParameterFXChainShimmerReverbWet},
+	{"Delay Left",	EditGlobalParameter,	0, CMiniDexed::ParameterFXChainShimmerReverbDelayTimeLeft},
+	{"Delay Right",	EditGlobalParameter,	0, CMiniDexed::ParameterFXChainShimmerReverbDelayTimeRight},
+	{"Frequency",	EditGlobalParameter,	0, CMiniDexed::ParameterFXChainShimmerReverbFrequency},
+	{"Amplitude",	EditGlobalParameter,	0, CMiniDexed::ParameterFXChainShimmerReverbAmplitude},
+	{"Decay Time",	EditGlobalParameter,	0, CMiniDexed::ParameterFXChainShimmerReverbDecayTime},
 	{0}
 };
 

src/uimenu.h

@@ -138,7 +138,17 @@ private:
 	static const TMenuItem s_MainMenu[];
 	static const TMenuItem s_TGMenu[];
 	static const TMenuItem s_EffectsMenu[];
+#ifdef ARM_ALLOW_MULTI_CORE
 	static const TMenuItem s_ReverbMenu[];
+	static const TMenuItem s_FXChainMenu[];
+	static const TMenuItem s_FXChainTube[];
+	static const TMenuItem s_FXChainChorus[];
+	static const TMenuItem s_FXChainFlanger[];
+	static const TMenuItem s_FXChainOrbitone[];
+	static const TMenuItem s_FXChainPhaser[];
+	static const TMenuItem s_FXChainTapeDelay[];
+	static const TMenuItem s_FXChainShimmerReverb[];
+#endif
 	static const TMenuItem s_EditVoiceMenu[];
 	static const TMenuItem s_OperatorMenu[];
 	static const TMenuItem s_SaveMenu[];