Enum SubframeHeaderType

pub enum SubframeHeaderType {
    Constant,
    Verbatim,
    Fixed {
        order: u8,
    },
    Lpc {
        order: NonZero<u8>,
    },
}

A subframe header’s type and order

This is always a 6-bit field.

Bits	Type	Order
000000	CONSTANT	N/A
000001	VERBATIM	N/A
000010 to 000111	reserved	N/A
001000 to 001100	FIXED	v - 8
001101 to 011111	reserved	N/A
100000 to 111111	LPC	v - 31

Variants

Constant

All samples are the same

Example

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

let data: &[u8] = &[0b0_000000_0];
let mut r = BitReader::endian(data, BigEndian);
r.skip(1).unwrap();  // pad bit
assert_eq!(
    r.parse::<SubframeHeaderType>().unwrap(),
    SubframeHeaderType::Constant,
);

Verbatim

All samples as stored verbatim, without compression

Example

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

let data: &[u8] = &[0b0_000001_0];
let mut r = BitReader::endian(data, BigEndian);
r.skip(1).unwrap();  // pad bit
assert_eq!(
    r.parse::<SubframeHeaderType>().unwrap(),
    SubframeHeaderType::Verbatim,
);

Fixed

Samples are stored with one of a set of fixed LPC parameters

Example

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

let data: &[u8] = &[0b0_001100_0];
let mut r = BitReader::endian(data, BigEndian);
r.skip(1).unwrap();  // pad bit
assert_eq!(
    r.parse::<SubframeHeaderType>().unwrap(),
    SubframeHeaderType::Fixed { order: 0b001100 - 8 },  // order = 4
);

Fields

order: u8

The predictor order, from 0..5

Lpc

Samples are stored with dynamic LPC parameters

Example

use flac_codec::stream::SubframeHeaderType;
use bitstream_io::{BitReader, BitRead, BigEndian};
use std::num::NonZero;

let data: &[u8] = &[0b0_100000_0];
let mut r = BitReader::endian(data, BigEndian);
r.skip(1).unwrap();  // pad bit
assert_eq!(
    r.parse::<SubframeHeaderType>().unwrap(),
    SubframeHeaderType::Lpc {
        order: NonZero::new(0b100000 - 31).unwrap(),  // order = 1
    },
);

Fields

order: NonZero<u8>

The predictor order, from 1..33

Implementations

impl SubframeHeaderType

pub const FIXED_COEFFS: [&[i64]; 5]

A set of FIXED subframe coefficients

Note that these are in the reverse order from how they’re usually presented, simply because we’ll be predicting samples in reverse order.

Trait Implementations

impl Debug for SubframeHeaderType

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

Formats the value using the given formatter.

impl FromBitStream for SubframeHeaderType

type Error = Error

Error generated during parsing, such as io::Error

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

Parse Self from reader

impl PartialEq for SubframeHeaderType

fn eq(&self, other: &SubframeHeaderType) -> 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 ToBitStream for SubframeHeaderType

type Error = Error

Error generated during building, such as io::Error

fn to_writer<W: BitWrite + ?Sized>(&self, w: &mut W) -> Result<(), 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 Eq for SubframeHeaderType

impl StructuralPartialEq for SubframeHeaderType