Struct rotary::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>
[src]
pub fn linear(buf: &'a [T]) -> Channel<'a, T>
[src]
Construct a linear channel buffer.
The buffer provided as-is constitutes the frames of the channel.
Examples
use rotary::Channel; let buf = &mut [1, 3, 5, 7]; let channel = Channel::linear(buf); assert_eq!(channel[1], 3); assert_eq!(channel[2], 5);
pub fn interleaved(
buf: &'a [T],
channels: usize,
channel: usize
) -> Channel<'a, T>
[src]
buf: &'a [T],
channels: usize,
channel: usize
) -> Channel<'a, T>
Construct an interleaved channel buffer.
The provided buffer must be the complete buffer, which includes all
other channels. The provided channels
argument is the total number of
channels in this buffer, and channel
indicates which specific channel
this buffer belongs to.
Note that this is typically not used directly, but instead through an abstraction which makes sure to provide the correct parameters.
Examples
use rotary::Channel; let buf = &[1, 2, 3, 4, 5, 6, 7, 8]; let channel = Channel::interleaved(buf, 2, 1); assert_eq!(channel[1], 4); assert_eq!(channel[2], 6);
pub fn frames(&self) -> usize
[src]
Access the number of frames on the current channel.
Examples
use rotary::Channels; fn test(buf: &dyn Channels<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<'a, T>
[src]
Construct an iterator over the channel.
Examples
use rotary::{Channels as _, ChannelsMut 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 Channel reference with a lifetime associated with the current channel instance instead of the underlying buffer.
Most of the time it is not necessary to use this, since Channel implements Copy and its lifetime would coerce to any compatible lifetime. This method is currently just here for completeness sake.
Both of these work equally well:
use rotary::Channel; struct Foo<'a> { channel: Channel<'a, i16>, } impl<'a> Foo<'a> { fn channel(&self) -> Channel<'_, i16> { self.channel.as_ref() } fn coerced_channel(&self) -> Channel<'_, i16> { self.channel } }
pub fn skip(self, n: usize) -> Channel<'a, T>
[src]
Construct a channel buffer where the first n
frames are skipped.
Examples
use rotary::{Channels as _, ChannelsMut 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 tail(self, n: usize) -> Channel<'a, T>
[src]
Construct a channel buffer where the last n
frames are included.
Examples
use rotary::{Channels as _, ChannelsMut as _}; let from = rotary::interleaved![[1.0f32; 4]; 2]; let mut to = rotary::interleaved![[0.0f32; 4]; 2]; to.channel_mut(0).as_mut().tail(2).copy_from(from.channel(0)); assert_eq!(to.as_slice(), &[0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0]);
pub fn limit(self, limit: usize) -> Channel<'a, T>
[src]
Limit the channel bufferto limit
number of frames.
Examples
use rotary::{Channels as _, ChannelsMut 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) -> Channel<'a, T>
[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::Channels; fn test(buf: &dyn Channels<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::Channels; fn test(buf: &dyn Channels<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::Channels; fn test(buf: &dyn Channels<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]);
Trait Implementations
impl<'_, T> Clone for Channel<'_, T>
[src]
impl<'_, T> Copy for Channel<'_, T>
[src]
impl<'_, T> Debug for Channel<'_, T> where
T: Copy + Debug,
[src]
T: Copy + Debug,
impl<'_, T> Eq for Channel<'_, T> where
T: Copy + Eq,
[src]
T: Copy + Eq,
impl<'_, T> Hash for Channel<'_, T> where
T: Copy + Hash,
[src]
T: Copy + Hash,
pub fn hash<H>(&self, state: &mut H) where
H: Hasher,
[src]
H: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<'_, T> Index<usize> for Channel<'_, T>
[src]
type Output = T
The returned type after indexing.
pub fn index(&self, index: usize) -> &<Channel<'_, T> as Index<usize>>::Output
[src]
impl<'a, T> IntoIterator for Channel<'a, T> where
T: Copy,
[src]
T: Copy,
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?
pub fn into_iter(self) -> <Channel<'a, T> as IntoIterator>::IntoIter
[src]
impl<'a, '_, T> IntoIterator for &'a Channel<'_, T> where
T: Copy,
[src]
T: Copy,
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?
pub fn into_iter(self) -> <&'a Channel<'_, T> as IntoIterator>::IntoIter
[src]
impl<'_, T> Ord for Channel<'_, T> where
T: Copy + Ord,
[src]
T: Copy + Ord,
pub fn cmp(&self, other: &Channel<'_, T>) -> 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<Channel<'_, T>> for Channel<'_, T> where
T: Copy + PartialEq<T>,
[src]
T: Copy + PartialEq<T>,
pub fn eq(&self, other: &Channel<'_, T>) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'_, T> PartialOrd<Channel<'_, T>> for Channel<'_, T> where
T: Copy + PartialOrd<T>,
[src]
T: Copy + PartialOrd<T>,
pub fn partial_cmp(&self, other: &Channel<'_, T>) -> 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]
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>,