param_interp.hpp

Go to the documentation of this file.

// sbl/dsp/param_interp.hpp — RAII parameter interpolator
//
// Linearly interpolates a parameter across a render block to eliminate
// zipper noise from step changes. The destructor writes the final value
// back to the state pointer, ensuring the next block picks up exactly
// where this one left off.
//
// Inspired by Mutable Instruments stmlib ParameterInterpolator (MIT).
//
// Usage:
//   float cutoff_state = 1000.0f;
//
//   void render(float* out, size_t n) {
//       sbl::dsp::ParameterInterpolator cutoff(&cutoff_state, new_cutoff, n);
//       for (size_t i = 0; i < n; ++i) {
//           filter.set_cutoff(cutoff.next());
//           out[i] = filter.process(in[i]);
//       }
//   }  // destructor stores final value
 
#pragma once
 
#include <cstdint>
 
namespace sbl::dsp {
 
class ParameterInterpolator {
public:
    /// @note All public methods are ISR-safe — bounded computation, no I/O.
 
    /**
     * @brief Construct interpolator for a block
     * @param state Pointer to persistent state (read on entry, written on exit)
     * @param target Target value for end of block
     * @param frames Number of samples in the block (must be > 0)
     */
    ParameterInterpolator(float* state, float target, uint16_t frames)
        : state_(state)
        , value_(*state)
        , increment_((target - *state) / static_cast<float>(frames))
    {}
 
    /** @brief Non-owning constructor (no write-back on destruction) */
    ParameterInterpolator(float start, float target, uint16_t frames)
        : state_(nullptr)
        , value_(start)
        , increment_((target - start) / static_cast<float>(frames))
    {}
 
    ~ParameterInterpolator() {
        if (state_) {
            *state_ = value_;
        }
    }
 
    // Non-copyable (owns state pointer)
    ParameterInterpolator(const ParameterInterpolator&) = delete;
    ParameterInterpolator& operator=(const ParameterInterpolator&) = delete;
 
    /** @brief Get next interpolated value */
    float next() {
        float v = value_;
        value_ += increment_;
        return v;
    }
 
    /** @brief Current value (without advancing) */
    float value() const { return value_; }
 
    /** @brief Per-sample increment */
    float increment() const { return increment_; }
 
private:
    float* state_;
    float value_;
    float increment_;
};
 
} // namespace sbl::dsp