Enum SampleType 

#[non_exhaustive]
pub enum SampleType {
    U8,
    I16,
    I24,
    I32,
    F32,
    F64,
}

Identifies the numeric type used to represent individual audio samples.

Purpose

SampleType provides a runtime representation of the sample format that can be inspected, serialised, and used for dispatch without needing generic type parameters. It mirrors the set of types that implement AudioSample.

Intended Usage

Use SampleType when the sample format must be described at runtime – for example when reading audio file headers, serialising audio metadata, or routing to SIMD dispatch paths via SampleType::from_type_id.

Variants

Variant	Type	Width	Notes
U8	u8	8-bit unsigned	Mid-scale 128 = silence
I16	i16	16-bit signed	CD-quality
I24	I24	24-bit signed	From the i24 crate
I32	i32	32-bit signed
F32	f32	32-bit float	Native DSP format
F64	f64	64-bit float	High-precision

I24: crate::I24

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

8-bit unsigned integer (u8). Mid-scale value 128 represents silence.

I16

16-bit signed integer (i16). CD-quality audio.

I24

24-bit signed integer (I24(crate::I24)). Common in studio audio.

I32

32-bit signed integer (i32). High-dynamic-range integer audio.

F32

32-bit floating point (f32). Native format for most DSP operations.

F64

64-bit floating point (f64). High-precision processing.

Implementations

impl SampleType

pub const fn as_str(self) -> &'static str

Returns the canonical short name (machine-oriented)

pub const fn description(self) -> &'static str

Returns a human-readable descriptive name

pub const fn bits(self) -> Option<u32>

Returns the bit-depth of the format, if defined

pub const fn bytes(self) -> Option<usize>

Returns the size in bytes of one sample, if defined

pub const fn is_integer(self) -> bool

Returns true if this is an integer-based sample format (U8, I16, I24, or I32).

pub const fn is_signed(self) -> bool

Returns true if this is a signed integer format (I16, I24, or I32).

Note: U8 is an integer type but is unsigned, so this returns false for it.

pub const fn is_unsigned(self) -> bool

Returns true if this is an unsigned integer format (currently only U8).

pub const fn is_float(self) -> bool

True if this is a floating-point sample format

pub const fn is_dsp_native(self) -> bool

True if this format is usable for DSP operations without conversion

impl SampleType

pub fn from_type_id(type_id: TypeId) -> Option<Self>

Returns the SampleType corresponding to a TypeId, or None if unrecognized.

This is useful for SIMD dispatch code that needs to determine the concrete sample type at runtime.

Example

use audio_samples::SampleType;
use std::any::TypeId;

assert_eq!(SampleType::from_type_id(TypeId::of::<f32>()), Some(SampleType::F32));
assert_eq!(SampleType::from_type_id(TypeId::of::<String>()), None);

pub const fn from_bits(bits: u16) -> Self

Creates a sample type from a number of bits per sample.

Panics

Panics if the bits value does not correspond to a supported sample type.

Trait Implementations

impl Clone for SampleType

fn clone(&self) -> SampleType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SampleType

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

Formats the value using the given formatter.

impl Display for SampleType

Formats the sample type as a string.

The standard format ({}) uses the short machine-readable identifier (e.g. "f32"). The alternate format ({:#}) uses the human-readable description (e.g. "32-bit floating point").

Examples

use audio_samples::SampleType;

assert_eq!(format!("{}", SampleType::F32), "f32");
assert_eq!(format!("{:#}", SampleType::F32), "32-bit floating point");

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

Formats the value using the given formatter.

impl Hash for SampleType

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

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 SampleType

fn eq(&self, other: &SampleType) -> 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 TryFrom<&str> for SampleType

Parses a SampleType from its canonical short-name string.

Accepts "u8", "i16", "i24", "i32", "f32", and "f64". Returns Err(()) for any unrecognised string.

Examples

use audio_samples::SampleType;

assert_eq!(SampleType::try_from("f32"), Ok(SampleType::F32));
assert_eq!(SampleType::try_from("i16"), Ok(SampleType::I16));
assert!(SampleType::try_from("unknown").is_err());

type Error = ()

The type returned in the event of a conversion error.

fn try_from(value: &str) -> Result<Self, Self::Error>

Performs the conversion.

impl Copy for SampleType

impl Eq for SampleType

impl StructuralPartialEq for SampleType