From d1408c6694b86eb7fc2dc60f3bc60b72d6160dd7 Mon Sep 17 00:00:00 2001 From: abscisys Date: Wed, 28 Dec 2022 01:27:21 +0100 Subject: [PATCH] Start FXRack parameter integration --- src/Makefile | 5 +- src/fx_chorus.h | 6 +- src/fx_flanger.h | 8 +-- src/fx_orbitone.cpp | 2 +- src/fx_orbitone.h | 2 +- src/fx_phaser.cpp | 4 +- src/fx_phaser.h | 4 +- src/fx_rack.cpp | 77 +++++++++++++++++++-- src/fx_rack.h | 38 ++++++++-- src/fx_shimmer_reverb.cpp | 1 - src/fx_shimmer_reverb.h | 10 +-- src/fx_tape_delay.cpp | 8 +-- src/fx_tape_delay.h | 6 +- src/fx_tube.h | 2 +- src/minidexed.cpp | 142 ++++++++++++++++++++++++++++++++++++++ src/minidexed.h | 96 ++++++++++++++++++++++++++ src/uimenu.cpp | 96 ++++++++++++++++++++++++-- src/uimenu.h | 10 +++ 18 files changed, 469 insertions(+), 48 deletions(-) diff --git a/src/Makefile b/src/Makefile index 385770d..7760a27 100644 --- a/src/Makefile +++ b/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 diff --git a/src/fx_chorus.h b/src/fx_chorus.h index dafc858..05456f1 100644 --- a/src/fx_chorus.h +++ b/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 diff --git a/src/fx_flanger.h b/src/fx_flanger.h index fcf43d0..35da343 100644 --- a/src/fx_flanger.h +++ b/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(); diff --git a/src/fx_orbitone.cpp b/src/fx_orbitone.cpp index 1f8b984..d189582 100644 --- a/src/fx_orbitone.cpp +++ b/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_; } diff --git a/src/fx_orbitone.h b/src/fx_orbitone.h index 9add593..8eac4be 100644 --- a/src/fx_orbitone.h +++ b/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_; diff --git a/src/fx_phaser.cpp b/src/fx_phaser.cpp index 6c780b5..c7730dc 100644 --- a/src/fx_phaser.cpp +++ b/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(); } diff --git a/src/fx_phaser.h b/src/fx_phaser.h index 63da390..d7acd24 100644 --- a/src/fx_phaser.h +++ b/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_; diff --git a/src/fx_rack.cpp b/src/fx_rack.cpp index 102f5c1..6996027 100644 --- a/src/fx_rack.cpp +++ b/src/fx_rack.cpp @@ -1,8 +1,12 @@ #include "fx_rack.h" -FXRack::FXRack(float32_t sampling_rate) : +#include + +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(sampling_rate); this->fxChorus_ = new FXUnit(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); - - sampleInL = sampleOutL; - sampleInR = sampleOutR; + this->processSample(sampleInL, sampleInR, sampleOutL, sampleOutR); + } + else + { + 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* FXRack::getTube() +{ + return this->fxTube_; +} + +FXUnit* FXRack::getChorus() +{ + return this->fxChorus_; +} + +FXUnit* FXRack::getFlanger() +{ + return this->fxFlanger_; +} + +FXUnit* FXRack::getOrbitone() +{ + return this->fxOrbitone_; +} + +FXUnit* FXRack::getPhaser() +{ + return this->fxPhaser_; +} + +FXUnit* FXRack::getTapeDelay() +{ + return this->fxTapeDelay_; +} + +FXUnit* FXRack::getShimmerReverb() +{ + return this->fxShimmerReverb_; +} diff --git a/src/fx_rack.h b/src/fx_rack.h index 2bbe483..34aa3cf 100644 --- a/src/fx_rack.h +++ b/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) : - _FXElement(sampling_rate), - wet_level_(wet_level) + FXUnit(float32_t sampling_rate, bool enable = true, float32_t wet_level = 0.5f) : + _FXElement(sampling_rate) { + 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 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* getTube(); + FXUnit* getChorus(); + FXUnit* getFlanger(); + FXUnit* getOrbitone(); + FXUnit* getPhaser(); + FXUnit* getTapeDelay(); + FXUnit* getShimmerReverb(); + private: void registerFX(FXElement* fx); + bool enable_; + FXChain fx_chain_; FXUnit* fxTube_; FXUnit* fxChorus_; diff --git a/src/fx_shimmer_reverb.cpp b/src/fx_shimmer_reverb.cpp index e16b3c9..34a584f 100644 --- a/src/fx_shimmer_reverb.cpp +++ b/src/fx_shimmer_reverb.cpp @@ -120,4 +120,3 @@ float32_t ShimmerReverb::getDecayTime() const { return this->decay_time_; } - diff --git a/src/fx_shimmer_reverb.h b/src/fx_shimmer_reverb.h index 27bbb45..57031fa 100644 --- a/src/fx_shimmer_reverb.h +++ b/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; diff --git a/src/fx_tape_delay.cpp b/src/fx_tape_delay.cpp index c3231f6..f61da73 100644 --- a/src/fx_tape_delay.cpp +++ b/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 = diff --git a/src/fx_tape_delay.h b/src/fx_tape_delay.h index a90d005..41f3081 100644 --- a/src/fx_tape_delay.h +++ b/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(); diff --git a/src/fx_tube.h b/src/fx_tube.h index c007e9f..c1b2a2b 100644 --- a/src/fx_tube.h +++ b/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; diff --git a/src/minidexed.cpp b/src/minidexed.cpp index 0240ea5..c678ade 100644 --- a/src/minidexed.cpp +++ b/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(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 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; diff --git a/src/uimenu.cpp b/src/uimenu.cpp index a1d44ce..3445ab8 100644 --- a/src/uimenu.cpp +++ b/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}, - {"Size", EditGlobalParameter, 0, CMiniDexed::ParameterReverbSize}, + {"Enable", EditGlobalParameter, 0, CMiniDexed::ParameterReverbEnable}, + {"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} }; diff --git a/src/uimenu.h b/src/uimenu.h index 78384be..0325e49 100644 --- a/src/uimenu.h +++ b/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[];