smoothed_value.hpp

Go to the documentation of this file.

#pragma once
 
#include <cmath>
#include <algorithm>
#include <limits>
 
namespace pulp::signal {

template<typename T = float>
class SmoothedValue {
public:
    SmoothedValue() = default;
    explicit SmoothedValue(T initial) : current_(initial), target_(initial) {}

    // Set the smoothing time in seconds and sample rate
    void set_ramp_time(T seconds, T sample_rate) {
        // Public control inputs can be malformed. Keep the conversion to int
        // defined and fail closed to the historical one-sample behavior.
        constexpr int kMaxRampSamples = (std::numeric_limits<int>::max)();
        if (!std::isfinite(seconds) || !std::isfinite(sample_rate) || seconds <= T(0) ||
            sample_rate <= T(0)) {
            ramp_samples_ = 1;
            return;
        }
        // Compare in a wider type before converting to int.  In particular,
        // float(INT_MAX) rounds to 2^31, which otherwise leaves an out-of-range
        // value eligible for the conversion below.
        const long double sample_count_wide =
            static_cast<long double>(seconds) * static_cast<long double>(sample_rate);
        if (!std::isfinite(sample_count_wide) ||
            sample_count_wide > static_cast<long double>(kMaxRampSamples)) {
            ramp_samples_ = kMaxRampSamples;
            return;
        }
        ramp_samples_ = static_cast<int>(seconds * sample_rate);
        if (ramp_samples_ < 1) ramp_samples_ = 1;
    }
 
    // Set the target value (begins ramping)
    void set_target(T value) {
        target_ = value;
        if (ramp_samples_ <= 1) {
            current_ = value;
            steps_remaining_ = 0;
            increment_ = T(0);
        } else {
            increment_ = (target_ - current_) / static_cast<T>(ramp_samples_);
            steps_remaining_ = ramp_samples_;
        }
    }
 
    // Jump immediately to value (no smoothing)
    void set_immediate(T value) {
        current_ = value;
        target_ = value;
        steps_remaining_ = 0;
        increment_ = T(0);
    }
 
    // Get the next smoothed sample
    T next() {
        if (steps_remaining_ > 0) {
            current_ += increment_;
            --steps_remaining_;
            if (steps_remaining_ == 0) current_ = target_;
        }
        return current_;
    }
 
    // Skip N samples of smoothing
    void skip(int n) {
        if (n <= 0) return;
        if (steps_remaining_ <= 0) return;
        if (n >= steps_remaining_) {
            current_ = target_;
            steps_remaining_ = 0;
        } else {
            current_ += increment_ * static_cast<T>(n);
            steps_remaining_ -= n;
        }
    }
 
    // Is smoothing still active?
    bool is_smoothing() const { return steps_remaining_ > 0; }
 
    // Current value (without advancing)
    T current() const { return current_; }
    T target() const { return target_; }
 
private:
    T current_ = T(0);
    T target_ = T(0);
    T increment_ = T(0);
    int ramp_samples_ = 1;
    int steps_remaining_ = 0;
};
 
using SmoothedValue64 = SmoothedValue<double>;
 
} // namespace pulp::signal