Struct hls_m3u8::MasterPlaylist

#[non_exhaustive]
pub struct MasterPlaylist<'a> {
    pub has_independent_segments: bool,
    pub start: Option<ExtXStart>,
    pub media: Vec<ExtXMedia<'a>>,
    pub variant_streams: Vec<VariantStream<'a>>,
    pub session_data: Vec<ExtXSessionData<'a>>,
    pub session_keys: Vec<ExtXSessionKey<'a>>,
    pub unknown_tags: Vec<Cow<'a, str>>,
}

The master playlist describes all of the available variants for your content.

Each variant is a version of the stream at a particular bitrate and is contained in a separate playlist called MediaPlaylist.

Examples

A MasterPlaylist can be parsed from a str:

use core::convert::TryFrom;
use hls_m3u8::MasterPlaylist;

// the concat! macro joins multiple `&'static str`.
let master_playlist = MasterPlaylist::try_from(concat!(
    "#EXTM3U\n",
    "#EXT-X-STREAM-INF:",
    "BANDWIDTH=150000,CODECS=\"avc1.42e00a,mp4a.40.2\",RESOLUTION=416x234\n",
    "http://example.com/low/index.m3u8\n",
    "#EXT-X-STREAM-INF:",
    "BANDWIDTH=240000,CODECS=\"avc1.42e00a,mp4a.40.2\",RESOLUTION=416x234\n",
    "http://example.com/lo_mid/index.m3u8\n",
    "#EXT-X-STREAM-INF:",
    "BANDWIDTH=440000,CODECS=\"avc1.42e00a,mp4a.40.2\",RESOLUTION=416x234\n",
    "http://example.com/hi_mid/index.m3u8\n",
    "#EXT-X-STREAM-INF:",
    "BANDWIDTH=640000,CODECS=\"avc1.42e00a,mp4a.40.2\",RESOLUTION=640x360\n",
    "http://example.com/high/index.m3u8\n",
    "#EXT-X-STREAM-INF:BANDWIDTH=64000,CODECS=\"mp4a.40.5\"\n",
    "http://example.com/audio/index.m3u8\n"
))?;

println!("{}", master_playlist.has_independent_segments);

or it can be constructed through a builder

use hls_m3u8::tags::{ExtXStart, VariantStream};
use hls_m3u8::types::{Float, StreamData};

MasterPlaylist::builder()
    .variant_streams(vec![
        VariantStream::ExtXStreamInf {
            uri: "http://example.com/low/index.m3u8".into(),
            frame_rate: None,
            audio: None,
            subtitles: None,
            closed_captions: None,
            stream_data: StreamData::builder()
                .bandwidth(150000)
                .codecs(&["avc1.42e00a", "mp4a.40.2"])
                .resolution((416, 234))
                .build()
                .unwrap(),
        },
        VariantStream::ExtXStreamInf {
            uri: "http://example.com/lo_mid/index.m3u8".into(),
            frame_rate: None,
            audio: None,
            subtitles: None,
            closed_captions: None,
            stream_data: StreamData::builder()
                .bandwidth(240000)
                .codecs(&["avc1.42e00a", "mp4a.40.2"])
                .resolution((416, 234))
                .build()
                .unwrap(),
        },
    ])
    .has_independent_segments(true)
    .start(ExtXStart::new(Float::new(1.23)))
    .build()?;

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

has_independent_segments: bool

Indicates that all media samples in a MediaSegment can be decoded without information from other segments.

Note

This field is optional and by default false. If the field is true, it applies to every MediaSegment in every MediaPlaylist of this MasterPlaylist.

start: Option<ExtXStart>

A preferred point at which to start playing a playlist.

Note

This field is optional and by default the playlist should be played from the start.

media: Vec<ExtXMedia<'a>>

A list of all ExtXMedia tags, which describe an alternative rendition.

For example, three ExtXMedia tags can be used to identify audio-only MediaPlaylists, that contain English, French, and Spanish renditions of the same presentation. Or, two ExtXMedia tags can be used to identify video-only MediaPlaylists that show two different camera angles.

Note

This field is optional.

variant_streams: Vec<VariantStream<'a>>

