decay_envelope.hpp

Go to the documentation of this file.

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

inline double exp_decay_coefficient(double ms, double sample_rate) {
    const double samples = 0.001 * std::max(ms, 1e-6) * sample_rate;
    return std::exp(-1.0 / std::max(samples, 1e-9));
}

inline double t60_decay_coefficient(double ms, double sample_rate) {
    const double samples = 0.001 * std::max(ms, 1e-6) * sample_rate;
    return std::pow(10.0, -3.0 / std::max(samples, 1e-9));
}

template <typename SampleType = float>
class DecayEnvelopeT {
public:
    static constexpr double silence_floor = 1e-5;

    DecayEnvelopeT() { update(); }
 
    void set_sample_rate(double sr) {
        sample_rate_ = sr > 0.0 ? sr : sample_rate_;
        update();
    }

    void set_attack_ms(double ms) {
        attack_ms_ = std::max(ms, 0.0);
        update();
    }

    void set_hold_ms(double ms) {
        hold_ms_ = std::max(ms, 0.0);
        update();
    }

    void set_decay_time_constant_ms(double ms) {
        decay_ms_ = std::max(ms, 0.0);
        decay_is_t60_ = false;
        update();
    }

    void set_decay_t60_ms(double ms) {
        decay_ms_ = std::max(ms, 0.0);
        decay_is_t60_ = true;
        update();
    }
 
    double attack_ms() const { return attack_ms_; }
    double hold_ms() const { return hold_ms_; }
    double decay_ms() const { return decay_ms_; }

    void trigger(SampleType peak = SampleType{1}) {
        peak_ = static_cast<double>(peak);
        level_ = 0.0;
        attack_phase_ = 0.0;
        hold_remaining_ = hold_samples_;
        stage_ = attack_samples_ > 0.0 ? Stage::attack : Stage::hold;
        if (stage_ == Stage::hold) level_ = 1.0;
        active_ = peak_ != 0.0;
    }

    void reset() {
        level_ = 0.0;
        attack_phase_ = 0.0;
        hold_remaining_ = 0;
        stage_ = Stage::idle;
        active_ = false;
    }
 
    bool is_active() const { return active_; }

    SampleType process() {
        if (!active_) return SampleType{0};
 
        switch (stage_) {
            case Stage::attack:
                attack_phase_ += attack_step_;
                if (attack_phase_ >= 1.0) {
                    attack_phase_ = 1.0;
                    stage_ = Stage::hold;
                }
                level_ = attack_phase_;
                break;
 
            case Stage::hold:
                level_ = 1.0;
                if (hold_remaining_ > 0) {
                    --hold_remaining_;
                } else {
                    stage_ = Stage::decay;
                }
                break;
 
            case Stage::decay:
                level_ = snap_to_zero(level_ * decay_coef_);
                if (level_ < silence_floor) {
                    level_ = 0.0;
                    active_ = false;
                    stage_ = Stage::idle;
                }
                break;
 
            case Stage::idle:
                level_ = 0.0;
                break;
        }
 
        return static_cast<SampleType>(level_ * peak_);
    }

    SampleType value() const { return static_cast<SampleType>(level_ * peak_); }
 
private:
    enum class Stage { idle, attack, hold, decay };
 
    void update() {
        attack_samples_ = 0.001 * attack_ms_ * sample_rate_;
        attack_step_ = attack_samples_ > 0.0 ? 1.0 / attack_samples_ : 1.0;
        hold_samples_ = static_cast<long>(0.001 * hold_ms_ * sample_rate_);
        decay_coef_ = decay_is_t60_ ? t60_decay_coefficient(decay_ms_, sample_rate_)
                                    : exp_decay_coefficient(decay_ms_, sample_rate_);
    }
 
    double sample_rate_ = 44100.0;
    double attack_ms_ = 0.5;
    double hold_ms_ = 0.0;
    double decay_ms_ = 200.0;
    bool decay_is_t60_ = false;
 
    double attack_samples_ = 0.0;
    double attack_step_ = 1.0;
    long hold_samples_ = 0;
    double decay_coef_ = 0.0;
 
    Stage stage_ = Stage::idle;
    double level_ = 0.0;
    double peak_ = 1.0;
    double attack_phase_ = 0.0;
    long hold_remaining_ = 0;
    bool active_ = false;
};
 
using DecayEnvelope = DecayEnvelopeT<float>;
using DecayEnvelope64 = DecayEnvelopeT<double>;
 
}  // namespace pulp::signal