processor_node_adapter.hpp

Go to the documentation of this file.

#pragma once
 
#include <pulp/format/graph_runtime_executor.hpp>
#include <pulp/format/audio_input_provider.hpp>
#include <pulp/format/process_block.hpp>
#include <pulp/format/processor.hpp>
#include <pulp/format/processor_block_adapter.hpp>
#include <pulp/state/store.hpp>
 
#include <memory>
#include <array>
#include <span>
#include <string>
#include <vector>
 
namespace pulp::format {

class ProcessorNode {
public:
    explicit ProcessorNode(Processor& processor) noexcept
        : processor_(&processor) {}

    bool prepare(const PrepareContext& context);
    bool release() noexcept;

    void set_audio_input_provider(AudioInputBusProvider provider) noexcept {
        input_provider_ = provider;
    }

    GraphRuntimeNodeBinding binding(graph::NodeId node_id, bool required = true) noexcept;

    static bool process_binding(ProcessBlock& block,
                                const GraphRuntimeNodeProcessContext& ctx,
                                void* user_data) noexcept;
 
    Processor& processor() noexcept { return *processor_; }
    const Processor& processor() const noexcept { return *processor_; }
 
  private:
    // The routed block for a node with one main input and one main output and
    // no dense modulation: the views and context are prepared, so a block only
    // points them at this block's buffers (see process_binding).
    bool process_main_bus_block(const ProcessBlock& block,
                                const GraphRuntimeNodeProcessContext& ctx) noexcept;
 
    Processor* processor_;
    // Caller-owned MIDI/parameter fallback storage for the block bridge. Sized
    // once in prepare() and reused across blocks; never resized on the RT path.
    ProcessorBlockAdapterScratch scratch_;
    // The block's bus set, rebuilt per block by clear() and add_*(). Reusing it
    // avoids constructing all kMaxBuses entries for the one to three buses a
    // node uses.
    BusBufferSet buses_;
    // Chosen at prepare(): true when the node has at most one (main) input bus
    // and no dense modulation, so process_binding takes process_main_bus_block.
    bool main_bus_fast_path_ = false;
    // The context handed to the processor when the block carries no complete
    // transport; only sample_rate and num_samples change per block.
    ProcessContext block_context_{};
    bool block_context_from_transport_ = false;
    NodeCapabilities capabilities_{};
    AudioInputBusProvider input_provider_{};
    std::array<BusRole, BusBufferSet::kMaxBuses> input_roles_{};
    std::array<int, BusBufferSet::kMaxBuses> input_channels_{};
    std::array<bool, BusBufferSet::kMaxBuses> input_optional_{};
    // Descriptor-owned names are copied during prepare() so the routed block
    // can publish stable, non-owning string_views without allocating on RT.
    std::array<std::string, BusBufferSet::kMaxBuses> input_names_{};
    std::size_t input_bus_count_ = 0;
    bool prepared_ = false;
};

class ProcessorNodeInstance final {
  public:
    static std::shared_ptr<ProcessorNodeInstance>
    create(std::unique_ptr<Processor> processor) noexcept;
 
    ~ProcessorNodeInstance();
    ProcessorNodeInstance(const ProcessorNodeInstance&) = delete;
    ProcessorNodeInstance& operator=(const ProcessorNodeInstance&) = delete;
 
    bool prepare(const PrepareContext& context) noexcept;
    bool release() noexcept;
    void set_audio_input_provider(AudioInputBusProvider provider) noexcept {
        adapter_.set_audio_input_provider(provider);
    }
    GraphRuntimeNodeBinding binding(graph::NodeId node_id, bool required = true) noexcept {
        return adapter_.binding(node_id, required);
    }
 
    const PluginDescriptor& descriptor() const noexcept {
        return descriptor_;
    }
    int graph_type_version() const noexcept {
        return graph_type_version_;
    }
    void set_graph_type_version(int version) noexcept {
        graph_type_version_ = version;
    }
    std::string_view graph_type_id() const noexcept {
        return graph_type_id_;
    }
    void set_graph_type_id(std::string id) {
        graph_type_id_ = std::move(id);
    }
    int graph_state_schema_version() const noexcept {
        return graph_state_schema_version_;
    }
    void set_graph_state_schema_version(int version) noexcept {
        graph_state_schema_version_ = version;
    }
    std::span<const state::ParamInfo> parameter_catalog() const noexcept {
        return parameter_catalog_;
    }
    const state::ParamInfo* parameter(state::ParamID id) const noexcept;
    state::StateStore& state_store() noexcept {
        return state_store_;
    }
    const state::StateStore& state_store() const noexcept {
        return state_store_;
    }
    Processor& processor() noexcept {
        return *processor_;
    }
    const Processor& processor() const noexcept {
        return *processor_;
    }
 
  private:
    explicit ProcessorNodeInstance(std::unique_ptr<Processor> processor)
        : processor_(std::move(processor)), adapter_(*processor_) {}
 
    state::StateStore state_store_;
    // Declared after the store so Processor destruction runs first while its
    // StateStore pointer is still valid.
    std::unique_ptr<Processor> processor_;
    PluginDescriptor descriptor_;
    std::vector<state::ParamInfo> parameter_catalog_;
    int graph_type_version_ = 1;
    std::string graph_type_id_;
    int graph_state_schema_version_ = 1;
    ProcessorNode adapter_;
    bool prepared_ = false;
};
 
} // namespace pulp::format