Struct rotary::channel::Channel [−][src]
The buffer of a single channel.
This doesn’t provide direct access to the underlying buffer, but rather allows us to copy data usinga number of utility functions.
Implementations
impl<'a, T> Channel<'a, T> where
T: Sample,
[src]
T: Sample,
pub fn linear(buf: &'a [T]) -> Self
[src]
Construct a linear buffer.
pub fn interleaved(buf: &'a [T], channels: usize, channel: usize) -> Self
[src]
Construct an interleaved buffer.
pub fn frames(&self) -> usize
[src]
Access the number of frames on the current channel.
Examples
use rotary::Buf; fn test(buf: &dyn Buf<f32>) { let left = buf.channel(0); let right = buf.channel(1); assert_eq!(left.frames(), 16); assert_eq!(right.frames(), 16); } test(&rotary::dynamic![[0.0; 16]; 2]); test(&rotary::sequential![[0.0; 16]; 2]); test(&rotary::interleaved![[0.0; 16]; 2]);
pub fn iter(&self) -> Iter<'_, T>ⓘ
[src]
Construct an iterator over the channel.
Examples
use rotary::{Buf as _, BufMut as _}; let mut left = rotary::interleaved![[0.0f32; 4]; 2]; let mut right = rotary::dynamic![[0.0f32; 4]; 2]; for (l, r) in left.channel_mut(0).iter_mut().zip(right.channel_mut(0)) { *l = 1.0; *r = 1.0; } assert!(left.channel(0).iter().eq(right.channel(0).iter())); assert_eq!(left.as_slice(), &[1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0]); assert_eq!(&right[0], &[1.0, 1.0, 1.0, 1.0]); assert_eq!(&right[1], &[0.0, 0.0, 0.0, 0.0]);
pub fn as_ref(&self) -> Channel<'_, T>
[src]
Construct a new mutable channel that has a lifetime of the current instance.
pub fn skip(self, n: usize) -> Self
[src]
Construct a channel buffer where the first n
frames are skipped.
Examples
use rotary::{Buf as _, BufMut as _}; let mut from = rotary::interleaved![[0.0f32; 4]; 2]; *from.frame_mut(0, 2).unwrap() = 1.0; *from.frame_mut(0, 3).unwrap() = 1.0; let mut to = rotary::interleaved![[0.0f32; 4]; 2]; to.channel_mut(0).copy_from(from.channel(0).skip(2)); assert_eq!(to.as_slice(), &[1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0]);
pub fn limit(self, limit: usize) -> Self
[src]
Limit the channel bufferto limit
number of frames.
Examples
use rotary::{Buf as _, BufMut as _}; let from = rotary::interleaved![[1.0f32; 4]; 2]; let mut to = rotary::interleaved![[0.0f32; 4]; 2]; to.channel_mut(0).copy_from(from.channel(0).limit(2)); assert_eq!(to.as_slice(), &[1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0]);
pub fn chunk(self, n: usize, len: usize) -> Self
[src]
Construct a range of frames corresponds to the chunk with len
and
position n
.
Which is the range n * len .. n * len + len
.
pub fn chunks(&self, chunk: usize) -> usize
[src]
How many chunks of the given size can you divide buf into.
This includes one extra chunk even if the chunk doesn’t divide the frame length evenly.
Examples
use rotary::Buf; fn test(buf: &dyn Buf<f32>) { let left = buf.channel(0); let right = buf.channel(1); assert_eq!(left.chunks(4), 4); assert_eq!(right.chunks(4), 4); assert_eq!(left.chunks(6), 3); assert_eq!(right.chunks(6), 3); } test(&rotary::dynamic![[0.0; 16]; 2]); test(&rotary::sequential![[0.0; 16]; 2]); test(&rotary::interleaved![[0.0; 16]; 2]);
pub fn copy_into_slice(&self, out: &mut [T]) where
T: Copy,
[src]
T: Copy,
Copy into the given slice of output.
Examples
use rotary::Buf; fn test(buf: &dyn Buf<f32>) { let channel = buf.channel(0); let mut buf = vec![0.0; 16]; channel.copy_into_slice(&mut buf[..]); assert!(buf.iter().all(|f| *f == 1.0)); } test(&rotary::dynamic![[1.0; 16]; 2]); test(&rotary::sequential![[1.0; 16]; 2]); test(&rotary::interleaved![[1.0; 16]; 2]);
pub fn copy_into_iter<'out, I>(&self, iter: I) where
I: IntoIterator<Item = &'out mut T>,
T: 'out + Copy,
[src]
I: IntoIterator<Item = &'out mut T>,
T: 'out + Copy,
Copy into the given iterator.
Examples
use rotary::Buf; fn test(buf: &dyn Buf<f32>) { let channel = buf.channel(0); let mut buf = vec![0.0; 16]; // Copy into every other position in `buf`. channel.copy_into_iter(buf.iter_mut().step_by(2)); for (n, f) in buf.into_iter().enumerate() { if n % 2 == 0 { assert_eq!(f, 1.0); } else { assert_eq!(f, 0.0); } } } test(&rotary::dynamic![[1.0; 16]; 2]); test(&rotary::sequential![[1.0; 16]; 2]); test(&rotary::interleaved![[1.0; 16]; 2]);
pub fn map_into_slice<M>(&self, out: &mut [T], m: M) where
M: Fn(usize) -> usize,
T: Copy,
[src]
M: Fn(usize) -> usize,
T: Copy,
Copy into the given slice, mapping the index by the given mapping function.
Examples
use rotary::Buf; fn test(buf: &dyn Buf<f32>) { let channel = buf.channel(0); let mut buf = vec![0.0; channel.frames() * 2]; // Copy into every other position in `buf`. channel.map_into_slice(&mut buf[..], |n| n * 2); for (n, f) in buf.into_iter().enumerate() { if n % 2 == 0 { assert_eq!(f, 1.0); } else { assert_eq!(f, 0.0); } } } test(&rotary::dynamic![[1.0; 16]; 2]); test(&rotary::sequential![[1.0; 16]; 2]); test(&rotary::interleaved![[1.0; 16]; 2]);
Trait Implementations
impl<'a, T: Clone> Clone for Channel<'a, T> where
T: Sample,
[src]
T: Sample,
impl<'a, T: Copy> Copy for Channel<'a, T> where
T: Sample,
[src]
T: Sample,
impl<'a, T: Debug> Debug for Channel<'a, T> where
T: Sample,
[src]
T: Sample,
impl<'a, T> IntoIterator for Channel<'a, T> where
T: Sample,
[src]
T: Sample,
type Item = T
The type of the elements being iterated over.
type IntoIter = Iter<'a, T>
Which kind of iterator are we turning this into?
fn into_iter(self) -> Self::IntoIter
[src]
impl<'a, T> IntoIterator for &'a Channel<'_, T> where
T: Sample,
[src]
T: Sample,
Auto Trait Implementations
impl<'a, T> RefUnwindSafe for Channel<'a, T> where
T: RefUnwindSafe,
T: RefUnwindSafe,
impl<'a, T> Send for Channel<'a, T> where
T: Sync,
T: Sync,
impl<'a, T> Sync for Channel<'a, T> where
T: Sync,
T: Sync,
impl<'a, T> Unpin for Channel<'a, T>
impl<'a, T> UnwindSafe for Channel<'a, T> where
T: RefUnwindSafe,
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> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn clone_into(&self, target: &mut T)
[src]
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>,