bit_reducer.hpp

Go to the documentation of this file.

// sbl/dsp/primitives/bit_reducer.hpp — Amplitude bit-depth reduction
//
// Uniform quantization to N levels. Reduces the effective bit depth of a
// signal by snapping sample values to a grid. Fractional bit depths produce
// intermediate step counts for smooth knob sweeps.
//
// Domain: waveshape. Quantization changes the instantaneous input-output
// relationship — it's a staircase transfer function. Harmonically, it adds
// quantization noise whose character depends on the step count.
//
// Usage:
//   sbl::dsp::primitives::BitReducer br;
//   br.set_bits(8.0f);                    // 256 levels
//   float y = br.process(x);             // per-sample
//   br.process(buf, frames);             // block in-place
 
#ifndef SBL_DSP_PRIMITIVES_BIT_REDUCER_HPP_
#define SBL_DSP_PRIMITIVES_BIT_REDUCER_HPP_
 
#include <cmath>
#include <cstdint>
 
namespace sbl::dsp::primitives {
 
class BitReducer {
public:
    /// Set quantization depth in bits. Fractional values allowed.
    /// Caches the level count internally.
    void set_bits(float bits) {
        bits_ = bits;
        levels_ = exp2f(bits);
        inv_levels_ = 1.0f / levels_;
    }
 
    float bits() const { return bits_; }
 
    /// Process a single sample.
    float process(float x) const {
        return roundf(x * levels_) * inv_levels_;
    }
 
    /// Process a block of samples in-place.
    void process(float* buf, uint16_t n) const {
        for (uint16_t i = 0; i < n; ++i) {
            buf[i] = process(buf[i]);
        }
    }
 
private:
    float bits_ = 16.0f;
    float levels_ = 65536.0f;
    float inv_levels_ = 1.0f / 65536.0f;
};
 
} // namespace sbl::dsp::primitives
 
#endif // SBL_DSP_PRIMITIVES_BIT_REDUCER_HPP_