Struct CodecInfo 

#[non_exhaustive]
pub struct CodecInfo {
    pub id: CodecId,
    pub capabilities: CodecCapabilities,
    pub decoder_factory: Option<DecoderFactory>,
    pub encoder_factory: Option<EncoderFactory>,
    pub probe: Option<ProbeFn>,
    pub tags: Vec<CodecTag>,
}

A single registration: capabilities, decoder/encoder factories, optional probe, and the container tags this codec claims.

Codec crates build one of these per codec id inside their register(reg) function and hand it to CodecRegistry::register. The struct is #[non_exhaustive] so additional fields can be added without breaking existing codec crates — construction is only possible through CodecInfo::new plus the builder methods below.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

id: CodecId

capabilities: CodecCapabilities

decoder_factory: Option<DecoderFactory>

encoder_factory: Option<EncoderFactory>

probe: Option<ProbeFn>

Probe function that returns a confidence in 0.0..=1.0 for a given ProbeContext. None means “confidence 1.0 for every claimed tag” — the correct default for codecs whose tag claims are unambiguous.

tags: Vec<CodecTag>

Tags this codec is willing to be looked up under. One codec may claim many tags (an AAC decoder covers several WaveFormat ids, a FourCC, an MP4 OTI, and a Matroska CodecID string at once).

Implementations

impl CodecInfo

pub fn new(id: CodecId) -> Self

Start a new registration for id with empty capabilities, no factories, no probe, and no tags. Chain the builder methods below to fill it in, then hand the result to CodecRegistry::register.

pub fn capabilities(self, caps: CodecCapabilities) -> Self

Replace the capability description. The default built by Self::new is a placeholder (audio-flavoured, no flags); every real registration should call this.

pub fn decoder(self, factory: DecoderFactory) -> Self

pub fn encoder(self, factory: EncoderFactory) -> Self

pub fn probe(self, probe: ProbeFn) -> Self

pub fn tag(self, tag: CodecTag) -> Self

Claim a single container tag for this codec. Equivalent to .tags([tag]) but avoids the array ceremony for single-tag claims.

pub fn tags(self, tags: impl IntoIterator<Item = CodecTag>) -> Self

Claim a set of container tags for this codec. Takes any iterable (arrays, Vec, Option, …) so the common case of a codec with 3-6 tags reads as one clean block.