Enum StreamingQuality 

pub enum StreamingQuality {
    Original,
    Mbps20,
    Mbps10,
    Mbps8,
    Mbps4,
    Mbps2,
    Mbps1,
    Kbps720,
}

A ceiling on how much bandwidth a video stream may consume.

A quality step is a bundle of concrete transcode parameters — total stream ceiling, the audio share of it, and the resolution that ceiling can carry — not just a label. Those numbers are Jellyfin encoding domain vocabulary, so they live here and the frontend only ever names a variant; the labels the picker shows are served over IPC by player_get_streaming_qualities.

The ladder is deliberately expressed in bandwidth rather than resolution: it exists to fit a connection, and the resolution cap is chosen from the bitrate so the encoder does not spend a small budget on pixels it cannot afford. See docs/architecture/01-rust-backend.md (“Streaming quality ladder”).

TRACES: UR-074 | DR-162

Variants

Original

No client-imposed cap — the server may direct-play the source as-is.

Mbps20

Mbps10

Mbps8

Mbps4

Mbps2

Mbps1

Kbps720

Implementations

impl StreamingQuality

pub const ALL: [StreamingQuality; 8]

The ladder, highest first, for enumerating across the IPC boundary.

pub fn max_bitrate(&self) -> Option<u64>

Total bits per second the stream may use (video + audio), or None for the uncapped Original.

This is the number that goes to PlaybackInfo as MaxStreamingBitrate and into the device profile. Sending it there — not just on the transcode URL — is what makes the cap real: a stream the server decides to direct play is served at the source file’s own bitrate, and no URL parameter afterwards can reduce it.

pub fn audio_bitrate(&self) -> u64

Bits per second allotted to the audio track.

The value shrinks with the ladder because at the bottom rungs a fixed 384 kbps would be a third of the entire budget.

pub fn video_bitrate(&self) -> Option<u64>

Bits per second allotted to the video track: the total minus the audio share, so the two together honour max_bitrate rather than overshooting it by the size of the audio track.

pub fn max_height(&self) -> Option<u32>

Resolution ceiling that suits the bitrate, or None to leave the source resolution alone. Scaling down is what keeps a small budget looking like clean video instead of blocky 1080p.

pub fn label(&self) -> &'static str

Human label for the picker. Lives in Rust with the numbers it describes, so the two cannot drift apart.

pub fn detail(&self) -> &'static str

Secondary line for the picker: what the cap means in practice.

Trait Implementations

impl Clone for StreamingQuality

fn clone(&self) -> StreamingQuality

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for StreamingQuality

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

Formats the value using the given formatter.

impl Default for StreamingQuality

fn default() -> StreamingQuality

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for StreamingQuality

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl NamedType for StreamingQuality

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 StreamingQuality

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

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 StreamingQuality

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 StreamingQuality

impl Eq for StreamingQuality

impl StructuralPartialEq for StreamingQuality