mpe_buffer.hpp

Go to the documentation of this file.

#pragma once

 
#include <pulp/midi/mpe_voice_tracker.hpp>
#include <algorithm>
#include <array>
#include <cstdint>
#include <limits>
#include <span>
#include <vector>
 
namespace pulp::midi {

struct MpeExpressionEvent {
    enum class Kind : uint8_t {
        NoteOn,
        NoteOff,
        PitchBend,
        Pressure,
        Timbre,
    };
 
    int32_t sample_offset = 0;  
    Kind kind = Kind::NoteOn;
    MpeNoteState state;         
};

class MpeBuffer {
  public:
    // Graph runtime scratch starts empty and is reserved by its off-RT prepare
    // step. Standalone adapter buffers retain the historical eager capacity.
    explicit MpeBuffer(bool reserve_storage = true) {
        if (reserve_storage)
            reserve(kInitialCapacity);
    }
 
    bool add(const MpeExpressionEvent& e) {
        if (!can_append()) {
            record_drop();
            return false;
        }
        events_.push_back(e);
        return true;
    }
    bool add(MpeExpressionEvent&& e) {
        if (!can_append()) {
            record_drop();
            return false;
        }
        events_.push_back(std::move(e));
        return true;
    }

    bool add_batch(std::span<const MpeExpressionEvent> events) {
        if (!can_append(events.size())) {
            record_drops(events.size());
            return false;
        }
        events_.insert(events_.end(), events.begin(), events.end());
        return true;
    }
 
    void clear() {
        events_.clear();
        dropped_events_ = 0;
    }
    bool empty() const { return events_.empty(); }
    std::size_t size() const { return events_.size(); }
    std::size_t capacity() const { return events_.capacity(); }
    std::uint32_t dropped_event_count() const { return dropped_events_; }
    void reserve(std::size_t capacity) {
        events_.reserve(capacity);
        sort_index_.reserve(capacity);
        sort_reorder_.reserve(capacity);
    }
    void set_realtime_capacity_limit(bool enabled = true) {
        limit_to_reserved_capacity_ = enabled;
    }
 
    void sort() {
        // Match MidiBuffer's allocation-free insertion-stable index sort.
        // Producer order at equal offsets is semantic for retriggers:
        // retirement must remain immediately before the replacement note-on.
        const std::size_t count = events_.size();
        if (count < 2) return;
        sort_index_.resize(count);
        for (std::size_t i = 0; i < count; ++i) sort_index_[i] = i;
        const auto& source = events_;
        std::sort(sort_index_.begin(), sort_index_.end(),
            [&source](std::size_t a, std::size_t b) {
                if (source[a].sample_offset != source[b].sample_offset) {
                    return source[a].sample_offset < source[b].sample_offset;
                }
                return a < b;
            });
        sort_reorder_.resize(count);
        for (std::size_t i = 0; i < count; ++i) {
            sort_reorder_[i] = std::move(events_[sort_index_[i]]);
        }
        events_.swap(sort_reorder_);
    }
 
    auto begin()       { return events_.begin(); }
    auto end()         { return events_.end(); }
    auto begin() const { return events_.begin(); }
    auto end() const   { return events_.end(); }
 
    const MpeExpressionEvent& operator[](std::size_t i) const { return events_[i]; }
 
private:
    bool can_append(std::size_t count = 1) const {
        return !limit_to_reserved_capacity_
            || count <= events_.capacity() - events_.size();
    }
    void record_drop() {
        record_drops(1);
    }
    void record_drops(std::size_t count) {
        const auto max = std::numeric_limits<std::uint32_t>::max();
        const auto available = static_cast<std::uint64_t>(max - dropped_events_);
        const auto increment = std::min<std::uint64_t>(count, available);
        dropped_events_ += static_cast<std::uint32_t>(increment);
    }
 
    static constexpr std::size_t kInitialCapacity = 128;
    std::vector<MpeExpressionEvent> events_;
    std::vector<std::size_t> sort_index_;
    std::vector<MpeExpressionEvent> sort_reorder_;
    bool limit_to_reserved_capacity_ = false;
    std::uint32_t dropped_events_ = 0;
};

inline void bind_tracker_to_buffer(MpeVoiceTracker& tracker,
                                   MpeBuffer& out,
                                   int32_t& current_sample_offset,
                                   bool* expression_event_dropped = nullptr) {
    using K = MpeExpressionEvent::Kind;
    tracker.on_note_lifecycle = [&out, &current_sample_offset,
                                 expression_event_dropped](
        const MpeNoteState* note_off, const MpeNoteState* note_on) {
        std::array<MpeExpressionEvent, 2> events{};
        std::size_t count = 0;
        if (note_off) {
            events[count++] = {current_sample_offset, K::NoteOff, *note_off};
        }
        if (note_on) {
            events[count++] = {current_sample_offset, K::NoteOn, *note_on};
        }
        const bool appended = out.add_batch(
            std::span<const MpeExpressionEvent>{events.data(), count});
        // A rejected start/retrigger would let raw MIDI advance without the
        // matching MPE lifecycle. Pure releases instead use the tracker's
        // bounded deferred-release queue and are flushed at the next block.
        if (!appended && note_on && expression_event_dropped)
            *expression_event_dropped = true;
        return appended;
    };
    tracker.on_pitch_bend = [&out, &current_sample_offset,
                             expression_event_dropped](const MpeNoteState& s) {
        if (!out.add({current_sample_offset, K::PitchBend, s}) &&
            expression_event_dropped) {
            *expression_event_dropped = true;
        }
    };
    tracker.on_pressure = [&out, &current_sample_offset,
                           expression_event_dropped](const MpeNoteState& s) {
        if (!out.add({current_sample_offset, K::Pressure, s}) &&
            expression_event_dropped) {
            *expression_event_dropped = true;
        }
    };
    tracker.on_timbre = [&out, &current_sample_offset,
                         expression_event_dropped](const MpeNoteState& s) {
        if (!out.add({current_sample_offset, K::Timbre, s}) &&
            expression_event_dropped) {
            *expression_event_dropped = true;
        }
    };
}
 
} // namespace pulp::midi