pitch_ramp.hpp

Go to the documentation of this file.

#pragma once
 
#include <algorithm>
#include <cmath>
#include <cstdint>
#include <span>
 
namespace ts {

class PitchRamp {
public:
    static constexpr int samples_per_slot = 8;

    static constexpr int unity = 0x38000;

    static constexpr int units_per_octave = 0x4000;
    static constexpr int milli_semitone_divisor = 375;

    static constexpr int domain_max = 0x3FFFF;

    explicit PitchRamp(std::span<const std::int32_t> ramp_exp) noexcept : table_(ramp_exp) {}

    [[nodiscard]] static int domain_of(double ratio) noexcept
    {
        if (!(ratio > 0.0)) {
            return 0;
        }
        const double units = unity + (std::log2(ratio) * units_per_octave);
        return std::clamp(static_cast<int>(std::lround(units)), 0, domain_max) & ~1;
    }

    [[nodiscard]] std::int32_t increment_of(int value) const noexcept
    {
        if (value == 0) {
            return 0;
        }
        const auto index = static_cast<std::size_t>((value >> 6) & 0xFF);
        const int fraction = value & 0x3F;
        const std::int64_t interpolated =
            (static_cast<std::int64_t>(table_[index]) * (0x40 - fraction))
            + (static_cast<std::int64_t>(table_[index + 1]) * fraction);
        const std::int64_t rounded = (interpolated + ((interpolated >> 63) & 0x3F)) >> 6;
        return static_cast<std::int32_t>(rounded >> (0xF - ((value >> 0xE) & 0xF)));
    }

    void arm(double from_ratio, double to_ratio) noexcept
    {
        current_ = domain_of(from_ratio);
        target_ = domain_of(to_ratio);
        const auto delta = static_cast<std::int64_t>(target_) - current_;
        step_ = static_cast<int>((delta * max_rate) >> 13);
        if (step_ == 0 && current_ < target_) {
            step_ = 1;
        }
        active_ = current_ != target_ && step_ != 0;
    }

    [[nodiscard]] bool is_active() const noexcept { return active_; }

    [[nodiscard]] std::int32_t next_slot() noexcept
    {
        if (!active_) {
            return increment_of(target_);
        }
 
        current_ = step_ < 0 ? std::max(target_, current_ + step_)
                             : std::min(target_, current_ + step_);
        if (current_ == target_) {
            active_ = false;
        }
        return increment_of(current_);
    }
 
private:
    static constexpr int max_rate = 0xFFF;
 
    std::span<const std::int32_t> table_;
    int current_ = unity;
    int target_ = unity;
    int step_ = 0;
    bool active_ = false;
};
 
} // namespace ts