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 one channel from another.

See [utils::copy][crate::utils::copy] if you want to copy an entire buffer into 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 one channel from another.

This will copy the channel while translating each sample according to its Translate implementation.

This is used for converting one type of sample to another.

See [utils::translate][crate::utils::translate] if you want to translate an entire buffer.

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.