lowpass_gate.hpp

Go to the documentation of this file.

#pragma once
 
#include <pulp/signal/tpt_filter.hpp>
#include <pulp/signal/vactrol.hpp>
 
#include <algorithm>
#include <cmath>
 
namespace pulp::signal {

template <typename SampleType = float>
class LowpassGateT {
public:
    LowpassGateT() { update(); }
 
    void set_sample_rate(double sr) {
        sample_rate_ = sr > 0.0 ? sr : sample_rate_;
        vactrol_.prepare(sample_rate_);
        update();
    }

    void set_rise_ms(double ms) { vactrol_.set_rise_ms(ms); }

    void set_fall_ms(double ms) { vactrol_.set_fall_ms(ms); }

    void set_colour(double amount) { colour_ = std::clamp(amount, 0.0, 1.0); }

    void set_closed_cutoff_hz(double hz) {
        closed_hz_ = std::clamp(hz, 10.0, 20000.0);
        update();
    }

    void set_open_cutoff_hz(double hz) {
        open_hz_ = std::clamp(hz, 10.0, 20000.0);
        update();
    }

    void set_gain_exponent(double e) { gain_exponent_ = std::clamp(e, 0.25, 4.0); }
 
    void reset() {
        vactrol_.reset();
        gate_filter_.reset();
    }

    double control() const { return vactrol_.control(); }

    SampleType process(SampleType input, double target) {
        const double control_ = vactrol_.process(target);
 
        const double vca = std::pow(control_, gain_exponent_);
        // The two paths are complementary: the amplitude term carries the whole
        // gate at colour 0 and is bypassed at colour 1, while the filter blend
        // below does the opposite.
        double x = static_cast<double>(input) * (1.0 - (1.0 - colour_) * (1.0 - vca));
 
        // The corner sweeps geometrically with the control, because pitch and
        // brightness are heard geometrically: a linear sweep spends nearly all
        // its travel in the top octave and sounds like it does nothing.
        gate_filter_.set_cutoff(static_cast<SampleType>(
            closed_limit_ * std::pow(open_limit_ / closed_limit_, control_)));
        const double filtered = gate_filter_.process_lowpass(static_cast<SampleType>(x));
 
        // Mirror of the amplitude blend: colour 0 leaves the signal unfiltered.
        x = x + colour_ * (filtered - x);
        return static_cast<SampleType>(x);
    }
 
private:
    void update() {
        gate_filter_.prepare(static_cast<SampleType>(sample_rate_));
        const double nyquist = 0.49 * sample_rate_;
        open_limit_ = std::min(open_hz_, nyquist);
        closed_limit_ = std::min(closed_hz_, nyquist);
    }
 
    double sample_rate_ = 44100.0;
    double colour_ = 0.5;
    double closed_hz_ = 60.0;
    double open_hz_ = 12000.0;
    double gain_exponent_ = 1.5;
 
    double open_limit_ = 12000.0;
    double closed_limit_ = 60.0;
 
    VactrolConditionerT<SampleType> vactrol_{};
    TptFilterT<SampleType> gate_filter_;
};
 
using LowpassGate = LowpassGateT<float>;
using LowpassGate64 = LowpassGateT<double>;
 
}  // namespace pulp::signal