Struct rotary::masked_audio_buffer::MaskedAudioBuffer

pub struct MaskedAudioBuffer<T, M> where
    T: Sample,
    M: Mask,  { /* fields omitted */ }

A dynamically sized, multi-channel audio buffer that supports masking.

Masked channels still exist, but they are returned empty.

use rotary::BitSet;

let mut buffer = rotary::MaskedAudioBuffer::<f32, BitSet<u128>>::with_topology(2, 256);

let all_zeros = vec![0.0; 256];

// Before masking it contains the default value of all zeros.
assert_eq!(buffer.get(1), Some(&all_zeros[..]));

buffer.mask(1);

// After masking, this channel will always return an empty buffer.
assert_eq!(buffer.get(1), Some(&[][..]));

Masked channels will also be skipped by iterators, such as MaskedAudioBuffer::iter_mut and MaskedAudioBuffer::iter_mut_with_channels.

use rotary::BitSet;

let mut buffer = rotary::MaskedAudioBuffer::<f32, BitSet<u128>>::with_topology(2, 256);

assert_eq!(buffer.iter_mut().count(), 2);

buffer.mask(1);

assert_eq!(buffer.iter_mut().count(), 1);

Implementations

impl<T, M> MaskedAudioBuffer<T, M> where
    T: Sample,
    M: Mask, 

pub fn new() -> Self

Construct a new empty audio buffer.

Examples

use rotary::BitSet;

let mut buffer = rotary::MaskedAudioBuffer::<f32, BitSet<u128>>::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

use rotary::BitSet;

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

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

pub fn unmasked(&self) -> Unmasked<M::Iter>

Iterate over the index of all enabled channels.

Examples

use rotary::BitSet;

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

assert_eq!(vec![0, 1, 2, 3], buffer.unmasked().collect::<Vec<usize>>());

buffer.mask(1);

assert_eq!(vec![0, 2, 3], buffer.unmasked().collect::<Vec<usize>>());

buffer.unmask(1);

assert_eq!(vec![0, 1, 2, 3], buffer.unmasked().collect::<Vec<usize>>());

pub fn unmask(&mut self, index: usize)

Unmask the channel identified by the given index.

Examples

use rotary::BitSet;

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

let expected = vec![0.0; 256];

assert_eq!(buffer.get(0), Some(&expected[..]));
buffer.mask(0);
assert_eq!(buffer.get(0), Some(&[][..]));
buffer.unmask(0);
assert_eq!(buffer.get(0), Some(&expected[..]));

pub fn mask(&mut self, index: usize)

Mask the channel identified by the given index.

Examples

use rotary::BitSet;

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

let expected = vec![0.0; 256];

assert_eq!(buffer.get(0), Some(&expected[..]));
buffer.mask(0);
assert_eq!(buffer.get(0), Some(&[][..]));
buffer.unmask(0);
assert_eq!(buffer.get(0), Some(&expected[..]));

pub fn iter_mut_with_channels(&mut self) -> IterMutWithChannels<'_, T, M>

Build an iterator over all enabled channels.

Examples

use rotary::BitSet;

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

buffer.mask(1);

let mut channels = Vec::new();

for (n, chan) in buffer.iter_mut_with_channels() {
    channels.push(n);

    for f in chan {
        *f = 1.0;
    }
}

let all_zeros = vec![0.0; 256];
let all_ones = vec![1.0; 256];

// disabled channels are empty and when re-enabled will contain whatever
// the buffer originally contained.
assert_eq!(&buffer[1], &[][..]);

buffer.unmask(1);

assert_eq!(&channels[..], &[0, 2, 3]);
assert_eq!(&buffer[0], &all_ones[..]);
assert_eq!(&buffer[1], &all_zeros[..]);
assert_eq!(&buffer[2], &all_ones[..]);
assert_eq!(&buffer[3], &all_ones[..]);

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

Construct a mutable iterator over all available channels.

Examples

use rotary::BitSet;

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

let all_zeros = vec![0.0; 256];

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

buffer.mask(1);

for chan in buffer.iter_mut() {
    for b in chan {
        *b = 1.0;
    }
}

let all_ones = vec![1.0; 256];

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

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

Construct a mutable iterator over all available channels.

Examples

use rotary::BitSet;
use rand::Rng as _;

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

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

With a disabled channel:

use rotary::BitSet;

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

buffer.mask(1);

for chan in buffer.iter_mut() {
    for f in chan {
        *f = 1.0;
    }
}

let all_zeros = vec![0.0; 256];
let all_ones = vec![1.0; 256];

// disabled channels are empty and when re-enabled will contain whatever
// the buffer originally contained.
assert_eq!(&buffer[1], &[][..]);

buffer.unmask(1);

assert_eq!(&buffer[0], &all_ones[..]);
assert_eq!(&buffer[1], &all_zeros[..]);
assert_eq!(&buffer[2], &all_ones[..]);
assert_eq!(&buffer[3], &all_ones[..]);

pub fn frames(&self) -> usize

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

Examples

use rotary::BitSet;

let mut buffer = rotary::MaskedAudioBuffer::<f32, BitSet<u128>>::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

use rotary::BitSet;

let mut buffer = rotary::MaskedAudioBuffer::<f32, BitSet<u128>>::new();

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

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

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

Examples

use rotary::BitSet;

let mut buffer = rotary::MaskedAudioBuffer::<f32, BitSet<u128>>::new();

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

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

Set the number of channels in use.

Examples

use rotary::BitSet;

let mut buffer = rotary::MaskedAudioBuffer::<f32, BitSet<u128>>::new();

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

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

Get a reference to the buffer of the given channel.

Examples

use rotary::BitSet;

let mut buffer = rotary::MaskedAudioBuffer::<f32, BitSet<u128>>::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

use rotary::BitSet;

let mut buffer = rotary::MaskedAudioBuffer::<f32, BitSet<u128>>::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 _;
use rotary::BitSet;

let mut buffer = rotary::MaskedAudioBuffer::<f32, BitSet<u128>>::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 _;
use rotary::BitSet;

let mut buffer = rotary::MaskedAudioBuffer::<f32, BitSet<u128>>::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

use rotary::BitSet;

let mut buffer = rotary::MaskedAudioBuffer::<f32, BitSet<u128>>::new();

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

buffer.mask(1);

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], &[][..]); // <- disabled channels are empty.
assert_eq!(buffers[2], &expected[..]);
assert_eq!(buffers[3], &expected[..]);

Trait Implementations

impl<T, M> Index<usize> for MaskedAudioBuffer<T, M> where
    T: Sample,
    M: Mask, 

type Output = [T]

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T, M> IndexMut<usize> for MaskedAudioBuffer<T, M> where
    T: Sample,
    M: Mask, 

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

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

impl<'a, T, M> IntoIterator for &'a mut MaskedAudioBuffer<T, M> where
    T: Sample,
    M: Mask, 

type IntoIter = IterMut<'a, T, M>

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, M> IntoIterator for &'a MaskedAudioBuffer<T, M> where
    T: Sample,
    M: Mask, 

type IntoIter = Iter<'a, T, M>

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.