midi_lane.hpp

Go to the documentation of this file.

#pragma once
 
#include <pulp/timebase/tick.hpp>
#include <pulp/timeline/item_id.hpp>
 
#include <compare>
#include <cstdint>
#include <vector>
 
// Storage shape for the continuous controller and expression streams a MIDI
// clip carries alongside its notes.
//
// Every address field below is the MIDI wire value it names, not a Pulp-local
// enumeration of controller families: `group` and `channel` are the address a
// UMP channel-voice message carries, `status` is that message's status nibble,
// and `bank`/`index` are the controller's own bank and index numbers. A plain
// continuous controller leaves `bank` zero; a registered or assignable
// controller fills it. Keeping the wire encoding means a lane is emitted
// without a translation table, and a controller family nobody anticipated
// needs new *values*, never a new C++ type.
//
// The layout is per-stream rather than one interleaved event list, because the
// question a player asks on every seek is "what did this one stream last say
// at or before t" — answerable by binary search within a single lane, but only
// a linear scan across an interleaved list.
namespace pulp::timeline {


inline constexpr std::uint8_t midi_lane_address_maximum = 15u;

struct MidiLaneAddress {
    std::uint8_t group = 0;
    std::uint8_t channel = 0;
    std::uint8_t status = 0;
    std::uint8_t bank = 0;
    std::uint8_t index = 0;
 
    constexpr auto operator<=>(const MidiLaneAddress&) const = default;
};

constexpr bool midi_lane_address_well_formed(const MidiLaneAddress& address) noexcept {
    return address.group <= midi_lane_address_maximum &&
           address.channel <= midi_lane_address_maximum &&
           address.status <= midi_lane_address_maximum;
}

struct MidiLanePoint {
    ItemId id;
    timebase::TickPosition position;
    std::uint32_t value = 0;
    bool chased = false;
 
    constexpr auto operator<=>(const MidiLanePoint&) const = default;
};

struct MidiExpressionLane {
    ItemId id;
    MidiLaneAddress address;
    std::vector<MidiLanePoint> points;
 
    auto operator<=>(const MidiExpressionLane&) const = default;
};

 
} // namespace pulp::timeline