Struct rotary::audio_buffer::AudioBuffer

pub struct AudioBuffer<T> where
    T: Sample,  { /* fields omitted */ }

A multi-channel AudioBuffer audio buffer for the given type.

A AudioBuffer audio buffer is constrained to only support sample-apt types, which have the following properties allowing the container to work more efficiently:

• The type T does not need to be dropped.
• The type T can safely be initialized with the all-zeros bit pattern.

Implementations

impl<T> AudioBuffer<T> where
    T: Sample, 

pub fn new() -> Self

Construct a new empty audio buffer.

Examples

let mut buffer = rotary::AudioBuffer::<f32>::new();

assert_eq!(buffer.frames(), 0);

pub fn with_topology(channels: usize, frames: usize) -> Self

Allocate an audio buffer with the given topology. A “topology” is a given number of channels and the corresponding number of frames in their buffers.

Examples

let mut buffer = rotary::AudioBuffer::<f32>::with_topology(4, 256);

assert_eq!(buffer.frames(), 256);
assert_eq!(buffer.channels(), 4);

pub fn frames(&self) -> usize

Get the number of frames in the channels of an audio buffer.

Examples

let mut buffer = rotary::AudioBuffer::<f32>::new();

assert_eq!(buffer.frames(), 0);
buffer.resize(256);
assert_eq!(buffer.frames(), 256);

pub fn channels(&self) -> usize

Check how many channels there are in the buffer.

Examples

let mut buffer = rotary::AudioBuffer::<f32>::new();

assert_eq!(buffer.channels(), 0);
buffer.resize_channels(2);
assert_eq!(buffer.channels(), 2);

pub fn iter(&self) -> Iter<'_, T>

Construct a mutable iterator over all available channels.

Examples

use rand::Rng as _;

let mut buffer = rotary::AudioBuffer::<f32>::with_topology(4, 256);

let all_zeros = vec![0.0; 256];

for chan in buffer.iter() {
    assert_eq!(chan, &all_zeros[..]);
}

pub fn iter_mut(&mut self) -> IterMut<'_, T>

Construct a mutable iterator over all available channels.

Examples

use rand::Rng as _;

let mut buffer = rotary::AudioBuffer::<f32>::with_topology(4, 256);
let mut rng = rand::thread_rng();

for chan in buffer.iter_mut() {
    rng.fill(chan);
}

pub fn resize(&mut self, len: usize)

Set the size of the buffer. The size is the size of each channel’s buffer.

If the size of the buffer increases as a result, the new regions in the frames will be zeroed. If the size decreases, the region will be left untouched. So if followed by another increase, the data will be “dirty”.

Examples

let mut buffer = rotary::AudioBuffer::<f32>::new();

assert_eq!(buffer.channels(), 0);
assert_eq!(buffer.frames(), 0);

buffer.resize_channels(4);
buffer.resize(256);

assert_eq!(buffer[1][128], 0.0);
buffer[1][128] = 42.0;

assert_eq!(buffer.channels(), 4);
assert_eq!(buffer.frames(), 256);

Decreasing and increasing the size will not touch a buffer that has already been allocated.

assert_eq!(buffer[1][128], 0.0);
buffer[1][128] = 42.0;

buffer.resize(64);
assert!(buffer[1].get(128).is_none());

buffer.resize(256);
assert_eq!(buffer[1][128], 42.0);

pub fn resize_channels(&mut self, channels: usize)

Set the number of channels in use.

If the size of the buffer increases as a result, the new channels will be zeroed. If the size decreases, the channels that falls outside of the new size will be dropped.

Examples

let mut buffer = rotary::AudioBuffer::<f32>::new();

assert_eq!(buffer.channels(), 0);
assert_eq!(buffer.frames(), 0);

buffer.resize_channels(4);
buffer.resize(256);

assert_eq!(buffer.channels(), 4);
assert_eq!(buffer.frames(), 256);

pub fn get(&self, index: usize) -> Option<&[T]>

Get a reference to the buffer of the given channel.

Examples

let mut buffer = rotary::AudioBuffer::<f32>::new();

buffer.resize_channels(4);
buffer.resize(256);

let expected = vec![0.0; 256];

assert_eq!(Some(&expected[..]), buffer.get(0));
assert_eq!(Some(&expected[..]), buffer.get(1));
assert_eq!(Some(&expected[..]), buffer.get(2));
assert_eq!(Some(&expected[..]), buffer.get(3));
assert_eq!(None, buffer.get(4));

pub fn get_or_default(&mut self, index: usize) -> &[T]

Get the given channel or initialize the buffer with the default value.

Examples

let mut buffer = rotary::AudioBuffer::<f32>::new();

buffer.resize(256);

let expected = vec![0f32; 256];

assert_eq!(buffer.get_or_default(0), &expected[..]);
assert_eq!(buffer.get_or_default(1), &expected[..]);

assert_eq!(buffer.channels(), 2);

pub fn get_mut(&mut self, index: usize) -> Option<&mut [T]>

Get a mutable reference to the buffer of the given channel.

Examples

use rand::Rng as _;

let mut buffer = rotary::AudioBuffer::<f32>::new();

buffer.resize_channels(2);
buffer.resize(256);

let mut rng = rand::thread_rng();

if let Some(left) = buffer.get_mut(0) {
    rng.fill(left);
}

if let Some(right) = buffer.get_mut(1) {
    rng.fill(right);
}

pub fn get_or_default_mut(&mut self, index: usize) -> &mut [T]

Get the given channel or initialize the buffer with the default value.

If a channel that is out of bound is queried, the buffer will be empty.

Examples

use rand::Rng as _;

let mut buffer = rotary::AudioBuffer::<f32>::new();

buffer.resize(256);

let mut rng = rand::thread_rng();

rng.fill(buffer.get_or_default_mut(0));
rng.fill(buffer.get_or_default_mut(1));

assert_eq!(buffer.channels(), 2);

pub fn into_vecs(self) -> Vec<Vec<T>>

Convert into a vector of vectors.

Examples

let mut buffer = rotary::AudioBuffer::<f32>::new();
buffer.resize_channels(4);
buffer.resize(512);

let expected = vec![0.0; 512];

let buffers = buffer.into_vecs();
assert_eq!(buffers.len(), 4);
assert_eq!(buffers[0], &expected[..]);
assert_eq!(buffers[1], &expected[..]);
assert_eq!(buffers[2], &expected[..]);
assert_eq!(buffers[3], &expected[..]);

Trait Implementations

impl<T> Drop for AudioBuffer<T> where
    T: Sample, 

fn drop(&mut self)

Executes the destructor for this type.

impl<T> Index<usize> for AudioBuffer<T> where
    T: Sample, 

type Output = [T]

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T> IndexMut<usize> for AudioBuffer<T> where
    T: Sample, 

fn index_mut(&mut self, index: usize) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<'a, T> IntoIterator for &'a AudioBuffer<T> where
    T: Sample, 

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

type Item = <Self::IntoIter as Iterator>::Item

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut AudioBuffer<T> where
    T: Sample, 

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

type Item = <Self::IntoIter as Iterator>::Item

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.