class audio_data<Interleaved> audio¶

uint32_t channels = 0

Number of channels.

chan<fbase*, Interleaved> data{}

Pointers to channel data.

size_t size

Number of samples per channel.

size_t capacity

Allocated capacity per channel.

int64_t position = 0

Position of the first sample in the audio data.

std::shared_ptr<void> deallocator

Deallocator for the data.

bool operator==(const audio_data& other) const noexcept = default

[[nodiscard]] constexpr audio_data() noexcept : size(0), capacity(0) { … }

audio_data(const audio_data&) noexcept            = default

Converts between planar and interleaved layouts.

Parameters

other

Source buffer with the opposite interleaving layout.

audio_data(audio_data&&) noexcept                 = default

audio_data& operator=(const audio_data&) noexcept = default

audio_data& operator=(audio_data&&) noexcept      = default

template <std::invocable Fn>
[[nodiscard]] audio_data(std::span<fbase* const> pointers, size_t size, Fn&& deallocator)
    requires(!Interleaved)

[[nodiscard]] audio_data(std::span<fbase* const> pointers, size_t size)
    requires(!Interleaved)

[[nodiscard]] audio_data(fbase* pointer, size_t channels, size_t size)
    requires(Interleaved)

template <std::invocable Fn>
[[nodiscard]] audio_data(fbase* pointer, size_t channels, size_t size, Fn&& deallocator)
    requires(Interleaved)

[[nodiscard]] explicit audio_data(size_t channels, size_t size = 0)

Constructs an audio_data buffer with the specified channel count and optional initial size.

Allocates aligned storage and initializes channel pointers according to layout: - Interleaved: a single contiguous block. - Planar: per-channel blocks aligned to 64 bytes (allocated as single memory block).If size is 0, an empty buffer is created without allocating sample storage.Capacity is set to size, and can be increased later via reserve().

Parameters

channels	Number of audio channels (1..max_audio_channels).
size	Optional initial number of samples per channel (capacity); 0 defers allocation.

{'pre': 'channels > 0 && channels <= max_audio_channels'}{'post': 'Channel pointers are initialized; storage (if allocated) is owned and freed automatically.'}{'exception': 'std::bad_alloc If memory allocation fails.'}

[[nodiscard]] audio_data(size_t channels, size_t size, fbase value)

Constructs an audio buffer and initializes all samples to a constant value.

Parameters

channels	Number of channels to allocate.
size	Number of samples per channel.
value	Initial sample value applied to every element.

{'exception': 'std::bad_alloc If memory allocation fails.'}

size_t total_samples() const noexcept

Calculates the total number of audio samples.

This function computes the total number of samples by multiplying the size (number of frames) by the number of channels in the audio data.

Returns

The total number of samples as a size_t value.

void reset()

Resets the object to its default state.

This function assigns a default-constructed instance of the object to itself, effectively resetting all its members to their default values.

void fill(fbase value)

Fills the audio data with the specified value.

This function sets all elements of the audio data to the given value.

Parameters

value

The value to fill the audio data with.

void multiply(fbase value)

Multiplies the audio data by a specified scalar value.

This function scales the audio data by the given factor, modifying the current data in place.

Parameters

value

The scalar value to multiply the audio data by.

void clear()

Clears all audio data, leaving the container empty (size == 0).

void resize(size_t new_size)

Resizes the container to hold exactly new_size elements.

- If new_size <= current capacity, adjusts size without reallocating. - Otherwise, increases capacity (rounded up) via reserve() and then updates size.Preserves existing elements up to min(old_size, new_size). When growing, newly added elements may be left uninitialized. Shrinking does not reduce capacity. May reallocate on growth, invalidating pointers/references to elements.

Parameters

new_size

Number of elements desired.

void resize(size_t new_size, fbase value)

Resize to the specified length and initialize newly added samples.

Preserves existing data. If the size grows, the appended region is filled with the given value; if it shrinks, the buffer is truncated. Works with both interleaved and planar layouts, applying initialization across all channels as appropriate.

Parameters

new_size	Target number of frames (samples per channel).
value	Sample value used to initialize newly created elements.

