Struct rotary::interleaved::Interleaved [−][src]
A dynamically sized, multi-channel interleaved audio buffer.
An audio buffer is constrained to only support sample-apt types. For more information of what this means, see Sample.
An interleaved audio buffer stores all audio data interleaved in memory, one sample from each channel in sequence until we’re out of samples. This naturally makes the buffer a bit harder to work with, and we have to rely on iterators to access logical channels.
Resized regions aren’t zeroed, so certain operations might cause stale data to be visible after a resize.
let mut buffer = rotary::Interleaved::<f32>::with_topology(2, 4); for (c, s) in buffer .get_mut(0) .unwrap() .iter_mut() .zip(&[1.0, 2.0, 3.0, 4.0]) { *c = *s; } for (c, s) in buffer .get_mut(1) .unwrap() .iter_mut() .zip(&[5.0, 6.0, 7.0, 8.0]) { *c = *s; } assert_eq!(buffer.as_slice(), &[1.0, 5.0, 2.0, 6.0, 3.0, 7.0, 4.0, 8.0]);
Implementations
impl<T> Interleaved<T> where
T: Sample,
[src]
T: Sample,
pub fn new() -> Self
[src]
Construct a new empty audio buffer.
Examples
let mut buffer = rotary::Interleaved::<f32>::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
let mut buffer = rotary::Interleaved::<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 dynamic!.
Examples
use rotary::BitSet; let mut buffer = rotary::interleaved![[2.0; 256]; 4]; assert_eq!(buffer.frames(), 256); assert_eq!(buffer.channels(), 4); for chan in &buffer { assert!(chan.iter().eq(&[2.0; 256][..])); }
pub fn into_vec(self) -> Vec<T>
[src]
Take ownership of the backing vector.
Examples
let mut buffer = rotary::Interleaved::<f32>::with_topology(2, 4); for (c, s) in buffer.get_mut(0).unwrap().iter_mut().zip(&[1.0, 2.0, 3.0, 4.0]) { *c = *s; } for (c, s) in buffer.get_mut(1).unwrap().iter_mut().zip(&[1.0, 2.0, 3.0, 4.0]) { *c = *s; } buffer.resize(3); assert_eq!(buffer.into_vec(), vec![1.0, 1.0, 2.0, 2.0, 3.0, 3.0])
pub fn as_slice(&self) -> &[T]
[src]
Access the underlying vector as a slice.
Examples
let mut buffer = rotary::Interleaved::<f32>::with_topology(2, 4); for (c, s) in buffer.get_mut(0).unwrap().iter_mut().zip(&[1.0, 2.0, 3.0, 4.0]) { *c = *s; } for (c, s) in buffer.get_mut(1).unwrap().iter_mut().zip(&[1.0, 2.0, 3.0, 4.0]) { *c = *s; } buffer.resize(3); assert_eq!(buffer.as_slice(), &[1.0, 1.0, 2.0, 2.0, 3.0, 3.0])
pub fn frames(&self) -> usize
[src]
Get the number of frames in the channels of an audio buffer.
Examples
let mut buffer = rotary::Interleaved::<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::Interleaved::<f32>::new(); assert_eq!(buffer.channels(), 0); buffer.resize_channels(2); assert_eq!(buffer.channels(), 2);
pub fn offset(&self, offset: usize) -> Interleaved<&[T]>
[src]
Offset the interleaved buffer and return a wrapped buffer.
This is provided as a special operation for this buffer kind, because it can be done more efficiently than what is available through Buf::offset.
pub fn offset_mut(&mut self, offset: usize) -> Interleaved<&mut [T]>
[src]
Offset the interleaved buffer and return a mutable wrapped buffer.
This is provided as a special operation for this buffer kind, because it can be done more efficiently than what is available through Buf::offset.
Examples
use rotary::{Buf as _, BufMut as _}; let mut buffer = rotary::Interleaved::with_topology(2, 4); buffer.offset_mut(2).channel_mut(0).copy_from_slice(&[1.0, 1.0]); assert_eq!(buffer.as_slice(), &[0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0])
pub fn limit(&self, limit: usize) -> Interleaved<&[T]>
[src]
Limit the interleaved buffer and return a wrapped buffer.
This is provided as a special operation for this buffer kind, because it can be done more efficiently than what is available through Buf::limit.
Examples
use rotary::{Buf as _, BufMut as _}; let from = rotary::interleaved![[1.0f32; 4]; 2]; let mut to = rotary::Interleaved::<f32>::with_topology(2, 4); to.channel_mut(0).copy_from(from.limit(2).channel(0)); assert_eq!(to.as_slice(), &[1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0]);
pub fn limit_mut(&mut self, limit: usize) -> Interleaved<&mut [T]>
[src]
Limit the interleaved buffer and return a mutable wrapped buffer.
This is provided as a special operation for this buffer kind, because it can be done more efficiently than what is available through Buf::limit.
pub fn resize_channels(&mut self, channels: usize)
[src]
Resize to the given 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::Interleaved::<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)
[src]
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::Interleaved::<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); { let mut chan = buffer.get_mut(1).unwrap(); assert_eq!(chan.get(127), Some(0.0)); *chan.get_mut(127).unwrap() = 42.0; assert_eq!(chan.get(127), Some(42.0)); } buffer.resize(128); assert_eq!(buffer.frame(1, 127), Some(42.0)); buffer.resize(256); assert_eq!(buffer.frame(1, 127), Some(42.0)); buffer.resize_channels(2); assert_eq!(buffer.frame(1, 127), Some(42.0)); buffer.resize(64); assert_eq!(buffer.frame(1, 127), None);
pub fn get(&self, channel: usize) -> Option<Channel<'_, T>>
[src]
Get a reference to a channel.
Examples
let mut buffer = rotary::Interleaved::<f32>::with_topology(2, 4); for (c, s) in buffer.get_mut(0).unwrap().iter_mut().zip(&[1.0, 2.0, 3.0, 4.0]) { *c = *s; } for (c, s) in buffer.get_mut(1).unwrap().iter_mut().zip(&[5.0, 6.0, 7.0, 8.0]) { *c = *s; } assert_eq!(buffer.get(0).unwrap().iter().nth(2), Some(&3.0)); assert_eq!(buffer.get(1).unwrap().iter().nth(2), Some(&7.0));
pub fn frame(&self, channel: usize, frame: usize) -> Option<T>
[src]
Helper to access a single frame in a single channel.
Examples
let mut buffer = rotary::Interleaved::<f32>::with_topology(2, 256); assert_eq!(buffer.frame(1, 128), Some(0.0)); *buffer.frame_mut(1, 128).unwrap() = 1.0; assert_eq!(buffer.frame(1, 128), Some(1.0));
pub fn get_mut(&mut self, channel: usize) -> Option<ChannelMut<'_, T>>
[src]
Get a mutable reference to a channel.
Examples
let mut buffer = rotary::Interleaved::<f32>::with_topology(2, 4); for (c, s) in buffer.get_mut(0).unwrap().iter_mut().zip(&[1.0, 2.0, 3.0, 4.0]) { *c = *s; } for (c, s) in buffer.get_mut(1).unwrap().iter_mut().zip(&[5.0, 6.0, 7.0, 8.0]) { *c = *s; } assert_eq!(buffer.as_slice(), &[1.0, 5.0, 2.0, 6.0, 3.0, 7.0, 4.0, 8.0]);
pub fn frame_mut(&mut self, channel: usize, frame: usize) -> Option<&mut T>
[src]
Helper to access a single frame in a single channel mutably.
Examples
let mut buffer = rotary::Interleaved::<f32>::with_topology(2, 256); assert_eq!(buffer.frame(1, 128), Some(0.0)); *buffer.frame_mut(1, 128).unwrap() = 1.0; assert_eq!(buffer.frame(1, 128), Some(1.0));
pub fn iter(&self) -> Iter<'_, T>ⓘ
[src]
Construct an iterator over all available channels.
Examples
let mut buffer = rotary::Interleaved::<f32>::with_topology(2, 4); let mut it = buffer.iter_mut(); for (c, f) in it.next().unwrap().iter_mut().zip(&[1.0, 2.0, 3.0, 4.0]) { *c = *f; } for (c, f) in it.next().unwrap().iter_mut().zip(&[5.0, 6.0, 7.0, 8.0]) { *c = *f; } let channels = buffer.iter().collect::<Vec<_>>(); let left = channels[0].iter().copied().collect::<Vec<_>>(); let right = channels[1].iter().copied().collect::<Vec<_>>(); assert_eq!(left, &[1.0, 2.0, 3.0, 4.0]); assert_eq!(right, &[5.0, 6.0, 7.0, 8.0]);
pub fn iter_mut(&mut self) -> IterMut<'_, T>ⓘ
[src]
Construct a mutable iterator over all available channels.
Examples
let mut buffer = rotary::Interleaved::<f32>::with_topology(2, 4); let mut it = buffer.iter_mut(); for (c, f) in it.next().unwrap().iter_mut().zip(&[1.0, 2.0, 3.0, 4.0]) { *c = *f; } for (c, f) in it.next().unwrap().iter_mut().zip(&[5.0, 6.0, 7.0, 8.0]) { *c = *f; } assert_eq!(buffer.as_slice(), &[1.0, 5.0, 2.0, 6.0, 3.0, 7.0, 4.0, 8.0]);
Trait Implementations
impl<T> Buf<T> for Interleaved<T> where
T: Sample,
[src]
T: Sample,
fn frames(&self) -> usize
[src]
fn channels(&self) -> usize
[src]
fn channel(&self, channel: usize) -> BufChannel<'_, T>
[src]
fn offset(self, offset: usize) -> Offset<Self> where
Self: Sized,
[src]
Self: Sized,
fn limit(self, limit: usize) -> Limit<Self> where
Self: Sized,
[src]
Self: Sized,
impl<T> BufMut<T> for Interleaved<T> where
T: Sample,
[src]
T: Sample,
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]
impl<T> Debug for Interleaved<T> where
T: Sample + Debug,
[src]
T: Sample + Debug,
impl<T> Eq for Interleaved<T> where
T: Sample + Eq,
[src]
T: Sample + Eq,
impl<T> Hash for Interleaved<T> where
T: Sample + Hash,
[src]
T: Sample + 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<'a, T> IntoIterator for &'a Interleaved<T> where
T: Sample,
[src]
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
[src]
impl<'a, T> IntoIterator for &'a mut Interleaved<T> where
T: Sample,
[src]
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
[src]
impl<T> Ord for Interleaved<T> where
T: Sample + Ord,
[src]
T: Sample + 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<Interleaved<T>> for Interleaved<T> where
T: Sample + PartialEq,
[src]
T: Sample + PartialEq,
impl<T> PartialOrd<Interleaved<T>> for Interleaved<T> where
T: Sample + PartialOrd,
[src]
T: Sample + PartialOrd,
Auto Trait Implementations
impl<T> RefUnwindSafe for Interleaved<T> where
T: RefUnwindSafe,
T: RefUnwindSafe,
impl<T> Send for Interleaved<T> where
T: Send,
T: Send,
impl<T> Sync for Interleaved<T> where
T: Sync,
T: Sync,
impl<T> Unpin for Interleaved<T> where
T: Unpin,
T: Unpin,
impl<T> UnwindSafe for Interleaved<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>,