signal_graph_execution_snapshot.hpp

Go to the documentation of this file.

#pragma once
 
#include <pulp/host/signal_graph_runtime.hpp>
 
namespace pulp::host {
 
namespace detail {
class TimelineAutomationDelivery;
}

class SnapshotParameterIngressPasskey {
    SnapshotParameterIngressPasskey() = default;
    friend class detail::TimelineAutomationDelivery;
};

class SignalGraph::ExecutionSnapshot {
  public:
    ExecutionSnapshot() = default;
    explicit operator bool() const noexcept { return snapshot_ != nullptr; }
    std::uint64_t sample_region_binding_generation() const noexcept;
    std::vector<SampleRegionRuntimeReceipt> sample_region_runtime_receipts() const;
 
    bool inject_midi(NodeId midi_input_node,
                     const midi::MidiBuffer& events) const noexcept;
    bool inject_midi(NodeId midi_input_node, const midi::MidiBuffer& events,
                     const midi::MpeBuffer& mpe) const noexcept;
    // Generic live-mailbox injection into this pinned generation. Available to
    // any host holding the snapshot handle.
    bool inject_parameter_events(
        NodeId plugin_node,
        const state::ParameterEventQueue& events) const noexcept;
    // Exact-generation injection into a node's owner-claimed exact mailbox,
    // gated by a passkey only the timeline delivery path can construct. Separate
    // from the generic live path above so a claimed node's timeline stream and
    // ordinary live injection never share one mailbox.
    bool inject_exact_parameter_events(
        NodeId plugin_node,
        const state::ParameterEventQueue& events,
        SnapshotParameterIngressPasskey) const noexcept;
    void process(audio::BufferView<float>& output,
                 const audio::BufferView<const float>& input,
                 int num_samples) const noexcept;
    void process(audio::BufferView<float>& output,
                 const audio::BufferView<const float>& input,
                 int num_samples,
                 const format::ProcessContext& transport) const noexcept;
 
  private:
    friend class PreparedTopologyEdit;
    ExecutionSnapshot(SignalGraph& owner,
                      std::shared_ptr<SignalGraph::CompiledGraph> snapshot) noexcept
        : owner_(&owner), snapshot_(std::move(snapshot)),
          processing_lease_(owner.processing_handle_lifetime_) {
        if (owner.spectral_mode_.load(std::memory_order_acquire) ||
            (snapshot_ && snapshot_->spectral)) {
            owner.spectral_error_.store(SpectralError::SpectralPinnedExecutionUnsupported,
                                        std::memory_order_relaxed);
            snapshot_.reset();
            processing_lease_.reset();
        }
    }
 
    SignalGraph* owner_ = nullptr;
    std::shared_ptr<SignalGraph::CompiledGraph> snapshot_;
    std::shared_ptr<int> processing_lease_;
};
 
} // namespace pulp::host