block.hpp

Go to the documentation of this file.

// sbl/dsp/types/block.hpp — Statically-allocated audio buffer types
//
// MonoBlock<N> and StereoBlock<N> are simple buffer-owning types for
// passing audio data between processing stages. They are data types,
// not processing units — no DSP, just buffer ownership with clean
// accessors.
//
// Usage:
//   MonoBlock<48> mono;
//   osc.process(mono.buf(), mono.size());
//
//   StereoBlock<48> stereo;
//   delay.process(stereo.buf_l(), stereo.buf_r(), stereo.size());
 
#ifndef SBL_DSP_TYPES_BLOCK_HPP_
#define SBL_DSP_TYPES_BLOCK_HPP_
 
#include <cstdint>
 
namespace sbl::dsp::types {
 
/// Mono audio buffer with static allocation.
template <uint16_t N>
struct MonoBlock {
    float data[N] = {};
 
    float* buf() { return data; }
    const float* buf() const { return data; }
 
    static constexpr uint16_t size() { return N; }
 
    void clear() {
        for (uint16_t i = 0; i < N; ++i) data[i] = 0.0f;
    }
 
    void clear(uint16_t n) {
        for (uint16_t i = 0; i < n; ++i) data[i] = 0.0f;
    }
};
 
/// Stereo audio buffer with static allocation.
template <uint16_t N>
struct StereoBlock {
    float left[N] = {};
    float right[N] = {};
 
    float* buf_l() { return left; }
    float* buf_r() { return right; }
    const float* buf_l() const { return left; }
    const float* buf_r() const { return right; }
 
    static constexpr uint16_t size() { return N; }
 
    void clear() {
        for (uint16_t i = 0; i < N; ++i) {
            left[i] = 0.0f;
            right[i] = 0.0f;
        }
    }
 
    void clear(uint16_t n) {
        for (uint16_t i = 0; i < n; ++i) {
            left[i] = 0.0f;
            right[i] = 0.0f;
        }
    }
};
 
} // namespace sbl::dsp::types
 
#endif // SBL_DSP_TYPES_BLOCK_HPP_