noise.hpp

Go to the documentation of this file.

// sbl/widgets/source/noise.hpp — Noise generator (Audio Stack — Widgets)
//
// White noise via Galois LFSR (maximal-length 32-bit).
// Pink noise via Paul Kellet's single-pole IIR filter bank.
//
// Usage:
//   sbl::widgets::source::Noise noise;
//   noise.set_color(NoiseColor::Pink);
//   noise.process(buf, frames);
 
#pragma once
 
#include <cstdint>
 
namespace sbl::widgets::source {
 
enum class NoiseColor : uint8_t {
    White,
    Pink,
};
 
class Noise {
public:
    /// @note All public methods are ISR-safe — bounded computation, no I/O.
 
    /** @brief Set noise color */
    void set_color(NoiseColor c) { color_ = c; }
 
    /** @brief Set output amplitude (0.0 = silence, 1.0 = full scale) */
    void set_amplitude(float amp) { amplitude_ = amp; }
 
    /**
     * @brief Generate noise 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) {
            float white = next_white();
 
            if (color_ == NoiseColor::Pink) {
                out[i] = pink_filter(white) * amplitude_;
            } else {
                out[i] = white * amplitude_;
            }
        }
    }
 
    /** @brief Seed the LFSR (for reproducible output in tests) */
    void seed(uint32_t s) { lfsr_ = s ? s : 1; }
 
private:
    NoiseColor color_ = NoiseColor::White;
    float amplitude_ = 1.0f;
 
    // Galois LFSR — 32-bit maximal length (taps: 32, 22, 2, 1)
    uint32_t lfsr_ = 0x12345678u;
 
    // Paul Kellet pink noise filter state
    float b0_ = 0, b1_ = 0, b2_ = 0, b3_ = 0, b4_ = 0, b5_ = 0, b6_ = 0;
 
    float next_white() {
        // Galois LFSR: if LSB set, XOR with polynomial
        uint32_t lsb = lfsr_ & 1u;
        lfsr_ >>= 1;
        if (lsb) lfsr_ ^= 0xD0000001u;  // Maximal-length polynomial
        // Convert to float [-1.0, 1.0]
        return (static_cast<float>(lfsr_) / 2147483648.0f) - 1.0f;
    }
 
    float pink_filter(float white) {
        // Paul Kellet's economy method (7 state variables)
        // Spectral density falls at ~3 dB/octave
        b0_ = 0.99886f * b0_ + white * 0.0555179f;
        b1_ = 0.99332f * b1_ + white * 0.0750759f;
        b2_ = 0.96900f * b2_ + white * 0.1538520f;
        b3_ = 0.86650f * b3_ + white * 0.3104856f;
        b4_ = 0.55000f * b4_ + white * 0.5329522f;
        b5_ = -0.7616f * b5_ + white * 0.0168980f;
        float pink = b0_ + b1_ + b2_ + b3_ + b4_ + b5_ + b6_ + white * 0.5362f;
        b6_ = white * 0.115926f;
 
        // Normalize (pink sum is roughly ±3.5)
        pink *= 0.11f;
        if (pink > 1.0f) pink = 1.0f;
        if (pink < -1.0f) pink = -1.0f;
 
        return pink;
    }
};
 
} // namespace sbl::widgets::source