Struct rotary::masked_dynamic::MaskedDynamic [−][src]
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::MaskedDynamic::<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 MaskedDynamic::iter_mut and MaskedDynamic::iter_mut_with_channels.
use rotary::BitSet; let mut buffer = rotary::MaskedDynamic::<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> MaskedDynamic<T, M> where
T: Sample,
M: Mask,
[src]
T: Sample,
M: Mask,
pub fn new() -> Self
[src]
Construct a new empty audio buffer.
Examples
use rotary::BitSet; let mut buffer = rotary::MaskedDynamic::<f32, BitSet<u128>>::new(); assert_eq!(buffer.frames(), 0);
pub fn with_topology(channels: usize, frames: usize) -> Self
[src]
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::MaskedDynamic::<f32, BitSet<u128>>::with_topology(4, 256); assert_eq!(buffer.frames(), 256); assert_eq!(buffer.channels(), 4);
pub fn with_buffer(buffer: Dynamic<T>) -> Self
[src]
Construct a masked audio buffer from an existing audio buffer. The kind
of mask needs to be specified through M
.
Examples
let buffer = rotary::dynamic![[2.0; 128]; 4]; let mut buffer = rotary::MaskedDynamic::<_, rotary::BitSet<u128>>::with_buffer(buffer); buffer.mask(1); let mut channels = Vec::new(); for (n, chan) in buffer.iter_with_channels() { channels.push(n); assert_eq!(chan, vec![2.0; 128]); } assert_eq!(channels, vec![0, 2, 3]);
pub fn from_array<const F: usize, const C: usize>(channels: [[T; F]; C]) -> Self
[src]
Allocate a masked audio buffer from a fixed-size array.
Examples
use rotary::BitSet; let mut buffer = rotary::MaskedDynamic::<f32, BitSet<u128>>::from_array([[2.0; 256]; 4]); assert_eq!(buffer.frames(), 256); assert_eq!(buffer.channels(), 4); buffer.mask(1); let mut channels = Vec::new(); for (n, chan) in buffer.iter_with_channels() { channels.push(n); assert_eq!(chan, vec![2.0; 256]); } assert_eq!(channels, vec![0, 2, 3]);
pub fn unmasked(&self) -> Unmasked<M::Iter>ⓘ
[src]
Iterate over the index of all enabled channels.
Examples
use rotary::BitSet; let mut buffer = rotary::MaskedDynamic::<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)
[src]
Unmask the channel identified by the given index
.
Examples
use rotary::BitSet; let mut buffer = rotary::MaskedDynamic::<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)
[src]
Mask the channel identified by the given index
.
Examples
use rotary::BitSet; let mut buffer = rotary::MaskedDynamic::<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>ⓘNotable traits for IterMutWithChannels<'a, T, M>
impl<'a, T, M> Iterator for IterMutWithChannels<'a, T, M> where
T: Sample,
M: Mask, type Item = (usize, &'a mut [T]);
[src]
Notable traits for IterMutWithChannels<'a, T, M>
impl<'a, T, M> Iterator for IterMutWithChannels<'a, T, M> where
T: Sample,
M: Mask, type Item = (usize, &'a mut [T]);
Build an iterator over all enabled channels.
Examples
use rotary::BitSet; let mut buffer = rotary::MaskedDynamic::<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; } } assert_eq!(channels, vec![0, 2, 3]); 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>ⓘ
[src]
Construct an iterator over all available channels.
Examples
use rotary::BitSet; let mut buffer = rotary::MaskedDynamic::<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_with_channels(&self) -> IterWithChannels<'_, T, M>ⓘNotable traits for IterWithChannels<'a, T, M>
impl<'a, T, M> Iterator for IterWithChannels<'a, T, M> where
T: Sample,
M: Mask, type Item = (usize, &'a [T]);
[src]
Notable traits for IterWithChannels<'a, T, M>
impl<'a, T, M> Iterator for IterWithChannels<'a, T, M> where
T: Sample,
M: Mask, type Item = (usize, &'a [T]);
Build an iterator over all enabled channels.
Examples
use rotary::BitSet; let mut buffer = rotary::MaskedDynamic::<f32, BitSet<u128>>::with_topology(4, 256); buffer.mask(1); let mut channels = Vec::new(); for (n, chan) in buffer.iter_with_channels() { channels.push(n); } assert_eq!(channels, vec![0, 2, 3]); let all_zeros = vec![0.0; 256]; assert_eq!(&buffer[1], &[][..]); buffer.unmask(1); assert_eq!(&channels[..], &[0, 2, 3]); assert_eq!(&buffer[0], &all_zeros[..]); assert_eq!(&buffer[1], &all_zeros[..]); assert_eq!(&buffer[2], &all_zeros[..]); assert_eq!(&buffer[3], &all_zeros[..]);
pub fn iter_mut(&mut self) -> IterMut<'_, T, M>ⓘ
[src]
Construct a mutable iterator over all available channels.
Examples
use rotary::BitSet; use rand::Rng as _; let mut buffer = rotary::MaskedDynamic::<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::MaskedDynamic::<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
[src]
Get the number of frames in the channels of an audio buffer.
Examples
use rotary::BitSet; let mut buffer = rotary::MaskedDynamic::<f32, BitSet<u128>>::new(); assert_eq!(buffer.frames(), 0); buffer.resize(256); assert_eq!(buffer.frames(), 256);
pub fn channels(&self) -> usize
[src]
Check how many channels there are in the buffer.
Examples
use rotary::BitSet; let mut buffer = rotary::MaskedDynamic::<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)
[src]
Set the size of the buffer. The size is the size of each channel’s buffer.
Examples
use rotary::BitSet; let mut buffer = rotary::MaskedDynamic::<f32, BitSet<u128>>::new(); buffer.resize_channels(4); buffer.resize(256);
pub fn resize_channels(&mut self, channels: usize)
[src]
Set the number of channels in use.
Examples
use rotary::BitSet; let mut buffer = rotary::MaskedDynamic::<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]>
[src]
Get a reference to the buffer of the given channel.
Examples
use rotary::BitSet; let mut buffer = rotary::MaskedDynamic::<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]
[src]
Get the given channel or initialize the buffer with the default value.
Examples
use rotary::BitSet; let mut buffer = rotary::MaskedDynamic::<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]>
[src]
Get a mutable reference to the buffer of the given channel.
Examples
use rand::Rng as _; use rotary::BitSet; let mut buffer = rotary::MaskedDynamic::<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]
[src]
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::MaskedDynamic::<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>>
[src]
Convert into a vector of vectors.
Examples
use rotary::BitSet; let mut buffer = rotary::MaskedDynamic::<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> Buf<T> for MaskedDynamic<T, M> where
T: Sample,
M: Mask,
[src]
T: Sample,
M: Mask,
fn channels(&self) -> usize
[src]
fn is_masked(&self, channel: usize) -> bool
[src]
fn channel(&self, channel: usize) -> BufChannel<'_, T>
[src]
impl<T, M> BufMut<T> for MaskedDynamic<T, M> where
T: Sample,
M: Mask,
[src]
T: Sample,
M: Mask,
fn channel_mut(&mut self, channel: usize) -> BufChannelMut<'_, T>
[src]
fn resize(&mut self, frames: usize)
[src]
fn resize_topology(&mut self, channels: usize, frames: usize)
[src]
fn set_masked(&mut self, channel: usize, masked: bool)
[src]
impl<T, M> Debug for MaskedDynamic<T, M> where
T: Sample + Debug,
M: Mask,
[src]
T: Sample + Debug,
M: Mask,
impl<T, M> Eq for MaskedDynamic<T, M> where
T: Sample + Eq,
M: Mask,
[src]
T: Sample + Eq,
M: Mask,
impl<T, M, const F: usize, const C: usize> From<[[T; F]; C]> for MaskedDynamic<T, M> where
T: Sample,
M: Mask,
[src]
T: Sample,
M: Mask,
Allocate a masked audio buffer from a fixed-size array.
impl<T, M> Hash for MaskedDynamic<T, M> where
T: Sample + Hash,
M: Mask,
[src]
T: Sample + Hash,
M: Mask,
fn hash<H: Hasher>(&self, state: &mut H)
[src]
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<T, M> Index<usize> for MaskedDynamic<T, M> where
T: Sample,
M: Mask,
[src]
T: Sample,
M: Mask,
type Output = [T]
The returned type after indexing.
fn index(&self, index: usize) -> &Self::Output
[src]
impl<T, M> IndexMut<usize> for MaskedDynamic<T, M> where
T: Sample,
M: Mask,
[src]
T: Sample,
M: Mask,
impl<'a, T, M> IntoIterator for &'a mut MaskedDynamic<T, M> where
T: Sample,
M: Mask,
[src]
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
[src]
impl<'a, T, M> IntoIterator for &'a MaskedDynamic<T, M> where
T: Sample,
M: Mask,
[src]
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
[src]
impl<T, M> Ord for MaskedDynamic<T, M> where
T: Sample + Ord,
M: Mask,
[src]
T: Sample + Ord,
M: Mask,
fn cmp(&self, other: &Self) -> Ordering
[src]
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<T, M> PartialEq<MaskedDynamic<T, M>> for MaskedDynamic<T, M> where
T: Sample + PartialEq,
M: Mask,
[src]
T: Sample + PartialEq,
M: Mask,
impl<T, M> PartialOrd<MaskedDynamic<T, M>> for MaskedDynamic<T, M> where
T: Sample + PartialOrd,
M: Mask,
[src]
T: Sample + PartialOrd,
M: Mask,
Auto Trait Implementations
impl<T, M> RefUnwindSafe for MaskedDynamic<T, M> where
M: RefUnwindSafe,
T: RefUnwindSafe,
M: RefUnwindSafe,
T: RefUnwindSafe,
impl<T, M> !Send for MaskedDynamic<T, M>
impl<T, M> !Sync for MaskedDynamic<T, M>
impl<T, M> Unpin for MaskedDynamic<T, M> where
M: Unpin,
M: Unpin,
impl<T, M> UnwindSafe for MaskedDynamic<T, M> where
M: UnwindSafe,
T: RefUnwindSafe,
M: UnwindSafe,
T: RefUnwindSafe,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,