Enum DynamicRange 

#[non_exhaustive]
pub enum DynamicRange {
    Unspecified,
    Limited,
    Full,
    Other(SmolStr),
}

Sample range — limited (TV / studio swing) vs. full (PC).

Self::to_u32 / Self::from_u32 use the FFmpeg AVColorRange code points (UNSPECIFIED=0, MPEG=1, JPEG=2); FFmpeg is the source of truth. Default is Self::Unspecified (FFmpeg AVCOL_RANGE_UNSPECIFIED, code 0); Self::Other carries any name this build does not enumerate, so the text round-trip is lossless.

Tier. Self::Other needs a heap, so it exists only at the alloc / std tier; at the no-alloc tier this vocabulary is closed and an unrecognised slug is rejected rather than collapsed onto a named variant — an error beats a wrong value.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Unspecified

Unspecified — caller assumes Limited.

Limited

Limited / studio swing (8-bit luma 16..235, chroma 16..240); FFmpeg AVCOL_RANGE_MPEG.

Full

Full / PC swing (8-bit 0..255); FFmpeg AVCOL_RANGE_JPEG.

Other(SmolStr)

Available on crate features alloc or std only.

A slug this vocabulary does not enumerate — carried verbatim, ASCII-folded to lowercase by the parse gate. The crate-wide extension idiom: a downstream backend naming a value mediaframe has never heard of keeps that name, and it round-trips through as_str / FromStr / serde intact.

Requires the alloc feature (std includes it) — the payload is heap-capable. At the no-alloc tier the vocabulary is closed and an unrecognised slug is rejected instead.

Implementations

impl DynamicRange

pub const fn is_unspecified(&self) -> bool

Returns true if this value is of type Unspecified. Returns false otherwise

pub const fn is_limited(&self) -> bool

Returns true if this value is of type Limited. Returns false otherwise

pub const fn is_full(&self) -> bool

Returns true if this value is of type Full. Returns false otherwise

pub const fn is_other(&self) -> bool

Returns true if this value is of type Other. Returns false otherwise

impl DynamicRange

pub fn as_str(&self) -> &str

Lowercase FFmpeg-style identifier for this variant (AVCOL_RANGE_* slug; tv / pc).

pub const fn to_u32(&self) -> Option<u32>

The FFmpeg AVColorRange code point.

None for Self::Other: it names something FFmpeg has no code for, and inventing one would lose the name.

pub const fn from_u32(v: u32) -> Option<Self>

Decodes from the FFmpeg AVColorRange code produced by Self::to_u32.

None for a code this build names nothing for — a number is FFmpeg’s spelling, not a name to preserve.

pub fn other(slug: impl AsRef<str>) -> Self

Available on crate features alloc or std only.

The open escape for a slug this vocabulary does not name, ASCII-folded to the crate’s lowercase canon.

The one construction path for Self::Other: folding here is what keeps the whole value space lowercase-canonical, so the derived Eq / Hash compare names rather than spellings. Constructing the variant directly bypasses the fold and is not the supported spelling.

impl DynamicRange

pub const ROSTER: &'static [Self]

Every dynamic range this vocabulary names, in declaration order.

A slice rather than an array: how many names this build carries is a fact about the release, not part of the type, so a later addition stays a minor change.

The open escape arm is not a member. The roster answers “which names does this build know”, and the escape is precisely the arm that carries a name it does not — listing it would need a slug to put in it, and there isn’t one.

Trait Implementations

impl Arbitrary for DynamicRange

Available on crate feature quickcheck only.

fn arbitrary(__quickcheck_g: &mut Gen) -> Self

Return an arbitrary value.

fn shrink(&self) -> Box<dyn Iterator<Item = Self>>

Return an iterator of values that are smaller than itself.

impl<'a> Arbitrary<'a> for DynamicRange

Available on crate feature arbitrary only.

fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self>

Generate an arbitrary value of Self from the given unstructured data.

fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self, Error>

Generate an arbitrary value of Self from the entirety of the given unstructured data.

fn size_hint(depth: usize) -> (usize, Option<usize>)

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

impl Clone for DynamicRange

fn clone(&self) -> DynamicRange

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DynamicRange

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

Formats the value using the given formatter.

impl Default for DynamicRange

fn default() -> Self

Returns the “default value” for a type.

impl DefaultInstance for DynamicRange

Available on crate feature buffa only.

fn default_instance() -> &'static Self

Return a reference to the single default instance of this type.

impl<'de> Deserialize<'de> for DynamicRange

Available on crate feature serde only.

fn deserialize<D: Deserializer<'de>>(de: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl Display for DynamicRange

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

Formats the value using the given formatter.

impl Eq for DynamicRange

impl FromStr for DynamicRange

type Err = Infallible

Infallible wherever the escape arm exists, which is exactly where the parse is total; the vocabulary’s own refusal at the no-alloc tier, where it is closed. The predicate is the one that gates Self::Other, so the two cannot drift.

fn from_str(s: &str) -> Result<Self, Self::Err>

Reads a sample-range name: the canonical slug Self::as_str renders, or FFmpeg’s spelling of the same code point where the two differ.

Emission is injective and canonical — never a synonym — so parse(display(x)) == x holds for every named variant. Parse also takes av_color_range_name’s unknown (Self::Unspecified); tv and pc are already FFmpeg’s own spellings.

Errors

