message.hpp

Go to the documentation of this file.

#pragma once
 
#include <cstdint>
#include <cstddef>
 
// choc_MIDI.h's Message::operator== calls `memcmp` unqualified and includes no
// string header of its own. The call is type-dependent, so ADL runs at the point
// of instantiation and finds nothing (the arguments are pointers to a
// fundamental type); the name can only be resolved by ordinary lookup at the
// point of the template's *definition*. So the declaration has to precede this
// include, not merely exist in the instantiating TU.
//
// `<string.h>` rather than `<cstring>` on purpose: CHOC needs global `::memcmp`,
// and only the C header is guaranteed to declare names in the global namespace
// ([depr.c.headers]) — `<cstring>` only guarantees `std::memcmp`. libc++ happens
// to expose the global one transitively via `<string>`, which is why this
// compiled on macOS and broke the GCC/libstdc++ Linux build.
#include <string.h>
 
#include <choc/audio/choc_MIDI.h>
 
namespace pulp::midi {

struct MidiEvent {
    choc::midi::ShortMessage message;
    int32_t sample_offset = 0; 
    double timestamp = 0.0;    

    const uint8_t* data() const { return message.data(); }
    uint32_t size() const { return message.length(); }

    static MidiEvent note_on(uint8_t channel, uint8_t note, uint8_t velocity) {
        const auto status = static_cast<uint8_t>(0x90 | (channel & 0x0F));
        const auto note_byte = static_cast<uint8_t>(note & 0x7F);
        const auto velocity_byte = static_cast<uint8_t>(velocity & 0x7F);
        return {choc::midi::ShortMessage(status, note_byte, velocity_byte), 0, 0.0};
    }

    static MidiEvent note_off(uint8_t channel, uint8_t note, uint8_t velocity = 0) {
        const auto status = static_cast<uint8_t>(0x80 | (channel & 0x0F));
        const auto note_byte = static_cast<uint8_t>(note & 0x7F);
        const auto velocity_byte = static_cast<uint8_t>(velocity & 0x7F);
        return {choc::midi::ShortMessage(status, note_byte, velocity_byte), 0, 0.0};
    }

    static MidiEvent cc(uint8_t channel, uint8_t controller, uint8_t value) {
        const auto status = static_cast<uint8_t>(0xB0 | (channel & 0x0F));
        const auto controller_byte = static_cast<uint8_t>(controller & 0x7F);
        const auto value_byte = static_cast<uint8_t>(value & 0x7F);
        return {choc::midi::ShortMessage(status, controller_byte, value_byte), 0, 0.0};
    }

    static MidiEvent pitch_bend(uint8_t channel, uint16_t value) {
        value &= 0x3FFF;
        return {choc::midi::ShortMessage(
            static_cast<uint8_t>(0xE0 | (channel & 0x0F)),
            static_cast<uint8_t>(value & 0x7F),
            static_cast<uint8_t>((value >> 7) & 0x7F)), 0, 0.0};
    }

    static MidiEvent poly_pressure(uint8_t channel, uint8_t note, uint8_t pressure) {
        const auto status = static_cast<uint8_t>(0xA0 | (channel & 0x0F));
        const auto note_byte = static_cast<uint8_t>(note & 0x7F);
        const auto pressure_byte = static_cast<uint8_t>(pressure & 0x7F);
        return {choc::midi::ShortMessage(status, note_byte, pressure_byte), 0, 0.0};
    }

    static MidiEvent program_change(uint8_t channel, uint8_t program) {
        const auto status = static_cast<uint8_t>(0xC0 | (channel & 0x0F));
        const auto program_byte = static_cast<uint8_t>(program & 0x7F);
        return {choc::midi::ShortMessage(status, program_byte, 0), 0, 0.0};
    }
 
    bool is_note_on() const  { return message.isNoteOn(); }
    bool is_note_off() const { return message.isNoteOff(); }
    bool is_cc() const       { return message.isController(); }
    bool is_pitch_bend() const { return message.isPitchWheel(); }
    bool is_program_change() const { return message.isProgramChange(); }
    bool is_poly_pressure() const {
        return message.isAftertouch();
    }

    uint8_t channel() const  { return message.getChannel0to15(); }
    uint8_t note() const     { return message.getNoteNumber().note; }
    uint8_t velocity() const { return message.getVelocity(); }
    uint8_t cc_number() const { return message.getControllerNumber(); }
    uint8_t cc_value() const  { return message.getControllerValue(); }
};
 
} // namespace pulp::midi