panic.hpp

Go to the documentation of this file.

#pragma once

 
#include <pulp/midi/buffer.hpp>
#include <pulp/midi/keyboard_state.hpp>
#include <pulp/midi/panic.hpp>
 
#include <array>
#include <atomic>
#include <cstddef>
#include <cstdint>
 
namespace pulp::format {

enum class PanicMode : std::uint8_t {
    immediate = 2,
    release = 1,
};

struct PanicCapabilities {
    bool serviced = false;
    bool midi_out = false;
};

struct PanicOutcome {
    bool serviced = false;
    PanicMode mode = PanicMode::immediate;
    std::size_t events_emitted = 0;
    std::size_t events_deferred = 0;
    bool complete = true;
    bool carried = false;
};

class PanicState {
  public:
    void request(PanicMode mode) noexcept {
        const auto wanted = static_cast<std::uint8_t>(mode);
        auto current = pending_.load(std::memory_order_relaxed);
        while (current < wanted &&
               !pending_.compare_exchange_weak(current, wanted, std::memory_order_acq_rel,
                                               std::memory_order_relaxed)) {
        }
    }

    bool take(PanicMode& mode) noexcept {
        const auto taken = pending_.exchange(0, std::memory_order_acq_rel);
        if (taken == 0)
            return false;
        mode = static_cast<PanicMode>(taken);
        return true;
    }

    bool carrying() const noexcept {
        return carry_.load(std::memory_order_acquire) != 0;
    }

    std::uint64_t deferred_events() const noexcept {
        return deferred_total_.load(std::memory_order_relaxed);
    }
 
    bool pending() const noexcept {
        return pending_.load(std::memory_order_acquire) != 0;
    }

    void attach(bool midi_out) noexcept {
        midi_out_.store(midi_out, std::memory_order_relaxed);
        attached_.store(true, std::memory_order_release);
    }
    void detach() noexcept {
        attached_.store(false, std::memory_order_release);
    }
 
    PanicCapabilities capabilities() const noexcept {
        const bool attached = attached_.load(std::memory_order_acquire);
        return {attached, attached && midi_out_.load(std::memory_order_relaxed)};
    }

    void observe_midi_out(const midi::MidiBuffer& midi_out) noexcept {
        if (!midi_out_.load(std::memory_order_relaxed))
            return;
        for (const auto& event : midi_out)
            emitted_.process(event);
    }

    const midi::MidiKeyboardState& emitted_notes() const noexcept {
        return emitted_;
    }

    PanicOutcome emit_midi(PanicMode mode, midi::MidiBuffer& out,
                           std::int32_t sample_offset = 0) noexcept {
        PanicOutcome outcome;
        outcome.serviced = true;
        outcome.mode = mode;
        bool full = false;
        const auto put = [&](const midi::MidiEvent& event) {
            if (!full && out.add(event)) {
                ++outcome.events_emitted;
                return true;
            }
            full = true;
            ++outcome.events_deferred;
            return false;
        };
        midi::for_each_held_note(emitted_, 0xFFFFu, [&](std::uint8_t ch, std::uint8_t note) {
            auto event = midi::MidiEvent::note_off(ch, note);
            event.sample_offset = sample_offset;
            if (put(event))
                emitted_.process(event); // ended: no longer held downstream
        });
        const auto scope =
            mode == PanicMode::immediate ? midi::PanicScope{} : midi::PanicScope::release_only();
        std::array<midi::MidiEvent, midi::kMaxPanicMessages> messages;
        const auto count = midi::panic_messages(scope, messages, sample_offset);
        std::size_t next = message_cursor_;
        for (; next < count; ++next) {
            if (!put(messages[next]))
                break;
        }
        // Everything after the first refused message is deferred too.
        outcome.events_deferred += next < count ? count - next - 1 : 0;
        message_cursor_ = static_cast<std::uint16_t>(next < count ? next : 0);
        outcome.complete = !full;
        if (full) {
            const auto wanted = static_cast<std::uint8_t>(mode);
            if (carry_.load(std::memory_order_relaxed) < wanted)
                carry_.store(wanted, std::memory_order_release);
            deferred_total_.fetch_add(outcome.events_deferred, std::memory_order_relaxed);
        } else {
            carry_.store(0, std::memory_order_release);
            emitted_.reset();
        }
        return outcome;
    }

    bool take_carry(PanicMode& mode) noexcept {
        const auto carried = carry_.load(std::memory_order_acquire);
        if (carried == 0)
            return false;
        mode = static_cast<PanicMode>(carried);
        return true;
    }

    void restart_messages() noexcept {
        message_cursor_ = 0;
    }
 
  private:
    std::atomic<std::uint8_t> pending_{0};
    std::atomic<std::uint8_t> carry_{0};
    std::atomic<std::uint64_t> deferred_total_{0};
    std::uint16_t message_cursor_ = 0; // audio thread only
    std::atomic<bool> attached_{false};
    std::atomic<bool> midi_out_{false};
    midi::MidiKeyboardState emitted_;
};

template <typename Proc>
inline PanicOutcome service_panic(Proc& processor, PanicState& state, midi::MidiBuffer& midi_out,
                                  std::int32_t sample_offset = 0) noexcept {
    PanicMode mode = PanicMode::immediate;
    const bool fresh = state.take(mode);
    bool carried = false;
    if (!fresh) {
        if (!state.take_carry(mode))
            return {};
        carried = true;
    } else {
        state.restart_messages();
        // A new request while an earlier panic is still being sent keeps the
        // harder of the two.
        PanicMode carried_mode = PanicMode::release;
        if (state.take_carry(carried_mode) &&
            static_cast<std::uint8_t>(carried_mode) > static_cast<std::uint8_t>(mode))
            mode = carried_mode;
        processor.on_panic(mode);
    }
    if (!state.capabilities().midi_out) {
        PanicOutcome outcome;
        outcome.serviced = true;
        outcome.mode = mode;
        return outcome;
    }
    auto outcome = state.emit_midi(mode, midi_out, sample_offset);
    outcome.carried = carried;
    return outcome;
}
 
} // namespace pulp::format