block_ops.hpp

Go to the documentation of this file.

// block_ops.hpp — whole-buffer MIDI block clear / drop-check / copy helpers.
//
// These three operations reset a MIDI block, test whether it dropped any
// message (event / sysex / UMP) against its realtime capacity, and append one
// block's full contents into another while propagating that incompleteness.
// The host graph's reference walk and the format layer's routed executor both
// gather inbound MIDI edge-by-edge, and their bit-exactness (routed-vs-walk
// parity) depends on these semantics being identical on both sides of the
// host/format boundary — which cannot share a header from either layer. They
// live here, in core/midi, the one module both already depend on.
//
// Defined `inline` so every including TU shares one ODR-safe definition.
#pragma once
 
#include <pulp/midi/buffer.hpp>
#include <pulp/midi/ump_buffer.hpp>
#include <pulp/midi/mpe_buffer.hpp>
#include <algorithm>
#include <array>
#include <span>
 
namespace pulp::midi {
 
// Clear a MIDI block's events, sysex, and attached UMP — the full reset applied
// before gathering a node's inbound MIDI.
inline void clear_midi_block(MidiBuffer& block) noexcept {
    block.clear();
    block.clear_sysex();
    if (auto* ump = block.ump()) ump->clear();
}
 
// True if the block dropped any event / sysex / UMP message (capacity limit
// hit).
inline bool midi_block_has_drops(const MidiBuffer& block) noexcept {
    if (block.dropped_event_count() > 0 || block.dropped_sysex_count() > 0) {
        return true;
    }
    const auto* ump = block.ump();
    return ump != nullptr && ump->dropped_event_count() > 0;
}
 
// Append only SysEx and UMP sidecars after a caller has transformed the short
// messages. This keeps sidecar capacity and missing-destination behavior shared
// with whole-block copies.
inline bool copy_midi_sidecars(const MidiBuffer& src, MidiBuffer& dst) noexcept {
    bool copied_all = !midi_block_has_drops(src);
    for (const auto& sx : src.sysex()) {
        if (sx.data.empty()) {
            if (!dst.add_sysex({}, sx.sample_offset, sx.timestamp)) {
                copied_all = false;
            }
        } else if (!dst.add_sysex_copy(sx.data.data(), sx.data.size(),
                                       sx.sample_offset, sx.timestamp)) {
            copied_all = false;
        }
    }
    const auto* src_ump = src.ump();
    auto* dst_ump = dst.ump();
    if (src_ump != nullptr && dst_ump != nullptr) {
        for (const auto& ev : *src_ump) {
            if (!dst_ump->add(ev)) copied_all = false;
        }
    } else if (src_ump != nullptr && !src_ump->empty()) {
        copied_all = false;
    }
    return copied_all;
}
 
// Append every event / sysex / UMP message from `src` to `dst`. Returns false
// if `src` already carried a drop or an add() dropped here (the incompleteness
// propagated downstream). RT-safe when both buffers are reserved (add() respects
// the realtime capacity limit).
inline bool copy_midi_block(const MidiBuffer& src, MidiBuffer& dst) noexcept {
    bool copied_all = !midi_block_has_drops(src);
    for (const auto& ev : src) {
        if (!dst.add(ev)) copied_all = false;
    }
    return copy_midi_sidecars(src, dst) && copied_all;
}
 
// Append an MPE sidecar while preserving producer order. The fixed chunk keeps
// the copy bounded even when a caller supplies a large prepared buffer.
inline bool copy_mpe_block(const MpeBuffer& src, MpeBuffer& dst) noexcept {
    bool copied_all = src.dropped_event_count() == 0;
    constexpr std::size_t kChunk = 64;
    std::array<MpeExpressionEvent, kChunk> chunk{};
    std::size_t offset = 0;
    while (offset < src.size()) {
        const auto count = std::min<std::size_t>(kChunk, src.size() - offset);
        for (std::size_t i = 0; i < count; ++i)
            chunk[i] = src[offset + i];
        if (!dst.add_batch(std::span<const MpeExpressionEvent>(chunk.data(), count)))
            copied_all = false;
        offset += count;
    }
    return copied_all;
}
 
inline bool mpe_buffer_has_drops(const MpeBuffer& block) noexcept {
    return block.dropped_event_count() != 0;
}
 
}  // namespace pulp::midi