rms_feedback.h

/*
 * Copyright © 2023-2024 Mark Adams
 *
 * This file is part of The Synthstrom Audible Deluge Firmware.
 *
 * The Synthstrom Audible Deluge Firmware is free software: you can redistribute it and/or modify it under the
 * terms of the GNU General Public License as published by the Free Software Foundation,
 * either version 3 of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along with this program.
 * If not, see <https://www.gnu.org/licenses/>.
 */
 
#pragma once
 
#include "definitions_cxx.hpp"
#include "dsp/filter/ladder_components.h"
#include "dsp_ng/core/types.hpp"
#include <cmath>
#include <span>
 
namespace deluge::dsp {
class [[gnu::hot]] RMSFeedbackCompressor {
public:
    RMSFeedbackCompressor();

    constexpr void setup(q31_t a, q31_t r, q31_t t, q31_t rat, q31_t fc, FixedPoint<31> blend, float baseGain) {
        setAttack(a);
        setRelease(r);
        setThreshold(t);
        setRatio(rat);
        setSidechain(fc);
        setBlend(blend);
        baseGain_ = baseGain;
    }

    void reset() {
        state = 0;
        er = 0;
        mean = 0;
        onLastTime = false;
    }

    void render(StereoBuffer<q31_t> buffer, q31_t volAdjustL, q31_t volAdjustR, q31_t finalVolume);

    void renderVolNeutral(StereoBuffer<q31_t> buffer, q31_t finalVolume);

    [[nodiscard]] float runEnvelope(float current, float desired, float numSamples) const;

    [[nodiscard]] inline constexpr q31_t getAttack() const { return attackKnobPos; }

    [[nodiscard]] inline constexpr float getAttackMS() const { return attackMS; }

    constexpr int32_t setAttack(q31_t attack) {
        // this exp will be between 1 and 7ish, half the knob range is about 2.5
        attackMS = 0.5 + (std::exp(2 * float(attack) / ONE_Q31f) - 1) * 10;
        a_ = (-1000.0f / kSampleRate) / attackMS;
        attackKnobPos = attack;
        return attackMS;
    };

    [[nodiscard]] inline constexpr q31_t getRelease() const { return releaseKnobPos; }

    [[nodiscard]] inline constexpr float getReleaseMS() const { return releaseMS; }

    constexpr int32_t setRelease(q31_t release) {
        // this exp will be between 1 and 7ish, half the knob range is about 2.5
        releaseMS = 50 + (std::exp(2 * float(release) / ONE_Q31f) - 1) * 50;
        r_ = (-1000.0f / kSampleRate) / releaseMS;
        releaseKnobPos = release;
        return releaseMS;
    };

    [[nodiscard]] inline constexpr q31_t getThreshold() const { return thresholdKnobPos; }
    constexpr void setThreshold(q31_t t) {
        thresholdKnobPos = t;
        threshold = 1 - 0.8f * (float(thresholdKnobPos) / ONE_Q31f);
    }

    [[nodiscard]] inline constexpr q31_t getRatio() const { return ratioKnobPos; }

    [[nodiscard]] inline constexpr float getRatioForDisplay() const { return ratio; }

    constexpr int32_t setRatio(q31_t rat) {
        ratioKnobPos = rat;
        fraction = 0.5f + (float(ratioKnobPos) / ONE_Q31f) / 2;
        ratio = 1 / (1 - fraction);
        return ratio;
    }

    q31_t getSidechain() { return sideChainKnobPos; }

    [[nodiscard]] inline constexpr float getSidechainForDisplay() const { return fc_hz; }

    constexpr int32_t setSidechain(q31_t f) {
        sideChainKnobPos = f;
        // this exp will be between 1 and 5ish, half the knob range is about 2
        // the result will then be from 0 to 100hz with half the knob range at 60hz
        fc_hz = (std::exp(1.5 * float(f) / ONE_Q31f) - 1) * 30;
        float fc = fc_hz / float(kSampleRate);
        float wc = fc / (1 + fc);
        hpfA_ = wc * ONE_Q31;
        return fc_hz;
    }

    constexpr FixedPoint<31> getBlend() { return wet; }

    constexpr int32_t getBlendForDisplay() { return wet.raw() > (127 << 24) ? 100 : 100 * (wet.raw() >> 24) >> 7; }

    constexpr int32_t setBlend(FixedPoint<31> blend) {
        // hack to allow it to get to full wet. Safe since this isn't a modulatable param and doesn't need the headroom
        dry = 1.f - blend;
        wet = blend;
        return getBlendForDisplay();
    }

    constexpr void setBaseGain(float baseGain) { baseGain_ = baseGain; }

    void updateER(float numSamples, q31_t finalVolume);

    float calcRMS(StereoBuffer<q31_t> buffer);

    uint8_t gainReduction = 0;
 
private:
    float a_ = (-1000.0f / kSampleRate);
    float r_ = (-1000.0f / kSampleRate);
    float fraction = 0.5;
    float er = 0;
    float threshdb = 17;
    float threshold = 1;
    q31_t hpfA_ = ONE_Q16;

    float state = 0;
    q31_t currentVolumeL = 0;
    q31_t currentVolumeR = 0;
    float rms = 0;
    float mean = 0;
    uint32_t lastSaturationTanHWorkingValue[2] = {0};
    bool onLastTime = false;
 
    // sidechain filter
    deluge::dsp::filter::BasicFilterComponent hpfL;
    deluge::dsp::filter::BasicFilterComponent hpfR;
    // for display
    float attackMS = 0;
    float releaseMS = 0;
    float ratio = 2;
    float fc_hz;

    float baseGain_;
 
    // raw knob positions
    q31_t thresholdKnobPos = 0;
    q31_t ratioKnobPos = 0;
    q31_t attackKnobPos = 0;
    q31_t releaseKnobPos = 0;
    q31_t sideChainKnobPos = 0;
    FixedPoint<31> dry;
    FixedPoint<31> wet;
};
} // namespace deluge::dsp