Struct An

pub struct An<X: AudioNode>(pub X);

AudioNode wrapper that implements operators and traits.

Tuple Fields

0: X

Implementations

impl<X: AudioNode> An<X>

pub fn reset(&mut self)

pub fn set_sample_rate(&mut self, sample_rate: f64)

pub fn tick(&mut self, input: &Frame<f32, X::Inputs>) -> Frame<f32, X::Outputs>

pub fn process( &mut self, size: usize, input: &BufferRef<'_>, output: &mut BufferMut<'_>, )

pub fn route(&mut self, input: &SignalFrame, frequency: f64) -> SignalFrame

pub fn inputs(&self) -> usize

pub fn outputs(&self) -> usize

pub fn set_hash(&mut self, hash: u64)

pub fn ping(&mut self, probe: bool, hash: AttoHash) -> AttoHash

pub fn get_mono(&mut self) -> f32

pub fn get_stereo(&mut self) -> (f32, f32)

pub fn filter_mono(&mut self, x: f32) -> f32

pub fn filter_stereo(&mut self, x: f32, y: f32) -> (f32, f32)

Trait Implementations

impl<X> Add<An<X>> for Net

where X: AudioNode + Send + Sync + 'static,

type Output = Net

The resulting type after applying the + operator.

fn add(self, y: An<X>) -> Self::Output

Performs the + operation.

impl<X> Add<An<X>> for f32

where X: AudioNode, X::Inputs: Size<f32>, X::Outputs: Size<f32>,

type Output = An<Unop<X, FrameAddScalar<<X as AudioNode>::Outputs>>>

The resulting type after applying the + operator.

fn add(self, y: An<X>) -> Self::Output

Performs the + operation.

impl<X, Y> Add<An<Y>> for An<X>

where X: AudioNode, Y: AudioNode<Outputs = X::Outputs>, X::Inputs: Add<Y::Inputs>, <X::Inputs as Add<Y::Inputs>>::Output: Size<f32>,

type Output = An<Binop<FrameAdd<<X as AudioNode>::Outputs>, X, Y>>

The resulting type after applying the + operator.

fn add(self, y: An<Y>) -> Self::Output

Performs the + operation.

impl<X> Add<Net> for An<X>

where X: AudioNode + Send + Sync + 'static,

type Output = Net

The resulting type after applying the + operator.

fn add(self, y: Net) -> Self::Output

Performs the + operation.

impl<X> Add<f32> for An<X>

where X: AudioNode, X::Inputs: Size<f32>, X::Outputs: Size<f32>,

type Output = An<Unop<X, FrameAddScalar<<X as AudioNode>::Outputs>>>

The resulting type after applying the + operator.

fn add(self, y: f32) -> Self::Output

Performs the + operation.

impl<X: AudioNode + Sync + Send> AudioUnit for An<X>

where X::Inputs: Size<f32>, X::Outputs: Size<f32>,

fn reset(&mut self)

Reset the input state of the unit to an initial state where it has not processed any data. In other words, reset time to zero.

fn set_sample_rate(&mut self, sample_rate: f64)

Set the sample rate of the unit. The default sample rate is 44100 Hz. The unit is allowed to reset itself here in response to sample rate changes. If the sample rate stays unchanged, then the goal is to maintain current state.

fn tick(&mut self, input: &[f32], output: &mut [f32])

Process one sample. The length of input and output must be equal to inputs and outputs, respectively.

fn process( &mut self, size: usize, input: &BufferRef<'_>, output: &mut BufferMut<'_>, )

Process up to 64 (MAX_BUFFER_SIZE) samples. If size is zero then this is a no-op, which is permitted.

fn set(&mut self, setting: Setting)

Set a parameter. What formats are recognized depends on the component.

fn inputs(&self) -> usize

Number of inputs to this unit. Equals size of the input argument in tick and process. This should be fixed after construction.

fn outputs(&self) -> usize

Number of outputs from this unit. Equals size of the output argument in tick and process. This should be fixed after construction.

fn route(&mut self, input: &SignalFrame, frequency: f64) -> SignalFrame

Route constants, latencies and frequency responses at frequency Hz from inputs to outputs. Return output signal.

fn get_id(&self) -> u64

Return an ID code for this type of unit.

fn set_hash(&mut self, hash: u64)

Set unit pseudorandom phase hash. Override this to use the hash. This is called from ping (only). It should not be called by users.

fn ping(&mut self, probe: bool, hash: AttoHash) -> AttoHash

