Struct SeekTable 

pub struct SeekTable {
    pub points: Contiguous<{ Self::MAX_POINTS }, SeekPoint>,
}

A SEEKTABLE metadata block

Because FLAC frames do not store their compressed length, a seek table is used for random access within a FLAC file. By mapping a sample number to a byte offset, one can quickly reach different parts of the file without decoding the whole thing.

Also note that seek point byte offsets are relative to the start of the first FLAC frame, and not relative to the start of the entire file. This allows us to change the size of the set of metadata blocks without having to recalculate the contents of the seek table.

Because the byte and sample offsets are file-specific, a seek table generated for one file should not be transferred to another FLAC file where the frames are different sizes and in different positions.

This block may occur only once in a FLAC file.

Its seekpoints occupy the entire block.

Example

use bitstream_io::{BitReader, BitRead, BigEndian};
use flac_codec::metadata::{BlockHeader, BlockType, SeekTable, SeekPoint};

let data: &[u8] = &[
    0x83, 0x00, 0x00, 0x48,  // block header
    // seekpoint 0
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x14,
    // seekpoint 1
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x14,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c,
    0x00, 0x14,
    // seekpoint 2
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22,
    0x00, 0x14,
    // seekpoint 3
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c,
    0x00, 0x14,
];

let mut r = BitReader::endian(data, BigEndian);
let header = r.parse::<BlockHeader>().unwrap();
assert_eq!(
    &header,
    &BlockHeader {
        last: true,
        block_type: BlockType::SeekTable,
        size: 0x48u8.into(),
    },
);

let seektable = r.parse_using::<SeekTable>(header.size).unwrap();

assert_eq!(
    Vec::from(seektable.points),
    vec![
        SeekPoint::Defined {
            sample_offset: 0x00,
            byte_offset: 0x00,
            frame_samples: 0x14,
        },
        SeekPoint::Defined {
            sample_offset: 0x14,
            byte_offset: 0x0c,
            frame_samples: 0x14,
        },
        SeekPoint::Defined {
            sample_offset: 0x28,
            byte_offset: 0x22,
            frame_samples: 0x14,
        },
        SeekPoint::Defined {
            sample_offset: 0x3c,
            byte_offset: 0x3c,
            frame_samples: 0x14,
        },
    ],
);

Fields

points: Contiguous<{ Self::MAX_POINTS }, SeekPoint>

The seek table’s individual seek points

Implementations

impl SeekTable

pub const MAX_POINTS: usize = 932_067usize

The maximum number of seek points that fit into a seek table

Trait Implementations

impl AsBlockRef for SeekTable

fn as_block_ref(&self) -> BlockRef<'_>

Returns fresh reference to ourself.

impl Clone for SeekTable

fn clone(&self) -> SeekTable

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SeekTable

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

Formats the value using the given formatter.

impl Default for SeekTable

fn default() -> SeekTable

Returns the “default value” for a type.

impl From<SeekTable> for Block

fn from(b: SeekTable) -> Self

Converts to this type from the input type.

impl FromBitStreamUsing for SeekTable

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, Self::Error>

Parse Self from reader with the given context

impl MetadataBlock for SeekTable

const TYPE: BlockType = BlockType::SeekTable

The metadata block’s type

const MULTIPLE: bool = false

Whether the block can occur multiple times in a file

fn bytes(&self) -> Option<BlockSize>

Size of block, in bytes, not including header

fn total_size(&self) -> Option<BlockSize>

Size of block, in bytes, including block header

impl OptionalMetadataBlock for SeekTable

const OPTIONAL_TYPE: OptionalBlockType = OptionalBlockType::SeekTable

Our optional block type

impl PartialEq for SeekTable

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

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<Block> for SeekTable

type Error = ()

The type returned in the event of a conversion error.

fn try_from(block: Block) -> Result<Self, ()>

Performs the conversion.

impl Eq for SeekTable

impl StructuralPartialEq for SeekTable