panic.hpp

Go to the documentation of this file.

#pragma once

 
#include <pulp/midi/keyboard_state.hpp>
#include <pulp/midi/message.hpp>
 
#include <cstddef>
#include <cstdint>
#include <optional>
#include <span>
 
namespace pulp::midi {

enum class PanicMessageKind : std::uint8_t {
    all_sound_off,         
    all_notes_off,         
    reset_all_controllers, 
    sustain_off,           
    pitch_bend_centre,     
};

struct PanicScope {
    std::uint16_t channel_mask = 0xFFFFu;
    bool all_sound_off = true;
    bool all_notes_off = true;
    bool reset_all_controllers = true;
    bool sustain_off = true;
    bool pitch_bend_centre = true;

    static constexpr PanicScope release_only() {
        PanicScope scope;
        scope.all_sound_off = false;
        return scope;
    }
 
    constexpr bool includes_channel(unsigned channel) const {
        return channel < 16u && ((channel_mask >> channel) & 1u) != 0u;
    }
};

inline constexpr std::size_t kMaxPanicMessages = 16u * 5u;

inline constexpr std::size_t kMaxNoteOffs = 16u * 128u;
 
namespace panic_detail {
inline constexpr std::uint8_t kCcSustain = 64;
inline constexpr std::uint8_t kCcResetAllControllers = 121;
inline constexpr std::uint8_t kCcAllSoundOff = 120;
inline constexpr std::uint8_t kCcAllNotesOff = 123;
inline constexpr std::uint16_t kPitchBendCentre = 8192;
 
inline constexpr std::size_t kind_count(const PanicScope& scope) {
    return std::size_t{scope.all_sound_off} + std::size_t{scope.all_notes_off} +
           std::size_t{scope.reset_all_controllers} + std::size_t{scope.sustain_off} +
           std::size_t{scope.pitch_bend_centre};
}
 
inline constexpr unsigned popcount16(std::uint16_t mask) {
    unsigned n = 0;
    for (; mask != 0u; mask = static_cast<std::uint16_t>(mask & (mask - 1u)))
        ++n;
    return n;
}
} // namespace panic_detail

inline constexpr std::size_t panic_message_count(const PanicScope& scope) {
    return panic_detail::kind_count(scope) * panic_detail::popcount16(scope.channel_mask);
}

inline std::size_t panic_messages(const PanicScope& scope, std::span<MidiEvent> out,
                                  std::int32_t sample_offset = 0) noexcept {
    using namespace panic_detail;
    std::size_t n = 0;
    const auto put = [&](MidiEvent event) {
        if (n >= out.size())
            return false;
        event.sample_offset = sample_offset;
        out[n++] = event;
        return true;
    };
    for (unsigned ch = 0; ch < 16u; ++ch) {
        if (!scope.includes_channel(ch))
            continue;
        const auto channel = static_cast<std::uint8_t>(ch);
        if (scope.sustain_off && !put(MidiEvent::cc(channel, kCcSustain, 0)))
            return n;
        if (scope.all_notes_off && !put(MidiEvent::cc(channel, kCcAllNotesOff, 0)))
            return n;
        if (scope.all_sound_off && !put(MidiEvent::cc(channel, kCcAllSoundOff, 0)))
            return n;
        if (scope.reset_all_controllers && !put(MidiEvent::cc(channel, kCcResetAllControllers, 0)))
            return n;
        if (scope.pitch_bend_centre && !put(MidiEvent::pitch_bend(channel, kPitchBendCentre)))
            return n;
    }
    return n;
}

template <typename Fn>
inline void for_each_held_note(const MidiKeyboardState& keys, std::uint16_t channel_mask,
                               Fn&& fn) noexcept(noexcept(fn(std::uint8_t{}, std::uint8_t{}))) {
    for (unsigned ch = 0; ch < 16u; ++ch) {
        if (((channel_mask >> ch) & 1u) == 0u)
            continue;
        for (unsigned note = 0; note < 128u; ++note) {
            if (keys.is_note_on(static_cast<std::uint8_t>(ch), static_cast<std::uint8_t>(note)))
                fn(static_cast<std::uint8_t>(ch), static_cast<std::uint8_t>(note));
        }
    }
}

inline std::size_t held_note_offs(const MidiKeyboardState& keys, std::span<MidiEvent> out,
                                  std::uint16_t channel_mask = 0xFFFFu,
                                  std::int32_t sample_offset = 0) noexcept {
    std::size_t n = 0;
    for_each_held_note(keys, channel_mask, [&](std::uint8_t ch, std::uint8_t note) {
        if (n >= out.size())
            return;
        auto event = MidiEvent::note_off(ch, note);
        event.sample_offset = sample_offset;
        out[n++] = event;
    });
    return n;
}

inline std::size_t all_note_offs(std::span<MidiEvent> out, std::uint16_t channel_mask = 0xFFFFu,
                                 std::int32_t sample_offset = 0) noexcept {
    std::size_t n = 0;
    for (unsigned ch = 0; ch < 16u; ++ch) {
        if (((channel_mask >> ch) & 1u) == 0u)
            continue;
        for (unsigned note = 0; note < 128u; ++note) {
            if (n >= out.size())
                return n;
            auto event =
                MidiEvent::note_off(static_cast<std::uint8_t>(ch), static_cast<std::uint8_t>(note));
            event.sample_offset = sample_offset;
            out[n++] = event;
        }
    }
    return n;
}

inline std::optional<PanicMessageKind> classify_panic_message(const MidiEvent& event) noexcept {
    using namespace panic_detail;
    const auto& msg = event.message;
    if (msg.isController()) {
        if (msg.getControllerValue() != 0)
            return std::nullopt;
        switch (msg.getControllerNumber()) {
        case kCcAllSoundOff:
            return PanicMessageKind::all_sound_off;
        case kCcAllNotesOff:
            return PanicMessageKind::all_notes_off;
        case kCcResetAllControllers:
            return PanicMessageKind::reset_all_controllers;
        case kCcSustain:
            return PanicMessageKind::sustain_off;
        default:
            return std::nullopt;
        }
    }
    if (msg.isPitchWheel() && msg.getPitchWheelValue() == kPitchBendCentre)
        return PanicMessageKind::pitch_bend_centre;
    return std::nullopt;
}
 
} // namespace pulp::midi