Struct symphonia_core::audio::AudioBuffer

pub struct AudioBuffer<S: Sample> { /* fields omitted */ }

AudioBuffer is a container for multi-channel planar audio sample data. An AudioBuffer is characterized by the duration (capacity), and audio specification (channels and sample rate). The capacity of an AudioBuffer is the maximum number of samples the buffer may store per channel. Manipulation of samples is accomplished through the Signal trait or direct buffer manipulation.

Implementations

impl<S: Sample> AudioBuffer<S>

pub fn new(duration: Duration, spec: SignalSpec) -> Self

Instantiate a new AudioBuffer using the specified signal specification and of the given duration.

pub fn unused() -> Self

Instantiates an unused AudioBuffer. An unused AudioBuffer will not allocate any memory, has a sample rate of 0, and no audio channels.

pub fn is_unused(&self) -> bool

Returns true if the AudioBuffer is unused.

pub fn spec(&self) -> &SignalSpec

Gets the signal specification for the buffer.

pub fn capacity(&self) -> usize

Gets the total capacity of the buffer. The capacity is the maximum number of frames a buffer can store.

pub fn planes(&self) -> AudioPlanes<'_, S>

Gets immutable references to all audio planes (channels) within the audio buffer.

Note: This is not a cheap operation. It is advisable that this call is only used when operating on batches of frames. Generally speaking, it is almost always better to use chan() to selectively choose the plane to read.

pub fn planes_mut(&mut self) -> AudioPlanesMut<'_, S>

Gets mutable references to all audio planes (channels) within the buffer.

Note: This is not a cheap operation. It is advisable that this call is only used when mutating batches of frames. Generally speaking, it is almost always better to use render(), fill(), chan_mut(), and chan_pair_mut() to mutate the buffer.

pub fn convert<T: Sample>(&self, dest: &mut AudioBuffer<T>) where
    S: IntoSample<T>, 

Converts the contents of an AudioBuffer into an equivalent destination AudioBuffer of a different type. If the types are the same then this is a copy operation.

pub fn make_equivalent<E: Sample>(&self) -> AudioBuffer<E>

Makes an equivalent AudioBuffer of a different type.

Trait Implementations

impl AsAudioBufferRef for AudioBuffer<f32>

fn as_audio_buffer_ref(&self) -> AudioBufferRef<'_>

impl AsAudioBufferRef for AudioBuffer<i32>

fn as_audio_buffer_ref(&self) -> AudioBufferRef<'_>

impl<S: Clone + Sample> Clone for AudioBuffer<S>

fn clone(&self) -> AudioBuffer<S>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S: Sample> Signal<S> for AudioBuffer<S>

fn clear(&mut self)

Clears all written frames from the buffer. This is a cheap operation and does not zero the underlying audio data.

fn frames(&self) -> usize

Gets the number of actual frames written to the buffer. Conversely, this also is the number of written samples in any one channel.

fn chan(&self, channel: usize) -> &[S]

Gets an immutable reference to all the written samples in the specified channel.

fn chan_mut(&mut self, channel: usize) -> &mut [S]

Gets a mutable reference to all the written samples in the specified channel.

fn chan_pair_mut(&mut self, first: usize, second: usize) -> (&mut [S], &mut [S])

Gets two mutable references to two different channels.

fn render_reserved(&mut self, n_frames: Option<usize>)

Renders a reserved number of frames. This is a cheap operation and simply advances the frame counter. The underlying audio data is not modified and should be overwritten through other means.

fn render<'a, F>(&'a mut self, n_frames: Option<usize>, render: F) -> Result<()> where
    F: FnMut(&mut AudioPlanesMut<'a, S>, usize) -> Result<()>, 

Renders a number of frames using the provided render function. The number of frames to render is specified by n_frames. If n_frames is None, the remaining number of frames in the buffer will be rendered. If the render function returns an error, the render operation is terminated prematurely.

fn transform<F>(&mut self, f: F) where
    F: Fn(S) -> S, 

Transforms every written sample in the signal using the transformation function provided. This function does not guarantee an order in which the samples are transformed.

fn fill<'a, F>(&'a mut self, fill: F) -> Result<()> where
    F: FnMut(&mut AudioPlanesMut<'a, S>, usize) -> Result<()>, 

Clears, and then renders the entire buffer using the fill function. This is a convenience wrapper around render and exhibits the same behaviour as render in regards to the fill function.