Struct rotary::Channel

pub struct Channel<'a, T> { /* fields omitted */ }

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>

pub fn linear(buf: &'a [T]) -> Channel<'a, T>

Construct a linear buffer.

pub fn interleaved(
    buf: &'a [T],
    channels: usize,
    channel: usize
) -> Channel<'a, T>

Construct an interleaved buffer.

pub fn frames(&self) -> usize

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<'a, T>

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>

Construct a new mutable channel that has a lifetime of the current instance.

pub fn skip(self, n: usize) -> Channel<'a, T>

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 tail(self, n: usize) -> Channel<'a, T>

Construct a channel buffer where the last n frames are included.

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).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>

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) -> Channel<'a, T>

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

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, 

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
    T: 'out + Copy,
    I: IntoIterator<Item = &'out mut T>, 

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]);

Trait Implementations

impl<'a, T> Clone for Channel<'a, T> where
    T: Clone, 

pub fn clone(&self) -> Channel<'a, T>

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a, T> Copy for Channel<'a, T> where
    T: Copy, 

impl<'a, T> Debug for Channel<'a, T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'_, T> Index<usize> for Channel<'_, T>

type Output = T

The returned type after indexing.

pub fn index(&self, index: usize) -> &<Channel<'_, T> as Index<usize>>::Output

Performs the indexing (container[index]) operation.

impl<'a, '_, T> IntoIterator for &'a Channel<'_, T> where
    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

Creates an iterator from a value.

impl<'a, T> IntoIterator for Channel<'a, T> where
    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

Creates an iterator from a value.