diff --git a/src/fx_flanger.h b/src/fx_flanger.h index 35da343..8edcd6e 100644 --- a/src/fx_flanger.h +++ b/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 }; \ No newline at end of file diff --git a/src/fx_orbitone.h b/src/fx_orbitone.h index 8eac4be..7a9a4de 100644 --- a/src/fx_orbitone.h +++ b/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 diff --git a/src/fx_phaser.cpp b/src/fx_phaser.cpp index c7730dc..8f94183 100644 --- a/src/fx_phaser.cpp +++ b/src/fx_phaser.cpp @@ -2,10 +2,10 @@ #include -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(); } diff --git a/src/fx_phaser.h b/src/fx_phaser.h index d7acd24..737d4d7 100644 --- a/src/fx_phaser.h +++ b/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]; }; \ No newline at end of file diff --git a/src/fx_rack.cpp b/src/fx_rack.cpp index 6996027..b710d76 100644 --- a/src/fx_rack.cpp +++ b/src/fx_rack.cpp @@ -2,10 +2,11 @@ #include -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(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); diff --git a/src/fx_rack.h b/src/fx_rack.h index 34aa3cf..40cc7ac 100644 --- a/src/fx_rack.h +++ b/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* getTube(); FXUnit* getChorus(); FXUnit* getFlanger(); @@ -116,6 +119,7 @@ private: void registerFX(FXElement* fx); bool enable_; + float32_t wet_level_; FXChain fx_chain_; FXUnit* fxTube_; diff --git a/src/fx_shimmer_reverb.cpp b/src/fx_shimmer_reverb.cpp index 34a584f..914cb8f 100644 --- a/src/fx_shimmer_reverb.cpp +++ b/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(SHIMMER_MAX_DELAY_TIME * sampling_rate)), + DelayLineLength(static_cast(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(this->DelayLineLength + this->write_pos_L_ - (this->delay_time_L_ + shimmerOffsetL) * this->getSamplingRate()) % this->DelayLineLength; + unsigned readPosR = static_cast(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]; diff --git a/src/fx_tape_delay.cpp b/src/fx_tape_delay.cpp index f61da73..9a3041f 100644 --- a/src/fx_tape_delay.cpp +++ b/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(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(fluttered_delay_time_L)) % this->MaxSampleDelayTime; - int right_write_pos = this->right_read_pos_ - static_cast(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(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 diff --git a/src/fx_tape_delay.h b/src/fx_tape_delay.h index 41f3081..5978514 100644 --- a/src/fx_tape_delay.h +++ b/src/fx_tape_delay.h @@ -23,7 +23,7 @@ #include -#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_; }; diff --git a/src/minidexed.cpp b/src/minidexed.cpp index 68b0e3b..347123a 100644 --- a/src/minidexed.cpp +++ b/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(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(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) diff --git a/src/minidexed.h b/src/minidexed.h index 6cbd840..525d08e 100644 --- a/src/minidexed.h +++ b/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* tg_mixer; AudioStereoMixer* reverb_send_mixer; - CSpinLock m_ReverbSpinLock; + CSpinLock m_FXSpinLock; FXRack* fx_rack; diff --git a/src/performanceconfig.cpp b/src/performanceconfig.cpp index 7249003..eb9c972 100644 --- a/src/performanceconfig.cpp +++ b/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 diff --git a/src/performanceconfig.h b/src/performanceconfig.h index ec32598..09a2e70 100644 --- a/src/performanceconfig.h +++ b/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 diff --git a/src/uimenu.cpp b/src/uimenu.cpp index 3445ab8..61e97dd 100644 --- a/src/uimenu.cpp +++ b/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 diff --git a/src/userinterface.h b/src/userinterface.h index 5de2846..938b5a2 100644 --- a/src/userinterface.h +++ b/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);