Bring the default EQ into effect space

build/depends.py

@@ -581,6 +581,7 @@ def sources(self, build):
 
                    "effects/native/nativebackend.cpp",
                    "effects/native/bitcrushereffect.cpp",
+                   "effects/native/eqdefault.cpp",
                    "effects/native/flangereffect.cpp",
                    "effects/native/filtereffect.cpp",
                    "effects/native/reverbeffect.cpp",

src/control/control.h

@@ -66,7 +66,7 @@ class ControlDoublePrivate : public QObject {
 
     // Set the behavior to be used when setting values and translating between
     // parameter and value space. Returns the previously set behavior (if any).
-    // The caller must nut delete the behavior at any time. The memory is managed
+    // The caller must not delete the behavior at any time. The memory is managed
     // by this function.
     void setBehavior(ControlNumericBehavior* pBehavior);
 

src/effects/effectprocessor.h

@@ -4,6 +4,7 @@
 #include <QString>
 #include <QMap>
 
+#include "controlobjectslave.h"
 #include "util/types.h"
 #include "engine/effects/groupfeaturestate.h"
 
@@ -35,14 +36,17 @@ class EffectProcessor {
 template <typename T>
 class GroupEffectProcessor : public EffectProcessor {
   public:
-    GroupEffectProcessor() {}
+    GroupEffectProcessor() {
+        m_pSampleRate = new ControlObjectSlave("[Master]", "samplerate");
+    }
     virtual ~GroupEffectProcessor() {
         for (typename QMap<QString, T*>::iterator it = m_groupState.begin();
              it != m_groupState.end();) {
             T* pState = it.value();
             it = m_groupState.erase(it);
             delete pState;
         }
+        delete m_pSampleRate;
     }
 
     virtual void initialize(const QSet<QString>& registeredGroups) {
@@ -73,9 +77,13 @@ class GroupEffectProcessor : public EffectProcessor {
                               const CSAMPLE* pInput, CSAMPLE* pOutput,
                               const unsigned int numSamples,
                               const GroupFeatureState& groupFeatures) = 0;
+    int getSampleRate() {
+        return static_cast<int>(m_pSampleRate->get());
+    }
 
   private:
     QMap<QString, T*> m_groupState;
+    ControlObjectSlave* m_pSampleRate;
 };
 
 #endif /* EFFECTPROCESSOR_H */

src/effects/native/eqdefault.cpp

@@ -0,0 +1,180 @@
+#include "effects/native/eqdefault.h"
+#include "util/math.h"
+
+// static
+QString EQDefault::getId() {
+    return "org.mixxx.effects.eqdefault";
+}
+
+// static
+EffectManifest EQDefault::getManifest() {
+    EffectManifest manifest;
+    manifest.setId(getId());
+    manifest.setName(QObject::tr("Default EQ"));
+    manifest.setAuthor("The Mixxx Team");
+    manifest.setVersion("1.0");
+    manifest.setDescription("The default Equalizer featuring \
+3 EngineFilterButterworth which can be modified from preferences");
+
+    EffectManifestParameter* low = manifest.addParameter();
+    low->setId("low");
+    low->setName(QObject::tr("Low"));
+    low->setDescription("Gain for Low Filter");
+    low->setControlHint(EffectManifestParameter::CONTROL_KNOB_LOGARITHMIC);
+    low->setValueHint(EffectManifestParameter::VALUE_FLOAT);
+    low->setSemanticHint(EffectManifestParameter::SEMANTIC_UNKNOWN);
+    low->setUnitsHint(EffectManifestParameter::UNITS_UNKNOWN);
+    low->setDefault(1.0);
+    low->setMinimum(0);
+    low->setMaximum(4.0);
+
+    EffectManifestParameter* mid = manifest.addParameter();
+    mid->setId("mid");
+    mid->setName(QObject::tr("Mid"));
+    mid->setDescription("Gain for Band Filter");
+    mid->setControlHint(EffectManifestParameter::CONTROL_KNOB_LOGARITHMIC);
+    mid->setValueHint(EffectManifestParameter::VALUE_FLOAT);
+    mid->setSemanticHint(EffectManifestParameter::SEMANTIC_UNKNOWN);
+    mid->setUnitsHint(EffectManifestParameter::UNITS_UNKNOWN);
+    mid->setDefault(1.0);
+    mid->setMinimum(0);
+    mid->setMaximum(4.0);
+
+    EffectManifestParameter* high = manifest.addParameter();
+    high->setId("high");
+    high->setName(QObject::tr("High"));
+    high->setDescription("Gain for High Filter");
+    high->setControlHint(EffectManifestParameter::CONTROL_KNOB_LOGARITHMIC);
+    high->setValueHint(EffectManifestParameter::VALUE_FLOAT);
+    high->setSemanticHint(EffectManifestParameter::SEMANTIC_UNKNOWN);
+    high->setUnitsHint(EffectManifestParameter::UNITS_UNKNOWN);
+    high->setDefault(1.0);
+    high->setMinimum(0);
+    high->setMaximum(4.0);
+
+    return manifest;
+}
+
+EQDefaultGroupState::EQDefaultGroupState()
+        : low(NULL), band(NULL), high(NULL),old_low(1.0),
+          old_mid(1.0), old_high(1.0) {
+    m_pLowBuf = new CSAMPLE[MAX_BUFFER_LEN];
+    m_pBandBuf = new CSAMPLE[MAX_BUFFER_LEN];
+    m_pHighBuf = new CSAMPLE[MAX_BUFFER_LEN];
+
+    // Initialize filters with the default values
+    low = new EngineFilterButterworth8Low(44100, 246);
+    band = new EngineFilterButterworth8Band(44100, 246, 2484);
+    high = new EngineFilterButterworth8High(44100, 2484);
+}
+
+EQDefaultGroupState::~EQDefaultGroupState() {
+    delete low;
+    delete band;
+    delete high;
+    delete m_pLowBuf;
+    delete m_pBandBuf;
+    delete m_pHighBuf;
+}
+
+void EQDefaultGroupState::setFilters(int sampleRate, int lowFreq, int highFreq) {
+    low->setFrequencyCorners(sampleRate, lowFreq);
+    band->setFrequencyCorners(sampleRate, lowFreq, highFreq);
+    high->setFrequencyCorners(sampleRate, highFreq);
+}
+
+EQDefault::EQDefault(EngineEffect* pEffect,
+                   const EffectManifest& manifest)
+        : m_pPotLow(pEffect->getParameterById("low")),
+          m_pPotMid(pEffect->getParameterById("mid")),
+          m_pPotHigh(pEffect->getParameterById("high")),
+          m_oldSampleRate(0), m_loFreq(0), m_hiFreq(0) {
+    Q_UNUSED(manifest);
+    m_pLoFreqCorner = new ControlObjectSlave("[Mixer Profile]", "LoEQFrequency");
+    m_pHiFreqCorner = new ControlObjectSlave("[Mixer Profile]", "HiEQFrequency");
+}
+
+EQDefault::~EQDefault() {
+    delete m_pLoFreqCorner;
+    delete m_pHiFreqCorner;
+}
+
+void EQDefault::processGroup(const QString& group,
+        EQDefaultGroupState* pState,
+        const CSAMPLE* pInput, CSAMPLE* pOutput,
+        const unsigned int numSamples,
+        const GroupFeatureState& groupFeatures) {
+    Q_UNUSED(group);
+    Q_UNUSED(groupFeatures);
+
+    float fLow = 0.f, fMid = 0.f, fHigh = 0.f;
+    fLow = m_pPotLow->value().toDouble();
+    fMid = m_pPotMid->value().toDouble();
+    fHigh = m_pPotHigh->value().toDouble();
+
+    int sampleRate = getSampleRate();
+    if (m_oldSampleRate != sampleRate ||
+            (m_loFreq != static_cast<int>(m_pLoFreqCorner->get())) ||
+            (m_hiFreq != static_cast<int>(m_pHiFreqCorner->get()))) {
+        m_loFreq = static_cast<int>(m_pLoFreqCorner->get());
+        m_hiFreq = static_cast<int>(m_pHiFreqCorner->get());
+        m_oldSampleRate = sampleRate;
+        pState->setFilters(sampleRate, m_loFreq, m_hiFreq);
+    }
+
+    // Process the new EQ'd signals.
+    // They use up to 16 frames history so in case we are just starting,
+    // 16 frames are junk, this is handled by ramp_delay
+    int ramp_delay = 0;
+    if (fLow || pState->old_low) {
+        pState->low->process(pInput, pState->m_pLowBuf, numSamples);
+        if(pState->old_low == 0) {
+            ramp_delay = 30;
+        }
+    }
+    if (fMid || pState->old_mid) {
+        pState->band->process(pInput, pState->m_pBandBuf, numSamples);
+        if(pState->old_mid== 0) {
+            ramp_delay = 30;
+        }
+    }
+    if (fHigh || pState->old_high) {
+        pState->high->process(pInput, pState->m_pHighBuf, numSamples);
+        if(pState->old_high == 0) {
+            ramp_delay = 30;
+        }
+    }
+
+    if (ramp_delay) {
+        // first use old gains
+        SampleUtil::copy3WithGain(pOutput,
+                pState->m_pLowBuf, pState->old_low,
+                pState->m_pBandBuf, pState->old_mid,
+                pState->m_pHighBuf, pState->old_high,
+                ramp_delay);
+        // Now ramp the remaining frames
+        SampleUtil::copy3WithRampingGain(&pOutput[ramp_delay],
+                &pState->m_pLowBuf[ramp_delay], pState->old_low, fLow,
+                &pState->m_pBandBuf[ramp_delay], pState->old_mid, fMid,
+                &pState->m_pHighBuf[ramp_delay], pState->old_high, fHigh,
+                numSamples - ramp_delay);
+    } else if (fLow != pState->old_low ||
+            fMid != pState->old_mid ||
+            fHigh != pState->old_high) {
+        SampleUtil::copy3WithRampingGain(pOutput,
+                pState->m_pLowBuf, pState->old_low, fLow,
+                pState->m_pBandBuf, pState->old_mid, fMid,
+                pState->m_pHighBuf, pState->old_high, fHigh,
+                numSamples);
+    } else {
+        SampleUtil::copy3WithGain(pOutput,
+                pState->m_pLowBuf, fLow,
+                pState->m_pBandBuf, fMid,
+                pState->m_pHighBuf, fHigh,
+                numSamples);
+    }
+
+    pState->old_low = fLow;
+    pState->old_mid = fMid;
+    pState->old_high = fHigh;
+}

src/effects/native/eqdefault.h

@@ -0,0 +1,71 @@
+#ifndef EQDEFAULT_H
+#define EQDEFAULT_H
+
+#include <QMap>
+
+#include "controlobjectslave.h"
+#include "effects/effect.h"
+#include "effects/effectprocessor.h"
+#include "engine/effects/engineeffect.h"
+#include "engine/effects/engineeffectparameter.h"
+#include "engine/enginefilterbutterworth8.h"
+#include "util.h"
+#include "util/types.h"
+#include "util/defs.h"
+#include "sampleutil.h"
+
+class EQDefaultGroupState {
+public:
+    EQDefaultGroupState();
+    ~EQDefaultGroupState();
+
+    void setFilters(int sampleRate, int lowFreq, int highFreq);
+
+    EngineFilterButterworth8Low* low;
+    EngineFilterButterworth8Band* band;
+    EngineFilterButterworth8High* high;
+
+    double old_low;
+    double old_mid;
+    double old_high;
+
+    CSAMPLE* m_pLowBuf;
+    CSAMPLE* m_pBandBuf;
+    CSAMPLE* m_pHighBuf;
+};
+
+class EQDefault : public GroupEffectProcessor<EQDefaultGroupState> {
+  public:
+    EQDefault(EngineEffect* pEffect, const EffectManifest& manifest);
+    virtual ~EQDefault();
+
+    static QString getId();
+    static EffectManifest getManifest();
+
+    // See effectprocessor.h
+    void processGroup(const QString& group,
+                      EQDefaultGroupState* pState,
+                      const CSAMPLE* pInput, CSAMPLE *pOutput,
+                      const unsigned int numSamples,
+                      const GroupFeatureState& groupFeatureState);
+
+  private:
+    QString debugString() const {
+        return getId();
+    }
+
+    EngineEffectParameter* m_pPotLow;
+    EngineEffectParameter* m_pPotMid;
+    EngineEffectParameter* m_pPotHigh;
+
+    ControlObjectSlave* m_pLoFreqCorner;
+    ControlObjectSlave* m_pHiFreqCorner;
+
+    int m_oldSampleRate;
+    int m_loFreq;
+    int m_hiFreq;
+
+    DISALLOW_COPY_AND_ASSIGN(EQDefault);
+};
+
+#endif /* EQDEFAULT_H */

src/effects/native/filtereffect.cpp

@@ -113,14 +113,14 @@ void FilterEffect::processGroup(const QString& group,
             // Freq from 2^5=32Hz to 2^(5+9)=16384
             double freq = getLowFrequencyCorner(depth + 1.0);
             double freq2 = getHighFrequencyCorner(depth + 1.0, bandpass_width);
-            pState->lowFilter.setFrequencyCorners(freq2);
-            pState->bandpassFilter.setFrequencyCorners(freq, freq2);
+            pState->lowFilter.setFrequencyCorners(44100, freq2);
+            pState->bandpassFilter.setFrequencyCorners(44100, freq, freq2);
         } else if (depth > 0.0) {
             // Highpass + bandpass
             double freq = getLowFrequencyCorner(depth);
             double freq2 = getHighFrequencyCorner(depth, bandpass_width);
-            pState->highFilter.setFrequencyCorners(freq);
-            pState->bandpassFilter.setFrequencyCorners(freq, freq2);
+            pState->highFilter.setFrequencyCorners(44100, freq);
+            pState->bandpassFilter.setFrequencyCorners(44100, freq, freq2);
         }
     }
 

src/effects/native/nativebackend.cpp

@@ -3,6 +3,7 @@
 #include "effects/native/nativebackend.h"
 #include "effects/native/flangereffect.h"
 #include "effects/native/bitcrushereffect.h"
+#include "effects/native/eqdefault.h"
 #include "effects/native/filtereffect.h"
 #include "effects/native/reverbeffect.h"
 #include "effects/native/echoeffect.h"
@@ -14,6 +15,7 @@ NativeBackend::NativeBackend(QObject* pParent)
     registerEffect<FilterEffect>();
     registerEffect<ReverbEffect>();
     registerEffect<EchoEffect>();
+    registerEffect<EQDefault>();
 }
 
 NativeBackend::~NativeBackend() {

src/engine/enginefilterblock.cpp

@@ -43,7 +43,7 @@ EngineFilterBlock::EngineFilterBlock(const char* group)
     m_pSampleRate = new ControlObjectSlave("[Master]", "samplerate");
     m_iOldSampleRate = 0;
 
-    //Setup Filter Controls
+    // Setup Filter Controls
 
     if (s_loEqFreq == NULL) {
         s_loEqFreq = new ControlPotmeter(ConfigKey("[Mixer Profile]", "LoEQFrequency"), 0., 22040);
@@ -54,7 +54,7 @@ EngineFilterBlock::EngineFilterBlock(const char* group)
 
     high = band = low = NULL;
 
-    //Load Defaults
+    // Load Defaults
     setFilters(true);
 
     /*