Struct rotary::sequential::Sequential [−][src]
A dynamically sized, multi-channel sequential audio buffer.
A sequential audio buffer stores all audio data sequentially in memory, one channel after another.
An audio buffer can only be resized if it contains a type which is sample-apt For more information of what this means, see Sample.
Resizing the buffer might therefore cause a fair bit of copying, and for the worst cases, this might result in having to copy a memory region byte-by-byte since they might overlap.
Resized regions also aren’t zeroed, so certain operations might cause stale data to be visible after a resize.
let mut buffer = rotary::Sequential::<f32>::with_topology(2, 4); buffer[0].copy_from_slice(&[1.0, 2.0, 3.0, 4.0]); buffer[1].copy_from_slice(&[2.0, 3.0, 4.0, 5.0]); buffer.resize(3); assert_eq!(&buffer[0], &[1.0, 2.0, 3.0]); assert_eq!(&buffer[1], &[2.0, 3.0, 4.0]); buffer.resize(4); assert_eq!(&buffer[0], &[1.0, 2.0, 3.0, 2.0]); // <- 2.0 is stale data. assert_eq!(&buffer[1], &[2.0, 3.0, 4.0, 5.0]); // <- 5.0 is stale data.
To access the full, currently assumed valid slice you can use Sequential::as_slice or Sequential::into_vec.
let mut buffer = rotary::Sequential::<f32>::with_topology(2, 4); buffer[0].copy_from_slice(&[1.0, 2.0, 3.0, 4.0]); buffer[1].copy_from_slice(&[2.0, 3.0, 4.0, 5.0]); buffer.resize(3); assert_eq!(buffer.as_slice(), &[1.0, 2.0, 3.0, 2.0, 3.0, 4.0]);
Implementations
impl<T> Sequential<T>
[src]
pub fn new() -> Self
[src]
Construct a new empty audio buffer.
Examples
let mut buffer = rotary::Sequential::<f32>::new(); assert_eq!(buffer.frames(), 0);
pub fn with_topology(channels: usize, frames: usize) -> Self where
T: Sample,
[src]
T: Sample,
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::Sequential::<f32>::with_topology(4, 256); assert_eq!(buffer.frames(), 256); assert_eq!(buffer.channels(), 4);
pub fn from_vec(data: Vec<T>, channels: usize, frames: usize) -> Self
[src]
Allocate an audio buffer from a fixed-size array.
See sequential!.
Examples
let mut buffer = rotary::sequential![[2.0; 256]; 4]; assert_eq!(buffer.frames(), 256); assert_eq!(buffer.channels(), 4); for chan in &buffer { assert_eq!(chan, vec![2.0; 256]); }
pub fn from_frames<const N: usize>(frames: [T; N], channels: usize) -> Self where
T: Copy,
[src]
T: Copy,
Allocate an audio buffer from a fixed-size array acting as a template for all the channels.
See sequential!.
Examples
let mut buffer = rotary::Sequential::from_frames([1.0, 2.0, 3.0, 4.0], 2); assert_eq!(buffer.frames(), 4); assert_eq!(buffer.channels(), 2); assert_eq!(buffer.as_slice(), &[1.0, 2.0, 3.0, 4.0, 1.0, 2.0, 3.0, 4.0]);
pub fn from_array<const F: usize, const C: usize>(channels: [[T; F]; C]) -> Self where
T: Copy,
[src]
T: Copy,
Allocate a sequential audio buffer from a fixed-size array.
See sequential!.
Examples
let mut buffer = rotary::Sequential::from_array([[1; 4]; 2]); assert_eq!(buffer.frames(), 4); assert_eq!(buffer.channels(), 2); assert_eq! { buffer.as_slice(), &[1, 1, 1, 1, 1, 1, 1, 1], }
Using a specific array topology.
let mut buffer = rotary::Sequential::from_array([[1, 2, 3, 4], [5, 6, 7, 8]]); assert_eq!(buffer.frames(), 4); assert_eq!(buffer.channels(), 2); assert_eq! { buffer.as_slice(), &[1, 2, 3, 4, 5, 6, 7, 8], }
pub fn into_vec(self) -> Vec<T>
[src]
Take ownership of the backing vector.
Examples
let mut buffer = rotary::Sequential::<f32>::with_topology(2, 4); buffer[0].copy_from_slice(&[1.0, 2.0, 3.0, 4.0]); buffer[1].copy_from_slice(&[2.0, 3.0, 4.0, 5.0]); buffer.resize(3); assert_eq!(buffer.into_vec(), vec![1.0, 2.0, 3.0, 2.0, 3.0, 4.0])
pub fn as_slice(&self) -> &[T]
[src]
Access the underlying vector as a slice.
Examples
let mut buffer = rotary::Sequential::<f32>::with_topology(2, 4); buffer[0].copy_from_slice(&[1.0, 2.0, 3.0, 4.0]); buffer[1].copy_from_slice(&[2.0, 3.0, 4.0, 5.0]); buffer.resize(3); assert_eq!(buffer.as_slice(), &[1.0, 2.0, 3.0, 2.0, 3.0, 4.0])
pub fn frames(&self) -> usize
[src]
Get the number of frames in the channels of an audio buffer.
Examples
let mut buffer = rotary::Sequential::<f32>::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
let mut buffer = rotary::Sequential::<f32>::new(); assert_eq!(buffer.channels(), 0); buffer.resize_channels(2); assert_eq!(buffer.channels(), 2);
pub fn iter(&self) -> Iter<'_, T>ⓘ
[src]
Construct an iterator over all available channels.
Examples
use rand::Rng as _; let mut buffer = rotary::Sequential::<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>ⓘNotable traits for IterMut<'a, T>
impl<'a, T> Iterator for IterMut<'a, T> type Item = &'a mut [T];
[src]
Notable traits for IterMut<'a, T>
impl<'a, T> Iterator for IterMut<'a, T> type Item = &'a mut [T];
Construct a mutable iterator over all available channels.
Examples
use rand::Rng as _; let mut buffer = rotary::Sequential::<f32>::with_topology(4, 256); let mut rng = rand::thread_rng(); for chan in buffer.iter_mut() { rng.fill(chan); }
pub fn resize_channels(&mut self, channels: usize) where
T: Sample,
[src]
T: Sample,
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::Sequential::<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 resize(&mut self, frames: usize) where
T: Sample,
[src]
T: Sample,
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::Sequential::<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 modify the underlying buffer:
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], 0.0);
Stale data
Resizing a channel doesn’t “free” the underlying data or zero previously initialized regions.
Old regions which were previously sized out and ignored might contain stale data from previous uses. So this should be kept in mind when resizing this buffer dynamically.
let mut buffer = rotary::Sequential::<f32>::new(); buffer.resize_channels(4); buffer.resize(128); let expected = (0..128).map(|v| v as f32).collect::<Vec<_>>(); for chan in buffer.iter_mut() { for (s, v) in chan.iter_mut().zip(&expected) { *s = *v; } } assert_eq!(buffer.get(0), Some(&expected[..])); assert_eq!(buffer.get(1), Some(&expected[..])); assert_eq!(buffer.get(2), Some(&expected[..])); assert_eq!(buffer.get(3), Some(&expected[..])); assert_eq!(buffer.get(4), None); buffer.resize_channels(2); assert_eq!(buffer.get(0), Some(&expected[..])); assert_eq!(buffer.get(1), Some(&expected[..])); assert_eq!(buffer.get(2), None); // shrink buffer.resize(64); assert_eq!(buffer.get(0), Some(&expected[..64])); assert_eq!(buffer.get(1), Some(&expected[..64])); assert_eq!(buffer.get(2), None); // increase - this causes some weirdness. buffer.resize(128); let first_overlapping = expected[..64] .iter() .chain(expected[..64].iter()) .copied() .collect::<Vec<_>>(); assert_eq!(buffer.get(0), Some(&first_overlapping[..])); // Note: second channel matches perfectly up with an old channel that was // masked out. assert_eq!(buffer.get(1), Some(&expected[..])); assert_eq!(buffer.get(2), None);
pub fn get(&self, channel: usize) -> Option<&[T]>
[src]
Get a reference to the buffer of the given channel.
Examples
let mut buffer = rotary::Sequential::<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_mut(&mut self, channel: usize) -> Option<&mut [T]>
[src]
Get a mutable reference to the buffer of the given channel.
Examples
use rand::Rng as _; let mut buffer = rotary::Sequential::<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); }
Trait Implementations
impl<T> Buf for Sequential<T>
[src]
fn frames_hint(&self) -> Option<usize>
[src]
fn channels(&self) -> usize
[src]
pub fn skip(self, n: usize) -> Skip<Self>
[src]
pub fn tail(self, n: usize) -> Tail<Self>
[src]
pub fn limit(self, limit: usize) -> Limit<Self>
[src]
pub fn chunk(self, n: usize, len: usize) -> Chunk<Self>
[src]
impl<T> Channels<T> for Sequential<T>
[src]
impl<T> ChannelsMut<T> for Sequential<T> where
T: Copy,
[src]
T: Copy,
fn channel_mut(&mut self, channel: usize) -> ChannelMut<'_, T>
[src]
fn copy_channels(&mut self, from: usize, to: usize)
[src]
impl<T> Debug for Sequential<T> where
T: Debug,
[src]
T: Debug,
impl<T> Eq for Sequential<T> where
T: Eq,
[src]
T: Eq,
impl<T> ExactSizeBuf for Sequential<T>
[src]
impl<T> Hash for Sequential<T> where
T: Hash,
[src]
T: Hash,
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> Index<usize> for Sequential<T>
[src]
type Output = [T]
The returned type after indexing.
fn index(&self, index: usize) -> &Self::Output
[src]
impl<T> IndexMut<usize> for Sequential<T>
[src]
impl<'a, T> IntoIterator for &'a Sequential<T>
[src]
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
[src]
impl<'a, T> IntoIterator for &'a mut Sequential<T>
[src]
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
[src]
impl<T> Ord for Sequential<T> where
T: Ord,
[src]
T: Ord,
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> PartialEq<Sequential<T>> for Sequential<T> where
T: PartialEq,
[src]
T: PartialEq,
impl<T> PartialOrd<Sequential<T>> for Sequential<T> where
T: PartialOrd,
[src]
T: PartialOrd,
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
impl<T> ResizableBuf for Sequential<T> where
T: Sample,
[src]
T: Sample,
Auto Trait Implementations
impl<T> RefUnwindSafe for Sequential<T> where
T: RefUnwindSafe,
T: RefUnwindSafe,
impl<T> Send for Sequential<T> where
T: Send,
T: Send,
impl<T> Sync for Sequential<T> where
T: Sync,
T: Sync,
impl<T> Unpin for Sequential<T> where
T: Unpin,
T: Unpin,
impl<T> UnwindSafe for Sequential<T> where
T: UnwindSafe,
T: UnwindSafe,
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>,