Ping contained AudioUnits and AudioNodes to obtain a deterministic pseudorandom hash. The local hash includes children, too. Leaf nodes should not need to override this. If probe is true, then this is a probe for computing the network hash and set_hash should not be called yet. To set a custom hash for a graph, call this method with ping set to false and hash initialized with the custom hash.

fn footprint(&self) -> usize

Memory footprint of this unit in bytes, without counting buffers and other allocations.

fn allocate(&mut self)

Preallocate all needed memory, including buffers for block processing.

fn get_mono(&mut self) -> f32

Retrieve the next mono sample from a generator. The node must have no inputs and 1 or 2 outputs. If there are two outputs, average them.

fn get_stereo(&mut self) -> (f32, f32)

Retrieve the next stereo sample (left, right) from a generator. The node must have no inputs and 1 or 2 outputs. If there is just one output, duplicate it.

fn filter_mono(&mut self, x: f32) -> f32

Filter the next mono sample x. The node must have exactly 1 input and 1 output.

fn filter_stereo(&mut self, x: f32, y: f32) -> (f32, f32)

Filter the next stereo sample (x, y). The node must have exactly 2 inputs and 2 outputs.

fn response(&mut self, output: usize, frequency: f64) -> Option<Complex64>

Evaluate frequency response of output at frequency Hz. Any linear response can be composed. Return None if there is no response or it could not be calculated.

fn response_db(&mut self, output: usize, frequency: f64) -> Option<f64>

Evaluate frequency response of output in dB at frequency Hz. Any linear response can be composed. Return None if there is no response or it could not be calculated.

fn latency(&mut self) -> Option<f64>

Causal latency in (fractional) samples. After a reset, we can discard this many samples from the output to avoid incurring a pre-delay. The latency may depend on the sample rate.

fn display(&mut self) -> String

Print information about this unit into a string.

impl<X> BitAnd<An<X>> for Net

where X: AudioNode + Send + Sync + 'static,

type Output = Net

The resulting type after applying the & operator.

fn bitand(self, y: An<X>) -> Self::Output

Performs the & operation.

impl<X, Y> BitAnd<An<Y>> for An<X>

where X: AudioNode, Y: AudioNode<Inputs = X::Inputs, Outputs = X::Outputs>,

type Output = An<Bus<X, Y>>

The resulting type after applying the & operator.

fn bitand(self, y: An<Y>) -> Self::Output

Performs the & operation.

impl<X> BitAnd<Net> for An<X>

where X: AudioNode + Send + Sync + 'static,

type Output = Net

The resulting type after applying the & operator.

fn bitand(self, y: Net) -> Self::Output

Performs the & operation.

impl<X> BitOr<An<X>> for Net

where X: AudioNode + Send + Sync + 'static,

type Output = Net

The resulting type after applying the | operator.

fn bitor(self, y: An<X>) -> Self::Output

Performs the | operation.

impl<X, Y> BitOr<An<Y>> for An<X>

where X: AudioNode, Y: AudioNode, X::Inputs: Add<Y::Inputs>, X::Outputs: Add<Y::Outputs>, <X::Inputs as Add<Y::Inputs>>::Output: Size<f32>, <X::Outputs as Add<Y::Outputs>>::Output: Size<f32>,

type Output = An<Stack<X, Y>>

The resulting type after applying the | operator.

fn bitor(self, y: An<Y>) -> Self::Output

Performs the | operation.

impl<X> BitOr<Net> for An<X>

where X: AudioNode + Send + Sync + 'static,

type Output = Net

The resulting type after applying the | operator.

fn bitor(self, y: Net) -> Self::Output

Performs the | operation.

impl<X> BitXor<An<X>> for Net

where X: AudioNode + Send + Sync + 'static,

type Output = Net

The resulting type after applying the ^ operator.

fn bitxor(self, y: An<X>) -> Self::Output

Performs the ^ operation.

impl<X, Y> BitXor<An<Y>> for An<X>

where X: AudioNode, Y: AudioNode<Inputs = X::Inputs>, X::Outputs: Add<Y::Outputs>, <X::Outputs as Add<Y::Outputs>>::Output: Size<f32>,

type Output = An<Branch<X, Y>>

The resulting type after applying the ^ operator.

fn bitxor(self, y: An<Y>) -> Self::Output

Performs the ^ operation.

impl<X> BitXor<Net> for An<X>

where X: AudioNode + Send + Sync + 'static,

type Output = Net

The resulting type after applying the ^ operator.

fn bitxor(self, y: Net) -> Self::Output

Performs the ^ operation.

impl<X: Clone + AudioNode> Clone for An<X>

