SushiDSP::RigGraph

static constexpr std::size_t kParameterRingCapacity = 1024

Maximum parameter changes that may be pending between two process() calls.

static constexpr std::size_t kMaxFanInOut = 8

Maximum outgoing edges from, or incoming edges into, any single node.

Bounds the fixed-size input-gather array RigGraph::process() uses per node.

static constexpr std::uint32_t kMaxChannels = 2

Maximum channels a node may declare on either side of its PortLayout.

Bounds every fixed-size per-channel array RigGraph::process() uses.

static bool channels_adapt(std::uint32_t from_channels, std::uint32_t to_channels)

Reports whether the adaptation table covers a producer/consumer channel pair.

The table is 1 into 2 (copied), 2 into 1 (summed and halved), and n into n.

RigGraph(std::uint32_t block_size, std::uint32_t max_live_buffers)

Constructs an empty rig graph.

NodeHandle add_node(std::unique_ptr< IAudioNode > node)

Adds a node to the graph, unconnected.

Not real-time safe; call only off the processing thread.

void connect(NodeHandle from, NodeHandle to)

Connects one node's output to another's input.

Not real-time safe.

void compile(const PrepareInfo &info)

Topologically sorts the graph and calls prepare() on every node.

Not real-time safe; call after every add_node/connect.

void remove_node(NodeHandle handle)

Removes a node and every edge touching it.

Not real-time safe; call only off the processing thread. The handle becomes invalid; other handles are unaffected.

void disconnect(NodeHandle from, NodeHandle to)

Removes a single edge, if present.

Not real-time safe.

IAudioNode * node(NodeHandle handle) const

Looks up a live node by handle.

std::vector< NodeHandle > nodes() const

Lists every live (non-removed) node handle, in add_node() order.

bool is_empty() const noexcept

Reports whether compile() produced an empty schedule, i.e.

the graph holds no live node and process() would write nothing. Real-time safe: reads one vector's size and allocates nothing.

std::vector< NodeHandle > upstream_of(NodeHandle handle) const

Lists the handles of every node with an edge into handle, in connect() call order.

Not real-time safe; call only off the processing thread.

bool push_parameter_change(const ParameterChange &change)

Queues a parameter write for the next process() call.

Control thread only; lock-free and allocation-free.

void process(ProcessContext &context)

Processes one block through every node in topological order.

Real-time safe.

std::uint32_t latency_samples() const

Longest path through the compiled graph, in base-rate samples: a node's latency plus the largest latency among its upstream paths, taken at the sink.

Allocation-free; call after compile(), which caches the value.

std::uint32_t live_buffer_count() const

Reports the single-channel buffers the compiled graph needs live at once: one per node output channel, plus the reserve the edge adaptation borrows while gathering one node's inputs.

compile() sizes buffer_pool_ from it; a host may read it to size its own pool. Valid only after a successful compile().