Enum Residuals 

pub enum Residuals<I> {
    Method0 {
        partitions: Vec<ResidualPartition<0b1111, I>>,
    },
    Method1 {
        partitions: Vec<ResidualPartition<0b11111, I>>,
    },
}

Residual values for FIXED or LPC subframes

Bits	Meaning
2	residual coding method
4	partition order
	residual partition₀
	(residual partition₁)
	⋮

The residual coding method can be 0 or 1. A coding method of 0 means 4-bit Rice parameters in residual partitions. A coding method of 5 means 5-bit Rice parameters in residual partitions (method 0 is the common case).

The number of residual partitions equals 2ⁿ where n is the partition order.

Example

use flac_codec::stream::{Residuals, ResidualPartition};
use bitstream_io::{BitReader, BitRead, BigEndian, BitCount};

let data: &[u8] = &[
    0b00_0000_00,  // coding method + partition order + partition
    // residual partition
    0b01010001,
    0b00010001,
    0b00010001,
    0b00010001,
    0b00010001,
    0b00010001,
    0b00010001,
    0b00010001,
    0b00010001,
    0b00010000,
    0b00000000,
];

let mut r = BitReader::endian(data, BigEndian);

assert_eq!(
    r.parse_using::<Residuals<i32>>((20, 1)).unwrap(),
    // coding method = 0b00
    // partition order = 0b0000, or 1 partition
    Residuals::Method0 {
        partitions: vec![
            ResidualPartition::Standard {
                rice: BitCount::new::<1>(),
                residuals: vec![
                     1, 2, 2, 2, 2, 2, 2, 2, 2, 2,
                     2, 2, 2, 2, 2, 2, 2, 2, 2
                ],
            }
        ],
    },
);

Variants

Method0

Coding method 0

Fields

partitions: Vec<ResidualPartition<0b1111, I>>

The residual partitions

Method1

Coding method 1

Fields

partitions: Vec<ResidualPartition<0b11111, I>>

The residual partitions

Implementations

impl<I> Residuals<I>

pub fn coding_method(&self) -> CodingMethod

The type of coding method in use, either Rice or Rice2

pub fn partition_order(&self) -> u32

The residual block’s partition order

Trait Implementations

impl<I: Debug> Debug for Residuals<I>

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

Formats the value using the given formatter.

impl<I: SignedInteger> FromBitStreamUsing for Residuals<I>

type Context = (usize, usize)

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, (block_size, predictor_order): (usize, usize), ) -> Result<Self, Error>

Parse Self from reader with the given context

impl<I: PartialEq> PartialEq for Residuals<I>

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

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<I: Eq> Eq for Residuals<I>

impl<I> StructuralPartialEq for Residuals<I>