Enum PlaybackKind 

pub enum PlaybackKind {
    DirectPlay,
    DirectStream,
    Transcode,
}

What the server is doing to the source to produce this stream.

Distinct from Transport because the two are genuinely independent: a direct-streamed remux and a transcode can both arrive over HLS, and a direct play can arrive progressively or as a local file. Keeping them apart is what lets the UI say “this is not costing the server anything” without inferring it from a URL shape.

TRACES: UR-079 | DR-228

Variants

DirectPlay

The source file is served untouched. No server CPU, no quality loss.

DirectStream

The container is repackaged but the codecs are copied — cheap, and visually identical to the source.

Transcode

The server is re-encoding. The only case where a bitrate ceiling can actually be honoured, and the only one that costs the server real work.

Implementations

impl PlaybackKind

pub fn needs_transcoding(&self) -> bool

Whether the server is spending encoder time on this stream.

The queue carries a needs_transcoding flag that predates this enum and that several seek/reload paths still branch on; this keeps the two from drifting by making one derive from the other.

TRACES: UR-079 | DR-228

Trait Implementations

impl Clone for PlaybackKind

fn clone(&self) -> PlaybackKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PlaybackKind

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for PlaybackKind

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl NamedType for PlaybackKind

fn sid() -> SpectaID

fn named_data_type( type_map: &mut TypeCollection, generics: &[DataType], ) -> NamedDataType

this is equivalent to [Type::inline] but returns a [NamedDataType] instead.

fn definition_named_data_type(type_map: &mut TypeCollection) -> NamedDataType

this is equivalent to [Type::definition] but returns a [NamedDataType] instead.

impl PartialEq for PlaybackKind

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

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Type for PlaybackKind

fn inline(type_map: &mut TypeCollection, generics: Generics<'_>) -> DataType

Returns the definition of a type using the provided generics.

fn reference(type_map: &mut TypeCollection, generics: &[DataType]) -> Reference

Generates a datatype corresponding to a reference to this type, as determined by its category. Getting a reference to a type implies that it should belong in the type map (since it has to be referenced from somewhere), so the output of definition will be put into the type map.

impl Copy for PlaybackKind

impl Eq for PlaybackKind

impl Flatten for PlaybackKind

impl StructuralPartialEq for PlaybackKind