Trait rotary::WriteBuf [−][src]
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);
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);
Implementations on Foreign Types
impl<'_, B> WriteBuf for &'_ mut B where
B: WriteBuf,
[src]
B: WriteBuf,
pub fn has_remaining_mut(&self) -> bool
[src]
pub fn remaining_mut(&self) -> usize
[src]
pub fn advance_mut(&mut self, n: usize)
[src]
Implementors
impl<B> WriteBuf for ReadWrite<B> where
B: ExactSizeBuf,
[src]
B: ExactSizeBuf,
fn remaining_mut(&self) -> usize
[src]
fn advance_mut(&mut self, n: usize)
[src]
impl<B> WriteBuf for Write<B>
[src]
fn remaining_mut(&self) -> usize
[src]
Remaining number of frames available.