wavetable.hpp

Go to the documentation of this file.

// sbl/dsp/wavetable.hpp — Wavetable reader with interpolation
//
// Thin wrapper around lut::lookup_linear/cubic for reading LUTE-generated
// float tables. Templated on Size to match compile-time table sizes (256, 1024).
//
// Usage:
//   sbl::dsp::WavetableReader<1024> reader;
//   reader.set_table(sbl::dsp::lut::sin_1024);
//   float s = reader.read(phase);            // linear interpolation
//   float s = reader.read_cubic(phase);      // cubic Hermite
//
// Block processing:
//   reader.read_block(phase_buf, out_buf, frames);
 
#pragma once
 
#include <cstdint>
 
#include <sbl/dsp/lut.hpp>
 
namespace sbl::dsp {
 
template<uint16_t Size>
class WavetableReader {
public:
    /// @note All public methods are ISR-safe — bounded computation, no I/O.
 
    /** @brief Set the wavetable to read from (must have Size+1 guard points for linear) */
    void set_table(const float* table) { table_ = table; }
 
    /** @brief Current table pointer */
    const float* table() const { return table_; }
 
    /**
     * @brief Read a single sample with linear interpolation
     * @param phase 32-bit phase (full range = one table cycle)
     * @return Interpolated sample value in [-1.0, 1.0]
     */
    float read(uint32_t phase) const {
        return lut::lookup_linear<Size>(table_, phase);
    }
 
    /**
     * @brief Read a single sample with cubic Hermite interpolation
     * @param phase 32-bit phase
     * @return Interpolated sample value (smoother, higher cost)
     */
    float read_cubic(uint32_t phase) const {
        return lut::lookup_cubic<Size>(table_, phase);
    }
 
    /**
     * @brief Read a block of samples using linear interpolation
     * @param phases Array of per-sample phase values
     * @param out Output sample buffer
     * @param frames Number of frames to process
     */
    void read_block(const uint32_t* phases, float* out, uint16_t frames) const {
        for (uint16_t i = 0; i < frames; ++i) {
            out[i] = lut::lookup_linear<Size>(table_, phases[i]);
        }
    }
 
private:
    const float* table_ = nullptr;
};
 
} // namespace sbl::dsp