feat(iori): wip support for discontinued parts

Author: Yesterday17

crates/iori-hls/src/m3u8_rs.rs

@@ -76,23 +76,37 @@ impl From<m3u8_rs::Resolution> for Resolution {
 
 impl From<m3u8_rs::MediaPlaylist> for MediaPlaylist {
     fn from(value: m3u8_rs::MediaPlaylist) -> Self {
+        let mut current_part_index = value.discontinuity_sequence;
+        let mut segments = Vec::with_capacity(value.segments.len());
+
+        for segment in value.segments {
+            if segment.discontinuity {
+                current_part_index += 1;
+            }
+
+            let segment: crate::models::MediaSegment = (segment, current_part_index).into();
+            segments.push(segment);
+        }
+
         MediaPlaylist {
             media_sequence: value.media_sequence,
-            segments: value.segments.into_iter().map(MediaSegment::from).collect(),
+            segments,
             end_list: value.end_list,
+            discontinuity_sequence: value.discontinuity_sequence,
         }
     }
 }
 
-impl From<m3u8_rs::MediaSegment> for MediaSegment {
-    fn from(value: m3u8_rs::MediaSegment) -> Self {
+impl From<(m3u8_rs::MediaSegment, u64)> for MediaSegment {
+    fn from((value, part_index): (m3u8_rs::MediaSegment, u64)) -> Self {
         MediaSegment {
             uri: value.uri,
             duration: (value.duration as f64).into(),
             title: value.title,
             byte_range: value.byte_range.map(ByteRange::from),
             key: value.key.map(Key::from),
             map: value.map.map(Map::from),
+            part_index,
         }
     }
 }

crates/iori-hls/src/models.rs

@@ -104,6 +104,7 @@ impl From<hls::MediaType> for AlternativeMediaType {
 #[derive(Debug, Clone, PartialEq, Comparable)]
 pub struct MediaPlaylist {
     pub media_sequence: u64,
+    pub discontinuity_sequence: u64,
     pub segments: Vec<MediaSegment>,
     pub end_list: bool,
 }
@@ -116,6 +117,7 @@ pub struct MediaSegment {
     pub byte_range: Option<ByteRange>,
     pub key: Option<Key>,
     pub map: Option<Map>,
+    pub part_index: u64,
 }
 
 impl<'a>
@@ -125,15 +127,17 @@ impl<'a>
         Option<ByteRange>,
         Option<Key>,
         Option<Map>,
+        u64,
     )> for MediaSegment
 {
     fn from(
-        (inf, uri, byte_range, key, map): (
+        (inf, uri, byte_range, key, map, part_index): (
             hls::Inf<'a>,
             Cow<'a, str>,
             Option<ByteRange>,
             Option<Key>,
             Option<Map>,
+            u64,
         ),
     ) -> Self {
         Self {
@@ -146,6 +150,7 @@ impl<'a>
             byte_range,
             key,
             map,
+            part_index,
         }
     }
 }

crates/iori-hls/src/parse.rs

@@ -19,12 +19,14 @@ pub fn parse_playlist_res(input: &[u8]) -> Result<Playlist, M3u8ParseError> {
 
     // media playlist
     let mut media_sequence = 0;
+    let mut discontinuity_sequence = 0;
     let mut segments: Vec<MediaSegment> = Vec::new();
     let mut end_list = false;
 
     // Maps(initial segment information) and keys(encryption information)
     let mut current_key: Option<Key> = None;
     let mut current_map: Option<Map> = None;
+    let mut current_part_index = 0;
 
     // Pending tags, which should be cleared after the URI line is processed
     let mut pending_inf: Option<hls::Inf> = None;
@@ -35,6 +37,13 @@ pub fn parse_playlist_res(input: &[u8]) -> Result<Playlist, M3u8ParseError> {
         match line {
             HlsLine::KnownTag(KnownTag::Hls(tag)) => match tag {
                 hls::Tag::MediaSequence(seq) => media_sequence = seq.media_sequence(),
+                hls::Tag::DiscontinuitySequence(seq) => {
+                    discontinuity_sequence = seq.discontinuity_sequence();
+                    current_part_index = discontinuity_sequence;
+                }
+                hls::Tag::Discontinuity(_) => {
+                    current_part_index += 1;
+                }
                 hls::Tag::Inf(inf) => pending_inf = Some(inf),
                 hls::Tag::Byterange(range) => pending_byterange = Some(range.into()),
                 hls::Tag::Key(key) => current_key = Some(key.into()),
@@ -63,6 +72,7 @@ pub fn parse_playlist_res(input: &[u8]) -> Result<Playlist, M3u8ParseError> {
                             pending_byterange.take(),
                             current_key.clone(),
                             current_map.clone(),
+                            current_part_index,
                         )
                             .into(),
                     );
@@ -83,6 +93,7 @@ pub fn parse_playlist_res(input: &[u8]) -> Result<Playlist, M3u8ParseError> {
     } else {
         Playlist::MediaPlaylist(MediaPlaylist {
             media_sequence,
+            discontinuity_sequence,
             segments,
             end_list,
         })

crates/iori-hls/tests/cases.rs

@@ -12,7 +12,7 @@ fn test_accuracy_radiko_01() {
 }
 
 #[test]
-fn test_accuracy_archive_02() {
+fn test_accuracy_archive_01() {
     let data = include_bytes!("./fixtures/archive_01.m3u8");
     let old_result = iori_hls::m3u8_rs::parse_playlist_res(data);
     let new_result = iori_hls::parse::parse_playlist_res(data);
@@ -21,3 +21,14 @@ fn test_accuracy_archive_02() {
     let new_result = new_result.expect("New parse engine should not error");
     assert_changes!(old_result, new_result, Changed::Unchanged);
 }
+
+#[test]
+fn test_accuracy_archive_02() {
+    let data = include_bytes!("./fixtures/archive_02.m3u8");
+    let old_result = iori_hls::m3u8_rs::parse_playlist_res(data);
+    let new_result = iori_hls::parse::parse_playlist_res(data);
+
+    let old_result = old_result.expect("Old parse engine should not error");
+    let new_result = new_result.expect("New parse engine should not error");
+    assert_changes!(old_result, new_result, Changed::Unchanged);
+}

crates/iori-hls/tests/fixtures/archive_02.m3u8

@@ -0,0 +1,19 @@
+#EXTM3U
+#EXT-X-VERSION:3
+#EXT-X-TARGETDURATION:10
+#EXT-X-MEDIA-SEQUENCE:0
+#EXT-X-DISCONTINUITY-SEQUENCE:0
+
+#EXTINF:10.0,
+segment_0.ts
+#EXTINF:10.0,
+segment_1.ts
+
+#EXT-X-DISCONTINUITY
+#EXTINF:10.0,
+segment_2.ts
+#EXTINF:10.0,
+segment_3.ts
+
+#EXT-X-ENDLIST
+

crates/iori/src/hls/segment.rs

@@ -23,6 +23,8 @@ pub struct M3u8Segment {
     /// Media sequence id from the m3u8 file
     pub media_sequence: u64,
 
+    pub part_index: u64,
+
     pub duration: f64,
     pub format: SegmentFormat,
 }
@@ -59,6 +61,10 @@ impl StreamingSegment for M3u8Segment {
     fn format(&self) -> SegmentFormat {
         self.format.clone()
     }
+
+    fn part_index(&self) -> u64 {
+        self.part_index
+    }
 }
 
 impl RemoteStreamingSegment for M3u8Segment {

crates/iori/src/hls/source.rs

@@ -166,6 +166,7 @@ impl HlsMediaPlaylistSource {
                 initial_segment: initial_segment.clone(),
                 sequence: self.sequence.fetch_add(1, Ordering::Relaxed),
                 media_sequence,
+                part_index: segment.part_index,
                 byte_range: segment.byte_range.as_ref().map(|r| crate::ByteRange {
                     offset: r.offset.unwrap_or(next_range_start),
                     length: Some(r.length),

crates/iori/src/lib.rs

@@ -58,6 +58,7 @@ pub trait StreamingSource {
     ) -> impl Future<Output = IoriResult<impl Stream<Item = IoriResult<Vec<Self::Segment>>>>>;
 }
 
+/// A segment of a streaming source
 pub trait StreamingSegment {
     /// Stream id
     fn stream_id(&self) -> u64;
@@ -68,6 +69,11 @@ pub trait StreamingSegment {
     /// Sequence ID of the segment, starts from 0
     fn sequence(&self) -> u64;
 
+    /// Optional part index of the segment
+    fn part_index(&self) -> u64 {
+        0
+    }
+
     /// File name of the segment
     fn file_name(&self) -> &str;