partial_parameters.hpp

Go to the documentation of this file.

#pragma once
 
#include <cstdint>
#include <span>
#include <utility>
 
namespace ts {

class PartialParameters {
public:
    static constexpr int stride = 0x6E;

    static constexpr int no_multisample = 0xFFFF;

    PartialParameters() = default;

    explicit PartialParameters(const std::uint8_t* block) noexcept : block_(block) {}

    [[nodiscard]] std::span<const std::uint8_t> raw() const noexcept
    {
        return {block_, static_cast<std::size_t>(stride)};
    }

    [[nodiscard]] bool is_present() const noexcept
    {
        return block_ != nullptr && multisample() != no_multisample;
    }

    [[nodiscard]] int multisample() const noexcept { return u16(0x02); }

    [[nodiscard]] int key_center() const noexcept { return block_[0x04]; }

    [[nodiscard]] int pan() const noexcept { return block_[0x0F]; }

    [[nodiscard]] int key_transpose() const noexcept { return block_[0x10]; }

    [[nodiscard]] int coarse_tune_raw() const noexcept { return block_[0x11]; }

    [[nodiscard]] int coarse_tune_milli_semitones() const noexcept
    {
        return (coarse_tune_raw() - 0x40) * 10;
    }

    [[nodiscard]] int pitch_key_follow() const noexcept { return block_[0x13]; }

    [[nodiscard]] int cutoff_base() const noexcept { return block_[0x2F]; }

    [[nodiscard]] int resonance() const noexcept { return block_[0x30]; }

    [[nodiscard]] int filter_type() const noexcept { return block_[0x31]; }

    [[nodiscard]] int velocity_curve() const noexcept { return block_[0x2E] & 0x0F; }

    [[nodiscard]] int velocity_crossfade_curve() const noexcept { return block_[0x4E] & 0x0F; }

    [[nodiscard]] int velocity_low() const noexcept { return block_[0x4F]; }

    [[nodiscard]] int velocity_high() const noexcept { return block_[0x51]; }

    [[nodiscard]] int level_at_low() const noexcept { return block_[0x50]; }

    [[nodiscard]] int level_at_high() const noexcept { return block_[0x52]; }

    [[nodiscard]] int tva_base_level() const noexcept { return block_[0x53]; }

    [[nodiscard]] std::pair<int, int> velocity_window() const noexcept
    {
        return velocity_low() <= velocity_high() ? std::pair{velocity_low(), velocity_high()}
                                                 : std::pair{velocity_high(), velocity_low()};
    }

    [[nodiscard]] bool accepts_velocity(int velocity) const noexcept
    {
        const auto [low, high] = velocity_window();
        return velocity >= low && velocity <= high;
    }

    [[nodiscard]] int transposed_key(int note) const noexcept;

    [[nodiscard]] friend bool operator==(const PartialParameters& left,
                                         const PartialParameters& right) noexcept
    {
        return left.block_ == right.block_;
    }
 
private:
    [[nodiscard]] int u16(int offset) const noexcept
    {
        return block_[offset] | (block_[offset + 1] << 8);
    }
 
    const std::uint8_t* block_ = nullptr;
};
 
} // namespace ts