Struct Padding 

pub struct Padding {
    pub size: BlockSize,
}

A PADDING metadata block

Padding blocks are empty blocks consisting of all 0 bytes. If one wishes to edit the metadata in other blocks, adjusting the size of the padding block allows us to do so without have to rewrite the entire FLAC file. For example, when adding 10 bytes to a comment, we can subtract 10 bytes from the padding and the total size of all blocks remains unchanged. Therefore we can simply overwrite the old comment block with the new without affecting the following FLAC audio frames.

This block may occur multiple times in a FLAC file.

Example

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

let data: &[u8] = &[
    0x81, 0x00, 0x00, 0x0a,  // block header
    // padding bytes
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
];

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

assert_eq!(
    r.parse_using::<Padding>(header.size).unwrap(),
    Padding {
        size: 0x0au8.into(),
    },
);

Fields

size: BlockSize

The size of the padding, in bytes

Trait Implementations

impl AsBlockRef for Padding

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

Returns fresh reference to ourself.

impl Clone for Padding

fn clone(&self) -> Padding

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Padding

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

Formats the value using the given formatter.

impl Default for Padding

fn default() -> Padding

Returns the “default value” for a type.

impl From<Padding> for Block

fn from(b: Padding) -> Self

Converts to this type from the input type.

impl FromBitStreamUsing for Padding

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 Padding

const TYPE: BlockType = BlockType::Padding

The metadata block’s type

const MULTIPLE: bool = true

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 Padding

const OPTIONAL_TYPE: OptionalBlockType = OptionalBlockType::Padding

Our optional block type

impl PartialEq for Padding

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

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 Padding

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 Padding

impl PortableMetadataBlock for Padding

impl StructuralPartialEq for Padding