Enum TrackOrigin 

#[non_exhaustive]
pub enum TrackOrigin {
    Embedded,
    Sidecar,
    External,
    Derived,
    Other(SmolStr),
}

Available on crate features alloc or std only.

Where this subtitle track came from, relative to the media file it accompanies.

Open vocabulary: the named variants cover the buckets a media pipeline sorts tracks into, and Self::Other carries a classification this build does not name. mediaframe is a shared library, not one pipeline’s private enum — the set of provenances worth distinguishing belongs to whoever is doing the classifying, so a downstream that tracks a distinction this crate has not heard of keeps its name rather than losing it to a nearby variant.

Embedded is the default — the typical case is a subtitle stream multiplexed inside the container. The named variants keep stable, append-only u32 ids; Self::Other has none (see Self::to_u32), so the slug from Self::as_str is the spelling that always survives.

#[non_exhaustive] is retained: promoting a slug that rides Other today into a named variant tomorrow stays a minor change.

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.

Embedded

Stream multiplexed into the container alongside the video / audio tracks (e.g. an .mkv with embedded .srt-equivalent subtitle streams). The default origin.

Sidecar

Separate subtitle file living next to the media file on disk — typically an external .srt / .vtt / .ass paired with the video by filename stem.

External

Externally sourced — downloaded from an online subtitle database, or otherwise obtained ready-made from outside the original media container. The track existed as subtitle text before this pipeline saw the media; contrast Self::Derived, which this pipeline produced from the media itself.

Derived

Produced by a processing pass over the media rather than obtained as subtitle text — an automatic-speech-recognition transcript, a machine translation of another track, OCR of image-based subtitles, or any comparable derivation.

The axis this variant adds is provenance-by-derivation: the bytes have no existence independent of a pipeline stage, so their quality, licensing and re-generability differ from a track that arrived as text. Self::External covers the arrived-as-text case even when the arrival was a download.

Other(SmolStr)

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

Implementations

impl TrackOrigin

pub const fn is_embedded(&self) -> bool

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

pub const fn is_sidecar(&self) -> bool

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

pub const fn is_external(&self) -> bool

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

pub const fn is_derived(&self) -> bool

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

pub const fn is_other(&self) -> bool

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

impl TrackOrigin

pub fn unwrap_embedded(self)

Unwraps this value to the TrackOrigin::Embedded variant. Panics if this value is of any other type.

pub fn unwrap_embedded_ref(&self)

Unwraps this reference to the TrackOrigin::Embedded variant. Panics if this value is of any other type.

pub fn unwrap_embedded_mut(&mut self)

Unwraps this mutable reference to the TrackOrigin::Embedded variant. Panics if this value is of any other type.

pub fn unwrap_sidecar(self)

Unwraps this value to the TrackOrigin::Sidecar variant. Panics if this value is of any other type.

pub fn unwrap_sidecar_ref(&self)

Unwraps this reference to the TrackOrigin::Sidecar variant. Panics if this value is of any other type.

pub fn unwrap_sidecar_mut(&mut self)

Unwraps this mutable reference to the TrackOrigin::Sidecar variant. Panics if this value is of any other type.

pub fn unwrap_external(self)

Unwraps this value to the TrackOrigin::External variant. Panics if this value is of any other type.

pub fn unwrap_external_ref(&self)

Unwraps this reference to the TrackOrigin::External variant. Panics if this value is of any other type.

pub fn unwrap_external_mut(&mut self)

Unwraps this mutable reference to the TrackOrigin::External variant. Panics if this value is of any other type.

pub fn unwrap_derived(self)

Unwraps this value to the TrackOrigin::Derived variant. Panics if this value is of any other type.

pub fn unwrap_derived_ref(&self)

Unwraps this reference to the TrackOrigin::Derived variant. Panics if this value is of any other type.

pub fn unwrap_derived_mut(&mut self)

Unwraps this mutable reference to the TrackOrigin::Derived variant. Panics if this value is of any other type.

pub fn unwrap_other(self) -> SmolStr

Unwraps this value to the TrackOrigin::Other variant. Panics if this value is of any other type.

pub fn unwrap_other_ref(&self) -> &SmolStr

Unwraps this reference to the TrackOrigin::Other variant. Panics if this value is of any other type.

pub fn unwrap_other_mut(&mut self) -> &mut SmolStr

Unwraps this mutable reference to the TrackOrigin::Other variant. Panics if this value is of any other type.

impl TrackOrigin

pub fn try_unwrap_embedded(self) -> Result<(), TryUnwrapError<Self>>

Attempts to unwrap this value to the TrackOrigin::Embedded variant. Returns a [TryUnwrapError] with the original value if this value is of any other type.

pub fn try_unwrap_embedded_ref(&self) -> Result<(), TryUnwrapError<&Self>>

Attempts to unwrap this reference to the TrackOrigin::Embedded variant. Returns a [TryUnwrapError] with the original value if this value is of any other type.

pub fn try_unwrap_embedded_mut( &mut self, ) -> Result<(), TryUnwrapError<&mut Self>>

Attempts to unwrap this mutable reference to the TrackOrigin::Embedded variant. Returns a [TryUnwrapError] with the original value if this value is of any other type.

pub fn try_unwrap_sidecar(self) -> Result<(), TryUnwrapError<Self>>

