wavetable_osc.hpp

Go to the documentation of this file.

// sbl/widgets/source/wavetable_osc.hpp — Wavetable oscillator (Audio Stack — Widgets)
//
// Composes PhaseAccumulator + WavetableReader into a complete oscillator.
// Frequency can be set via Hz, MIDI note, or direct phase increment.
//
// Usage:
//   sbl::widgets::source::WavetableOsc<1024> osc;
//   osc.set_wavetable(sbl::dsp::lut::sin_1024);
//   osc.set_frequency(440.0f);
//   osc.process(buf, frames);
 
#pragma once
 
#include <cstdint>
 
#include <sbl/dsp/phase.hpp>
#include <sbl/dsp/wavetable.hpp>
#include <sbl/dsp/pitch.hpp>
 
namespace sbl::widgets::source {
 
template<uint16_t TableSize>
class WavetableOsc {
public:
    /// @note All public methods are ISR-safe — bounded computation, no I/O.
 
    /** @brief Set wavetable (must have guard points for interpolation) */
    void set_wavetable(const float* table) { reader_.set_table(table); }
 
    /**
     * @brief Set frequency in Hz
     * @param freq_hz Frequency in Hz (e.g., 440.0f)
     * @param sr Sample rate (default 48000)
     */
    void set_frequency(float freq_hz, float sr = 48000.0f) {
        phase_.set_increment(dsp::PhaseAccumulator::freq_to_inc(freq_hz, sr));
    }
 
    /**
     * @brief Set frequency from MIDI note number (requires FPU)
     * @param midi_note MIDI note (69 = A4 = 440 Hz)
     * @param sample_rate Sample rate
     */
    void set_note(float midi_note, float sample_rate = 48000.0f) {
        phase_.set_increment(dsp::note_to_phase_increment(midi_note, sample_rate));
    }
 
    /** @brief Set phase increment directly */
    void set_increment(uint32_t inc) { phase_.set_increment(inc); }
 
    /** @brief Set output amplitude (0.0 = silence, 1.0 = full scale) */
    void set_amplitude(float amp) { amplitude_ = amp; }
 
    /**
     * @brief Generate audio samples
     * @param out Output buffer (float, [-1.0, 1.0])
     * @param frames Number of samples
     */
    void process(float* out, uint16_t frames) {
        for (uint16_t i = 0; i < frames; ++i) {
            phase_.advance();
            out[i] = reader_.read(phase_.phase()) * amplitude_;
        }
    }
 
    /** @brief Hard sync — reset phase to zero */
    void sync() { phase_.reset(); }
 
    /** @brief Reset phase to a specific value */
    void sync(uint32_t phase) { phase_.reset(phase); }
 
    /** @brief Current phase */
    uint32_t phase() const { return phase_.phase(); }
 
    /** @brief Current phase increment */
    uint32_t increment() const { return phase_.increment(); }
 
private:
    dsp::PhaseAccumulator phase_;
    dsp::WavetableReader<TableSize> reader_;
    float amplitude_ = 1.0f;
};
 
} // namespace sbl::widgets::source