Your ROOT_URL in app.ini is https://source.parasitstudio.de:63000/ but you are visiting https://source.parasitstudio.de/wirtz/MiniDexed/commit/a376b41e721e2079ff6077880a74914534fcd3a1?style=split&whitespace=show-all You should set ROOT_URL correctly, otherwise the web may not work correctly.
wirtz
/
MiniDexed
mirror of https://github.com/probonopd/MiniDexed
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Fixing the Chorus and enhancing the FXEngine to disable internal LFO

Browse Source
pull/409/head
abscisys 3 years ago
parent acc96b1291
commit a376b41e72
6 changed files with 126 additions and 94 deletions
  1. 118
      src/fx_chorus.cpp
  2. 24
      src/fx_chorus.h
  3. 5
      src/fx_components.cpp
  4. 3
      src/fx_components.h
  5. 62
      src/fx_engine.hpp
  6. 8
      src/test/fxrack_test.cpp

118
src/fx_chorus.cpp
Unescape View File

@ -4,89 +4,92 @@
#define CHORUS_BUFFER_SIZE 8192 #define CHORUS_BUFFER_SIZE 8192
#define LFO_MIN_FREQ 0.0f #define LFO1_MAX_FREQ 0.25f
#define LFO_MAX_FREQ 1.0f #define LFO2_MAX_FREQ 0.35f
Chorus::Chorus(float32_t sampling_rate, unsigned voices, float32_t rate, float32_t depth, float32_t feedback) : #define FULLSCALE_DEPTH_RATIO 384.0f
Chorus::Chorus(float32_t sampling_rate) :
FXElement(sampling_rate), FXElement(sampling_rate),
NumVoices(voices), engine_(sampling_rate, LFO1_MAX_FREQ, LFO2_MAX_FREQ),
sample_position_ratio_(sampling_rate / 1000.0f), rate_(0.0f),
lfo_(sampling_rate, LFO::Waveform::Sine, LFO_MIN_FREQ, LFO_MAX_FREQ) depth_(0.0f),
fullscale_depth_(0.0f),
feedback_(0.0f)
{ {
this->delay_buffersL_ = new float32_t*[this->NumVoices]; this->lfo_[LFO_Index::Sin1] = new LFO(sampling_rate, LFO::Waveform::Sine, 0.0f, LFO1_MAX_FREQ);
this->delay_buffersR_ = new float32_t*[this->NumVoices]; this->lfo_[LFO_Index::Cos1] = new LFO(sampling_rate, LFO::Waveform::Sine, 0.0f, LFO1_MAX_FREQ, Constants::MPI_2);
this->lfo_[LFO_Index::Sin2] = new LFO(sampling_rate, LFO::Waveform::Sine, 0.0f, LFO2_MAX_FREQ);
for(unsigned i = 0; i < this->NumVoices; ++i) this->lfo_[LFO_Index::Cos2] = new LFO(sampling_rate, LFO::Waveform::Sine, 0.0f, LFO2_MAX_FREQ, Constants::MPI_2);
{
this->delay_buffersL_[i] = new float32_t[CHORUS_BUFFER_SIZE]; this->setRate(0.1f);
this->delay_buffersR_[i] = new float32_t[CHORUS_BUFFER_SIZE]; this->setDepth(0.15f);
} this->setFeedback(0.15f);
this->delay_buffer_indices_ = new unsigned[this->NumVoices];
memset(this->delay_buffer_indices_, 0, this->NumVoices * sizeof(float32_t));
this->setRate(rate);
this->setDepth(depth);
this->setFeedback(feedback);
} }
Chorus::~Chorus() Chorus::~Chorus()
{ {
for(unsigned i = 0; i < this->NumVoices; ++i) for(unsigned i = 0; i < 4; ++i)
{ {
delete[] this->delay_buffersL_[i]; delete this->lfo_[i];
delete[] this->delay_buffersR_[i];
} }
delete[] this->delay_buffersL_;
delete[] this->delay_buffersR_;
delete[] this->delay_buffer_indices_;
} }
void Chorus::processSample(float32_t inL, float32_t inR, float32_t& outL, float32_t& outR) void Chorus::processSample(float32_t inL, float32_t inR, float32_t& outL, float32_t& outR)
{ {
float32_t sumL = 0.0f; typedef Engine::Reserve<2047> Memory;
float32_t sumR = 0.0f; Engine::DelayLine<Memory, 0> line;
for(unsigned i = 0; i < this->NumVoices; ++i) { Engine::Context c;
// Calculate the delay time based on the depth and rate parameters
float32_t delay = this->getDepth() * this->lfo_.process(); engine_.start(&c);
// Convert the delay time to samples // Update LFO.
unsigned delay_samples = static_cast<unsigned>(delay * this->sample_position_ratio_); float32_t sin_1 = this->lfo_[LFO_Index::Sin1]->process() * 4.0f;
float32_t cos_1 = this->lfo_[LFO_Index::Cos1]->process() * 4.0f;
// Mix the input audio with the delayed audio float32_t sin_2 = this->lfo_[LFO_Index::Sin2]->process() * 4.0f;
sumL += inL + this->delay_buffersL_[i][(CHORUS_BUFFER_SIZE + this->delay_buffer_indices_[i] - delay_samples) % CHORUS_BUFFER_SIZE]; float32_t cos_2 = this->lfo_[LFO_Index::Cos2]->process() * 4.0f;
sumR += inR + this->delay_buffersR_[i][(CHORUS_BUFFER_SIZE + this->delay_buffer_indices_[i] - delay_samples) % CHORUS_BUFFER_SIZE];
float32_t wet;
// Update the delay buffer for this voice
this->delay_buffersL_[i][this->delay_buffer_indices_[i]] = inL + sumL * this->getFeedback() / static_cast<float32_t>(i + 1); // Sum L & R channel to send to chorus line.
this->delay_buffersR_[i][this->delay_buffer_indices_[i]] = inR + sumR * this->getFeedback() / static_cast<float32_t>(i + 1); c.read(inL, 0.5f);
this->delay_buffer_indices_[i] = (delay_buffer_indices_[i] + 1) % CHORUS_BUFFER_SIZE; c.read(inR, 0.5f);
} c.write(line, 0.0f);
// Average the mixed audio from all voices to create the output c.interpolate(line, sin_1 * this->fullscale_depth_ + 1200, 0.5f);
outL = sumL / static_cast<float32_t>(this->NumVoices); c.interpolate(line, sin_2 * this->fullscale_depth_ + 800, 0.5f);
outR = sumR / static_cast<float32_t>(this->NumVoices); c.write(wet, 0.0f);
outL = wet;
c.interpolate(line, cos_1 * this->fullscale_depth_ + 800, 0.5f);
c.interpolate(line, cos_2 * this->fullscale_depth_ + 1200, 0.5f);
c.write(wet, 0.0f);
outR = wet;
} }
void Chorus::setDepth(float32_t depth) void Chorus::setRate(float32_t rate)
{ {
this->depth_ = constrain(depth, 0.0f, 10.0f); this->rate_ = constrain(rate, 0.0f, 1.0f);
for(unsigned i = 0; i < 4; ++i)
{
this->lfo_[i]->setNormalizedFrequency(this->rate_);
}
} }
float32_t Chorus::getDepth() const float32_t Chorus::getRate() const
{ {
return this->depth_; return this->depth_;
} }
void Chorus::setRate(float32_t rate) void Chorus::setDepth(float32_t depth)
{ {
this->lfo_.setNormalizedFrequency(rate); this->depth_ = constrain(depth, 0.0f, 1.0f);
this->fullscale_depth_ = this->depth_ * FULLSCALE_DEPTH_RATIO;
} }
float32_t Chorus::getRate() const float32_t Chorus::getDepth() const
{ {
return this->lfo_.getNormalizedFrequency(); return this->depth_;
} }
void Chorus::setFeedback(float32_t feedback) void Chorus::setFeedback(float32_t feedback)
@ -98,4 +101,3 @@ float32_t Chorus::getFeedback() const
{ {
return this->feedback_; return this->feedback_;
} }

