Struct AuxInput 

pub struct AuxInput<'a, S: Sample = f32> { /* private fields */ }

Immutable view of an auxiliary input bus.

Provides access to input channels for a single auxiliary bus (typically sidechain). Created via AuxiliaryBuffers::sidechain() or AuxiliaryBuffers::input().

Type Parameter

S is the sample type, defaulting to f32.

Example: Block-Based Analysis

if let Some(sc) = aux.sidechain() {
    // Calculate RMS of sidechain for keying
    let rms = sc.rms(0);

    // Or iterate over all channels
    for ch in sc.iter_inputs() {
        // Process channel...
    }
}

Example: Sample-by-Sample Access

if let Some(sc) = aux.sidechain() {
    for i in 0..buffer.num_samples() {
        // .sample() returns S::ZERO if channel/index missing
        let key_l = sc.sample(0, i).to_f64().abs();
        let key_r = sc.sample(1, i).to_f64().abs();
        let key = (key_l + key_r) * 0.5;

        // Use for envelope follower, gate, ducker, etc.
    }
}

Implementations

impl<'a, S: Sample> AuxInput<'a, S>

pub fn num_samples(&self) -> usize

Number of samples in each channel.

pub fn num_channels(&self) -> usize

Number of channels in this bus.

pub fn input(&self, index: usize) -> &[S]

Get an input channel by index.

Returns an empty slice if the channel doesn’t exist. Matches Buffer::input() naming for API consistency.

pub fn sample(&self, channel: usize, index: usize) -> S

Get a single sample from a channel.

Returns [S::ZERO] if the channel or sample index doesn’t exist. This is a convenience method for sample-by-sample processing.

Example

// Instead of:
let sc = sidechain.input(0).get(i).copied().unwrap_or(S::ZERO);

// Use:
let sc = sidechain.sample(0, i);

pub fn iter_inputs(&self) -> impl Iterator<Item = &[S]> + '_

Iterate over all input channels.

pub fn rms(&self, channel: usize) -> S

Calculate the RMS (root mean square) level of a channel.

Returns zero if the channel doesn’t exist or is empty.

pub fn peak(&self, channel: usize) -> S

Calculate the peak level of a channel.

Returns zero if the channel doesn’t exist or is empty.

pub fn average(&self, channel: usize) -> S

Calculate the average absolute level of a channel.

Returns zero if the channel doesn’t exist or is empty.