Trait Processor 

pub trait Processor<T, const BUF_SIZE: usize>: Node<T, BUF_SIZE>
where
    T: Transcendental,
{
    // Required method
    fn process(
        &mut self,
        clock: &ClockTick,
        signal_inputs: &[&[T; BUF_SIZE]],
        control_inputs: &[T],
        clock_inputs: &[ClockTick],
        feedback_inputs: &[&[T; BUF_SIZE]],
    ) -> Result<(), ProcessError>;

    // Provided method
    fn latency(&self) -> usize { ... }
}

Passive processor of signals

Processors transform input signals into output signals. They have signal inputs and outputs, and may have control and clock ports.

Required Methods

fn process( &mut self, clock: &ClockTick, signal_inputs: &[&[T; BUF_SIZE]], control_inputs: &[T], clock_inputs: &[ClockTick], feedback_inputs: &[&[T; BUF_SIZE]], ) -> Result<(), ProcessError>

Process a block of signal

Arguments

• clock - Current clock tick
• signal_inputs - Signal input buffers (one per signal input)
• control_inputs - Control signal values (one per control input)
• clock_inputs - Clock signal values (one per clock input)
• feedback_inputs - Feedback values from previous blocks (one per feedback port)

The processor writes output samples into its own output port buffers, accessible via self.output_port_mut(index).

Provided Methods

fn latency(&self) -> usize

Latency in samples (for delay compensation)

Trait Implementations

impl<T, const BUF_SIZE: usize> Processable<T, BUF_SIZE> for Box<dyn Processor<T, BUF_SIZE>>

where T: Transcendental,

fn process_block( &mut self, ctx: &mut ProcessContext<'_>, ) -> Result<(), ProcessError>

Process one block of signal samples.

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors