aax_midi_packets.hpp

Go to the documentation of this file.

#pragma once

 
#include <pulp/midi/buffer.hpp>
#include <pulp/midi/message.hpp>
 
#include <array>
#include <cstdint>
#include <span>
#include <vector>
 
namespace pulp::format::aax {

struct MidiPacketBytes {
    std::array<uint8_t, 4> data{};
    uint8_t length = 0;
    uint32_t timestamp = 0;
};

inline void decode_midi_packets(std::span<const MidiPacketBytes> packets,
                                midi::MidiBuffer& out) {
    std::vector<uint8_t> sysex_buffer;
    bool sysex_in_progress = false;
    int32_t sysex_start_offset = 0;
 
    for (const auto& packet : packets) {
        if (packet.length == 0) {
            continue;
        }
 
        const bool starts_sysex =
            (!sysex_in_progress && packet.data[0] == 0xF0);
        if (starts_sysex || sysex_in_progress) {
            if (starts_sysex) {
                sysex_buffer.clear();
                sysex_start_offset = static_cast<int32_t>(packet.timestamp);
                sysex_in_progress = true;
            }
            for (uint8_t b = 0; b < packet.length && b < 4; ++b) {
                const uint8_t byte = packet.data[b];
                sysex_buffer.push_back(byte);
                if (byte == 0xF7) {
                    out.add_sysex(std::move(sysex_buffer), sysex_start_offset,
                                  0.0);
                    sysex_buffer.clear();
                    sysex_in_progress = false;
                    break;
                }
            }
            continue;
        }
 
        // Short channel-voice or system-common (1..3 bytes).
        if (packet.length > 3) {
            continue;
        }
        const unsigned char data1 = packet.length > 1 ? packet.data[1] : 0;
        const unsigned char data2 = packet.length > 2 ? packet.data[2] : 0;
        out.add(midi::MidiEvent{
            .message = choc::midi::ShortMessage(packet.data[0], data1, data2),
            .sample_offset = static_cast<int32_t>(packet.timestamp),
            .timestamp = 0.0,
        });
    }
 
    out.sort();
}

inline std::vector<MidiPacketBytes> fragment_sysex(
    std::span<const uint8_t> payload, uint32_t timestamp) {
    std::vector<MidiPacketBytes> packets;
    std::size_t offset = 0;
    while (offset < payload.size()) {
        const std::size_t chunk = std::min<std::size_t>(4, payload.size() - offset);
        MidiPacketBytes packet{};
        packet.timestamp = timestamp;
        packet.length = static_cast<uint8_t>(chunk);
        for (std::size_t b = 0; b < chunk; ++b) {
            packet.data[b] = payload[offset + b];
        }
        packets.push_back(packet);
        offset += chunk;
    }
    return packets;
}
 
} // namespace pulp::format::aax