Struct Sequential 

pub struct Sequential<S: Sample> { /* private fields */ }

A sequential audio block that owns its data.

• Layout: [ch0, ch0, ch0, ch1, ch1, ch1]
• Interpretation: All samples from ch0 are stored first, followed by all from ch1, etc.
• Terminology: Described as “channels first” in the sense that all data for one channel appears before any data for the next.
• Usage: Used in DSP pipelines where per-channel processing is easier and more efficient.

Example

use audio_blocks::*;

let block = Sequential::new(2, 3);
let mut block = Sequential::from_block(&block);

block.channel_mut(0).fill(0.0);
block.channel_mut(1).fill(1.0);

assert_eq!(block.channel(0), &[0.0, 0.0, 0.0]);
assert_eq!(block.channel(1), &[1.0, 1.0, 1.0]);

Implementations

impl<S: Sample + Default> Sequential<S>

pub fn new(num_channels: u16, num_frames: usize) -> Self

Creates a new audio block with the specified dimensions.

Allocates memory with exactly the specified number of channels and frames. The block is initialized with zeros.

Do not use in real-time processes!

Arguments

• num_channels - The number of audio channels
• num_frames - The number of frames per channel

Panics

Panics if the multiplication of num_channels and num_frames would overflow a usize.

impl<S: Sample> Sequential<S>

pub fn from_slice(data: &[S], num_channels: u16) -> Self

Creates a new sequential audio block by copying the data from a slice of sequential audio data.

Parameters

• data - The slice containing sequential audio samples
• num_channels - Number of audio channels in the data

Panics

Panics if the length of data is not evenly divisible by num_channels.

pub fn from_slice_limited( data: &[S], num_channels_visible: u16, num_frames_visible: usize, num_channels_allocated: u16, num_frames_allocated: usize, ) -> Self

Creates a new sequential audio block by copying the data from a slice of sequential audio data with limited visibility.

This function allows creating a block that exposes only a subset of the allocated channels and frames, which is useful for working with a logical section of a larger buffer.

Parameters

• data - The slice containing sequential audio samples
• num_channels_visible - Number of audio channels to expose
• num_frames_visible - Number of audio frames to expose
• num_channels_allocated - Total number of channels allocated in the data buffer
• num_frames_allocated - Total number of frames allocated in the data buffer

Panics

• Panics if the length of data doesn’t equal num_channels_allocated * num_frames_allocated
• Panics if num_channels_visible exceeds num_channels_allocated
• Panics if num_frames_visible exceeds num_frames_allocated

pub fn from_block(block: &impl AudioBlock<S>) -> Self

Creates a new audio block by copying data from another AudioBlock.

Converts any AudioBlock implementation to a sequential format by iterating through each channel of the source block and copying its samples. The new block will have the same dimensions as the source block.

Warning

This function allocates memory and should not be used in real-time audio processing contexts.

Arguments

• block - The source audio block to copy data from

pub fn channel(&self, channel: u16) -> &[S]

Returns a slice for a single channel.

Panics

Panics if channel index is out of bounds.

pub fn channel_mut(&mut self, channel: u16) -> &mut [S]

Returns a mutable slice for a single channel.

Panics

Panics if channel index is out of bounds.

pub fn channels(&self) -> impl ExactSizeIterator<Item = &[S]>

Returns an iterator over all channels in the block.

Each channel is represented as a slice of samples.

pub fn channels_mut(&mut self) -> impl ExactSizeIterator<Item = &mut [S]>

Returns a mutable iterator over all channels in the block.

Each channel is represented as a mutable slice of samples.

pub fn raw_data(&self) -> &[S]

Provides direct access to the underlying memory as a sequential slice.

This function gives access to all allocated data, including any reserved capacity beyond the visible range.

pub fn raw_data_mut(&mut self) -> &mut [S]

Provides direct mutable access to the underlying memory as a sequential slice.

This function gives mutable access to all allocated data, including any reserved capacity beyond the visible range.

pub fn view(&self) -> SequentialView<'_, S>

pub fn view_mut(&mut self) -> SequentialViewMut<'_, S>

Trait Implementations

impl<S: Sample> AudioBlock<S> for Sequential<S>

type PlanarView = [S; 0]

fn num_channels(&self) -> u16