fn clone(&self) -> An<X>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<X: AudioNode> Deref for An<X>

type Target = X

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<X: AudioNode> DerefMut for An<X>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<X> Mul<An<X>> for Net

where X: AudioNode + Send + Sync + 'static,

type Output = Net

The resulting type after applying the * operator.

fn mul(self, y: An<X>) -> Self::Output

Performs the * operation.

impl<X> Mul<An<X>> for f32

where X: AudioNode, X::Inputs: Size<f32>, X::Outputs: Size<f32>,

type Output = An<Unop<X, FrameMulScalar<<X as AudioNode>::Outputs>>>

The resulting type after applying the * operator.

fn mul(self, y: An<X>) -> Self::Output

Performs the * operation.

impl<X, Y> Mul<An<Y>> for An<X>

where X: AudioNode, Y: AudioNode<Outputs = X::Outputs>, X::Inputs: Add<Y::Inputs>, <X::Inputs as Add<Y::Inputs>>::Output: Size<f32>,

type Output = An<Binop<FrameMul<<X as AudioNode>::Outputs>, X, Y>>

The resulting type after applying the * operator.

fn mul(self, y: An<Y>) -> Self::Output

Performs the * operation.

impl<X> Mul<Net> for An<X>

where X: AudioNode + Send + Sync + 'static,

type Output = Net

The resulting type after applying the * operator.

fn mul(self, y: Net) -> Self::Output

Performs the * operation.

impl<X> Mul<f32> for An<X>

where X: AudioNode, X::Inputs: Size<f32>, X::Outputs: Size<f32>,

type Output = An<Unop<X, FrameMulScalar<<X as AudioNode>::Outputs>>>

The resulting type after applying the * operator.

fn mul(self, y: f32) -> Self::Output

Performs the * operation.

impl<X> Neg for An<X>

where X: AudioNode, X::Outputs: Size<f32>,

type Output = An<Unop<X, FrameNeg<<X as AudioNode>::Outputs>>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<X> Not for An<X>

where X: AudioNode,

The thru operator makes output arity match input arity and passes through missing outputs.

type Output = An<Thru<X>>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<X> Shr<An<X>> for Net

where X: AudioNode + Send + Sync + 'static,

type Output = Net

The resulting type after applying the >> operator.

fn shr(self, y: An<X>) -> Self::Output

Performs the >> operation.

impl<X, Y> Shr<An<Y>> for An<X>

where X: AudioNode, Y: AudioNode<Inputs = X::Outputs>,

type Output = An<Pipe<X, Y>>

The resulting type after applying the >> operator.

fn shr(self, y: An<Y>) -> Self::Output

Performs the >> operation.

impl<X> Shr<Net> for An<X>

where X: AudioNode + Send + Sync + 'static,

type Output = Net

The resulting type after applying the >> operator.

fn shr(self, y: Net) -> Self::Output

Performs the >> operation.

impl<X> Sub<An<X>> for Net

where X: AudioNode + Send + Sync + 'static,

type Output = Net

The resulting type after applying the - operator.

fn sub(self, y: An<X>) -> Self::Output

Performs the - operation.

impl<X> Sub<An<X>> for f32

where X: AudioNode, X::Inputs: Size<f32>, X::Outputs: Size<f32>,

type Output = An<Unop<X, FrameNegAddScalar<<X as AudioNode>::Outputs>>>

The resulting type after applying the - operator.

fn sub(self, y: An<X>) -> Self::Output

Performs the - operation.

impl<X, Y> Sub<An<Y>> for An<X>

where X: AudioNode, Y: AudioNode<Outputs = X::Outputs>, X::Outputs: Size<f32>, X::Inputs: Size<f32> + Add<Y::Inputs>, Y::Inputs: Size<f32>, <X::Inputs as Add<Y::Inputs>>::Output: Size<f32>,

type Output = An<Binop<FrameSub<<X as AudioNode>::Outputs>, X, Y>>

The resulting type after applying the - operator.

fn sub(self, y: An<Y>) -> Self::Output

Performs the - operation.

impl<X> Sub<Net> for An<X>

where X: AudioNode + Send + Sync + 'static,

type Output = Net

The resulting type after applying the - operator.

fn sub(self, y: Net) -> Self::Output

Performs the - operation.

impl<X> Sub<f32> for An<X>

where X: AudioNode, X::Inputs: Size<f32>, X::Outputs: Size<f32>,

type Output = An<Unop<X, FrameAddScalar<<X as AudioNode>::Outputs>>>

The resulting type after applying the - operator.

fn sub(self, y: f32) -> Self::Output

Performs the - operation.