Trait rotary::AsInterleavedMut[−][src]

pub trait AsInterleavedMut<T> {
    pub fn as_interleaved_mut(&mut self) -> &mut [T];

    pub fn as_interleaved_mut_ptr(&mut self) -> *mut T { ... }
}

A trait describing a buffer that is interleaved and mutable.

This allows for accessing the raw underlying interleaved buffer.

Required methods

`pub fn as_interleaved_mut(&mut self) -> &mut [T]`[src]

Access the underlying interleaved mutable buffer.

Examples

use rotary::{Channels, AsInterleaved, AsInterleavedMut};
use rotary::wrap;

fn test<B>(mut buffer: B) where B: Channels<i16> + AsInterleavedMut<i16> {
    buffer.as_interleaved_mut().copy_from_slice(&[1, 1, 2, 2, 3, 3, 4, 4]);

    assert_eq! {
        buffer.channel(0).iter().collect::<Vec<_>>(),
        &[1, 2, 3, 4],
    };

    assert_eq! {
        buffer.channel(1).iter().collect::<Vec<_>>(),
        &[1, 2, 3, 4],
    };

    assert_eq!(buffer.as_interleaved(), &[1, 1, 2, 2, 3, 3, 4, 4]);
}

test(rotary::interleaved![[0; 4]; 2]);
let mut buf = [0; 8];
test(wrap::interleaved(&mut buf, 2));

Loading content...

Provided methods

`pub fn as_interleaved_mut_ptr(&mut self) -> *mut T`[src]

Access a pointer to the underlying interleaved mutable buffer.

The length of the buffer is unspecified, unless preceded by a call to reserve_frames. Assuming the call doesn’t panic, the pointed to buffer is guaranteed to be both allocated and initialized up until the number of frames as specified as argument to reserve_frames.

Examples

use rotary::{AsInterleavedMut, InterleavedBuf, Channels};

fn test<B>(mut buffer: B) where B: InterleavedBuf + AsInterleavedMut<i16> {
    buffer.reserve_frames(16);
    // Note: call fills the buffer with ones.
    // Safety: We've initialized exactly 16 frames before calling this
    // function.
    let (channels, frames) = unsafe { fill_with_ones(buffer.as_interleaved_mut_ptr(), 16) };
    buffer.set_topology(channels, frames);
}

let mut buf = rotary::Interleaved::new();
test(&mut buf);

assert_eq! {
    buf.channel(0).iter().collect::<Vec<_>>(),
    &[1, 1, 1, 1, 1, 1, 1, 1],
};
assert_eq! {
    buf.channel(1).iter().collect::<Vec<_>>(),
    &[1, 1, 1, 1, 1, 1, 1, 1],
};