Returns the number of active audio channels.

fn num_frames(&self) -> usize

Returns the number of audio frames (samples per channel).

fn num_channels_allocated(&self) -> u16

Returns the total number of channels allocated in memory.

fn num_frames_allocated(&self) -> usize

Returns the total number of frames allocated in memory.

fn layout(&self) -> BlockLayout

Returns the memory layout of this audio block (interleaved, sequential, or planar).

fn sample(&self, channel: u16, frame: usize) -> S

Returns the sample value at the specified channel and frame position.

fn channel_iter(&self, channel: u16) -> impl ExactSizeIterator<Item = &S>

Returns an iterator over all samples in the specified channel.

fn channels_iter( &self, ) -> impl ExactSizeIterator<Item = impl ExactSizeIterator<Item = &S>>

Returns an iterator that yields an iterator for each channel.

fn frame_iter(&self, frame: usize) -> impl ExactSizeIterator<Item = &S>

Returns an iterator over all samples in the specified frame (across all channels).

fn frames_iter( &self, ) -> impl ExactSizeIterator<Item = impl ExactSizeIterator<Item = &S>>

Returns an iterator that yields an iterator for each frame.

fn as_view(&self) -> impl AudioBlock<S>

Creates a non-owning view of this audio block.

fn as_sequential_view(&self) -> Option<SequentialView<'_, S>>

Attempts to downcast this generic audio block to a concrete sequential view. This enables access to frame slices and the underlying raw data.

fn as_interleaved_view(&self) -> Option<InterleavedView<'_, S>>

Attempts to downcast this generic audio block to a concrete interleaved view. This enables access to frame slices and the underlying raw data.

fn as_planar_view(&self) -> Option<PlanarView<'_, S, Self::PlanarView>>

Attempts to downcast this generic audio block to a concrete planar view. This enables access to frame slices and the underlying raw data.

impl<S: Sample> AudioBlockMut<S> for Sequential<S>

type PlanarViewMut = [S; 0]

fn set_num_channels_visible(&mut self, num_channels: u16)

Sets the visible size of the audio block to the specified number of channels.

fn set_num_frames_visible(&mut self, num_frames: usize)

Sets the visible size of the audio block to the specified number of frames.

fn sample_mut(&mut self, channel: u16, frame: usize) -> &mut S

Returns a mutable reference to the sample at the specified channel and frame position.

fn channel_iter_mut( &mut self, channel: u16, ) -> impl ExactSizeIterator<Item = &mut S>

Returns a mutable iterator over all samples in the specified channel.

fn channels_iter_mut( &mut self, ) -> impl ExactSizeIterator<Item = impl ExactSizeIterator<Item = &mut S>>

Returns a mutable iterator that yields mutable iterators for each channel.

fn frame_iter_mut( &mut self, frame: usize, ) -> impl ExactSizeIterator<Item = &mut S>

Returns a mutable iterator over all samples in the specified frame (across all channels).

fn frames_iter_mut( &mut self, ) -> impl ExactSizeIterator<Item = impl ExactSizeIterator<Item = &mut S>>

Returns a mutable iterator that yields mutable iterators for each frame.

fn as_view_mut(&mut self) -> impl AudioBlockMut<S>

Creates a non-owning mutable view of this audio block.

fn as_sequential_view_mut(&mut self) -> Option<SequentialViewMut<'_, S>>

Attempts to downcast this generic audio block to a concrete sequential view. This enables access to frame slices and the underlying raw data.

fn set_visible(&mut self, num_channels: u16, num_frames: usize)

Sets the visible size of the audio block to the specified number of channels and frames.

fn as_interleaved_view_mut(&mut self) -> Option<InterleavedViewMut<'_, S>>

Attempts to downcast this generic audio block to a concrete interleaved view. This enables access to frame slices and the underlying raw data.

fn as_planar_view_mut( &mut self, ) -> Option<PlanarViewMut<'_, S, Self::PlanarViewMut>>

Attempts to downcast this generic audio block to a concrete planar view. This enables access to frame slices and the underlying raw data.

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

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S: Sample + Debug> Debug for Sequential<S>

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

Formats the value using the given formatter.

impl<S: Default + Sample> Default for Sequential<S>

fn default() -> Sequential<S>

Returns the “default value” for a type.