Attempts to unwrap this value to the TrackOrigin::Sidecar variant. Returns a [TryUnwrapError] with the original value if this value is of any other type.

pub fn try_unwrap_sidecar_ref(&self) -> Result<(), TryUnwrapError<&Self>>

Attempts to unwrap this reference to the TrackOrigin::Sidecar variant. Returns a [TryUnwrapError] with the original value if this value is of any other type.

pub fn try_unwrap_sidecar_mut( &mut self, ) -> Result<(), TryUnwrapError<&mut Self>>

Attempts to unwrap this mutable reference to the TrackOrigin::Sidecar variant. Returns a [TryUnwrapError] with the original value if this value is of any other type.

pub fn try_unwrap_external(self) -> Result<(), TryUnwrapError<Self>>

Attempts to unwrap this value to the TrackOrigin::External variant. Returns a [TryUnwrapError] with the original value if this value is of any other type.

pub fn try_unwrap_external_ref(&self) -> Result<(), TryUnwrapError<&Self>>

Attempts to unwrap this reference to the TrackOrigin::External variant. Returns a [TryUnwrapError] with the original value if this value is of any other type.

pub fn try_unwrap_external_mut( &mut self, ) -> Result<(), TryUnwrapError<&mut Self>>

Attempts to unwrap this mutable reference to the TrackOrigin::External variant. Returns a [TryUnwrapError] with the original value if this value is of any other type.

pub fn try_unwrap_derived(self) -> Result<(), TryUnwrapError<Self>>

Attempts to unwrap this value to the TrackOrigin::Derived variant. Returns a [TryUnwrapError] with the original value if this value is of any other type.

pub fn try_unwrap_derived_ref(&self) -> Result<(), TryUnwrapError<&Self>>

Attempts to unwrap this reference to the TrackOrigin::Derived variant. Returns a [TryUnwrapError] with the original value if this value is of any other type.

pub fn try_unwrap_derived_mut( &mut self, ) -> Result<(), TryUnwrapError<&mut Self>>

Attempts to unwrap this mutable reference to the TrackOrigin::Derived variant. Returns a [TryUnwrapError] with the original value if this value is of any other type.

pub fn try_unwrap_other(self) -> Result<SmolStr, TryUnwrapError<Self>>

Attempts to unwrap this value to the TrackOrigin::Other variant. Returns a [TryUnwrapError] with the original value if this value is of any other type.

pub fn try_unwrap_other_ref(&self) -> Result<&SmolStr, TryUnwrapError<&Self>>

Attempts to unwrap this reference to the TrackOrigin::Other variant. Returns a [TryUnwrapError] with the original value if this value is of any other type.

pub fn try_unwrap_other_mut( &mut self, ) -> Result<&mut SmolStr, TryUnwrapError<&mut Self>>

Attempts to unwrap this mutable reference to the TrackOrigin::Other variant. Returns a [TryUnwrapError] with the original value if this value is of any other type.

impl TrackOrigin

pub fn as_str(&self) -> &str

Canonical lowercase slug for this origin ("embedded" / "sidecar" / "external" / "derived"). Stable; matches what core::fmt::Display produces. Self::Other returns the wrapped slug verbatim.

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

Stable u32 wire id for the named origins: Embedded=0, Sidecar=1, External=2, Derived=3. Append-only — never renumber.

None for Self::Other: it names an origin this build has no id for, and inventing one would lose the name. The slug from Self::as_str is the spelling that always survives — which is why the wire codecs (serde, buffa) carry the slug and not this number.

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

Decodes from the stable u32 wire id produced by Self::to_u32. Unknown ids fall back to the default (Self::Embedded): the numeric space is this crate’s own and an id it never assigned carries no name to preserve, so Self::Other is not the right home for one. The round-trip is exact for the enumerated ids 0/1/2/3.

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

Strict counterpart to Self::from_u32: returns None for any code outside the enumerated set, instead of silently mapping it to the default. Used by the strict deserialize path so adversarial / corrupt wire values fail loudly rather than masquerading as Embedded.

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

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 TrackOrigin

pub const ROSTER: &'static [Self]

Every track origin 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 TrackOrigin

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 TrackOrigin

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 TrackOrigin

fn clone(&self) -> TrackOrigin

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TrackOrigin

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

Formats the value using the given formatter.

impl Default for TrackOrigin

fn default() -> TrackOrigin

Returns the “default value” for a type.

impl DefaultInstance for TrackOrigin

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 TrackOrigin

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 TrackOrigin

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

Formats the value using the given formatter.

impl Eq for TrackOrigin

impl FromStr for TrackOrigin

type Err = !

Unconditionally Infallible — unlike the all-tier vocabularies, this one needs no cfg split, because the module itself exists only where the escape does. There is no tier at which the parse can refuse, so there is nothing to fork.

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

Parses the canonical slug Self::as_str renders — the exact inverse of Display.

Errors

Never, and the type says so: a slug this vocabulary does not name rides Self::Other, ASCII-folded to lowercase by Self::other, so Self::Err is uninhabited and a caller can discharge it with an irrefutable let Ok(o) = s.parse::<TrackOrigin>();.

impl Hash for TrackOrigin

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 TrackOrigin

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 TrackOrigin

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for TrackOrigin

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 TrackOrigin