Struct CodecRegistry 

pub struct CodecRegistry { /* private fields */ }

Implementations

impl CodecRegistry

pub fn new() -> Self

pub fn register(&mut self, id: CodecId, implementation: CodecImplementation)

Register a codec implementation. The same codec id may be registered multiple times — for example a software FLAC decoder and (later) a hardware one would both register under id "flac".

pub fn register_decoder_impl( &mut self, id: CodecId, caps: CodecCapabilities, factory: DecoderFactory, )

Convenience: register a decoder-only implementation built from a caps + factory pair.

pub fn register_encoder_impl( &mut self, id: CodecId, caps: CodecCapabilities, factory: EncoderFactory, )

Convenience: register an encoder-only implementation.

pub fn register_both( &mut self, id: CodecId, caps: CodecCapabilities, decode: DecoderFactory, encode: EncoderFactory, )

Convenience: register a single implementation that handles both decode and encode for a codec id.

pub fn register_decoder(&mut self, id: CodecId, factory: DecoderFactory)

Backwards-compat shim: register a decoder-only impl with default software capabilities. Prefer register_decoder_impl for new code.

pub fn register_encoder(&mut self, id: CodecId, factory: EncoderFactory)

Backwards-compat shim: register an encoder-only impl with default software capabilities.

pub fn has_decoder(&self, id: &CodecId) -> bool

pub fn has_encoder(&self, id: &CodecId) -> bool

pub fn make_decoder_with( &self, params: &CodecParameters, prefs: &CodecPreferences, ) -> Result<Box<dyn Decoder>>

Build a decoder for params. Walks all implementations matching the codec id in increasing priority order, skipping any excluded by the caller’s preferences. Init-time fallback: if a higher-priority impl’s constructor returns an error, the next candidate is tried.

pub fn make_encoder_with( &self, params: &CodecParameters, prefs: &CodecPreferences, ) -> Result<Box<dyn Encoder>>

Build an encoder, with the same priority + fallback semantics.

pub fn make_decoder(&self, params: &CodecParameters) -> Result<Box<dyn Decoder>>

Default-preference shorthand for make_decoder_with.

pub fn make_encoder(&self, params: &CodecParameters) -> Result<Box<dyn Encoder>>

Default-preference shorthand for make_encoder_with.

pub fn decoder_ids(&self) -> impl Iterator<Item = &CodecId>

Iterate codec ids that have at least one decoder implementation.

pub fn encoder_ids(&self) -> impl Iterator<Item = &CodecId>

pub fn implementations(&self, id: &CodecId) -> &[CodecImplementation]

All registered implementations of a given codec id.

pub fn all_implementations( &self, ) -> impl Iterator<Item = (&CodecId, &CodecImplementation)>

Iterator over every (codec_id, impl) pair — useful for oxideav list to show capability flags per implementation.

pub fn claim_tag( &mut self, id: CodecId, tag: CodecTag, priority: u8, probe: Option<CodecProbe>, )

Attach a codec id to a container tag so demuxers can look up the right decoder without each container maintaining its own hand-written FourCC / WAVEFORMATEX / Matroska table.

A single tag may be claimed by multiple codecs — the typical reason is mislabelling in the wild: e.g. AVI FourCC DIV3 legally means MS-MPEG4v3 but in practice is applied to real MPEG-4 Part 2 streams often enough that both oxideav-msmpeg4 and oxideav-mpeg4video want to claim it, each with a probe that accepts the bitstream it actually understands.

Claims are stored sorted by priority descending; Self::resolve_tag walks them in order and returns the first whose probe accepts (or the first with no probe).

pub fn resolve_tag( &self, tag: &CodecTag, probe_data: Option<&[u8]>, ) -> Option<&CodecId>

Resolve a container tag to a codec id. Walks the priority- ordered claim list and returns the first matching one:

• Claim has a probe + probe_data is Some(d) → accept iff probe(d) returns true; otherwise skip and try the next.
• Claim has a probe + probe_data is None → accept (probing without bytes is impossible; fall back to priority).
• Claim has no probe → accept (catch-all).

Returns None if the tag has no claimants.

Example

use oxideav_codec::CodecRegistry;
use oxideav_core::{CodecId, CodecTag};

let mut reg = CodecRegistry::new();
reg.claim_tag(CodecId::new("flac"), CodecTag::fourcc(b"FLAC"), 10, None);

let resolved = reg.resolve_tag(&CodecTag::fourcc(b"FLAC"), None);
assert_eq!(resolved.map(|c| c.as_str()), Some("flac"));

pub fn claims_for_tag(&self, tag: &CodecTag) -> &[(CodecId, TagClaim)]

Return the full list of claims for a tag in priority order — useful for diagnostics (oxideav tags / error messages when no claim accepts the probed bytes).

pub fn all_tag_claims( &self, ) -> impl Iterator<Item = (&CodecTag, &CodecId, &TagClaim)>

Iterator over every tag claim currently registered — used by oxideav tags debug output and by integration tests that want to verify the full tag surface.

Trait Implementations

impl CodecResolver for CodecRegistry

Implement the shared CodecResolver interface so container demuxers can accept &dyn CodecResolver without depending on this crate directly — the trait lives in oxideav-core.

fn resolve_tag( &self, tag: &CodecTag, probe_data: Option<&[u8]>, ) -> Option<CodecId>

impl Default for CodecRegistry

fn default() -> CodecRegistry

Returns the “default value” for a type.