Returns ParseDynamicRangeError only at the no-alloc tier, where the vocabulary is closed. At the alloc / std tier this parse is total — a slug this type does not name rides Self::Other, ASCII-folded to lowercase by Self::other — and Self::Err is Infallible there, so the totality is checkable by the compiler rather than only promised here.

impl Hash for DynamicRange

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Message for DynamicRange

Available on crate feature buffa only.

fn compute_size(&self, _cache: &mut SizeCache) -> u32

Compute the encoded byte size of this message, recording nested sub-message sizes in cache for write_to to consume.

fn write_to(&self, _cache: &mut SizeCache, buf: &mut impl EncodeSink)

Write this message’s encoded bytes to a buffer, consuming nested-message sizes from cache (populated by a prior compute_size call on the same cache).

fn merge_field( &mut self, tag: Tag, buf: &mut impl Buf, ctx: DecodeContext<'_>, ) -> Result<(), DecodeError>

Processes a single already-decoded tag and its associated field data from buf.

fn clear(&mut self)

Clear all fields to their default values.

fn encode(&self, buf: &mut impl EncodeSink)

Compute size, then write. This is the primary encoding API.

fn try_encode(&self, buf: &mut impl EncodeSink) -> Result<(), EncodeError>

Encode, returning an error instead of panicking if the encoded size exceeds the 2 GiB protobuf limit (MAX_MESSAGE_BYTES).

fn encode_with_cache(&self, cache: &mut SizeCache, buf: &mut impl EncodeSink)

Encode using a caller-supplied SizeCache, for reuse across many encodes in a hot loop. Clears the cache first.

fn try_encode_with_cache( &self, cache: &mut SizeCache, buf: &mut impl EncodeSink, ) -> Result<(), EncodeError>

Encode with a caller-supplied SizeCache, returning an error instead of panicking if the encoded size exceeds the 2 GiB protobuf limit (MAX_MESSAGE_BYTES). Clears the cache first.

fn try_encode_bounded( &self, max_bytes: u32, buf: &mut impl EncodeSink, ) -> Result<u32, EncodeError>

Encode this message into buf only if its encoded size fits within max_bytes, using a single size pass that is then reused for the write.

fn try_encode_bounded_with_cache( &self, max_bytes: u32, cache: &mut SizeCache, buf: &mut impl EncodeSink, ) -> Result<u32, EncodeError>

Like try_encode_bounded but reuses an existing SizeCache, clearing it first.

fn encoded_len(&self) -> u32

Compute the encoded byte size of this message.

fn try_encoded_len(&self) -> Result<u32, EncodeError>

Compute the encoded byte size, returning an error instead of panicking if it exceeds the 2 GiB protobuf limit (MAX_MESSAGE_BYTES).

fn encode_length_delimited(&self, buf: &mut impl EncodeSink)

Encode this message as a length-delimited byte sequence.

fn try_encode_length_delimited( &self, buf: &mut impl EncodeSink, ) -> Result<(), EncodeError>

Encode as a length-delimited byte sequence, returning an error instead of panicking if the encoded size exceeds the 2 GiB protobuf limit (MAX_MESSAGE_BYTES).

fn encode_to_vec(&self) -> Vec<u8>

Encode this message to a new Vec<u8>.

fn try_encode_to_vec(&self) -> Result<Vec<u8>, EncodeError>

Encode to a new Vec<u8>, returning an error instead of panicking if the encoded size exceeds the 2 GiB protobuf limit (MAX_MESSAGE_BYTES).

fn encode_to_bytes(&self) -> Bytes

Encode this message to a new bytes::Bytes.

fn try_encode_to_bytes(&self) -> Result<Bytes, EncodeError>

Encode to a new bytes::Bytes, returning an error instead of panicking if the encoded size exceeds the 2 GiB protobuf limit (MAX_MESSAGE_BYTES).

fn decode(buf: &mut impl Buf) -> Result<Self, DecodeError>

where Self: Sized,

Decode a message from a buffer.

fn decode_from_slice(data: &[u8]) -> Result<Self, DecodeError>

where Self: Sized,

Decode a message from a byte slice.

fn decode_length_delimited(buf: &mut impl Buf) -> Result<Self, DecodeError>

where Self: Sized,

Decode a length-delimited message from a buffer.

fn merge_to_limit( &mut self, buf: &mut impl Buf, ctx: DecodeContext<'_>, limit: usize, ) -> Result<(), DecodeError>

Merge fields from a buffer until buf.remaining() reaches limit.

fn merge_group( &mut self, buf: &mut impl Buf, ctx: DecodeContext<'_>, field_number: u32, ) -> Result<(), DecodeError>

Merges a group-encoded message from buf, reading fields until an EndGroup tag with the given field_number is encountered.

fn merge( &mut self, buf: &mut impl Buf, ctx: DecodeContext<'_>, ) -> Result<(), DecodeError>

Merge fields from a buffer into this message.

fn merge_from_slice(&mut self, data: &[u8]) -> Result<(), DecodeError>

Merge fields from a byte slice into this message.

fn merge_length_delimited( &mut self, buf: &mut impl Buf, ctx: DecodeContext<'_>, ) -> Result<(), DecodeError>

Merge fields from a length-delimited sub-message payload into this message.

impl PartialEq for DynamicRange

fn eq(&self, other: &DynamicRange) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for DynamicRange

Available on crate feature serde only.

fn serialize<S: Serializer>(&self, ser: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for DynamicRange