slew_limiter.hpp

Go to the documentation of this file.

// sbl/dsp/primitives/slew_limiter.hpp — Slew rate limiter (float)
//
// Per-sample rate limiting with independent rise and fall rates.
// Used for portamento, parameter smoothing, tape motor time slew,
// and envelope shapes.
//
// Rate is specified as maximum change per sample (in float units).
// Higher rate = faster slew. Rate of 0 = no change (hold).
//
// Usage:
//   sbl::dsp::SlewLimiter slew;
//   slew.set_rise_rate(0.01f);
//   slew.set_fall_rate(0.005f);
//   float out = slew.process(target);   // Per-sample rate limiting
 
#ifndef SBL_DSP_PRIMITIVES_SLEW_LIMITER_HPP_
#define SBL_DSP_PRIMITIVES_SLEW_LIMITER_HPP_
 
#include <cstdint>
 
namespace sbl::dsp::primitives {
 
class SlewLimiter {
public:
    /// @note All public methods are ISR-safe — bounded computation, no I/O.
 
    /** @brief Set maximum increase per sample */
    void set_rise_rate(float rate) { rise_rate_ = rate; }
 
    /** @brief Set maximum decrease per sample */
    void set_fall_rate(float rate) { fall_rate_ = rate; }
 
    /** @brief Set both rise and fall rates to the same value */
    void set_rate(float rate) { rise_rate_ = rate; fall_rate_ = rate; }
 
    /**
     * @brief Process one sample toward target with rate limiting
     * @param target Target value
     * @return Rate-limited output
     */
    float process(float target) {
        float diff = target - state_;
 
        if (diff > 0.0f) {
            if (diff > rise_rate_) {
                state_ += rise_rate_;
            } else {
                state_ = target;
            }
        } else if (diff < 0.0f) {
            if (-diff > fall_rate_) {
                state_ -= fall_rate_;
            } else {
                state_ = target;
            }
        }
 
        // Track remaining distance for consumers (e.g., modulation scaling)
        delta_ = (target >= state_) ? (target - state_) : (state_ - target);
 
        return state_;
    }
 
    /** @brief Current output value */
    float value() const { return state_; }
 
    /** @brief Distance from current state to last processed target (absolute) */
    float delta() const { return delta_; }
 
    /** @brief Reset to zero */
    void reset() { state_ = 0.0f; delta_ = 0.0f; }
 
    /** @brief Reset to a specific value */
    void reset(float initial) { state_ = initial; delta_ = 0.0f; }
 
private:
    float rise_rate_ = 0.0f;
    float fall_rate_ = 0.0f;
    float state_ = 0.0f;
    float delta_ = 0.0f;         // remaining distance after last process()
};
 
} // namespace sbl::dsp::primitives
 
#endif // SBL_DSP_PRIMITIVES_SLEW_LIMITER_HPP_