dither.hpp

// Copyright Take Vos 2021.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
 
#pragma once
 
#include "xorshift128p.hpp"
#include "../required.hpp"
 
namespace tt {
 
class dither {
public:
    dither(dither const &) = default;
    dither(dither &&) = default;
    dither &operator=(dither const &) = default;
    dither &operator=(dither &&) = default;
 
    dither(int num_bits) noexcept 
    {
        tt_axiom(num_bits > 0);
        auto maximum_value = static_cast<float>((1_uz << num_bits) - 1);
 
        // The maximum value from the rectangular probability density function.
        maximum_value *= 127.0f;
 
        // Triangular probability density function is has twice the range.
        maximum_value *= 2.0f;
 
        _multiplier = f32x4::broadcast(1.0f / maximum_value);
    }
 
    f32x4 next() noexcept
    {
        if (static_cast<bool>(++_counter & 1)) {
            auto rand = _state.next<u64x2>();
            auto spdf1 = i16x8{bit_cast<i8x16>(rand)};
            rand = rand.yx();
            auto spdf2 = i16x8{bit_cast<i8x16>(rand)};
 
            _tpdf = spdf1 + spdf2;
            return f32x4{i32x4{_tpdf}} * _multiplier;
        } else {
            auto second_tpdf = bit_cast<i16x8>(bit_cast<u64x2>(_tpdf).yx());
            return f32x4{i32x4{second_tpdf}} * _multiplier;
        }
    }
 
    [[nodiscard]] f32x4 next(f32x4 samples) noexcept
    {
        return samples + next();
    }
 
    [[nodiscard]] float next(float sample) noexcept
    {
        return get<0>(f32x4::broadcast(sample) + next());
    }
 
private:
    f32x4 _multiplier = {};
    i16x8 _tpdf = {};
    xorshift128p _state = {};
    unsigned char _counter = 0;
};
 
} // namespace tt