mpe_voice_tracker.hpp

Go to the documentation of this file.

#pragma once

 
#include <pulp/midi/message.hpp>
#include <pulp/midi/ump.hpp>
#include <array>
#include <cstdint>
#include <functional>
#include <optional>
 
namespace pulp::midi {

using MpeNoteGeneration = std::uint64_t;

struct MpeNoteState {
    bool active = false;
    uint8_t channel = 0;           
    uint8_t note = 0;              
    uint8_t velocity = 0;          
    float pitch_bend_semitones = 0.0f;  
    float pressure = 0.0f;         
    float timbre = 0.0f;           
    MpeNoteGeneration note_id = 0; 
    bool is_upper_zone = false;    
    bool detached = false;
};

class MpeVoiceTracker {
public:
    static constexpr std::size_t kMaxNotes = 128;

    static constexpr float kDefaultMemberBendSemitones = 48.0f;
    static constexpr float kDefaultManagerBendSemitones = 2.0f;
 
    explicit MpeVoiceTracker(MpeConfig config = MpeConfig::standard_lower())
        : config_(config) {}
 
    // ── Configuration ──────────────────────────────────────────────────────
 
    void set_config(const MpeConfig& cfg);
    const MpeConfig& config() const { return config_; }

    void set_member_bend_range(float semitones);
    void set_manager_bend_range(float semitones);
    float member_bend_range() const {
        return member_bend_semi_[1];
    }

    float member_bend_range(uint8_t channel) const {
        return member_bend_semi_[channel & 0x0F];
    }

    float manager_bend_range() const {
        return manager_bend_semi_[0];
    }

    float manager_bend_range(bool upper_zone) const {
        return manager_bend_semi_[upper_zone ? 1 : 0];
    }
 
    // ── Configuration from incoming MIDI ──────────────────────────────────

    void set_follow_configuration_messages(bool enabled) {
        follow_config_messages_ = enabled;
    }
    bool follows_configuration_messages() const {
        return follow_config_messages_;
    }

    std::function<void(const MpeConfig&)> on_config_change;

    void set_assignable_timbre_index(std::optional<uint8_t> cc_index) {
        if (cc_index) assignable_timbre_index_ = static_cast<uint8_t>(*cc_index & 0x7F);
        else assignable_timbre_index_.reset();
    }
    std::optional<uint8_t> assignable_timbre_index() const {
        return assignable_timbre_index_;
    }
 
    // ── Event ingestion ────────────────────────────────────────────────────

    bool process(const MidiEvent& event);

    bool process(const UmpPacket& p);
 
    // ── Queries ────────────────────────────────────────────────────────────
 
    std::size_t active_count() const;

    const MpeNoteState* find(uint8_t channel, uint8_t note) const;

    std::size_t snapshot(MpeNoteState* out, std::size_t max) const;

    bool note_generation_exhausted() const noexcept { return next_note_generation_ == 0; }

    std::uint64_t refused_note_on_count() const noexcept { return refused_note_on_count_; }

    bool advance_note_generation(MpeNoteGeneration next) noexcept;

    std::size_t pending_note_off_count() const noexcept { return pending_note_off_count_; }

    bool flush_pending_note_offs();

    const std::array<MpeNoteState, kMaxNotes>& slots() const { return notes_; }
 
    // ── Zone-wide (manager) state ─────────────────────────────────────────
 
    struct ZoneState {
        float pitch_bend_semitones = 0.0f;  
        float pressure = 0.0f;              
        float timbre = 0.0f;                
    };
    const ZoneState& lower_zone_state() const { return lower_zone_state_; }
    const ZoneState& upper_zone_state() const { return upper_zone_state_; }
 
    // ── Callbacks (host-thread setup; invoked inline during process()) ────

    std::function<bool(const MpeNoteState* note_off,
                       const MpeNoteState* note_on)> on_note_lifecycle;
 
    std::function<void(const MpeNoteState&)> on_note_on;
    std::function<void(const MpeNoteState&)> on_note_off;
    std::function<void(const MpeNoteState&)> on_pitch_bend;
    std::function<void(const MpeNoteState&)> on_pressure;
    std::function<void(const MpeNoteState&)> on_timbre;
 
    // ── Lifecycle ──────────────────────────────────────────────────────────
 
    void reset() noexcept;
 
private:
    void add_note(uint8_t ch, uint8_t note, uint8_t velocity, bool upper);
    void remove_note(uint8_t ch, uint8_t note);
    bool accept_note_lifecycle(const MpeNoteState* note_off,
                               const MpeNoteState* note_on) const;
    bool defer_note_off(const MpeNoteState& note_off) noexcept;
    std::optional<MpeNoteGeneration> take_note_generation() noexcept;
    void record_generation_refusal() noexcept;
 
    void update_channel_pitch_bend(uint8_t ch, float semitones, bool upper);
    void update_channel_pressure(uint8_t ch, float pressure, bool upper);
    void update_channel_timbre(uint8_t ch, float timbre, bool upper);
 
    void track_registered_parameter(const MidiEvent& event);
    void apply_registered_parameter(uint8_t ch, uint16_t param, uint8_t data_msb, uint8_t data_lsb);
    void apply_configuration_message(uint8_t manager_channel, uint8_t member_count);
    void release_notes_outside_zones();
 
    void apply_manager_message(const MidiEvent& event, bool upper);
    void apply_manager_ump(const UmpPacket& p, bool upper);
 
    // Per-note helpers — MIDI 2.0 UMP per-note pitch bend / per-note CC
    // target a specific (channel, note) pair rather than going via the
    // member-channel cache, so they only update that one note.
    void apply_per_note_pitch_bend(uint8_t ch, uint8_t note, float semitones);
    void apply_per_note_timbre(uint8_t ch, uint8_t note, float timbre);
    // UMP Per-Note Management (status 0xF0): `flags` bit-0 resets per-note
    // controllers to their defaults, bit-1 detaches channel-level
    // controllers from the note (`MpeNoteState::detached`).
    void apply_per_note_management(uint8_t ch, uint8_t note, uint8_t flags);
 
    static float ump_bend_normalised(uint32_t v32);
    static std::array<float, 16> make_member_ranges() {
        std::array<float, 16> r{};
        r.fill(kDefaultMemberBendSemitones);
        return r;
    }
 
    MpeConfig config_;
    std::array<MpeNoteState, kMaxNotes> notes_{};
    std::array<float, 16> channel_pitch_bend_{};
    std::array<float, 16> channel_pressure_{};
    std::array<float, 16> channel_timbre_{};
    ZoneState lower_zone_state_{};
    ZoneState upper_zone_state_{};
    std::array<float, 16> member_bend_semi_ = make_member_ranges();
    std::array<float, 2> manager_bend_semi_{kDefaultManagerBendSemitones,
                                            kDefaultManagerBendSemitones};

    struct ParameterSelection {
        uint8_t msb = 127;
        uint8_t lsb = 127;
        bool is_rpn = true;
        uint8_t data_msb = 0;
        uint8_t data_lsb = 0;
    };
    std::array<ParameterSelection, 16> selection_{};
    bool follow_config_messages_ = true;
    MpeNoteGeneration next_note_generation_ = 1;
    std::uint64_t refused_note_on_count_ = 0;
    std::array<MpeNoteState, kMaxNotes> pending_note_offs_{};
    std::size_t pending_note_off_head_ = 0;
    std::size_t pending_note_off_count_ = 0;
    std::optional<uint8_t> assignable_timbre_index_;
};
 
} // namespace pulp::midi