lpg.hpp

Go to the documentation of this file.

#pragma once

 
#include <pulp/signal/denormal.hpp>
#include <pulp/signal/tpt_filter.hpp>
 
#include <algorithm>
#include <cmath>
 
namespace pulp::signal {

template <typename SampleType = float> class LpgT {
  public:
    static constexpr double kRiseMs = 1.5;

    static constexpr double kStrikePulseMs = 3.0;

    static constexpr SampleType kVcaExponent = SampleType{1.5};
 
    static constexpr SampleType kDefaultFcMinHz = SampleType{40};
    static constexpr SampleType kDefaultFcMaxHz = SampleType{12000};
    static constexpr SampleType kMinFcHz = SampleType{10};
    static constexpr SampleType kMaxFcHz = SampleType{20000};
    static constexpr double kDefaultDecayMs = 150.0;

    static constexpr SampleType kDefaultDroop = SampleType{0.5};
    static constexpr SampleType kMaxDroop = SampleType{0.95};

    static constexpr SampleType kVelocityCurve = SampleType{0.7};

    static SampleType velocity_to_strike(SampleType velocity) {
        const SampleType v = std::clamp(velocity, SampleType{0}, SampleType{1});
        return std::pow(v, kVelocityCurve);
    }
 
    void prepare(SampleType sample_rate) {
        filter_.prepare(sample_rate);
        sample_rate_ = filter_.sample_rate();
        update_coefficients_();
        reset();
    }

    void set_decay_ms(double ms) {
        decay_ms_ = std::clamp(ms, 1.0, 5000.0);
        update_coefficients_();
    }
 
    void set_rise_ms(double ms) {
        rise_ms_ = std::clamp(ms, 0.05, 100.0);
        update_coefficients_();
    }

    void set_colour(SampleType c) {
        if (std::isnan(c))
            c = colour_;
        colour_ = std::clamp(c, SampleType{0}, SampleType{1});
        command_cutoff_();
    }

    void set_range_hz(SampleType min_hz, SampleType max_hz) {
        min_hz = normalize_cutoff_endpoint_(min_hz, kDefaultFcMinHz);
        max_hz = normalize_cutoff_endpoint_(max_hz, kDefaultFcMaxHz);
        if (min_hz > max_hz)
            std::swap(min_hz, max_hz);
        fc_min_ = min_hz;
        fc_max_ = max_hz;
        log_range_ = std::log(fc_max_ / fc_min_);
        command_cutoff_();
    }
 
    void set_droop(SampleType d) {
        droop_ = std::clamp(d, SampleType{0}, kMaxDroop);
    }

    void strike(SampleType level) {
        pulse_level_ = std::clamp(level, SampleType{0}, SampleType{1});
        pulse_remaining_ = pulse_samples_;
    }

    void set_gate(SampleType level) {
        gate_ = std::clamp(level, SampleType{0}, SampleType{1});
    }
 
    void reset() {
        control_ = SampleType{0};
        gate_ = SampleType{0};
        pulse_level_ = SampleType{0};
        pulse_remaining_ = 0;
        filter_.reset();
        command_cutoff_();
    }
 
    SampleType process(SampleType input) {
        advance_control_();
 
        // Amplitude and brightness are the same control through two different
        // laws — that coupling is the entire effect.
        const SampleType amplitude = control_ * std::sqrt(control_); // control^1.5
        // The commanded cutoff is capped at sample_rate / 4. Above that the
        // trapezoidal one-pole's step response exceeds one: near-Nyquist
        // content pumps the integrator state past the input bound, and the
        // next low-frequency sample reads it back out as a peak above the
        // input's — up to ~1.5x at 18 kHz / 44.1 kHz. At or below the cap
        // every state update is a convex combination, so peak out <= peak in
        // holds unconditionally, which is the no-boost contract the LPG's
        // consumers (and its own "can only attenuate" gain law) rely on.
        command_cutoff_();
 
        const SampleType filtered = filter_.process_lowpass(input);
        const SampleType gain = amplitude + colour_ * (SampleType{1} - amplitude);
        return filtered * gain;
    }

    SampleType control() const {
        return control_;
    }

    SampleType commanded_cutoff_hz() const {
        return commanded_cutoff_hz_;
    }

    SampleType cutoff_hz() const {
        return commanded_cutoff_hz();
    }
 
  private:
    static SampleType normalize_cutoff_endpoint_(SampleType hz, SampleType nan_fallback) {
        if (std::isnan(hz))
            hz = nan_fallback;
        return std::clamp(hz, kMinFcHz, kMaxFcHz);
    }
 
    void command_cutoff_() {
        const SampleType filter_control = SampleType{1} - colour_ * (SampleType{1} - control_);
        const SampleType cutoff = fc_min_ * std::exp(log_range_ * filter_control);
        filter_.set_cutoff(std::min(cutoff, SampleType{0.25} * sample_rate_));
        commanded_cutoff_hz_ = filter_.cutoff();
    }
 
    void update_coefficients_() {
        rise_coeff_ = coeff_for_(rise_ms_);
        fall_coeff_ = coeff_for_(decay_ms_);
        pulse_samples_ = static_cast<long long>(
            std::lround(kStrikePulseMs * 0.001 * static_cast<double>(sample_rate_)));
        if (pulse_samples_ < 1)
            pulse_samples_ = 1;
    }
 
    SampleType coeff_for_(double ms) const {
        const double samples = std::max(1.0e-6, ms * 0.001 * static_cast<double>(sample_rate_));
        return static_cast<SampleType>(1.0 - std::exp(-1.0 / samples));
    }
 
    void advance_control_() {
        SampleType target = gate_;
        if (pulse_remaining_ > 0) {
            target = std::max(target, pulse_level_);
            --pulse_remaining_;
        }
        if (target > control_) {
            control_ += rise_coeff_ * (target - control_);
        } else {
            // The droop is what makes the close non-exponential: as the cell
            // darkens the recovery slows, which is the decay contour of struck
            // wood and skin. droop = 0 recovers the plain first-order model.
            const SampleType coeff =
                fall_coeff_ * (SampleType{1} - droop_ * (SampleType{1} - control_));
            control_ += coeff * (target - control_);
        }
        control_ = std::clamp(snap_to_zero(control_), SampleType{0}, SampleType{1});
    }
 
    TptFilterT<SampleType> filter_{};
    SampleType sample_rate_ = SampleType{48000};
    SampleType control_ = SampleType{0};
    SampleType commanded_cutoff_hz_ = kDefaultFcMinHz;
    SampleType gate_ = SampleType{0};
    SampleType pulse_level_ = SampleType{0};
    SampleType rise_coeff_ = SampleType{0};
    SampleType fall_coeff_ = SampleType{0};
    long long pulse_remaining_ = 0;
    long long pulse_samples_ = 144;
    double rise_ms_ = kRiseMs;
    double decay_ms_ = kDefaultDecayMs;
    SampleType fc_min_ = kDefaultFcMinHz;
    SampleType fc_max_ = kDefaultFcMaxHz;
    SampleType log_range_ = static_cast<SampleType>(5.703782474656201); // log(12000 / 40)
    SampleType colour_ = SampleType{0.5};
    SampleType droop_ = kDefaultDroop;
};
 
using Lpg = LpgT<float>;
using Lpg64 = LpgT<double>;
 
} // namespace pulp::signal