Struct FullWaveRectification 

pub struct FullWaveRectification<F: Real> { /* private fields */ }

Full-wave rectifier that outputs the absolute value of the input signal.

This operation is essential for onset detection, as it converts bipolar audio signals into unipolar envelopes that can be used to detect amplitude changes.

The rectified signal is typically followed by a low-pass filter to extract the amplitude envelope.

Trait Implementations

impl<F: Real> AudioNode for FullWaveRectification<F>

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

Computes the absolute value of the input sample.

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

SIMD-optimized batch processing of multiple samples.

const ID: u64

Unique ID for hashing.

type Inputs = UInt<UTerm, B1>

Input arity.

type Outputs = UInt<UTerm, B1>

Output arity.

fn reset(&mut self)

Reset the input state of the component and all its children to an initial state where it has not processed any samples. In other words, reset time to zero. If allocate has been called previously, and the sample rate is unchanged, then it is expected that no memory allocation or deallocation takes place here.

fn set_sample_rate(&mut self, sample_rate: f64)

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

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

Process samples left over using tick after processing all full SIMD items. This is a convenience method for implementers.

fn set(&mut self, setting: Setting)

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

fn set_hash(&mut self, hash: u64)

Set node pseudorandom phase hash. This is called from ping (only). It should not be called by users. The node is allowed to reset itself here.

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

Ping contained 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 probe set to false and hash initialized with the custom hash. The node is allowed to reset itself here.

fn allocate(&mut self)

Preallocate all needed memory.

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. If there are no frequency responses in input, then frequency is ignored.

fn inputs(&self) -> usize

Number of inputs.

fn outputs(&self) -> usize

Number of outputs.

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 the channels.

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<Complex<f64>>

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, if any. 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. Voluntary latencies, such as delays, are not counted as latency.

impl<F: Clone + Real> Clone for FullWaveRectification<F>

fn clone(&self) -> FullWaveRectification<F>

Returns a duplicate of the value.

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

Performs copy-assignment from source.