void reserve(size_t new_capacity)

void append(const audio_data<!Interleaved>& other)

void prepend(const audio_data<!Interleaved>& other)

friend void swap(audio_data& a, audio_data& b) noexcept

void swap(audio_data& other) noexcept

[[nodiscard]] bool empty() const noexcept

Check whether this audio data container is empty.

Returns

true if no channels or no samples.

[[nodiscard]] strided_channel<fbase> channel(size_t index) const noexcept
    requires(Interleaved)

Retrieves a reference to the audio data of a specific channel.

This function returns a univector_ref<fbase> representing the audio data for the specified channel index. It is only available when the audio data is not interleaved (i.e., Interleaved is false).

Parameters

index

The index of the channel to retrieve. Must be less than the total number of channels.

Returns

A univector_ref<fbase> representing the audio data for the specified channel.

[[nodiscard]] univector_ref<fbase> interlaved() const noexcept
    requires(Interleaved)

Returns a reference to the interleaved audio data.

This function provides access to the interleaved audio data as a univector_ref<fbase>. It is only available when the audio data is interleaved (i.e., Interleaved is true).

Returns

A univector_ref<fbase> representing the interleaved audio data. The size of the returned reference is calculated as size * channels.

[[nodiscard]] fbase* const* pointers() const noexcept
    requires(!Interleaved)

Retrieves an array of pointers to the base type of the audio data.

This function returns a pointer to the underlying data array, which contains pointers to the base type (fbase*). It is only available when the audio data is not interleaved (i.e., Interleaved is false).

Returns

A pointer to the array of fbase* representing the audio data.

[[nodiscard]] size_t channel_count() const noexcept

Retrieves the number of audio channels.

[[nodiscard]] audio_data slice(size_t start, size_t length = SIZE_MAX) const

Creates a slice of the audio data starting at a specified position and with a specified length.

Parameters

start	The starting position of the slice (in samples).
length	The length of the slice (in samples). Defaults to SIZE_MAX, which means the slice will extend to the end of the audio data if not specified.

Returns

audio_data A new audio_data object representing the sliced portion of the original data.

{'exception': 'std::logic_error If the starting position is out of range.'}

[[nodiscard]] audio_data truncate(size_t length) const

Truncates the audio data to the specified length.

This function creates a new audio_data object that contains only the first length samples from the current audio data. If the specified length is greater than the size of the current audio data, the entire audio data is returned.

Parameters

length

The number of samples to retain in the truncated audio data.

Returns

A new audio_data object containing the truncated data.

[[nodiscard]] audio_data slice_past_end(size_t length)

Creates a new audio_data object representing a slice of audio data starting past the end of the current data.

This function reserves additional space in the current audio data to accommodate the specified length, then creates a new audio_data object that represents a slice of the specified length starting from the end of the current data. The new slice shares the same underlying data buffer as the original object.

Parameters

length

The length of the slice to create, in samples.

Returns

A new audio_data object representing the slice.

[[nodiscard]] audio_stat stat() const noexcept

Retrieves the statistical information of the audio data.

[[nodiscard]] bool is_silent(fbase threshold = fbase(1e-5)) const noexcept

Checks whether all samples in the buffer are effectively silent within a given amplitude threshold.

Parameters

threshold

Non-negative amplitude threshold. Any sample with absolute value strictly greater than this threshold makes the buffer non-silent. Values exactly equal to the threshold are treated as silent. Default: 1e-5.

Returns

true if every sample lies within [-threshold, threshold]; false otherwise.

[[nodiscard]] size_t find_peak() const noexcept

template <std::invocable<univector_ref<fbase>> Fn>
void for_channel(Fn&& fn)

Applies a given function to the audio data for each channel.

This function iterates over the audio channels and applies the provided function object fn to the data. The behavior depends on whether the audio data is interleaved or not:- If the data is interleaved, the function is called once with a single univector containing all the interleaved data. - If the data is not interleaved, the function is called for each channel separately with a univector containing the data for that specific channel.

Template parameters

Fn	The type of the function object to be applied.

Parameters

fn	The function object to be applied to the audio data. It should accept a univector as its argument.