Enum SampleFormat 

#[non_exhaustive]
pub enum SampleFormat {
    U8,
    S16,
    S32,
    F32,
    F64,
    S16p,
    S32p,
    F32p,
    F64p,
    S24,
    S24p,
}

Core OxiMedia types: errors, codecs, pixel/sample formats, timestamps. Audio sample format.

Defines how audio samples are stored in memory, including bit depth, signedness, and whether samples are interleaved or planar.

Formats ending with ‘p’ are planar (one plane per channel).

Examples

use oximedia_core::types::SampleFormat;

let format = SampleFormat::F32;
assert!(!format.is_planar());
assert_eq!(format.bytes_per_sample(), 4);

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

U8

Unsigned 8-bit integer, interleaved.

S16

Signed 16-bit integer, interleaved.

S32

Signed 32-bit integer, interleaved.

F32

32-bit floating point, interleaved.

F64

64-bit floating point, interleaved.

S16p

Signed 16-bit integer, planar.

S32p

Signed 32-bit integer, planar.

F32p

32-bit floating point, planar.

F64p

64-bit floating point, planar.

S24

Signed 24-bit integer, interleaved (stored in 3 bytes per sample). Common in professional audio interfaces and WAV files.

S24p

Signed 24-bit integer, planar (stored in 3 bytes per sample). Planar variant for professional audio pipelines.

Implementations

impl SampleFormat

pub const fn bytes_per_sample(&self) -> usize

Returns the number of bytes per sample.

Examples

use oximedia_core::types::SampleFormat;

assert_eq!(SampleFormat::U8.bytes_per_sample(), 1);
assert_eq!(SampleFormat::S16.bytes_per_sample(), 2);
assert_eq!(SampleFormat::F32.bytes_per_sample(), 4);
assert_eq!(SampleFormat::F64.bytes_per_sample(), 8);

pub const fn is_planar(&self) -> bool

Returns whether this format uses planar storage.

Planar formats store each channel in a separate contiguous memory region, as opposed to interleaved formats where samples alternate between channels.

Examples

use oximedia_core::types::SampleFormat;

assert!(!SampleFormat::F32.is_planar());
assert!(SampleFormat::F32p.is_planar());

pub const fn bits_per_sample(&self) -> u32

Returns the number of bits per sample.

Examples

use oximedia_core::types::SampleFormat;

assert_eq!(SampleFormat::U8.bits_per_sample(), 8);
assert_eq!(SampleFormat::S16.bits_per_sample(), 16);
assert_eq!(SampleFormat::F32.bits_per_sample(), 32);

pub const fn is_float(&self) -> bool

Returns whether this format uses floating point samples.

Examples

use oximedia_core::types::SampleFormat;

assert!(SampleFormat::F32.is_float());
assert!(SampleFormat::F64p.is_float());
assert!(!SampleFormat::S16.is_float());

pub const fn is_signed(&self) -> bool

Returns whether this format uses signed integer samples.

Examples

use oximedia_core::types::SampleFormat;

assert!(SampleFormat::S16.is_signed());
assert!(SampleFormat::S32p.is_signed());
assert!(!SampleFormat::U8.is_signed());

pub const fn to_packed(&self) -> SampleFormat

Returns the packed (interleaved) equivalent of this format.

If the format is already packed, returns self.

Examples

use oximedia_core::types::SampleFormat;

assert_eq!(SampleFormat::F32p.to_packed(), SampleFormat::F32);
assert_eq!(SampleFormat::S16.to_packed(), SampleFormat::S16);

pub const fn to_planar(&self) -> SampleFormat

Returns the planar equivalent of this format.

If the format is already planar, returns self. Note: U8 has no planar equivalent and returns U8.

Examples

use oximedia_core::types::SampleFormat;

assert_eq!(SampleFormat::F32.to_planar(), SampleFormat::F32p);
assert_eq!(SampleFormat::S16p.to_planar(), SampleFormat::S16p);

impl SampleFormat

pub const fn bit_depth(&self) -> u8

Returns the bit depth of this sample format.

Examples

use oximedia_core::types::SampleFormat;

assert_eq!(SampleFormat::U8.bit_depth(), 8);
assert_eq!(SampleFormat::S16.bit_depth(), 16);
assert_eq!(SampleFormat::S24.bit_depth(), 24);
assert_eq!(SampleFormat::F32.bit_depth(), 32);
assert_eq!(SampleFormat::F64.bit_depth(), 64);

pub fn dynamic_range_db(&self) -> f64

Returns the theoretical dynamic range in decibels for integer formats.

For floating-point formats, returns an approximate practical range. The formula for integer formats is 6.02 * bits + 1.76 dB.

Examples

use oximedia_core::types::SampleFormat;

let dr = SampleFormat::S16.dynamic_range_db();
assert!((dr - 98.09).abs() < 0.1); // ~96.3 + 1.76

pub const fn buffer_size(&self, sample_count: usize, channels: usize) -> usize

Returns the buffer size in bytes needed for sample_count samples across channels channels.

For interleaved formats, all channels are stored in a single buffer. For planar formats, this returns the total size of all per-channel planes.

Examples

use oximedia_core::types::SampleFormat;

// 1024 stereo F32 samples: 1024 * 2 * 4 = 8192 bytes
assert_eq!(SampleFormat::F32.buffer_size(1024, 2), 8192);

// Planar is the same total: 1024 * 4 * 2 planes = 8192
assert_eq!(SampleFormat::F32p.buffer_size(1024, 2), 8192);

Trait Implementations

impl Clone for SampleFormat

fn clone(&self) -> SampleFormat

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SampleFormat

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

Formats the value using the given formatter.

impl Default for SampleFormat

fn default() -> SampleFormat

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for SampleFormat

fn deserialize<__D>( __deserializer: __D, ) -> Result<SampleFormat, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for SampleFormat

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

Formats the value using the given formatter.

impl FormatCost for SampleFormat

fn conversion_cost(&self, target: &SampleFormat) -> Option<u32>

Returns the conversion cost from self to target, or None if no conversion path is available.

impl FromStr for SampleFormat

fn from_str(s: &str) -> Result<SampleFormat, <SampleFormat as FromStr>::Err>

Parses a sample format name string.

Examples

use oximedia_core::types::SampleFormat;

let fmt: SampleFormat = "f32".parse().expect("should parse");
assert_eq!(fmt, SampleFormat::F32);

type Err = OxiError

The associated error which can be returned from parsing.

impl Hash for SampleFormat

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for SampleFormat

fn eq(&self, other: &SampleFormat) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for SampleFormat

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for SampleFormat

impl Eq for SampleFormat

impl StructuralPartialEq for SampleFormat