Struct rotary::ChannelMut

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

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

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

Construct a linear buffer.

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

Construct an interleaved buffer.

pub fn as_mut(&mut self) -> ChannelMut<'_, T>

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

pub fn frames(&self) -> usize

The number of frames in the buffer.

Examples

use rotary::BufMut;

fn test(buf: &dyn BufMut<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 chunks(&self, chunk: usize) -> usize

The number of chunks that can fit with the given size.

Examples

use rotary::BufMut;

fn test(buf: &dyn BufMut<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 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 iter_mut(self) -> IterMut<'a, T>

Construct a mutable 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 skip(self, n: usize) -> ChannelMut<'a, T>

Construct a channel buffer where the first n frames are skipped.

Examples

use rotary::{Buf as _, BufMut as _};

let mut buffer = rotary::Interleaved::with_topology(2, 4);

buffer.channel_mut(0).skip(2).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 tail(self, n: usize) -> ChannelMut<'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) -> ChannelMut<'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).limit(2).copy_from(from.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 chunk(self, n: usize, len: usize) -> ChannelMut<'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.

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).chunk(1, 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]);

Examples

use rotary::Buf;

fn test(buf: &dyn Buf<f32>) {
    let channel = buf.channel(0);

    let mut buf = vec![0.0; 4];
    channel.chunk(3, 4).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_from_slice(&mut self, buf: &[T]) where
    T: Copy, 

Copy from the given slice.

Examples

use rotary::BufMut;

fn test(buf: &mut dyn BufMut<f32>) {
    buf.channel_mut(0).copy_from_slice(&[1.0; 4][..]);

    let mut out = vec![0.0; 8];
    buf.channel(0).copy_into_slice(&mut out);

    assert_eq!(out, vec![1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0]);
}

test(&mut rotary::dynamic![[0.0; 8]; 2]);
test(&mut rotary::sequential![[0.0; 8]; 2]);
test(&mut rotary::interleaved![[0.0; 8]; 2]);

pub fn copy_from_iter<I>(&mut self, iter: I) where
    I: IntoIterator<Item = T>, 

Copy a chunked destination from an iterator.

Examples

use rotary::BufMut;

fn test(buf: &mut dyn BufMut<f32>) {
    buf.channel_mut(0).skip(2).copy_from_iter(vec![1.0; 4]);

    let mut out = vec![0.0; 8];
    buf.channel(0).copy_into_slice(&mut out);

    assert_eq!(out, vec![0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0]);
}

test(&mut rotary::dynamic![[0.0; 8]; 2]);
test(&mut rotary::sequential![[0.0; 8]; 2]);
test(&mut rotary::interleaved![[0.0; 8]; 2]);

use rotary::BufMut;

fn test(buf: &mut dyn BufMut<f32>) {
    buf.channel_mut(0).skip(2).chunk(0, 2).copy_from_iter(vec![1.0; 4]);

    let mut out = vec![0.0; 8];
    buf.channel(0).copy_into_slice(&mut out);

    assert_eq!(out, vec![0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0]);
}

test(&mut rotary::dynamic![[0.0; 8]; 2]);
test(&mut rotary::sequential![[0.0; 8]; 2]);
test(&mut rotary::interleaved![[0.0; 8]; 2]);

pub fn copy_from(&mut self, from: Channel<'_, T>) where
    T: Copy, 

Copy this channel from another.

Examples

use rotary::{Buf as _, BufMut as _};

let from = rotary::dynamic![[1.0f32; 4]; 2];
let mut to = rotary::interleaved![[0.0f32; 4]; 3];

to.channel_mut(0).copy_from(from.channel(1));
assert_eq!(to.as_slice(), &[1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0]);

pub fn translate_from<U>(&mut self, from: Channel<'_, U>) where
    T: Translate<U>,
    U: Copy, 

Translate this channel from another.

This will translate each sample in the channel through the appropriate Translate implementation.

This is used for converting a buffer containing one type of sample into another.

Examples

use rotary::{Buf as _, BufMut as _};

let from = rotary::dynamic![[u16::MAX; 4]; 2];
let mut to = rotary::interleaved![[0.0f32; 4]; 3];

to.channel_mut(0).translate_from(from.channel(1));
assert_eq!(to.as_slice(), &[1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0]);

Trait Implementations

impl<'a, T> Debug for ChannelMut<'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 ChannelMut<'_, T>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<'_, T> IndexMut<usize> for ChannelMut<'_, T>

Get a mutable reference to the frame at the given index.

Panics

Panics if the given frame is out of bounds for this channel.

See frames.

Examples

use rotary::BufMut;

fn test(buf: &mut dyn BufMut<f32>) {
    buf.channel_mut(0)[1] = 1.0;
    buf.channel_mut(0)[7] = 1.0;

    let mut out = vec![0.0; 8];
    buf.channel(0).copy_into_slice(&mut out);

    assert_eq!(out, vec![0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0]);
}

test(&mut rotary::dynamic![[0.0; 8]; 2]);
test(&mut rotary::sequential![[0.0; 8]; 2]);
test(&mut rotary::interleaved![[0.0; 8]; 2]);

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

Performs the mutable indexing (container[index]) operation.

impl<'a, T> IntoIterator for ChannelMut<'a, T>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

pub fn into_iter(self) -> <ChannelMut<'a, T> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, '_, T> IntoIterator for &'a mut ChannelMut<'_, T>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

pub fn into_iter(self) -> <&'a mut ChannelMut<'_, T> as IntoIterator>::IntoIter

Creates an iterator from a value.