A list of all streams of this MasterPlaylist.

Note

This field is optional.

session_data: Vec<ExtXSessionData<'a>>

The ExtXSessionData tag allows arbitrary session data to be carried in a MasterPlaylist.

Note

This field is optional.

session_keys: Vec<ExtXSessionKey<'a>>

A list of ExtXSessionKeys, that allows the client to preload these keys without having to read the MediaPlaylists first.

Note

This field is optional.

unknown_tags: Vec<Cow<'a, str>>

A list of all tags that could not be identified while parsing the input.

Note

This field is optional.

Implementations

impl<'a> MasterPlaylist<'a>

pub fn builder() -> MasterPlaylistBuilder<'a>

Returns a builder for a MasterPlaylist.

Example

use hls_m3u8::tags::{ExtXStart, VariantStream};
use hls_m3u8::types::{Float, StreamData};

MasterPlaylist::builder()
    .variant_streams(vec![
        VariantStream::ExtXStreamInf {
            uri: "http://example.com/low/index.m3u8".into(),
            frame_rate: None,
            audio: None,
            subtitles: None,
            closed_captions: None,
            stream_data: StreamData::builder()
                .bandwidth(150000)
                .codecs(&["avc1.42e00a", "mp4a.40.2"])
                .resolution((416, 234))
                .build()
                .unwrap(),
        },
        VariantStream::ExtXStreamInf {
            uri: "http://example.com/lo_mid/index.m3u8".into(),
            frame_rate: None,
            audio: None,
            subtitles: None,
            closed_captions: None,
            stream_data: StreamData::builder()
                .bandwidth(240000)
                .codecs(&["avc1.42e00a", "mp4a.40.2"])
                .resolution((416, 234))
                .build()
                .unwrap(),
        },
    ])
    .has_independent_segments(true)
    .start(ExtXStart::new(Float::new(1.23)))
    .build()?;

pub fn audio_streams(&self) -> impl Iterator<Item = &VariantStream<'a>>

Returns all streams, which have an audio group id.

pub fn video_streams(&self) -> impl Iterator<Item = &VariantStream<'a>>

Returns all streams, which have a video group id.

pub fn unassociated_streams(&self) -> impl Iterator<Item = &VariantStream<'a>>

Returns all streams, which have no group id.

pub fn associated_with<'b>(
    &'b self,
    stream: &'b VariantStream<'_>
) -> impl Iterator<Item = &ExtXMedia<'a>> + 'b

Returns all ExtXMedia tags, associated with the provided stream.

pub fn into_owned(self) -> MasterPlaylist<'static>

Makes the struct independent of its lifetime, by taking ownership of all internal Cows.

Note

This is a relatively expensive operation.

Trait Implementations

impl<'a> Clone for MasterPlaylist<'a>

fn clone(&self) -> MasterPlaylist<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for MasterPlaylist<'a>

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

Formats the value using the given formatter.

impl<'a> Default for MasterPlaylist<'a>

fn default() -> MasterPlaylist<'a>

Returns the “default value” for a type.

impl<'a> Display for MasterPlaylist<'a>

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

Formats the value using the given formatter.

impl<'a> Hash for MasterPlaylist<'a>

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, 

Feeds a slice of this type into the given Hasher.

impl<'a> Ord for MasterPlaylist<'a>

fn cmp(&self, other: &MasterPlaylist<'a>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl<'a> PartialEq<MasterPlaylist<'a>> for MasterPlaylist<'a>

fn eq(&self, other: &MasterPlaylist<'a>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &MasterPlaylist<'a>) -> bool

This method tests for !=.

impl<'a> PartialOrd<MasterPlaylist<'a>> for MasterPlaylist<'a>

fn partial_cmp(&self, other: &MasterPlaylist<'a>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a> TryFrom<&'a str> for MasterPlaylist<'a>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(input: &'a str) -> Result<Self, Self::Error>

Performs the conversion.

impl<'a> Eq for MasterPlaylist<'a>

impl<'a> StructuralEq for MasterPlaylist<'a>

impl<'a> StructuralPartialEq for MasterPlaylist<'a>