Struct rsynth::buffer::AudioBufferIn

pub struct AudioBufferIn<'channels, 'samples, S> where
    S: 'static + Copy,  { /* fields omitted */ }

Audio input buffer.

It is guaranteed that all channels have the same number of frames.

Implementations

impl<'channels, 'samples, S> AudioBufferIn<'channels, 'samples, S> where
    S: 'static + Copy, 

pub fn new(channels: &'channels [&'samples [S]], length: usize) -> Self

Create a new audio input buffer.

Panics

Panics if one of the elements of channels does not have the given length.

pub fn number_of_channels(&self) -> usize

Get the number of channels.

pub fn number_of_frames(&self) -> usize

Get the number of frames.

pub fn channels(&self) -> &'channels [&'samples [S]]

Get the channels as slices.

pub fn index_frames<'s, 'v, R>(
    &'s self,
    range: R,
    vec: &'v mut Vec<&'s [S]>
) -> AudioBufferIn<'v, 's, S> where
    R: SliceIndex<[S], Output = [S]> + RangeBounds<usize> + Clone, 

Get an AudioBufferIn with all channels and the given range of frames.

The vector vec will be used to store the channels of the result.

Remark

The vector vec will be cleared before use in order to guarantee that all channels have the same length.

Usage in a real-time thread

This method will append number_of_channels elements to the given vector. This will cause memory to be allocated if this exceeds the capacity of the given vector.

Suggestion

You can use the vecstorage crate to re-use the memory of a vector for different lifetimes.

Remark

If you enable the rsor-0-1 Cargo feature, you can also use the index_frames_from_slice method.

Example

use rsynth::buffer::AudioBufferIn;
let mut vec = Vec::with_capacity(2);
let channel1 = vec![11, 12, 13, 14];
let channel2 = vec![21, 22, 23, 24];
let chunk = [channel1.as_slice(), channel2.as_slice()];
let chunk = AudioBufferIn::new(&chunk, 4);
let parts = chunk.index_frames(1..2, &mut vec);
assert_eq!(parts.number_of_frames(), 1);
assert_eq!(parts.number_of_channels(), 2);
let channels = parts.channels();
assert_eq!(channels[0], &[12]);
assert_eq!(channels[1], &[22]);

pub fn index_frames_from_slice<'s, 'v, R>(
    &'s self,
    range: R,
    slice: &'v mut Slice<[S]>
) -> AudioBufferIn<'v, 's, S> where
    R: SliceIndex<[S], Output = [S]> + RangeBounds<usize> + Clone, 

Get an AudioBufferIn with all channels and the given range of frames.

The Slice will be used to store the channels of the result.

Usage in a real-time thread

This method will append number_of_channels elements to the given Slice. This will cause memory to be allocated if this exceeds the capacity of the given Slice.

Example

use rsynth::rsor::Slice;
use rsynth::buffer::AudioBufferIn;
let mut slice = Slice::with_capacity(2);
let channel1 = vec![11, 12, 13, 14];
let channel2 = vec![21, 22, 23, 24];
let chunk = [channel1.as_slice(), channel2.as_slice()];
let chunk = AudioBufferIn::new(&chunk, 4);
let parts = chunk.index_frames_from_slice(1..2, &mut slice);
assert_eq!(parts.number_of_frames(), 1);
assert_eq!(parts.number_of_channels(), 2);
let channels = parts.channels();
assert_eq!(channels[0], &[12]);
assert_eq!(channels[1], &[22]);

pub fn get_channel(&self, index: usize) -> Option<&[S]>

Get the channel with the given index.

Return None when the index is out of bounds.

pub fn index_channel(&self, index: usize) -> &[S]

Get the channel with the given index.

Panics

Panics if the index is out of bounds.

Trait Implementations

impl<'channels, 'samples, S: Clone> Clone for AudioBufferIn<'channels, 'samples, S> where
    S: 'static + Copy, 

fn clone(&self) -> AudioBufferIn<'channels, 'samples, S>

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'channels, 'samples, S: Copy> Copy for AudioBufferIn<'channels, 'samples, S> where
    S: 'static + Copy, 

impl<'channels, 'samples, S: Debug> Debug for AudioBufferIn<'channels, 'samples, S> where
    S: 'static + Copy, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.