Enum SampleRate

pub enum SampleRate<R> {
    Streaminfo(u32),
    Hz88200,
    Hz176400,
    Hz192000,
    Hz8000,
    Hz16000,
    Hz22050,
    Hz24000,
    Hz32000,
    Hz44100,
    Hz48000,
    Hz96000,
    KHz(R),
    Hz(R),
    DHz(R),
}

Possible sample rates in a FLAC frame

Common rates are stored as a 4-bit value, while uncommon rates are stored as 8 or 16 bit values. Sample rates defined in the STREAMINFO metadata block are only possible on a “non-subset” stream, which is not streamable.

Bits	Sample Rate
0000	get from STREAMINFO
0001	88200 Hz
0010	176400 Hz
0011	192000 Hz
0100	8000 Hz
0101	16000 Hz
0110	22050 Hz
0111	24000 Hz
1000	32000 Hz
1001	44100 Hz
1010	48000 Hz
1011	96000 Hz
1100	read 8 bits, in kHz
1101	read 16 bits, in Hz
1110	read 16 bits, in 10s of Hz
1111	invalid sample rate

Handing uncommon frame rates is why this type is a generic with multiple implementations from reading from a bitstream. The first reads common rates, while the second reads additional bits if necessary.

Example

use flac_codec::stream::SampleRate;
use bitstream_io::{BitReader, BitRead, BigEndian};

let data: &[u8] = &[
    0b0110_1001,              // block size + sample rate
    0b0000_100_0,             // channels + bps + pad
    0x00,                     // frame number
    0x13,                     // uncommon block size (+1)
];

let mut r = BitReader::endian(data, BigEndian);
r.skip(4).unwrap();          // skip block size
let sample_rate = r.parse::<SampleRate<()>>().unwrap();  // reads 0b1001
assert_eq!(
    sample_rate,
    SampleRate::Hz44100,     // got defined sample rate
);
r.skip(8 + 8 + 8).unwrap();  // skip unnecessary bits for this example
assert_eq!(
    // since our rate is defined, no need to read additional bits
    r.parse_using::<SampleRate<u32>>(sample_rate).unwrap(),
    SampleRate::Hz44100,
);

Variants

Streaminfo(u32)

Get rate from STREAMINFO metadata block

Hz88200

88200 Hz

Hz176400

176,400 Hz

Hz192000

192,000 Hz

Hz8000

8,000 Hz

Hz16000

16,000 Hz

Hz22050

22,050 Hz

Hz24000

24,000 Hz

Hz32000

32,000 Hz

Hz44100

44,100 Hz

Hz48000

48,000 Hz

Hz96000

96,000 Hz

KHz(R)

8-bit value in kHz

Hz(R)

16-bit value in Hz

DHz(R)

16-bit value * 10 in Hz

Trait Implementations

impl<R: Clone> Clone for SampleRate<R>

fn clone(&self) -> SampleRate<R>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<R: Debug> Debug for SampleRate<R>

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

Formats the value using the given formatter.

impl Display for SampleRate<u32>

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

Formats the value using the given formatter.

impl From<SampleRate<u32>> for u32

fn from(rate: SampleRate<u32>) -> Self

Converts to this type from the input type.

impl FromBitStream for SampleRate<()>

type Error = Error

Error generated during parsing, such as io::Error

fn from_reader<R: BitRead + ?Sized>(r: &mut R) -> Result<Self, Self::Error>

Parse Self from reader

impl FromBitStreamUsing for SampleRate<()>

Reads the raw sample rate bits, which need to be finalized

type Context = Option<u32>

Some context to consume when parsing

type Error = Error

Error generated during parsing, such as io::Error

fn from_reader<R: BitRead + ?Sized>( r: &mut R, streaminfo_rate: Option<u32>, ) -> Result<Self, Self::Error>

Parse Self from reader with the given context

impl FromBitStreamUsing for SampleRate<u32>

type Context = SampleRate<()>

Some context to consume when parsing

type Error = Error

Error generated during parsing, such as io::Error

fn from_reader<R: BitRead + ?Sized>( r: &mut R, rate: SampleRate<()>, ) -> Result<Self, Self::Error>

Parse Self from reader with the given context

impl<R: PartialEq> PartialEq for SampleRate<R>

fn eq(&self, other: &SampleRate<R>) -> bool

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

const 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<R> ToBitStream for SampleRate<R>

Writes the raw sample rate bits

type Error = Error

Error generated during building, such as io::Error

fn to_writer<W: BitWrite + ?Sized>(&self, w: &mut W) -> Result<(), Self::Error>

Generate self to writer

fn bits<C>(&self) -> Result<C, Self::Error>

where C: Counter, Self: Sized,

Returns length of self in bits, if possible

fn bits_len<C, E>(&self) -> Result<C, Self::Error>

where C: Counter, E: Endianness, Self: Sized,

👎Deprecated since 4.0.0: use of bits() is preferred

Returns total length of self, if possible

impl TryFrom<u32> for SampleRate<u32>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(sample_rate: u32) -> Result<Self, Error>

Performs the conversion.

impl<R: Copy> Copy for SampleRate<R>

impl<R: Eq> Eq for SampleRate<R>

impl<R> StructuralPartialEq for SampleRate<R>