Gain effect

CMakeLists.txt

@@ -1259,6 +1259,7 @@ add_library(
   src/effects/backends/builtin/echoeffect.cpp
   src/effects/backends/builtin/filtereffect.cpp
   src/effects/backends/builtin/flangereffect.cpp
+  src/effects/backends/builtin/gaineffect.cpp
   src/effects/backends/builtin/glitcheffect.cpp
   src/effects/backends/builtin/graphiceqeffect.cpp
   src/effects/backends/builtin/linkwitzriley8eqeffect.cpp

src/effects/backends/builtin/builtinbackend.cpp

@@ -28,6 +28,7 @@
 #ifdef __RUBBERBAND__
 #include "effects/backends/builtin/pitchshifteffect.h"
 #endif
+#include "effects/backends/builtin/gaineffect.h"
 #include "effects/backends/builtin/tremoloeffect.h"
 #include "effects/backends/builtin/whitenoiseeffect.h"
 
@@ -66,6 +67,7 @@ BuiltInBackend::BuiltInBackend() {
     registerEffect<GlitchEffect>();
     registerEffect<CompressorEffect>();
     registerEffect<AutoGainControlEffect>();
+    registerEffect<GainEffect>();
 }
 
 std::unique_ptr<EffectProcessor> BuiltInBackend::createProcessor(

src/effects/backends/builtin/gaineffect.cpp

@@ -0,0 +1,98 @@
+#include "effects/backends/builtin/gaineffect.h"
+
+#include "effects/backends/effectmanifest.h"
+#include "engine/effects/engineeffectparameter.h"
+#include "util/math.h"
+#include "util/rampingvalue.h"
+
+namespace {
+inline CSAMPLE tanh_approx(CSAMPLE input) {
+    return input / (1 + input * input / (3 + input * input / 5));
+}
+} // namespace
+
+// static
+QString GainEffect::getId() {
+    return "org.mixxx.effects.gain";
+}
+
+// static
+EffectManifestPointer GainEffect::getManifest() {
+    EffectManifestPointer pManifest(new EffectManifest());
+    pManifest->setId(getId());
+    pManifest->setName(QObject::tr("Gain"));
+    pManifest->setShortName(QObject::tr("Gain"));
+    pManifest->setAuthor("The Mixxx Team");
+    pManifest->setVersion("1.0");
+    pManifest->setDescription(QObject::tr("Amplifies audio by gain amount"));
+    pManifest->setEffectRampsFromDry(true);
+
+    EffectManifestParameterPointer gain = pManifest->addParameter();
+    gain->setId("gain");
+    gain->setName(QObject::tr("Gain"));
+    gain->setShortName(QObject::tr("Gain"));
+    gain->setDescription(QObject::tr("The gain of the samples"));
+    gain->setValueScaler(EffectManifestParameter::ValueScaler::Linear);
+    gain->setUnitsHint(EffectManifestParameter::UnitsHint::Decibel);
+    gain->setDefaultLinkType(EffectManifestParameter::LinkType::Linked);
+    gain->setNeutralPointOnScale(0.0);
+    gain->setRange(-24.0, 0.0, 24.0);
+
+    EffectManifestParameterPointer clip = pManifest->addParameter();
+    clip->setId("clip");
+    clip->setName(QObject::tr("Clip"));
+    clip->setShortName(QObject::tr("Clip"));
+    clip->setDescription(QObject::tr("Clip samples to within -1 to 1"));
+    clip->setValueScaler(EffectManifestParameter::ValueScaler::Toggle);
+    clip->setUnitsHint(EffectManifestParameter::UnitsHint::Unknown);
+    clip->setRange(0, 0, 1);
+
+    return pManifest;
+}
+
+void GainEffect::loadEngineEffectParameters(
+        const QMap<QString, EngineEffectParameterPointer>& parameters) {
+    m_pGainParameter = parameters.value("gain");
+    m_pClipParameter = parameters.value("clip");
+}
+
+void GainEffect::processChannel(
+        GainGroupState* pState,
+        const CSAMPLE* pInput,
+        CSAMPLE* pOutput,
+        const mixxx::EngineParameters& engineParameters,
+        const EffectEnableState enableState,
+        const GroupFeatureState& groupFeatures) {
+    Q_UNUSED(groupFeatures);
+    Q_UNUSED(enableState);
+
+    const auto clip = m_pClipParameter->toBool();
+
+    CSAMPLE_GAIN gain;
+
+    if (enableState == EffectEnableState::Disabling) {
+        gain = 1;
+    } else {
+        gain = db2ratio(static_cast<float>(m_pGainParameter->value()));
+    }
+
+    if (enableState == EffectEnableState::Enabling) {
+        pState->previous_gain = 1;
+    }
+
+    RampingValue<CSAMPLE_GAIN> gain_ramping_value(
+            pState->previous_gain, gain, engineParameters.samplesPerBuffer());
+
+    for (SINT i = 0;
+            i < engineParameters.samplesPerBuffer();
+            i++) {
+        const auto gain_ramped = gain_ramping_value.getNth(i);
+        pOutput[i] = pInput[i] * gain_ramped;
+
+        if (clip) {
+            pOutput[i] = tanh_approx(pOutput[i]);
+        }
+    }
+
+    pState->previous_gain = gain;
+}

src/effects/backends/builtin/gaineffect.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include "effects/backends/effectprocessor.h"
+#include "util/class.h"
+
+struct GainGroupState : public EffectState {
+  public:
+    GainGroupState(const mixxx::EngineParameters& engineParameters)
+            : EffectState(engineParameters),
+              previous_gain(1.0) {
+    }
+    ~GainGroupState() override = default;
+    CSAMPLE_GAIN previous_gain;
+};
+
+class GainEffect : public EffectProcessorImpl<GainGroupState> {
+  public:
+    GainEffect() = default;
+    ~GainEffect() override = default;
+
+    static QString getId();
+    static EffectManifestPointer getManifest();
+
+    void processChannel(
+            GainGroupState* pState,
+            const CSAMPLE* pInput,
+            CSAMPLE* pOutput,
+            const mixxx::EngineParameters& engineParameters,
+            const EffectEnableState enableState,
+            const GroupFeatureState& groupFeatures) override;
+
+    void loadEngineEffectParameters(
+            const QMap<QString, EngineEffectParameterPointer>& parameters) override;
+
+  private:
+    EngineEffectParameterPointer m_pGainParameter;
+    EngineEffectParameterPointer m_pClipParameter;
+
+    DISALLOW_COPY_AND_ASSIGN(GainEffect);
+};