[feat]: Filter LFO (#23)

Reviewed-on: #23
Co-authored-by: HiveBeats <e1lama@protonmail.com>
Co-committed-by: HiveBeats <e1lama@protonmail.com>

src/BandPassFilter.cpp

@@ -1,23 +1,22 @@
 #include "BandPassFilter.h"
+#include "Settings.h"
 
-BandPassFilter::BandPassFilter(/* args */) {}
-
-BandPassFilter::BandPassFilter(Filter* filter) {
-    m_freq = filter->GetFreq();
-    m_q = filter->GetRes();
-    m_order = filter->GetPeakGain();
+BandPassFilter::BandPassFilter() {
+    SetParameters(200, 0.1, 0.001);
 }
 
-BandPassFilter::BandPassFilter(float freq, float res, float q) {}
+BandPassFilter::BandPassFilter(
+    Filter* filter) {
+    SetParameters(filter->GetFreq(), filter->GetRes(), filter->GetPeakGain());
+}
+
+BandPassFilter::BandPassFilter(float freq, float res,
+                                                       float q) {
+    SetParameters(freq, res, q);
+}
 
 BandPassFilter::~BandPassFilter() {}
 
-void BandPassFilter::CalculateCoefficients() {
-    CalculateNormals();
-    m_norm = 1 / (1 + m_k / m_q + m_k * m_k);
-    m_a0 = m_k / m_q * m_norm;
-    m_a1 = 0;
-    m_a2 = -m_a0;
-    m_b1 = 2 * (m_k * m_k - 1) * m_norm;
-    m_b2 = (1 - m_k / m_q + m_k * m_k) * m_norm;
+float BandPassFilter::GetSampleForFilterType() {
+    return m_lowo;
 }

src/Filter.cpp

@@ -1,36 +1,50 @@
 #include "Filter.h"
 #include "Settings.h"
+#include <algorithm>
+#include <cmath>
 
 Filter::Filter(/* args */) {}
 
 Filter::~Filter() {}
 
-void Filter::CalculateNormals() {
-    m_v = powf(10, fabs(m_order) / 20.0);
-    m_k = tanf(M_PI * m_freq);
-}
-
 void Filter::Trigger() {}
 
 void Filter::Release() {}
 
-float Filter::Process(float in) {
-    // may move to a compile-time dictionary calculation, if needed
-    CalculateCoefficients();
-    float out = in * m_a0 + m_z1;
-    m_z1 = in * m_a1 + m_z2 - m_b1 * out;
-    m_z2 = in * m_a2 - m_b2 * out;
-    return out;
-}
-
 void Filter::Process(std::vector<float>& samples) {
     for (std::size_t i = 0; i < samples.size(); i++) {
         samples[i] = Process(samples[i]);
     }
 }
 
-void Filter::SetParameters(float freq, float res, float q) {
-    m_freq = freq / SAMPLE_RATE;
-    m_q = res;
-    m_order = q;
+
+float Filter::Process(float in) {
+    m_notcho = in - m_damp * m_bando;
+    m_lowo = m_lowo + m_freq * m_bando;
+    m_higho = m_notcho - m_lowo;
+    m_bando =
+        m_freq * m_higho + m_bando - m_drive * m_bando * m_bando * m_bando;
+    // (m_notcho or m_lowo or m_higho or m_bando or m_peako)
+    float out = 0.5 * GetSampleForFilterType();
+    m_notcho = in - m_damp * m_bando;
+    m_lowo = m_lowo + m_freq * m_bando;
+    m_higho = m_notcho - m_lowo;
+    m_bando =
+        m_freq * m_higho + m_bando - m_drive * m_bando * m_bando * m_bando;
+    out += 0.5 * GetSampleForFilterType();
+
+    return out;
+}
+
+void Filter::SetParameters(float freq, float res, float drive) {
+    m_fc = freq;
+    m_res = res;
+    m_drive = drive;
+
+    // the fs*2 is because it's double sampled
+    m_freq =
+        2.0 * std::sinf(SYNTH_PI * std::min(0.25f, m_fc / (m_fs * 2)));
+
+    m_damp = std::min(2.0f * (1.0f - std::powf(m_res, 0.25f)),
+                            std::min(2.0f, 2.0f / m_freq - m_freq * 0.5f));
 }

src/HighPassFilter.cpp

@@ -1,23 +1,22 @@
 #include "HighPassFilter.h"
+#include "Settings.h"
 
-HighPassFilter::HighPassFilter(/* args */) {}
-
-HighPassFilter::HighPassFilter(Filter* filter) {
-    m_freq = filter->GetFreq();
-    m_q = filter->GetRes();
-    m_order = filter->GetPeakGain();
+HighPassFilter::HighPassFilter() {
+    SetParameters(200, 0.1, 0.001);
 }
 
-HighPassFilter::HighPassFilter(float freq, float res, float q) {}
+HighPassFilter::HighPassFilter(
+    Filter* filter) {
+    SetParameters(filter->GetFreq(), filter->GetRes(), filter->GetPeakGain());
+}
+
+HighPassFilter::HighPassFilter(float freq, float res,
+                                                       float q) {
+    SetParameters(freq, res, q);
+}
 
 HighPassFilter::~HighPassFilter() {}
 
-void HighPassFilter::CalculateCoefficients() {
-    CalculateNormals();
-    m_norm = 1 / (1 + m_k / m_q + m_k * m_k);
-    m_a0 = 1 * m_norm;
-    m_a1 = -2 * m_a0;
-    m_a2 = m_a0;
-    m_b1 = 2 * (m_k * m_k - 1) * m_norm;
-    m_b2 = (1 - m_k / m_q + m_k * m_k) * m_norm;
+float HighPassFilter::GetSampleForFilterType() {
+    return m_higho;
 }

src/LFO.cpp

@@ -0,0 +1,10 @@
+#include "LFO.h"
+
+
+LFO::LFO(/* args */): Oscillator(Sine, 0.f, 0.5f)
+{
+}
+
+LFO::~LFO()
+{
+}

src/LowPassFilter.cpp

@@ -2,32 +2,21 @@
 #include "Settings.h"
 
 LowPassFilter::LowPassFilter() {
-    // todo: defaults
-    m_freq = 200.f / SAMPLE_RATE;
-    m_q = 1.0f;//0.707f;
-    m_order = 0;
+    SetParameters(200, 0.1, 0.001);
 }
 
-LowPassFilter::LowPassFilter(float freq, float res, float q) {
-    m_freq = freq / SAMPLE_RATE;
-    m_q = res;
-    m_order = q;
+LowPassFilter::LowPassFilter(
+    Filter* filter) {
+    SetParameters(filter->GetFreq(), filter->GetRes(), filter->GetPeakGain());
 }
 
-LowPassFilter::LowPassFilter(Filter* filter) {
-    m_freq = filter->GetFreq();
-    m_q = filter->GetRes();
-    m_order = filter->GetPeakGain();
+LowPassFilter::LowPassFilter(float freq, float res,
+                                                       float q) {
+    SetParameters(freq, res, q);
 }
 
 LowPassFilter::~LowPassFilter() {}
 
-void LowPassFilter::CalculateCoefficients() {
-    CalculateNormals();
-    m_norm = 1 / (1 + m_k / m_q + m_k * m_k);
-    m_a0 = m_k * m_k * m_norm;
-    m_a1 = 2 * m_a0;
-    m_a2 = m_a0;
-    m_b1 = 2 * (m_k * m_k - 1) * m_norm;
-    m_b2 = (1 - m_k / m_q + m_k * m_k) * m_norm;
+float LowPassFilter::GetSampleForFilterType() {
+    return m_lowo;
 }

src/Renderer.cpp

@@ -257,6 +257,10 @@ float Renderer::DrawFilterPanel(Synth& synth, FilterGuiState& gui_filter,
     // apply values to real one
     // todo: thrid (order) parameter
     // todo: why resonance changing does not work?
+    // todo: limit filter lowest frequency  to ~40 hz
+    if (gui_filter.freq < 40.0) {
+        gui_filter.freq = 50.0;
+    }
     filter->SetParameters(gui_filter.freq, filter->GetRes(),
                           filter->GetPeakGain());
 

src/Synth.cpp

@@ -1,13 +1,14 @@
 #include "Synth.h"
+#include "FilterFactory.h"
 #include "KeyBoard.h"
 #include "Logger.h"
 #include "OscillatorType.h"
 #include "Settings.h"
-#include "FilterFactory.h"
-#include "LFO.h"
+#include "LowPassFilter.h"
 
 Synth::Synth(/* args */) {
     m_lfo = new LFO();
+    m_lfo->SetFreq(5.0);
     AddOscillator();
     AddOscillator();
     AddEffect(new ADSR());
@@ -38,8 +39,14 @@ void Synth::GetNote() {
 }
 
 void Synth::ApplyEffects() {
-    for (IEffect* effect : m_effects) {
-        effect->Process(m_out_signal);
+    auto* adsr = m_effects[0];
+    adsr->Process(m_out_signal);
+
+    Filter* filter = (Filter*)m_effects[1];
+
+    for (std::size_t i = 0; i < m_out_signal.size(); i++) {
+        ApplyFilterLfo();
+        m_out_signal[i] = filter->Process(m_out_signal[i]);
     }
 }
 
@@ -56,8 +63,7 @@ void Synth::UntriggerNoteOnEffects() {
 }
 
 void Synth::AddOscillator() {
-    m_oscillators.push_back(
-        new Oscillator(OscillatorType::Sine, 0.0f, VOLUME));
+    m_oscillators.push_back(new Oscillator(OscillatorType::Sine, 0.0f, VOLUME));
 }
 
 void Synth::Trigger(Note input) {
@@ -70,19 +76,14 @@ void Synth::Trigger(Note input) {
     TriggerNoteOnEffects();
 }
 
-// todo: fix this
 void Synth::ApplyFilterLfo() {
     float dt = m_lfo->Process();
     Filter* filter = (Filter*)m_effects[1];
     float freq = filter->GetFreq();
-    //todo: check formula
-    //filter->SetParameters(freq + dt * 0.2f, filter->GetRes(), filter->GetPeakGain());
+    filter->SetParameters(freq + dt, filter->GetRes(), filter->GetPeakGain());
 }
 
 void Synth::Process() {
-    //todo: on each sample. 
-    //in order to do that, we need to move to per-sample processing
-    //ApplyFilterLfo();
     GetNote();
     ApplyEffects();
 }
@@ -98,6 +99,7 @@ void Synth::AddEffect(IEffect* fx) { m_effects.push_back(fx); }
 void Synth::SetFilter(FilterType type) {
     Filter* old_filter = this->GetFilter();
     if (!old_filter->IsSameFilterType(type)) {
+        // todo: implement other types of state variable filters;
         Filter* new_filter = FilterFactory::CreateFilter(old_filter, type);
         delete old_filter;
         m_effects[1] = new_filter;