minblep.hpp

Go to the documentation of this file.

#pragma once

 
#include "detail/minblep_table.hpp"
 
#include <array>
#include <cmath>
#include <cstddef>
 
namespace pulp::signal::osc {
 
enum class MinBlepInsertResult {
    inserted,
    zero_height,
    invalid_position,
    non_finite_height,
    capacity_exceeded,
};

template <std::size_t MaximumEvents = 8> class MinBlepAccumulator {
  public:
    static_assert(MaximumEvents > 0, "minBLEP event capacity must be positive");
 
    static constexpr std::size_t capacity = MaximumEvents;
    static constexpr std::size_t kernel_samples = detail::kMinBlepKernelSamples;
    static constexpr std::size_t phases_per_sample = detail::kMinBlepPhasesPerSample;
 
    void reset() noexcept {
        slots_ = {};
        active_events_ = 0;
    }
 
    [[nodiscard]] MinBlepInsertResult insert(double position, double height) noexcept {
        if (!(position >= 0.0 && position <= 1.0))
            return MinBlepInsertResult::invalid_position;
        if (!std::isfinite(height))
            return MinBlepInsertResult::non_finite_height;
        if (height == 0.0)
            return MinBlepInsertResult::zero_height;
 
        for (auto& slot : slots_) {
            if (slot.active)
                continue;
            slot.active = true;
            slot.table_position = (1.0 - position) * static_cast<double>(phases_per_sample);
            slot.height = height;
            ++active_events_;
            return MinBlepInsertResult::inserted;
        }
        return MinBlepInsertResult::capacity_exceeded;
    }
 
    [[nodiscard]] double next() noexcept {
        double correction = 0.0;
        constexpr auto last_index = detail::kMinBlepResidual.size() - 1;
        for (auto& slot : slots_) {
            if (!slot.active)
                continue;
 
            const auto index = static_cast<std::size_t>(slot.table_position);
            const double fraction = slot.table_position - static_cast<double>(index);
            const double first = static_cast<double>(detail::kMinBlepResidual[index]);
            const double second = static_cast<double>(detail::kMinBlepResidual[index + 1]);
            correction += slot.height * (first + fraction * (second - first));
            slot.table_position += static_cast<double>(phases_per_sample);
            if (slot.table_position >= static_cast<double>(last_index)) {
                slot = {};
                --active_events_;
            }
        }
        return correction;
    }
 
    [[nodiscard]] std::size_t active_events() const noexcept {
        return active_events_;
    }
 
  private:
    struct Slot {
        double table_position = 0.0;
        double height = 0.0;
        bool active = false;
    };
 
    std::array<Slot, MaximumEvents> slots_{};
    std::size_t active_events_ = 0;
};
 
} // namespace pulp::signal::osc