Trait rotary::WriteBuf[][src]

pub trait WriteBuf {
    pub fn remaining_mut(&self) -> usize;
pub fn advance_mut(&mut self, n: usize); pub fn has_remaining_mut(&self) -> bool { ... } }

Trait used to govern sequential writing to an audio buffer.

This is the “out” part of “buffered I/O”. It allows for buffers to govern which slice of frames in them has been read so that operations can be performed in multiple stages.

This can be accomplished manually using available buffer combinators such as Buf::tail. But buffered I/O allows us to do this in a much more structured fashion.

Examples

use rotary::WriteBuf as _;
use rotary::{io, wrap};

// A simple buffer we want to read from to. Fits 2 channels with 64
// frames each.
let mut from = [0i16; 128];

// A buffer we want to write to. 2 channels with 512 frames each.
let to = rotary::interleaved![[0i16; 512]; 2];
let mut to = io::Write::new(to);

let mut steps = 0;

while to.has_remaining_mut() {
    // Fill the buffer with something interesting.
    recv_data(&mut from[..]);

    // Wrap the filled buffer according to format so it can be written to
    // correctly.
    io::copy_remaining(wrap::interleaved(&mut from[..], 2), &mut to);

    steps += 1;
}

// We needed to write 8 times to fill our entire buffer.
assert_eq!(steps, 8);

Required methods

pub fn remaining_mut(&self) -> usize[src]

Remaining number of frames that can be written.

Examples

use rotary::WriteBuf as _;

let mut buffer = [0, 1, 2, 3, 4, 5, 6, 7];
let buffer = rotary::wrap::interleaved(&mut buffer[..], 2);

assert_eq!(buffer.remaining_mut(), 4);

pub fn advance_mut(&mut self, n: usize)[src]

Advance the number of frames that have been written.

Examples

use rotary::WriteBuf as _;

let mut buffer = [0, 1, 2, 3, 4, 5, 6, 7];
let mut buffer = rotary::wrap::interleaved(&mut buffer[..], 2);

assert_eq!(buffer.remaining_mut(), 4);
buffer.advance_mut(2);
assert_eq!(buffer.remaining_mut(), 2);
Loading content...

Provided methods

pub fn has_remaining_mut(&self) -> bool[src]

Test if this buffer has remaining mutable frames that can be written.

Examples

use rotary::WriteBuf as _;

let mut buffer = [0, 1, 2, 3, 4, 5, 6, 7];
let mut buffer = rotary::wrap::interleaved(&mut buffer[..], 2);

assert!(buffer.has_remaining_mut());
assert_eq!(buffer.remaining_mut(), 4);
buffer.advance_mut(4);
assert_eq!(buffer.remaining_mut(), 0);
Loading content...

Implementations on Foreign Types

impl<'_, B> WriteBuf for &'_ mut B where
    B: WriteBuf
[src]

Loading content...

Implementors

impl<B> WriteBuf for ReadWrite<B> where
    B: ExactSizeBuf
[src]

impl<B> WriteBuf for Write<B>[src]

fn remaining_mut(&self) -> usize[src]

Remaining number of frames available.

impl<T> WriteBuf for Interleaved<&mut [T]>[src]

Loading content...