allpass.hpp

Go to the documentation of this file.

// sbl/dsp/allpass.hpp — Schroeder allpass filter
//
// y[n] = -g*x[n] + x[n-d] + g*y[n-d]
//
// Disperses energy in time without changing frequency magnitude response.
// Core building block for reverb diffusion networks.
//
// Float-domain processing — STM32H7 (Cortex-M7) has hardware FPU with
// single-cycle float ops.
//
// Usage:
//   float buf[256] = {};
//   sbl::dsp::AllpassFilter ap;
//   ap.init(buf, 256);
//   ap.set_feedback(0.5f);
//   float out = ap.process(in);
 
#pragma once
 
#include <cstdint>
 
namespace sbl::dsp {
 
class AllpassFilter {
public:
    /// @note All public methods are ISR-safe — bounded computation, no I/O.
 
    /**
     * @brief Construct with caller-provided buffer
     * @param buffer Float buffer (must outlive the AllpassFilter)
     * @param delay Delay length in samples (buffer size)
     */
    AllpassFilter(float* buffer, uint32_t delay)
        : buffer_(buffer), delay_(delay), write_pos_(0) {}
 
    /// Default constructor for array initialization (must call init() before use)
    AllpassFilter() = default;
 
    /**
     * @brief Initialize after default construction
     * @param buffer Float buffer (must outlive the AllpassFilter)
     * @param delay Delay length in samples
     */
    void init(float* buffer, uint32_t delay) {
        buffer_ = buffer;
        delay_ = delay;
        write_pos_ = 0;
    }
 
    /**
     * @brief Process a single sample
     *
     * Schroeder allpass: y = -g*x + x[n-d] + g*y[n-d]
     * where the buffer stores the output history.
     *
     * @param x Input sample in [-1.0, 1.0]
     * @return Allpass-filtered output in [-1.0, 1.0]
     */
    float process(float x) {
        float delayed = buffer_[write_pos_];
 
        float output = -feedback_ * x + delayed;
        float to_buffer = x + feedback_ * output;
 
        buffer_[write_pos_] = to_buffer;
 
        ++write_pos_;
        if (write_pos_ >= delay_) {
            write_pos_ = 0;
        }
 
        return output;
    }
 
    /**
     * @brief Set feedback coefficient
     * @param g Feedback gain, typically 0.5–0.7 for reverb diffusion
     */
    void set_feedback(float g) { feedback_ = g; }
 
    /** @brief Current feedback coefficient */
    float feedback() const { return feedback_; }
 
    /** @brief Zero the buffer and reset write position */
    void clear() {
        if (buffer_) {
            for (uint32_t i = 0; i < delay_; ++i) buffer_[i] = 0.0f;
        }
        write_pos_ = 0;
    }
 
    /** @brief Delay length in samples */
    uint32_t delay() const { return delay_; }
 
    /** @brief Current write position (for external tap reads) */
    uint32_t write_pos() const { return write_pos_; }
 
private:
    float* buffer_ = nullptr;
    uint32_t delay_ = 0;
    uint32_t write_pos_ = 0;
    float feedback_ = 0.5f;
};
 
} // namespace sbl::dsp