24
src/fx_chorus.h
Unescape View File

@ -15,17 +15,27 @@
// fx_chorus.h // fx_chorus.h
// //
// Stereo Chorus audio effects proposed in the context of the MiniDexed project // Stereo Chorus audio effects proposed in the context of the MiniDexed project
// This implemelntation is based on the Chorus FX from the Rings Eurorack module from Mutable Instruments
// //
#pragma once #pragma once
#include "fx_components.h" #include "fx_components.h"
#include "fx_engine.hpp"
class Chorus : public FXElement class Chorus : public FXElement
{ {
DISALLOW_COPY_AND_ASSIGN(Chorus); DISALLOW_COPY_AND_ASSIGN(Chorus);
public: public:
Chorus(float32_t sampling_rate, unsigned voices = 4, float32_t rate = 0.1f, float32_t depth = 5.0f, float32_t feedback = 0.5f); enum LFO_Index
{
Sin1 = 0,
Sin2,
Cos1,
Cos2
};
Chorus(float32_t sampling_rate);
virtual ~Chorus(); virtual ~Chorus();
virtual void processSample(float32_t inL, float32_t inR, float32_t& outL, float32_t& outR) override; virtual void processSample(float32_t inL, float32_t inR, float32_t& outL, float32_t& outR) override;
@ -40,13 +50,13 @@ public:
float32_t getFeedback() const; float32_t getFeedback() const;
private: private:
const unsigned NumVoices; // Number of voices in the chorus typedef FxEngine<2048, FORMAT_16_BIT, false> Engine;
const float32_t sample_position_ratio_; Engine engine_;
float32_t** delay_buffersL_;
float32_t** delay_buffersR_;
unsigned* delay_buffer_indices_;
LFO lfo_; float32_t rate_; // Normalized frequency for the 2 LFOs frequencies (0.0 - 10.0)
float32_t depth_; // Depth of the chorus in milliseconds (0.0 - 10.0) float32_t depth_; // Depth of the chorus in milliseconds (0.0 - 10.0)
float32_t fullscale_depth_; // Equivalent to depth_ but in the range of (0.0 - 384.0)
float32_t feedback_; // Feedback level of the chorus (0.0 - 1.0) float32_t feedback_; // Feedback level of the chorus (0.0 - 1.0)
LFO* lfo_[4];
}; };

