oximedia-net 0.1.2

Network streaming for OxiMedia
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

//! HLS playlist builders.

use crate::hls::{MasterPlaylist, MediaPlaylist, Segment, StreamInf, VariantStream};
use std::time::Duration;

/// Master playlist builder.
pub struct MasterPlaylistBuilder {
    playlist: MasterPlaylist,
}

impl MasterPlaylistBuilder {
    /// Creates a new master playlist builder.
    #[must_use]
    pub fn new() -> Self {
        Self {
            playlist: MasterPlaylist::new(),
        }
    }

    /// Sets HLS version.
    #[must_use]
    pub fn version(mut self, version: u8) -> Self {
        self.playlist.version = version;
        self
    }

    /// Enables independent segments.
    #[must_use]
    pub fn independent_segments(mut self) -> Self {
        self.playlist.independent_segments = true;
        self
    }

    /// Adds a variant stream.
    #[must_use]
    pub fn add_variant(
        mut self,
        bandwidth: u64,
        resolution: (u32, u32),
        codecs: impl Into<String>,
        uri: impl Into<String>,
    ) -> Self {
        let stream_inf = StreamInf {
            bandwidth,
            average_bandwidth: Some(bandwidth),
            codecs: Some(codecs.into()),
            resolution: Some(resolution),
            frame_rate: Some(30.0),
            hdcp_level: None,
            audio: None,
            video: None,
            subtitles: None,
            closed_captions: None,
        };

        self.playlist.variants.push(VariantStream {
            stream_inf,
            uri: uri.into(),
        });

        self
    }

    /// Builds the master playlist.
    #[must_use]
    pub fn build(self) -> MasterPlaylist {
        self.playlist
    }
}

impl Default for MasterPlaylistBuilder {
    fn default() -> Self {
        Self::new()
    }
}

/// Media playlist builder.
pub struct MediaPlaylistBuilder {
    playlist: MediaPlaylist,
}

impl MediaPlaylistBuilder {
    /// Creates a new media playlist builder.
    #[must_use]
    pub fn new() -> Self {
        Self {
            playlist: MediaPlaylist::new(),
        }
    }

    /// Sets HLS version.
    #[must_use]
    pub fn version(mut self, version: u8) -> Self {
        self.playlist.version = version;
        self
    }

    /// Sets target duration.
    #[must_use]
    pub fn target_duration(mut self, duration: u64) -> Self {
        self.playlist.target_duration = duration;
        self
    }

    /// Sets media sequence.
    #[must_use]
    pub fn media_sequence(mut self, sequence: u64) -> Self {
        self.playlist.media_sequence = sequence;
        self
    }

    /// Sets playlist type.
    #[must_use]
    pub fn playlist_type(mut self, ptype: crate::hls::PlaylistType) -> Self {
        self.playlist.playlist_type = Some(ptype);
        self
    }

    /// Adds a segment.
    #[must_use]
    pub fn add_segment(mut self, duration: Duration, uri: impl Into<String>) -> Self {
        self.playlist
            .segments
            .push(Segment::new(duration, uri.into()));
        self
    }

    /// Marks playlist as ended.
    #[must_use]
    pub fn ended(mut self) -> Self {
        self.playlist.ended = true;
        self
    }

    /// Builds the media playlist.
    #[must_use]
    pub fn build(self) -> MediaPlaylist {
        self.playlist
    }
}

impl Default for MediaPlaylistBuilder {
    fn default() -> Self {
        Self::new()
    }
}