types.hpp

Go to the documentation of this file.

// sbl/protocol/midi/types.hpp — MIDI message types
//
// Core types for MIDI protocol handling. All values follow the MIDI 1.0 spec.
 
#ifndef SBL_PROTOCOL_MIDI_TYPES_HPP_
#define SBL_PROTOCOL_MIDI_TYPES_HPP_
 
#include <cstdint>
 
namespace sbl::midi {
 
enum class MessageType : uint8_t {
    NoteOff         = 0x80,
    NoteOn          = 0x90,
    PolyPressure    = 0xA0,
    ControlChange   = 0xB0,
    ProgramChange   = 0xC0,
    ChannelPressure = 0xD0,
    PitchBend       = 0xE0,
 
    // System Real-Time (no channel, no data bytes)
    Clock           = 0xF8,
    Start           = 0xFA,
    Continue        = 0xFB,
    Stop            = 0xFC,
    ActiveSensing   = 0xFE,
    SystemReset     = 0xFF,
 
    // System Common
    SysEx           = 0xF0,
    SysExEnd        = 0xF7,
    TimeCode        = 0xF1,
    SongPosition    = 0xF2,
    SongSelect      = 0xF3,
    TuneRequest     = 0xF6,
 
    None            = 0x00,
};
 
struct MidiEvent {
    MessageType type = MessageType::None;
    uint8_t channel = 0;     ///< 0-15 for channel messages, 0 for system
    uint8_t data1 = 0;       ///< Note number, CC number, program, etc.
    uint8_t data2 = 0;       ///< Velocity, CC value, etc.
 
    /** @brief Note number (alias for data1) */
    uint8_t note() const { return data1; }
 
    /** @brief Velocity (alias for data2) */
    uint8_t velocity() const { return data2; }
 
    /** @brief CC number (alias for data1) */
    uint8_t cc_number() const { return data1; }
 
    /** @brief CC value (alias for data2) */
    uint8_t cc_value() const { return data2; }
 
    /**
     * @brief 14-bit pitch bend value, centered at 8192
     *
     * Range: 0 (max down) to 16383 (max up), 8192 = center.
     */
    int16_t pitch_bend_value() const {
        return static_cast<int16_t>((static_cast<uint16_t>(data2) << 7) | data1) - 8192;
    }
 
    /** @brief Raw 14-bit pitch bend (0-16383) */
    uint16_t pitch_bend_raw() const {
        return (static_cast<uint16_t>(data2) << 7) | data1;
    }
 
    /**
     * @brief Encode this event as raw MIDI bytes
     * @param out Buffer for MIDI bytes (must be at least 3 bytes)
     * @return Number of bytes written (0 if unsupported message type)
     */
    uint8_t to_bytes(uint8_t* out) const {
        switch (type) {
        // 3-byte channel messages
        case MessageType::NoteOn:
            out[0] = 0x90 | (channel & 0x0F);
            out[1] = data1 & 0x7F;
            out[2] = data2 & 0x7F;
            return 3;
        case MessageType::NoteOff:
            out[0] = 0x80 | (channel & 0x0F);
            out[1] = data1 & 0x7F;
            out[2] = data2 & 0x7F;
            return 3;
        case MessageType::ControlChange:
            out[0] = 0xB0 | (channel & 0x0F);
            out[1] = data1 & 0x7F;
            out[2] = data2 & 0x7F;
            return 3;
        case MessageType::PitchBend:
            out[0] = 0xE0 | (channel & 0x0F);
            out[1] = data1 & 0x7F;  // LSB
            out[2] = data2 & 0x7F;  // MSB
            return 3;
        case MessageType::PolyPressure:
            out[0] = 0xA0 | (channel & 0x0F);
            out[1] = data1 & 0x7F;
            out[2] = data2 & 0x7F;
            return 3;
 
        // 2-byte channel messages
        case MessageType::ProgramChange:
            out[0] = 0xC0 | (channel & 0x0F);
            out[1] = data1 & 0x7F;
            return 2;
        case MessageType::ChannelPressure:
            out[0] = 0xD0 | (channel & 0x0F);
            out[1] = data1 & 0x7F;
            return 2;
 
        // System Real-Time (1 byte, no data)
        case MessageType::Clock:         out[0] = 0xF8; return 1;
        case MessageType::Start:         out[0] = 0xFA; return 1;
        case MessageType::Continue:      out[0] = 0xFB; return 1;
        case MessageType::Stop:          out[0] = 0xFC; return 1;
        case MessageType::ActiveSensing: out[0] = 0xFE; return 1;
        case MessageType::SystemReset:   out[0] = 0xFF; return 1;
 
        // System Common
        case MessageType::SongPosition:
            out[0] = 0xF2;
            out[1] = data1 & 0x7F;
            out[2] = data2 & 0x7F;
            return 3;
        case MessageType::SongSelect:
            out[0] = 0xF3;
            out[1] = data1 & 0x7F;
            return 2;
        case MessageType::TuneRequest:
            out[0] = 0xF6;
            return 1;
 
        default:
            return 0;  // Unsupported (SysEx, None, etc.)
        }
    }
};
 
/// Callback type for parsed MIDI events
using MidiCallback = void(*)(const MidiEvent& event);
 
/// Number of data bytes expected for a channel message status byte
inline uint8_t expected_data_bytes(uint8_t status) {
    switch (status & 0xF0) {
        case 0xC0: return 1;  // Program Change
        case 0xD0: return 1;  // Channel Pressure
        default:   return 2;  // Note On/Off, CC, Poly AT, Pitch Bend
    }
}
 
} // namespace sbl::midi
 
#endif // SBL_PROTOCOL_MIDI_TYPES_HPP_