rill_core/traits/
processable.rs

1//! Processable trait and NodeVariant.
2
3use crate::math::Transcendental;
4use crate::queues::telemetry::TelemetryTx;
5use crate::time::ClockTick;
6use crate::traits::port::Port;
7use crate::traits::Node;
8use crate::traits::ProcessResult;
9
10// ============================================================================
11// ProcessContext
12// ============================================================================
13
14/// Processing context provided during signal graph execution.
15pub struct ProcessContext<'a> {
16    /// Current clock tick with sample-accurate timing information.
17    pub clock: &'a ClockTick,
18}
19
20// ============================================================================
21// Processable Trait
22// ============================================================================
23
24/// A node or component that can process a block of audio.
25///
26/// This is the main execution trait for the signal graph. Each node type
27/// (Source, Processor, Router, Sink) implements this via blanket impls
28/// that delegate to their respective `generate`/`process`/`route`/`consume`.
29pub trait Processable<T: Transcendental, const BUF_SIZE: usize> {
30    /// Process one block of audio samples.
31    ///
32    /// # Errors
33    /// Returns a [`ProcessError`](crate::traits::ProcessError) if processing fails.
34    fn process_block(&mut self, ctx: &mut ProcessContext) -> ProcessResult<()>;
35}
36
37// ============================================================================
38// Blanket Implementations
39// ============================================================================
40
41impl<T, const BUF_SIZE: usize> Processable<T, BUF_SIZE>
42    for Box<dyn crate::traits::Source<T, BUF_SIZE>>
43where
44    T: Transcendental,
45{
46    fn process_block(&mut self, ctx: &mut ProcessContext) -> ProcessResult<()> {
47        self.as_mut().generate(ctx.clock, &[], &[])
48    }
49}
50
51impl<T, const BUF_SIZE: usize> Processable<T, BUF_SIZE>
52    for Box<dyn crate::traits::Processor<T, BUF_SIZE>>
53where
54    T: Transcendental,
55{
56    fn process_block(&mut self, ctx: &mut ProcessContext) -> ProcessResult<()> {
57        self.as_mut().process(ctx.clock, &[], &[], &[], &[])
58    }
59}
60
61impl<T, const BUF_SIZE: usize> Processable<T, BUF_SIZE>
62    for Box<dyn crate::traits::Sink<T, BUF_SIZE>>
63where
64    T: Transcendental,
65{
66    fn process_block(&mut self, ctx: &mut ProcessContext) -> ProcessResult<()> {
67        self.as_mut().consume(ctx.clock, &[], &[], &[], &[])
68    }
69}
70
71impl<T, const BUF_SIZE: usize> Processable<T, BUF_SIZE>
72    for Box<dyn crate::traits::Router<T, BUF_SIZE>>
73where
74    T: Transcendental,
75{
76    fn process_block(&mut self, ctx: &mut ProcessContext) -> ProcessResult<()> {
77        (**self).route(ctx.clock, &[])
78    }
79}
80
81// ============================================================================
82// NodeVariant
83// ============================================================================
84
85/// A type-erased node that wraps any of the four node roles.
86///
87/// Dispatches `process_block` and `Node` methods to the inner node.
88pub enum NodeVariant<T: Transcendental, const BUF_SIZE: usize> {
89    /// Signal source node (generates audio).
90    Source(Box<dyn crate::traits::Source<T, BUF_SIZE>>),
91    /// Signal processor node (processes audio in-place).
92    Processor(Box<dyn crate::traits::Processor<T, BUF_SIZE>>),
93    /// Signal router node (routes signals between ports).
94    Router(Box<dyn crate::traits::Router<T, BUF_SIZE>>),
95    /// Signal sink node (consumes audio).
96    Sink(Box<dyn crate::traits::Sink<T, BUF_SIZE>>),
97}
98
99impl<T: Transcendental, const BUF_SIZE: usize> Processable<T, BUF_SIZE>
100    for NodeVariant<T, BUF_SIZE>
101{
102    fn process_block(&mut self, ctx: &mut ProcessContext) -> ProcessResult<()> {
103        match self {
104            NodeVariant::Source(src) => src.process_block(ctx),
105            NodeVariant::Processor(proc) => proc.process_block(ctx),
106            NodeVariant::Router(rt) => rt.process_block(ctx),
107            NodeVariant::Sink(sink) => sink.process_block(ctx),
108        }
109    }
110}
111
112impl<T: Transcendental, const BUF_SIZE: usize> NodeVariant<T, BUF_SIZE> {
113    /// Set the telemetry sender for the wrapped node.
114    pub fn set_telemetry_tx(&mut self, tx: TelemetryTx) {
115        match self {
116            NodeVariant::Source(src) => Node::set_telemetry_tx(src.as_mut(), tx),
117            NodeVariant::Processor(proc) => Node::set_telemetry_tx(proc.as_mut(), tx),
118            NodeVariant::Router(rt) => Node::set_telemetry_tx(rt.as_mut(), tx),
119            NodeVariant::Sink(sink) => Node::set_telemetry_tx(sink.as_mut(), tx),
120        }
121    }
122}
123
124// ============================================================================
125// Node for NodeVariant
126// ============================================================================
127
128impl<T: Transcendental, const BUF_SIZE: usize> Node<T, BUF_SIZE> for NodeVariant<T, BUF_SIZE> {
129    fn node_type_id(&self) -> crate::traits::NodeTypeId
130    where
131        Self: 'static + Sized,
132    {
133        unreachable!()
134    }
135    fn id(&self) -> crate::traits::NodeId {
136        match self {
137            NodeVariant::Source(src) => src.id(),
138            NodeVariant::Processor(proc) => proc.id(),
139            NodeVariant::Router(rt) => rt.id(),
140            NodeVariant::Sink(sink) => sink.id(),
141        }
142    }
143    fn set_id(&mut self, id: crate::traits::NodeId) {
144        match self {
145            NodeVariant::Source(src) => src.set_id(id),
146            NodeVariant::Processor(proc) => proc.set_id(id),
147            NodeVariant::Router(rt) => rt.set_id(id),
148            NodeVariant::Sink(sink) => sink.set_id(id),
149        }
150    }
151    fn metadata(&self) -> crate::traits::NodeMetadata {
152        match self {
153            NodeVariant::Source(src) => src.metadata(),
154            NodeVariant::Processor(proc) => proc.metadata(),
155            NodeVariant::Router(rt) => rt.metadata(),
156            NodeVariant::Sink(sink) => sink.metadata(),
157        }
158    }
159    fn init(&mut self, sample_rate: f32) {
160        match self {
161            NodeVariant::Source(src) => src.init(sample_rate),
162            NodeVariant::Processor(proc) => proc.init(sample_rate),
163            NodeVariant::Router(rt) => rt.init(sample_rate),
164            NodeVariant::Sink(sink) => sink.init(sample_rate),
165        }
166    }
167    fn resolve_resources(&mut self, buffers: &crate::buffer::BufferRegistry<T>) {
168        match self {
169            NodeVariant::Source(src) => src.resolve_resources(buffers),
170            NodeVariant::Processor(proc) => proc.resolve_resources(buffers),
171            NodeVariant::Router(rt) => rt.resolve_resources(buffers),
172            NodeVariant::Sink(sink) => sink.resolve_resources(buffers),
173        }
174    }
175    fn as_io_node_mut(&mut self) -> Option<&mut dyn crate::traits::node::IoNode<T, BUF_SIZE>> {
176        match self {
177            NodeVariant::Source(src) => src.as_io_node_mut(),
178            NodeVariant::Processor(proc) => proc.as_io_node_mut(),
179            NodeVariant::Router(rt) => rt.as_io_node_mut(),
180            NodeVariant::Sink(sink) => sink.as_io_node_mut(),
181        }
182    }
183    fn as_active_node_mut(
184        &mut self,
185    ) -> Option<&mut dyn crate::traits::node::ActiveNode<T, BUF_SIZE>> {
186        match self {
187            NodeVariant::Source(src) => src.as_active_node_mut(),
188            NodeVariant::Processor(proc) => proc.as_active_node_mut(),
189            NodeVariant::Router(rt) => rt.as_active_node_mut(),
190            NodeVariant::Sink(sink) => sink.as_active_node_mut(),
191        }
192    }
193    fn reset(&mut self) {
194        match self {
195            NodeVariant::Source(src) => src.reset(),
196            NodeVariant::Processor(proc) => proc.reset(),
197            NodeVariant::Router(rt) => rt.reset(),
198            NodeVariant::Sink(sink) => sink.reset(),
199        }
200    }
201    fn get_parameter(&self, id: &crate::traits::ParameterId) -> Option<crate::traits::ParamValue> {
202        match self {
203            NodeVariant::Source(src) => src.get_parameter(id),
204            NodeVariant::Processor(proc) => proc.get_parameter(id),
205            NodeVariant::Router(rt) => rt.get_parameter(id),
206            NodeVariant::Sink(sink) => sink.get_parameter(id),
207        }
208    }
209    fn set_parameter(
210        &mut self,
211        id: &crate::traits::ParameterId,
212        value: crate::traits::ParamValue,
213    ) -> ProcessResult<()> {
214        match self {
215            NodeVariant::Source(src) => src.set_parameter(id, value),
216            NodeVariant::Processor(proc) => proc.set_parameter(id, value),
217            NodeVariant::Router(rt) => rt.set_parameter(id, value),
218            NodeVariant::Sink(sink) => sink.set_parameter(id, value),
219        }
220    }
221    fn input_port(&self, index: usize) -> Option<&Port<T, BUF_SIZE>> {
222        match self {
223            NodeVariant::Source(src) => src.input_port(index),
224            NodeVariant::Processor(proc) => proc.input_port(index),
225            NodeVariant::Router(rt) => rt.input_port(index),
226            NodeVariant::Sink(sink) => sink.input_port(index),
227        }
228    }
229    fn input_port_mut(&mut self, index: usize) -> Option<&mut Port<T, BUF_SIZE>> {
230        match self {
231            NodeVariant::Source(src) => src.input_port_mut(index),
232            NodeVariant::Processor(proc) => proc.input_port_mut(index),
233            NodeVariant::Router(rt) => rt.input_port_mut(index),
234            NodeVariant::Sink(sink) => sink.input_port_mut(index),
235        }
236    }
237    fn output_port(&self, index: usize) -> Option<&Port<T, BUF_SIZE>> {
238        match self {
239            NodeVariant::Source(src) => src.output_port(index),
240            NodeVariant::Processor(proc) => proc.output_port(index),
241            NodeVariant::Router(rt) => rt.output_port(index),
242            NodeVariant::Sink(sink) => sink.output_port(index),
243        }
244    }
245    fn output_port_mut(&mut self, index: usize) -> Option<&mut Port<T, BUF_SIZE>> {
246        match self {
247            NodeVariant::Source(src) => src.output_port_mut(index),
248            NodeVariant::Processor(proc) => proc.output_port_mut(index),
249            NodeVariant::Router(rt) => rt.output_port_mut(index),
250            NodeVariant::Sink(sink) => sink.output_port_mut(index),
251        }
252    }
253    fn control_port(&self, index: usize) -> Option<&Port<T, BUF_SIZE>> {
254        match self {
255            NodeVariant::Source(src) => src.control_port(index),
256            NodeVariant::Processor(proc) => proc.control_port(index),
257            NodeVariant::Router(rt) => rt.control_port(index),
258            NodeVariant::Sink(sink) => sink.control_port(index),
259        }
260    }
261    fn control_port_mut(&mut self, index: usize) -> Option<&mut Port<T, BUF_SIZE>> {
262        match self {
263            NodeVariant::Source(src) => src.control_port_mut(index),
264            NodeVariant::Processor(proc) => proc.control_port_mut(index),
265            NodeVariant::Router(rt) => rt.control_port_mut(index),
266            NodeVariant::Sink(sink) => sink.control_port_mut(index),
267        }
268    }
269    fn num_signal_inputs(&self) -> usize {
270        match self {
271            NodeVariant::Source(src) => {
272                let n: &dyn Node<T, BUF_SIZE> = &**src;
273                n.num_signal_inputs()
274            }
275            NodeVariant::Processor(proc) => {
276                let n: &dyn Node<T, BUF_SIZE> = &**proc;
277                n.num_signal_inputs()
278            }
279            NodeVariant::Router(rt) => {
280                let n: &dyn Node<T, BUF_SIZE> = &**rt;
281                n.num_signal_inputs()
282            }
283            NodeVariant::Sink(sink) => {
284                let n: &dyn Node<T, BUF_SIZE> = &**sink;
285                n.num_signal_inputs()
286            }
287        }
288    }
289    fn num_signal_outputs(&self) -> usize {
290        match self {
291            NodeVariant::Source(src) => {
292                let n: &dyn Node<T, BUF_SIZE> = &**src;
293                n.num_signal_outputs()
294            }
295            NodeVariant::Processor(proc) => {
296                let n: &dyn Node<T, BUF_SIZE> = &**proc;
297                n.num_signal_outputs()
298            }
299            NodeVariant::Router(rt) => {
300                let n: &dyn Node<T, BUF_SIZE> = &**rt;
301                n.num_signal_outputs()
302            }
303            NodeVariant::Sink(sink) => {
304                let n: &dyn Node<T, BUF_SIZE> = &**sink;
305                n.num_signal_outputs()
306            }
307        }
308    }
309    fn num_control_inputs(&self) -> usize {
310        match self {
311            NodeVariant::Source(src) => {
312                let n: &dyn Node<T, BUF_SIZE> = &**src;
313                n.num_control_inputs()
314            }
315            NodeVariant::Processor(proc) => {
316                let n: &dyn Node<T, BUF_SIZE> = &**proc;
317                n.num_control_inputs()
318            }
319            NodeVariant::Router(rt) => {
320                let n: &dyn Node<T, BUF_SIZE> = &**rt;
321                n.num_control_inputs()
322            }
323            NodeVariant::Sink(sink) => {
324                let n: &dyn Node<T, BUF_SIZE> = &**sink;
325                n.num_control_inputs()
326            }
327        }
328    }
329    fn num_control_outputs(&self) -> usize {
330        match self {
331            NodeVariant::Source(src) => {
332                let n: &dyn Node<T, BUF_SIZE> = &**src;
333                n.num_control_outputs()
334            }
335            NodeVariant::Processor(proc) => {
336                let n: &dyn Node<T, BUF_SIZE> = &**proc;
337                n.num_control_outputs()
338            }
339            NodeVariant::Router(rt) => {
340                let n: &dyn Node<T, BUF_SIZE> = &**rt;
341                n.num_control_outputs()
342            }
343            NodeVariant::Sink(sink) => {
344                let n: &dyn Node<T, BUF_SIZE> = &**sink;
345                n.num_control_outputs()
346            }
347        }
348    }
349    fn num_clock_inputs(&self) -> usize {
350        match self {
351            NodeVariant::Source(src) => {
352                let n: &dyn Node<T, BUF_SIZE> = &**src;
353                n.num_clock_inputs()
354            }
355            NodeVariant::Processor(proc) => {
356                let n: &dyn Node<T, BUF_SIZE> = &**proc;
357                n.num_clock_inputs()
358            }
359            NodeVariant::Router(rt) => {
360                let n: &dyn Node<T, BUF_SIZE> = &**rt;
361                n.num_clock_inputs()
362            }
363            NodeVariant::Sink(sink) => {
364                let n: &dyn Node<T, BUF_SIZE> = &**sink;
365                n.num_clock_inputs()
366            }
367        }
368    }
369    fn num_clock_outputs(&self) -> usize {
370        match self {
371            NodeVariant::Source(src) => {
372                let n: &dyn Node<T, BUF_SIZE> = &**src;
373                n.num_clock_outputs()
374            }
375            NodeVariant::Processor(proc) => {
376                let n: &dyn Node<T, BUF_SIZE> = &**proc;
377                n.num_clock_outputs()
378            }
379            NodeVariant::Router(rt) => {
380                let n: &dyn Node<T, BUF_SIZE> = &**rt;
381                n.num_clock_outputs()
382            }
383            NodeVariant::Sink(sink) => {
384                let n: &dyn Node<T, BUF_SIZE> = &**sink;
385                n.num_clock_outputs()
386            }
387        }
388    }
389    fn num_feedback_ports(&self) -> usize {
390        match self {
391            NodeVariant::Source(src) => {
392                let n: &dyn Node<T, BUF_SIZE> = &**src;
393                n.num_feedback_ports()
394            }
395            NodeVariant::Processor(proc) => {
396                let n: &dyn Node<T, BUF_SIZE> = &**proc;
397                n.num_feedback_ports()
398            }
399            NodeVariant::Router(rt) => {
400                let n: &dyn Node<T, BUF_SIZE> = &**rt;
401                n.num_feedback_ports()
402            }
403            NodeVariant::Sink(sink) => {
404                let n: &dyn Node<T, BUF_SIZE> = &**sink;
405                n.num_feedback_ports()
406            }
407        }
408    }
409    fn state(&self) -> &crate::traits::NodeState<T, BUF_SIZE> {
410        match self {
411            NodeVariant::Source(src) => src.state(),
412            NodeVariant::Processor(proc) => proc.state(),
413            NodeVariant::Router(rt) => rt.state(),
414            NodeVariant::Sink(sink) => sink.state(),
415        }
416    }
417    fn state_mut(&mut self) -> &mut crate::traits::NodeState<T, BUF_SIZE> {
418        match self {
419            NodeVariant::Source(src) => src.state_mut(),
420            NodeVariant::Processor(proc) => proc.state_mut(),
421            NodeVariant::Router(rt) => rt.state_mut(),
422            NodeVariant::Sink(sink) => sink.state_mut(),
423        }
424    }
425}
rill_core/traits/processable.rs

rill_core/traits/
processable.rs
