Struct AudioIO 

pub struct AudioIO<'a> {
    pub input: Option<&'a [&'a [f32]]>,
    pub output: &'a mut [&'a mut [f32]],
    pub sidechain_in: Option<&'a [&'a [f32]]>,
    pub sidechain_out: Option<&'a mut [&'a mut [f32]]>,
}

Audio I/O view for buffer-based processing.

A thin, non-owning wrapper over per-channel sample slices - input and sidechain-input channels are borrowed immutably, output and sidechain-output channels mutably. AudioIO doesn’t allocate or own any sample storage itself: the caller (typically a host driving Processor::run once per audio callback) owns the actual buffers for the life of the stream and constructs a new AudioIO borrowing into them for each block, matching how real audio APIs (VST3’s AudioBusBuffers, CoreAudio’s AudioBufferList) hand a plugin raw pointers into host-owned memory rather than copying into a buffer the plugin owns.

input, sidechain_in, and sidechain_out are Option: a generator plugin (synth, noise source, …) may have no audio input at all, and sidechain busses are commonly absent. output is always present - every processor produces some output, even if it’s silence.

Example

fn process(audio: &mut AudioIO)
{
    let Some(input) = audio.input else { return };
    for ch in 0..input.len().min(audio.output.len())
    {
        let (input, output) = (input[ch], &mut audio.output[ch]);
        for i in 0..input.len().min(output.len())
        {
            output[i] = input[i];
        }
    }
}

// Building one for a call, from caller-owned storage:
let input_storage = vec![vec![0.0f32; 512]; 2];
let mut output_storage = vec![vec![0.0f32; 512]; 2];
let input: Vec<&[f32]> = input_storage.iter().map(Vec::as_slice).collect();
let mut output: Vec<&mut [f32]> = output_storage.iter_mut().map(Vec::as_mut_slice).collect();
let mut audio = AudioIO::new(Some(&input), &mut output, None, None);
process(&mut audio);

Fields

input: Option<&'a [&'a [f32]]>

Input audio channels, borrowed from caller-owned storage. None for a plugin with no audio input (e.g. an instrument/generator).

output: &'a mut [&'a mut [f32]]

Output audio channels, borrowed mutably from caller-owned storage.

sidechain_in: Option<&'a [&'a [f32]]>

Sidechain input channels. None when no sidechain bus is connected.

sidechain_out: Option<&'a mut [&'a mut [f32]]>

Sidechain output channels. None when no sidechain bus is connected.

Implementations

impl<'a> AudioIO<'a>

pub fn new( input: Option<&'a [&'a [f32]]>, output: &'a mut [&'a mut [f32]], sidechain_in: Option<&'a [&'a [f32]]>, sidechain_out: Option<&'a mut [&'a mut [f32]]>, ) -> Self

Wrap existing per-channel sample slices - no allocation.

Examples found in repository

examples/vst3_host_test.rs (line 62)

fn main() {
    let dir = Path::new("/Library/Audio/Plug-Ins/VST3");
    let found = scan_vst3(dir);
    println!("Found {} VST3 classes in {}", found.len(), dir.display());
    for d in found.iter().take(8) {
        println!("  [{}] {} - {}", d.format, d.vendor, d.name);
    }

    let descriptor = found
        .first()
        .expect("no VST3 plugins found to test against");
    println!("\nLoading: {} - {}", descriptor.vendor, descriptor.name);

    let mut plugin = load(descriptor).expect("failed to load VST3 plugin");
    println!(
        "Loaded '{}' by '{}': {} in / {} out, {} parameters",
        plugin.name(),
        plugin.vendor(),
        plugin.num_inputs(),
        plugin.num_outputs(),
        plugin.num_parameters()
    );

    plugin.prepare(48000, 512).expect("prepare failed");
    plugin.set_active(true).expect("set_active failed");

    for i in 0..plugin.num_parameters().min(5) {
        println!(
            "  param[{}] '{}' = {:.4}",
            i,
            plugin.parameter_name(i),
            plugin.get_parameter(i)
        );
    }

    let in_channels = plugin.num_inputs().max(1);
    let out_channels = plugin.num_outputs().max(1);

    // AudioIO borrows into caller-owned storage rather than allocating its
    // own - own the actual sample memory here, for the life of this block.
    let mut input_storage = vec![vec![0.0f32; 512]; in_channels];
    let mut output_storage = vec![vec![0.0f32; 512]; out_channels];

    for channel in &mut input_storage {
        for (i, sample) in channel.iter_mut().enumerate() {
            *sample = (i as f32 / 48000.0 * 440.0 * std::f32::consts::TAU).sin() * 0.25;
        }
    }

    let input: Vec<&[f32]> = input_storage.iter().map(Vec::as_slice).collect();
    let mut output: Vec<&mut [f32]> = output_storage.iter_mut().map(Vec::as_mut_slice).collect();
    let mut audio = AudioIO::new(Some(&input), &mut output, None, None);

    plugin.process(&mut audio);

    let mut peak = 0.0f32;
    let mut nonzero = false;
    for channel in &output_storage {
        for &s in channel.iter() {
            if s != 0.0 {
                nonzero = true;
            }
            peak = peak.max(s.abs());
        }
    }

    println!("\nOutput peak: {:.6}, nonzero: {}", peak, nonzero);
    println!(
        "OK: VST3 host rendered a real block of audio through '{}'.",
        plugin.name()
    );
}

