Enum BlockSize 

pub enum BlockSize<B> {
    Samples192,
    Samples576,
    Samples1152,
    Samples2304,
    Samples4608,
    Uncommon8(B),
    Uncommon16(B),
    Samples256,
    Samples512,
    Samples1024,
    Samples2048,
    Samples4096,
    Samples8192,
    Samples16384,
    Samples32768,
}

Possible block sizes in a FLAC frame, in samples

Common sizes are stored as a 4-bit value, while uncommon sizes are stored as 8 or 16 bit values.

Bits	Block Size
0000	invalid
0001	192
0010	576
0011	1152
0100	2304
0101	4606
0110	8 bit field (+1)
0111	16 bit field (+1)
1000	256
1001	512
1010	1024
1011	2048
1100	4096
1101	8192
1110	16384
1111	32768

Handing uncommon block sizes is why this type is a generic with two different implementations from reading from a bitstream. The first reads common sizes, while the second reads additional bits if necessary.

Example

use flac_codec::stream::BlockSize;
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);
let block_size = r.parse::<BlockSize<()>>().unwrap();  // reads 0b0110
assert_eq!(
    block_size,
    BlockSize::Uncommon8(()),  // need to read actual block size from end of frame
);
r.skip(4 + 8 + 8).unwrap();    // skip unnecessary bits for this example
assert_eq!(
    // read remainder of block size from end of frame
    r.parse_using::<BlockSize<u16>>(block_size).unwrap(),
    BlockSize::Uncommon8(0x13 + 1),
);

Variants

Samples192

192 samples

Samples576

576 samples

Samples1152

1152 samples

Samples2304

2304 samples

Samples4608

4608 samples

Uncommon8(B)

Uncommon 8 bit sample count + 1

Uncommon16(B)

Uncommon 16 bit sample count + 1

Samples256

256 samples

Samples512

512 samples

Samples1024

1024 samples

Samples2048

2048 samples

Samples4096

4096 samples

Samples8192

8192 samples

Samples16384

16384 samples

Samples32768

32768 samples

Trait Implementations

impl<B: Clone> Clone for BlockSize<B>

fn clone(&self) -> BlockSize<B>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<B: Debug> Debug for BlockSize<B>

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

Formats the value using the given formatter.

impl Display for BlockSize<u16>

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

Formats the value using the given formatter.

impl From<BlockSize<u16>> for u16

fn from(size: BlockSize<u16>) -> Self

Converts to this type from the input type.

impl FromBitStream for BlockSize<()>

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 BlockSize<u16>

type Context = BlockSize<()>

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, size: BlockSize<()>, ) -> Result<Self, Error>

Parse Self from reader with the given context

impl<B: PartialEq> PartialEq for BlockSize<B>

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

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<u16> for BlockSize<u16>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(size: u16) -> Result<Self, Error>

Performs the conversion.

impl<B: Copy> Copy for BlockSize<B>

impl<B: Eq> Eq for BlockSize<B>

impl<B> StructuralPartialEq for BlockSize<B>