Struct DspGraph 

pub struct DspGraph<T: Sample, Edge: GraphEdge> { /* private fields */ }

Directed graph structure for audio processing

Consists of processor nodes and typed edges that describe the signal flow. When constructing a DspGraph, a capacity needs to be provided to preallocate internal data structures. This ensures realtime safety when adding nodes and edges at runtime.

Two graph variants are provided by the library, differentiated by their edge types:

• BasicDspGraph: lightweight graph without rewiring support
• RewireDspGraph: graph with channel rewiring capabilities

Most users should use the type aliases rather than DspGraph directly:

Nodes and edges can be added using DspGraph::add_processor and DspGraph::connect. Connections can also be dynamically enabled, disabled or updated.

The graph owns the processing nodes as well as their corresponding output buffers. Conversely, the input and output buffers that the graph operates on must be managed outside of the graph structure. To run the audio processing graph, use the DspGraph::process method, which takes the input and output buffers as arguments.

Implementations

impl<T: Sample, Edge: GraphEdge> DspGraph<T, Edge>

pub fn new( num_channels: usize, frame_size: FrameSize, max_num_edges: Option<usize>, ) -> Self

Creates a new DspGraph with preallocated capacity for internal data structures

• num_channels: Maximum number of channels a node will process. Needs to be known upfront for summing operations.
• frame_size: Maximum number of frames for block-wise processing.
• max_num_edges: Graph capacity used for preallocation. This value also bounds the maximum number of nodes that can be added. If None, defaults to 64.

pub fn add_processor<P: Processor<T> + Send + 'static>( &mut self, processor: P, output_buffer: MultiChannelBuffer<T>, ) -> Result<NodeIndex, AudioGraphError>

Adds a processor node to the graph along with its associated output buffer

Returns the NodeIndex of the newly added processor node (or an error if something went wrong). The node index can be used to reference the node when adding an edge to it using DspGraph::connect.

pub fn connect( &mut self, from: GraphNode, to: GraphNode, channel_selection: Option<ChannelSelection>, ) -> Result<EdgeIndex, AudioGraphError>

Connects two nodes in the graph with an edge

The direction of the edge is so that the to node will access the output buffer of the from node as its input buffer during processing. These nodes can be either processor nodes added via DspGraph::add_processor, or the input or output nodes of the entire graph (see GraphNode).

Optionally, a ChannelSelection can be provided to specify which channels of the from node’s output buffer should be processed by the to node. If no selection is provided, all channels are connected by default.

Returns the EdgeIndex of the newly created edge (or an error if something went wrong). The edge index can be used to reference the edge for further operations such as enabling/disabling the connection.

pub fn remove_connection( &mut self, edge: EdgeIndex, ) -> Result<(), AudioGraphError>

Removes an existing connection from the graph

NOT realtime safe for the RewireDspGraph variant

Alternative: Use DspGraph::disable_connection to temporarily disable a connection.

pub fn enable_connection( &mut self, edge: EdgeIndex, ) -> Result<(), AudioGraphError>

Enables an existing connection in the graph

pub fn disable_connection( &mut self, edge: EdgeIndex, ) -> Result<(), AudioGraphError>

Disables an existing connection in the graph

pub fn process( &mut self, input: &dyn AudioBuffer<T>, output: &mut dyn AudioBuffer<T>, num_frames: FrameSize, )

Processes audio data through the graph

impl<T: Sample> DspGraph<T, RewireProcessorChannel>

pub fn rewire( &mut self, edge_index: EdgeIndex, rewire_mapping: &[(usize, usize)], ) -> Result<(), AudioGraphError>

Rewires an existing connection in the graph to use a different channel mapping between the edge’s source and destination nodes.

NOT realtime safe

The rewire_mapping parameter is a slice of tuples where each tuple defines a channel mapping in the form (source_channel, destination_channel).

Note: Mapping multiple source channels to the same destination channel returns an error.

Example

use audiograph::{FrameSize, GraphNode, MultiChannelBuffer, NoOp, RewireDspGraph};

let frame_size = FrameSize(1024);

let mut dsp_graph = RewireDspGraph::<f32>::new(4, frame_size, None);

let node1 = dsp_graph
    .add_processor(
        NoOp {},
        MultiChannelBuffer::new(4, frame_size), // 4 output channels
    )
    .unwrap();

let node2 = dsp_graph
    .add_processor(
        NoOp {},
        MultiChannelBuffer::new(4, frame_size), // 4 output channels
    )
    .unwrap();

// Connect nodes with default channel selection (i.e., all channels in order)
dsp_graph
    .connect(GraphNode::Input, node1.into(), None)
    .unwrap();

let edge = dsp_graph.connect(node1.into(), node2.into(), None).unwrap();

dsp_graph
    .connect(node2.into(), GraphNode::Output, None)
    .unwrap();

// Rewire the edge to swap channels 0 and 1, while keeping channels 2 and 3 the same
dsp_graph
    .rewire(edge, &[(0, 1), (1, 0), (2, 2), (3, 3)])
    .unwrap();

pub fn remove_rewire( &mut self, edge_index: EdgeIndex, ) -> Result<(), AudioGraphError>

Removes rewiring from an existing connection, reverting to the default channel selection (i.e. all channels connected)

NOT realtime-safe

pub fn connect_rewired( &mut self, from: GraphNode, to: GraphNode, wiring: &[(usize, usize)], ) -> Result<EdgeIndex, AudioGraphError>

Connects two nodes and creates a rewired mapping in one step

NOT realtime-safe

See RewireDspGraph::connect and RewireDspGraph::rewire for details.