examples/au_host_test.rs (line 56)

fn main() {
    let found = scan_au();
    println!("Found {} Audio Units", found.len());
    for d in found.iter().take(5) {
        println!(
            "  [{}] {} - {} ({})",
            d.format, d.vendor, d.name, d.category
        );
    }

    let effect = found
        .iter()
        .find(|d| d.category == "Effect")
        .expect("no Effect-type Audio Unit found to test against");
    println!("\nLoading: {} - {}", effect.vendor, effect.name);
    assert_eq!(effect.format, PluginFormat::Au);

    let mut plugin = load(effect).expect("failed to load AU");
    println!(
        "Loaded '{}' by '{}': {} in / {} out, {} parameters",
        plugin.name(),
        plugin.vendor(),
        plugin.num_inputs(),
        plugin.num_outputs(),
        plugin.num_parameters()
    );

    plugin.prepare(48000, 512).expect("prepare failed");
    plugin.set_active(true).expect("set_active failed");

    let in_channels = plugin.num_inputs();
    let out_channels = plugin.num_outputs().max(1);

    // AudioIO borrows into caller-owned storage rather than allocating its
    // own - own the actual sample memory here, for the life of this block.
    let mut input_storage = vec![vec![0.0f32; 512]; in_channels];
    let mut output_storage = vec![vec![0.0f32; 512]; out_channels];

    // Feed a simple 440Hz sine into every input channel.
    for channel in &mut input_storage {
        for (i, sample) in channel.iter_mut().enumerate() {
            *sample = (i as f32 / 48000.0 * 440.0 * std::f32::consts::TAU).sin() * 0.25;
        }
    }

    let input: Vec<&[f32]> = input_storage.iter().map(Vec::as_slice).collect();
    let mut output: Vec<&mut [f32]> = output_storage.iter_mut().map(Vec::as_mut_slice).collect();
    let mut audio = AudioIO::new(Some(&input), &mut output, None, None);

    plugin.process(&mut audio);

    let mut peak = 0.0f32;
    let mut nonzero = false;
    for channel in &output_storage {
        for &s in channel.iter() {
            if s != 0.0 {
                nonzero = true;
            }
            peak = peak.max(s.abs());
        }
    }

    println!("Output peak: {:.6}, nonzero: {}", peak, nonzero);
    println!(
        "OK: AU host rendered a real block of audio through '{}'.",
        plugin.name()
    );

    // Also verify parameter enumeration/get/set against whichever scanned
    // Effect actually exposes AU parameters (Doomsday above may not).
    println!("\nSearching for an Effect with exposed parameters...");
    for candidate in found.iter().filter(|d| d.category == "Effect").take(40) {
        let Ok(mut p) = load(candidate) else {
            continue;
        };
        if p.prepare(48000, 512).is_err() {
            continue;
        }
        if p.num_parameters() == 0 {
            continue;
        }

        println!(
            "  {} - {}: {} parameters",
            candidate.vendor,
            candidate.name,
            p.num_parameters()
        );
        for i in 0..p.num_parameters().min(3) {
            let before = p.get_parameter(i);
            p.set_parameter(i, 0.75);
            let after = p.get_parameter(i);
            println!(
                "    [{}] '{}': {:.4} -> set 0.75 -> {:.4}",
                i,
                p.parameter_name(i),
                before,
                after
            );
        }
        break;
    }
}

Trait Implementations

impl Default for AudioIO<'_>

fn default() -> Self

An empty view (no channels). Mainly useful as a placeholder before the first real block is available.