latency_aware_control_smoother.hpp

Go to the documentation of this file.

#pragma once

 
#include <cassert>
#include <cmath>
 
namespace pulp::signal {
 
class LatencyAwareControlSmoother {
public:
    enum class Domain { linear, semitone };
 
    struct Config {
        Domain domain = Domain::linear;
        float attack_seconds = 0.05f;   // toward larger values
        float release_seconds = 0.05f;  // toward smaller values
    };

    void prepare(double sample_rate, const Config& config) {
        assert(sample_rate > 0.0);
        config_ = config;
        // Per-sample retention coefficients; tau == 0 snaps immediately.
        attack_k_ = coefficient(config.attack_seconds, sample_rate);
        release_k_ = coefficient(config.release_seconds, sample_rate);
        current_ = 0.0;
        target_ = 0.0;
    }

    void set_target(float value) { target_ = static_cast<double>(value); }

    void set_immediate(float value) {
        target_ = static_cast<double>(value);
        current_ = target_;
    }
 
    float target() const { return static_cast<float>(target_); }
    float current() const { return static_cast<float>(current_); }

    float value_at(int offset) const {
        return static_cast<float>(project(offset));
    }

    float ratio_at(int offset) const {
        return std::exp2(static_cast<float>(project(offset)) / 12.0f);
    }

    float advance(int samples) {
        current_ = project(samples);
        return static_cast<float>(current_);
    }
 
    bool is_settled(float tolerance) const {
        return std::abs(current_ - target_) <= static_cast<double>(tolerance);
    }
 
private:
    static double coefficient(float seconds, double sample_rate) {
        if (seconds <= 0.0f) return 0.0;
        // Standard one-pole: value covers ~63% of the step per tau.
        return std::exp(-1.0 / (static_cast<double>(seconds) * sample_rate));
    }
 
    double project(int offset) const {
        const double k = target_ > current_ ? attack_k_ : release_k_;
        if (k <= 0.0) return offset >= 0 ? target_ : current_;
        return target_ + (current_ - target_) * std::pow(k, static_cast<double>(offset));
    }
 
    Config config_;
    double attack_k_ = 0.0;
    double release_k_ = 0.0;
    double current_ = 0.0;
    double target_ = 0.0;
};
 
} // namespace pulp::signal