Parametric EQ (#47)

* Basic parametric eq

Software/GuitarPedal/Effect-Modules/eq_module.cpp → Software/GuitarPedal/Effect-Modules/geq_module.cpp

@@ -1,10 +1,11 @@
-#include "eq_module.h"
+#include "geq_module.h"
 #include <q/fx/biquad.hpp>
 
 constexpr uint8_t NUM_FILTERS = 6;
 
 using namespace bkshepherd;
 
+namespace {
 const float minGain = -15.f;
 const float maxGain = 15.f;
 
@@ -14,6 +15,7 @@ const float q[NUM_FILTERS] = {0.7f, 0.8f, 1.1f, 1.4f, 1.6f, 1.8f};
 cycfi::q::peaking filter[NUM_FILTERS] = {{0, centerFrequency[0], 48000, q[0]}, {0, centerFrequency[1], 48000, q[1]},
                                          {0, centerFrequency[2], 48000, q[2]}, {0, centerFrequency[3], 48000, q[3]},
                                          {0, centerFrequency[4], 48000, q[4]}, {0, centerFrequency[5], 48000, q[5]}};
+} // namespace
 
 static constexpr uint8_t s_paramCount = NUM_FILTERS;
 static const ParameterMetaData s_metaData[s_paramCount] = {
@@ -80,9 +82,9 @@ static const ParameterMetaData s_metaData[s_paramCount] = {
 };
 
 // Default Constructor
-EQModule::EQModule() : BaseEffectModule() {
+GraphicEQModule::GraphicEQModule() : BaseEffectModule() {
     // Set the name of the effect
-    m_name = "EQ";
+    m_name = "GraphicEQ";
 
     // Setup the meta data reference for this Effect
     m_paramMetaData = s_metaData;
@@ -92,19 +94,19 @@ EQModule::EQModule() : BaseEffectModule() {
 }
 
 // Destructor
-EQModule::~EQModule() {
+GraphicEQModule::~GraphicEQModule() {
     // No Code Needed
 }
 
-void EQModule::Init(float sample_rate) {
+void GraphicEQModule::Init(float sample_rate) {
     BaseEffectModule::Init(sample_rate);
 
     for (uint8_t i = 0; i < NUM_FILTERS; i++) {
         filter[i].config(GetParameterAsFloat(i), centerFrequency[i], sample_rate, q[i]);
     }
 }
 
-void EQModule::ProcessMono(float in) {
+void GraphicEQModule::ProcessMono(float in) {
     float out = in;
 
     for (uint8_t i = 0; i < NUM_FILTERS; i++) {
@@ -115,35 +117,41 @@ void EQModule::ProcessMono(float in) {
     m_audioRight = m_audioLeft;
 }
 
-void EQModule::ProcessStereo(float inL, float inR) {
+void GraphicEQModule::ProcessStereo(float inL, float inR) {
     // Calculate the mono effect
     ProcessMono(inL);
 }
 
-void EQModule::ParameterChanged(int parameter_id) {
+void GraphicEQModule::ParameterChanged(int parameter_id) {
     filter[parameter_id].config(GetParameterAsFloat(parameter_id), centerFrequency[parameter_id], GetSampleRate(), q[parameter_id]);
 }
 
-void EQModule::DrawUI(OneBitGraphicsDisplay &display, int currentIndex, int numItemsTotal, Rectangle boundsToDrawIn, bool isEditing) {
+void GraphicEQModule::DrawUI(OneBitGraphicsDisplay &display, int currentIndex, int numItemsTotal, Rectangle boundsToDrawIn,
+                             bool isEditing) {
+    display.WriteStringAligned(m_name, Font_7x10, boundsToDrawIn, Alignment::topCentered, true);
 
     const int width = boundsToDrawIn.GetWidth();
     const int barWidth = 10;
 
     const int stepWidth = (width / NUM_FILTERS);
 
+    // This is used to help the "max" gain take up the full vertical amount of the screen
+    const float magnitudeMultiplier = 1.4f;
+
     int top = 30;
 
+    // Draw centerline
+    display.DrawLine(0, top, width, top, true);
+
     int x = 0;
     for (int i = 0; i < NUM_FILTERS; i++) {
-        bool positive = GetParameterAsFloat(i) > 0.0f;
-        float magnitude = std::abs(GetParameterAsFloat(i));
-        if (positive) {
-            Rectangle r(x, top - magnitude, barWidth, magnitude);
-            display.DrawRect(r, true, true);
-        } else {
-            Rectangle r(x, top, barWidth, magnitude);
-            display.DrawRect(r, true, true);
-        }
+        const int gainParamId = i;
+        const bool positive = GetParameterAsFloat(gainParamId) > 0.0f;
+        const float magnitude = std::abs(GetParameterAsFloat(gainParamId)) * magnitudeMultiplier;
+        const int y = positive ? top - magnitude : top;
+
+        Rectangle r(x, y, barWidth, magnitude);
+        display.DrawRect(r, true, true);
         x += stepWidth;
     }
 }

Software/GuitarPedal/Effect-Modules/eq_module.h → Software/GuitarPedal/Effect-Modules/geq_module.h

@@ -1,21 +1,21 @@
 #pragma once
-#ifndef EQ_MODULE_H
-#define EQ_MODULE_H
+#ifndef GEQ_MODULE_H
+#define GEQ_MODULE_H
 
 #include <stdint.h>
 
 #include "base_effect_module.h"
 
 #ifdef __cplusplus
 
-/** @file eq_module.h */
+/** @file geq_module.h */
 
 namespace bkshepherd {
 
-class EQModule : public BaseEffectModule {
+class GraphicEQModule : public BaseEffectModule {
   public:
-    EQModule();
-    ~EQModule();
+    GraphicEQModule();
+    ~GraphicEQModule();
 
     void Init(float sample_rate) override;
     void ProcessMono(float in) override;

Software/GuitarPedal/Effect-Modules/peq_module.cpp

@@ -0,0 +1,173 @@
+#include "peq_module.h"
+#include <q/fx/biquad.hpp>
+
+using namespace bkshepherd;
+
+namespace {
+const float minGain = -15.f;
+const float maxGain = 15.f;
+
+const float qLows = 2.0f;
+const float qMids = 2.0f;
+const float qHighs = 2.0f;
+
+const float defaultLowFreq = 100.f;
+const float defaultMidFreq = 800.f;
+const float defaultHighFreq = 4000.f;
+
+cycfi::q::peaking filterLows = {0, defaultLowFreq, 48000, qLows};
+cycfi::q::peaking filterMids = {0, defaultMidFreq, 48000, qMids};
+cycfi::q::peaking filterHighs = {0, defaultHighFreq, 48000, qHighs};
+} // namespace
+
+static constexpr uint8_t s_paramCount = 9;
+static const ParameterMetaData s_metaData[s_paramCount] = {{
+                                                               name : "Low Freq",
+                                                               valueType : ParameterValueType::Float,
+                                                               valueBinCount : 0,
+                                                               defaultValue : {.float_value = defaultLowFreq},
+                                                               knobMapping : 0,
+                                                               midiCCMapping : -1,
+                                                               minValue : static_cast<int>(defaultLowFreq - 80.f),
+                                                               maxValue : static_cast<int>(defaultLowFreq + 80.f)
+                                                           },
+                                                           {
+                                                               name : "Mid Freq",
+                                                               valueType : ParameterValueType::Float,
+                                                               valueBinCount : 0,
+                                                               defaultValue : {.float_value = defaultMidFreq},
+                                                               knobMapping : 1,
+                                                               midiCCMapping : -1,
+                                                               minValue : static_cast<int>(defaultMidFreq - 550.f),
+                                                               maxValue : static_cast<int>(defaultMidFreq + 550.f)
+                                                           },
+                                                           {
+                                                               name : "High Freq",
+                                                               valueType : ParameterValueType::Float,
+                                                               valueBinCount : 0,
+                                                               defaultValue : {.float_value = defaultHighFreq},
+                                                               knobMapping : 2,
+                                                               midiCCMapping : -1,
+                                                               minValue : static_cast<int>(defaultHighFreq - 3000.f),
+                                                               maxValue : static_cast<int>(defaultHighFreq + 3000.f)
+                                                           },
+                                                           {
+                                                               name : "Low Gain",
+                                                               valueType : ParameterValueType::Float,
+                                                               valueBinCount : 0,
+                                                               defaultValue : {.float_value = 0.0f},
+                                                               knobMapping : 3,
+                                                               midiCCMapping : -1,
+                                                               minValue : static_cast<int>(minGain),
+                                                               maxValue : static_cast<int>(maxGain)
+                                                           },
+                                                           {
+                                                               name : "Mid Gain",
+                                                               valueType : ParameterValueType::Float,
+                                                               valueBinCount : 0,
+                                                               defaultValue : {.float_value = 0.0f},
+                                                               knobMapping : 4,
+                                                               midiCCMapping : -1,
+                                                               minValue : static_cast<int>(minGain),
+                                                               maxValue : static_cast<int>(maxGain)
+                                                           },
+                                                           {
+                                                               name : "High Gain",
+                                                               valueType : ParameterValueType::Float,
+                                                               valueBinCount : 0,
+                                                               defaultValue : {.float_value = 0.0f},
+                                                               knobMapping : 5,
+                                                               midiCCMapping : -1,
+                                                               minValue : static_cast<int>(minGain),
+                                                               maxValue : static_cast<int>(maxGain)
+                                                           }};
+
+// Default Constructor
+ParametricEQModule::ParametricEQModule() : BaseEffectModule() {
+    // Set the name of the effect
+    m_name = "ParaEQ";
+
+    // Setup the meta data reference for this Effect
+    m_paramMetaData = s_metaData;
+
+    // Initialize Parameters for this Effect
+    this->InitParams(s_paramCount);
+}
+
+// Destructor
+ParametricEQModule::~ParametricEQModule() {
+    // No Code Needed
+}
+
+void ParametricEQModule::Init(float sample_rate) {
+    BaseEffectModule::Init(sample_rate);
+
+    filterLows.config(GetParameterAsFloat(3), GetParameterAsFloat(0), sample_rate, qLows);
+    filterMids.config(GetParameterAsFloat(4), GetParameterAsFloat(1), sample_rate, qMids);
+    filterHighs.config(GetParameterAsFloat(5), GetParameterAsFloat(2), sample_rate, qHighs);
+}
+
+void ParametricEQModule::ProcessMono(float in) {
+    float out = in;
+
+    out = filterLows(out);
+    out = filterMids(out);
+    out = filterHighs(out);
+
+    m_audioLeft = out;
+    m_audioRight = m_audioLeft;
+}
+
+void ParametricEQModule::ProcessStereo(float inL, float inR) {
+    // Calculate the mono effect
+    ProcessMono(inL);
+}
+
+void ParametricEQModule::ParameterChanged(int parameter_id) {
+    switch (parameter_id) {
+    case 0:
+    case 3:
+        filterLows.config(GetParameterAsFloat(3), GetParameterAsFloat(0), GetSampleRate(), qLows);
+        break;
+    case 1:
+    case 4:
+        filterMids.config(GetParameterAsFloat(4), GetParameterAsFloat(1), GetSampleRate(), qMids);
+        break;
+    case 2:
+    case 5:
+        filterHighs.config(GetParameterAsFloat(5), GetParameterAsFloat(2), GetSampleRate(), qHighs);
+        break;
+    }
+}
+
+void ParametricEQModule::DrawUI(OneBitGraphicsDisplay &display, int currentIndex, int numItemsTotal, Rectangle boundsToDrawIn,
+                                bool isEditing) {
+    display.WriteStringAligned(m_name, Font_7x10, boundsToDrawIn, Alignment::topCentered, true);
+
+    const int width = boundsToDrawIn.GetWidth();
+    const int barWidth = 10;
+
+    const int stepWidth = (width / 3);
+
+    // This is used to help the "max" gain take up the full vertical amount of the screen
+    const float magnitudeMultiplier = 1.4f;
+
+    int top = 30;
+
+    // Draw centerline
+    display.DrawLine(0, top, width, top, true);
+
+    // Don't default this to 0 so that the "3" bars stay centered
+    int x = stepWidth / 2;
+    for (int i = 0; i < 3; i++) {
+        const int gainParamId = i + 3;
+
+        const bool positive = GetParameterAsFloat(gainParamId) > 0.0f;
+        const float magnitude = std::abs(GetParameterAsFloat(gainParamId)) * magnitudeMultiplier;
+        const int y = positive ? top - magnitude : top;
+
+        Rectangle r(x, y, barWidth, magnitude);
+        display.DrawRect(r, true, true);
+        x += stepWidth;
+    }
+}

Software/GuitarPedal/Effect-Modules/peq_module.h

@@ -0,0 +1,29 @@
+#pragma once
+#ifndef PEQ_MODULE_H
+#define PEQ_MODULE_H
+
+#include <stdint.h>
+
+#include "base_effect_module.h"
+
+#ifdef __cplusplus
+
+/** @file peq_module.h */
+
+namespace bkshepherd {
+
+class ParametricEQModule : public BaseEffectModule {
+  public:
+    ParametricEQModule();
+    ~ParametricEQModule();
+
+    void Init(float sample_rate) override;
+    void ProcessMono(float in) override;
+    void ProcessStereo(float inL, float inR) override;
+    void ParameterChanged(int parameter_id) override;
+    void DrawUI(OneBitGraphicsDisplay &display, int currentIndex, int numItemsTotal, Rectangle boundsToDrawIn,
+                bool isEditing) override;
+};
+} // namespace bkshepherd
+#endif
+#endif

Software/GuitarPedal/guitar_pedal.cpp

@@ -7,11 +7,12 @@
 #include "Effect-Modules/chopper_module.h"
 #include "Effect-Modules/chorus_module.h"
 #include "Effect-Modules/compressor_module.h"
-#include "Effect-Modules/eq_module.h"
+#include "Effect-Modules/geq_module.h"
 #include "Effect-Modules/looper_module.h"
 #include "Effect-Modules/metro_module.h"
 #include "Effect-Modules/multi_delay_module.h"
 #include "Effect-Modules/overdrive_module.h"
+#include "Effect-Modules/peq_module.h"
 #include "Effect-Modules/pitch_shifter_module.h"
 #include "Effect-Modules/reverb_module.h"
 #include "Effect-Modules/tuner_module.h"
@@ -547,7 +548,7 @@ int main(void) {
     crossFaderTransitionTimeInSamples = hardware.GetNumberOfSamplesForTime(crossFaderTransitionTimeInSeconds);
 
     // Init the Effects Modules
-    availableEffectsCount = 13;
+    availableEffectsCount = 14;
     availableEffects = new BaseEffectModule *[availableEffectsCount];
     availableEffects[0] = new ModulatedTremoloModule();
     availableEffects[1] = new OverdriveModule();
@@ -561,7 +562,8 @@ int main(void) {
     availableEffects[9] = new PitchShifterModule();
     availableEffects[10] = new CompressorModule();
     availableEffects[11] = new LooperModule();
-    availableEffects[12] = new EQModule();
+    availableEffects[12] = new GraphicEQModule();
+    availableEffects[13] = new ParametricEQModule();
 
     for (int i = 0; i < availableEffectsCount; i++) {
         availableEffects[i]->Init(sample_rate);