delay_line.hpp

Go to the documentation of this file.

// sbl/dsp/delay_line.hpp — Circular buffer delay line
//
// Fixed-size delay line with caller-provided storage. Supports integer
// and fractional delay reads with linear interpolation.
//
// Usage:
//   float buf[1024];
//   sbl::dsp::DelayLine delay(buf, 1024);
//   delay.write(sample);
//   float out = delay.read(480);   // 10ms delay at 48kHz
 
#pragma once
 
#include <cstdint>
 
namespace sbl::dsp {
 
class DelayLine {
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 DelayLine)
     * @param max_delay Maximum delay in samples (buffer size)
     */
    DelayLine(float* buffer, uint32_t max_delay)
        : buffer_(buffer), max_delay_(max_delay), write_pos_(0) {}
 
    /** @brief Write a sample to the delay line */
    void write(float sample) {
        buffer_[write_pos_] = sample;
        ++write_pos_;
        if (write_pos_ >= max_delay_) {
            write_pos_ = 0;
        }
    }
 
    /**
     * @brief Read a sample at integer delay
     * @param delay Delay in samples (0 = most recent write)
     * @return Delayed sample
     */
    float read(uint32_t delay) const {
        if (delay >= max_delay_) delay = max_delay_ - 1;
        uint32_t pos = (write_pos_ + max_delay_ - delay - 1) % max_delay_;
        return buffer_[pos];
    }
 
    /**
     * @brief Read with fractional delay (float)
     *
     * Linear interpolation between adjacent samples.
     *
     * @param delay Fractional delay in samples (e.g. 10.5f)
     * @return Linearly interpolated sample
     */
    float read_fractional(float delay) const {
        uint32_t int_delay = static_cast<uint32_t>(delay);
        float frac = delay - static_cast<float>(int_delay);
 
        float a = read(int_delay);
        float b = read(int_delay + 1);
 
        return a + frac * (b - a);
    }
 
    /** @brief Zero all samples in the buffer */
    void clear() {
        for (uint32_t i = 0; i < max_delay_; ++i) {
            buffer_[i] = 0.0f;
        }
        write_pos_ = 0;
    }
 
    /** @brief Maximum delay in samples */
    uint32_t max_delay() const { return max_delay_; }
 
private:
    float* buffer_;
    uint32_t max_delay_;
    uint32_t write_pos_;
};
 
} // namespace sbl::dsp