5
src/fx_components.cpp
Unescape View File

@ -6,19 +6,20 @@
// Constants implemlentation // // Constants implemlentation //
/////////////////////////////// ///////////////////////////////
const float32_t Constants::M2PI = 2.0f * PI; const float32_t Constants::M2PI = 2.0f * PI;
const float32_t Constants::MPI_2 = PI / 2.0f;
const float32_t Constants::M1_PI = 1.0f / PI; const float32_t Constants::M1_PI = 1.0f / PI;
///////////////////////// /////////////////////////
// LFO implemlentation // // LFO implemlentation //
///////////////////////// /////////////////////////
LFO::LFO(float32_t sampling_rate, Waveform waveform, float32_t min_frequency, float32_t max_frequency) : LFO::LFO(float32_t sampling_rate, Waveform waveform, float32_t min_frequency, float32_t max_frequency, float32_t initial_phase) :
FXBase(sampling_rate), FXBase(sampling_rate),
min_frequency_(min_frequency), min_frequency_(min_frequency),
max_frequency_(max_frequency), max_frequency_(max_frequency),
waveform_(waveform), waveform_(waveform),
normalized_frequency_(-1.0f), normalized_frequency_(-1.0f),
frequency_(0.0f), frequency_(0.0f),
phase_(0.0f), phase_(initial_phase),
phase_increment_(0.0f), phase_increment_(0.0f),
current_sample_(0.0f), current_sample_(0.0f),
new_phase_(true), new_phase_(true),

3
src/fx_components.h
Unescape View File

@ -25,6 +25,7 @@
struct Constants struct Constants
{ {
const static float32_t M2PI; // 2 * PI const static float32_t M2PI; // 2 * PI
const static float32_t MPI_2; // PI / 2
const static float32_t M1_PI; // 1 / PI const static float32_t M1_PI; // 1 / PI
}; };
@ -41,7 +42,7 @@ public:
Noise Noise
} Waveform; } Waveform;
LFO(float32_t sampling_rate, Waveform waveform = Waveform::Sine, float32_t min_frequency = 0.01f, float32_t max_frequency = 10.0f); LFO(float32_t sampling_rate, Waveform waveform = Waveform::Sine, float32_t min_frequency = 0.01f, float32_t max_frequency = 10.0f, float32_t initial_phase = 0.0f);
~LFO(); ~LFO();
void setWaveform(Waveform waveform); void setWaveform(Waveform waveform);

62
src/fx_engine.hpp
Unescape View File

