slew.hpp

Go to the documentation of this file.

// sbl/dsp/slew.hpp — Slew rate limiter
//
// Per-sample rate limiting with independent rise and fall rates.
// Used for portamento, parameter smoothing, and envelope shapes.
//
// Rate is specified as maximum change per sample (in sample units).
// Higher rate = faster slew. Rate of 0 = no change (hold).
//
// Usage:
//   sbl::dsp::SlewLimiter slew;
//   slew.set_rise_rate(1000);
//   slew.set_fall_rate(500);
//   Sample out = slew.process(target);   // Per-sample rate limiting
 
#pragma once
 
#include <cstdint>
 
#include <sbl/dsp/types.hpp>
 
namespace sbl::dsp {
 
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(uint32_t rate) { rise_rate_ = rate; }
 
    /** @brief Set maximum decrease per sample */
    void set_fall_rate(uint32_t rate) { fall_rate_ = rate; }
 
    /** @brief Set both rise and fall rates to the same value */
    void set_rate(uint32_t rate) { rise_rate_ = rate; fall_rate_ = rate; }
 
    /**
     * @brief Process one sample toward target with rate limiting
     * @param target Target value
     * @return Rate-limited output
     */
    Sample process(Sample target) {
        int32_t delta = target - state_;
 
        if (delta > 0) {
            // Rising
            if (static_cast<uint32_t>(delta) > rise_rate_) {
                state_ += static_cast<int32_t>(rise_rate_);
            } else {
                state_ = target;
            }
        } else if (delta < 0) {
            // Falling
            uint32_t abs_delta = static_cast<uint32_t>(-delta);
            if (abs_delta > fall_rate_) {
                state_ -= static_cast<int32_t>(fall_rate_);
            } else {
                state_ = target;
            }
        }
 
        return state_;
    }
 
    /** @brief Current output value */
    Sample value() const { return state_; }
 
    /** @brief Reset to zero */
    void reset() { state_ = 0; }
 
    /** @brief Reset to a specific value */
    void reset(Sample initial) { state_ = initial; }
 
private:
    uint32_t rise_rate_ = 0;
    uint32_t fall_rate_ = 0;
    Sample state_ = 0;
};
 
} // namespace sbl::dsp