@ -61,7 +61,8 @@ struct DataType<FORMAT_16_BIT>
template < template <
size_t size, size_t size,
Format format = FORMAT_16_BIT> Format format = FORMAT_16_BIT,
bool enable_lfo = true>
class FxEngine : public FXBase class FxEngine : public FXBase
{ {
DISALLOW_COPY_AND_ASSIGN(FxEngine); DISALLOW_COPY_AND_ASSIGN(FxEngine);
@ -69,20 +70,23 @@ class FxEngine : public FXBase
public: public:
typedef typename DataType<format>::T T; typedef typename DataType<format>::T T;
FxEngine(float32_t sampling_rate, float32_t max_lfo_frequency = 1.0f) : FxEngine(float32_t sampling_rate, float32_t max_lfo1_frequency = 1.0f, float32_t max_lfo2_frequency = 1.0f) :
FXBase(sampling_rate) FXBase(sampling_rate)
{ {
this->buffer_ = new uint16_t[size]; this->buffer_ = new uint16_t[size];
this->lfo_[LFO_1] = new LFO(sampling_rate, LFO::Waveform::Sine, 0.0f, max_lfo_frequency); this->lfo_[LFO_1] = enable_lfo ? new LFO(sampling_rate, LFO::Waveform::Sine, 0.0f, max_lfo1_frequency) : nullptr;
this->lfo_[LFO_2] = new LFO(sampling_rate, LFO::Waveform::Sine, 0.0f, max_lfo_frequency); this->lfo_[LFO_2] = enable_lfo ? new LFO(sampling_rate, LFO::Waveform::Sine, 0.0f, max_lfo2_frequency) : nullptr;
this->clear(); this->clear();
} }
~FxEngine() ~FxEngine()
{ {
delete[] this->buffer_; delete[] this->buffer_;
delete this->lfo_[LFO_1]; if(enable_lfo)
delete this->lfo_[LFO_2]; {
delete this->lfo_[LFO_1];
delete this->lfo_[LFO_2];
}
} }
void clear() void clear()
@ -159,19 +163,19 @@ public:
this->accumulator_ += value; this->accumulator_ += value;
} }
inline void write(float32_t &value) inline void write(float32_t& value)
{ {
value = this->accumulator_; value = this->accumulator_;
} }
inline void write(float32_t &value, float32_t scale) inline void write(float32_t& value, float32_t scale)
{ {
value = this->accumulator_; value = this->accumulator_;
this->accumulator_ *= scale; this->accumulator_ *= scale;
} }
template <typename D> template <typename D>
inline void write(D &d, int32_t offset, float32_t scale) inline void write(D& d, int32_t offset, float32_t scale)
{ {
assert(D::base + D::length <= size); assert(D::base + D::length <= size);
T w = DataType<format>::compress(this->accumulator_); T w = DataType<format>::compress(this->accumulator_);
@ -187,26 +191,26 @@ public:
} }
template <typename D> template <typename D>
inline void write(D &d, float32_t scale) inline void write(D& d, float32_t scale)
{ {
this->write(d, 0, scale); this->write(d, 0, scale);
} }
template <typename D> template <typename D>
inline void writeAllPass(D &d, int32_t offset, float32_t scale) inline void writeAllPass(D& d, int32_t offset, float32_t scale)
{ {
this->write(d, offset, scale); this->write(d, offset, scale);
this->accumulator_ += this->previous_read_; this->accumulator_ += this->previous_read_;
} }
template <typename D> template <typename D>
inline void writeAllPass(D &d, float32_t scale) inline void writeAllPass(D& d, float32_t scale)
{ {
this->writeAllPass(d, 0, scale); this->writeAllPass(d, 0, scale);
} }
template <typename D> template <typename D>
inline void read(D &d, int32_t offset, float32_t scale) inline void read(D& d, int32_t offset, float32_t scale)
{ {
assert(D::base + D::length <= size); assert(D::base + D::length <= size);
T r; T r;
@ -224,25 +228,25 @@ public:
} }
template <typename D> template <typename D>
inline void read(D &d, float32_t scale) inline void read(D& d, float32_t scale)
{ {
this->read(d, 0, scale); this->read(d, 0, scale);
} }
inline void lp(float32_t &state, float32_t coefficient) inline void lp(float32_t& state, float32_t coefficient)
{ {
state += coefficient * (this->accumulator_ - state); state += coefficient * (this->accumulator_ - state);
this->accumulator_ = state; this->accumulator_ = state;
} }
inline void hp(float32_t &state, float32_t coefficient) inline void hp(float32_t& state, float32_t coefficient)
{ {
state += coefficient * (this->accumulator_ - state); state += coefficient * (this->accumulator_ - state);
this->accumulator_ -= state; this->accumulator_ -= state;
} }
template <typename D> template <typename D>
inline void interpolate(D &d, float32_t offset, float32_t scale) inline void interpolate(D& d, float32_t offset, float32_t scale)
{ {
assert(D::base + D::length <= size); assert(D::base + D::length <= size);
MAKE_INTEGRAL_FRACTIONAL(offset); MAKE_INTEGRAL_FRACTIONAL(offset);
@ -254,10 +258,10 @@ public:
} }
template <typename D> template <typename D>
inline void interpolate(D &d, float32_t offset, LFOIndex index, float32_t amplitude, float32_t scale) inline void interpolate(D& d, float32_t offset, LFOIndex index, float32_t amplitude, float32_t scale)
{ {
assert(D::base + D::length <= size); assert(D::base + D::length <= size);
offset += amplitude * lfo_value_[index]; offset += amplitude * this->lfo_value_[index];
MAKE_INTEGRAL_FRACTIONAL(offset); MAKE_INTEGRAL_FRACTIONAL(offset);
float32_t a = DataType<format>::decompress(this->buffer_[(this->write_ptr_ + offset_integral + D::base) & MASK]); float32_t a = DataType<format>::decompress(this->buffer_[(this->write_ptr_ + offset_integral + D::base) & MASK]);
float32_t b = DataType<format>::decompress(this->buffer_[(this->write_ptr_ + offset_integral + D::base + 1) & MASK]); float32_t b = DataType<format>::decompress(this->buffer_[(this->write_ptr_ + offset_integral + D::base + 1) & MASK]);
@ -276,7 +280,18 @@ public:
inline void setLFOFrequency(LFOIndex index, float32_t frequency) inline void setLFOFrequency(LFOIndex index, float32_t frequency)
{ {
this->lfo_[index]->setFrequency(frequency); if(enable_lfo)
{
this->lfo_[index]->setFrequency(frequency);
}
}
inline void setLFONormalizedFrequency(LFOIndex index, float32_t normalized_frequency)
{
if(enable_lfo)
{
this->lfo_[index]->setNormalizedFrequency(normalized_frequency);
}
} }
inline void start(Context *c) inline void start(Context *c)
@ -290,8 +305,11 @@ public:
c->previous_read_ = 0.0f; c->previous_read_ = 0.0f;
c->buffer_ = buffer_; c->buffer_ = buffer_;
c->write_ptr_ = write_ptr_; c->write_ptr_ = write_ptr_;
c->lfo_value_[LFO_1] = this->lfo_[LFO_1]->process(); if(enable_lfo)
c->lfo_value_[LFO_2] = this->lfo_[LFO_2]->process(); {
c->lfo_value_[LFO_1] = this->lfo_[LFO_1]->process();
c->lfo_value_[LFO_2] = this->lfo_[LFO_2]->process();
}
} }
private: private:

8
src/test/fxrack_test.cpp
Unescape View File

@ -189,10 +189,10 @@ int main()
rack->getTube()->setWetLevel(1.0f); rack->getTube()->setWetLevel(1.0f);
rack->getTube()->setOverdrive(1.0f); rack->getTube()->setOverdrive(1.0f);
rack->getChorus()->setEnable(false); rack->getChorus()->setEnable(true);
rack->getChorus()->setWetLevel(0.5f); rack->getChorus()->setWetLevel(0.5f);
rack->getChorus()->setRate(0.2f); rack->getChorus()->setRate(0.5f);
rack->getChorus()->setDepth(0.15f); rack->getChorus()->setDepth(0.5f);
rack->getChorus()->setFeedback(0.15f); rack->getChorus()->setFeedback(0.15f);
rack->getPhaser()->setEnable(false); rack->getPhaser()->setEnable(false);
@ -210,7 +210,7 @@ int main()
rack->getTapeDelay()->setFlutterLevel(0.0f); rack->getTapeDelay()->setFlutterLevel(0.0f);
rack->getTapeDelay()->setFeedbak(0.5f); rack->getTapeDelay()->setFeedbak(0.5f);
rack->getShimmerReverb()->setEnable(true); rack->getShimmerReverb()->setEnable(false);
rack->getShimmerReverb()->setWetLevel(0.7f); rack->getShimmerReverb()->setWetLevel(0.7f);
rack->getShimmerReverb()->setInputGain(0.45f); rack->getShimmerReverb()->setInputGain(0.45f);
rack->getShimmerReverb()->setTime(0.89f); rack->getShimmerReverb()->setTime(0.89f);

Write Preview
Loading…
Cancel
Save