rx-player 4.5.0 → 4.6.0-dev.2026100600

package/src/parsers/manifest/dash/wasm-parser/rs/processor/mod.rs

@@ -1,19 +1,15 @@
-use quick_xml::events::Event;
-use quick_xml::Reader;
-use std::io::BufReader;
-
 mod attributes;
 mod s_element;
 
 use crate::errors::ParsingError;
 use crate::events::*;
 use crate::reader::MPDReader;
+use crate::xml::{Event, Reader};
 
 pub use s_element::SegmentObject;
 
 pub struct MPDProcessor {
-    reader: quick_xml::Reader<BufReader<MPDReader>>,
-    reader_buf: Vec<u8>,
+    reader: Reader<MPDReader>,
     segment_objs_buf: Vec<SegmentObject>,
 }
 
@@ -22,23 +18,18 @@ impl MPDProcessor {
     ///
     /// # Arguments
     ///
-    /// * `reader` - A BufReader allowing to read the MPD document
-    pub fn new(reader: BufReader<MPDReader>) -> Self {
-        let mut reader = Reader::from_reader(reader);
-        reader.expand_empty_elements(true);
-        reader.trim_text(true);
-        reader.check_end_names(false);
+    /// * `reader` - Reader allowing to read the MPD document
+    pub fn new(reader: MPDReader) -> Self {
         MPDProcessor {
-            reader,
-            reader_buf: Vec::new(),
+            reader: Reader::new(reader),
             segment_objs_buf: Vec::new(),
         }
     }
 
-    pub fn process_tags(&mut self) {
+    pub fn process(&mut self) {
         loop {
-            match self.read_next_event() {
-                Ok(Event::Start(tag)) => match tag.name().as_ref() {
+            match self.reader.read_event() {
+                Ok(Event::Start(tag)) => match tag.name() {
                     b"MPD" => {
                         TagName::MPD.report_tag_open();
                         attributes::report_mpd_attrs(&tag);
@@ -87,7 +78,10 @@ impl MPDProcessor {
                         TagName::SegmentBase.report_tag_open();
                         attributes::report_segment_base_attrs(&tag);
                     }
-                    b"Initialization" => attributes::report_initialization_attrs(&tag),
+                    b"Initialization" => {
+                        TagName::Initialization.report_tag_open();
+                        attributes::report_initialization_attrs(&tag);
+                    }
                     b"SegmentTemplate" => {
                         TagName::SegmentTemplate.report_tag_open();
                         attributes::report_segment_template_attrs(&tag);
@@ -112,7 +106,7 @@ impl MPDProcessor {
                         attributes::report_base_url_attrs(&tag);
                         self.process_base_url_element();
                     }
-                    b"cenc:pssh" => self.process_cenc_element(),
+                    b"cenc:pssh" => self.process_cenc_pssh_element(),
                     b"Location" => self.process_location_element(),
                     b"Label" => {
                         TagName::Label.report_tag_open();
@@ -128,7 +122,116 @@ impl MPDProcessor {
 
                     _ => {}
                 },
-                Ok(Event::End(tag)) => match tag.name().as_ref() {
+                // Handle empty elements directly. Expanding them into synthetic Start and End
+                // events adds substantial work on large explicit SegmentTimelines, where every
+                // `<S />` is empty.
+                Ok(Event::Empty(tag)) => match tag.name() {
+                    b"MPD" => {
+                        TagName::MPD.report_tag_open();
+                        attributes::report_mpd_attrs(&tag);
+                        TagName::MPD.report_tag_close();
+                    }
+                    b"Period" => {
+                        TagName::Period.report_tag_open();
+                        attributes::report_period_attrs(&tag);
+                        TagName::Period.report_tag_close();
+                    }
+                    b"AdaptationSet" => {
+                        TagName::AdaptationSet.report_tag_open();
+                        attributes::report_adaptation_set_attrs(&tag);
+                        TagName::AdaptationSet.report_tag_close();
+                    }
+                    b"Representation" => {
+                        TagName::Representation.report_tag_open();
+                        attributes::report_representation_attrs(&tag);
+                        TagName::Representation.report_tag_close();
+                    }
+                    b"Accessibility" => {
+                        TagName::Accessibility.report_tag_open();
+                        attributes::report_scheme_attrs(&tag);
+                        TagName::Accessibility.report_tag_close();
+                    }
+                    b"ContentComponent" => {
+                        TagName::ContentComponent.report_tag_open();
+                        attributes::report_content_component_attrs(&tag);
+                        TagName::ContentComponent.report_tag_close();
+                    }
+                    b"ContentProtection" => {
+                        TagName::ContentProtection.report_tag_open();
+                        attributes::report_content_protection_attrs(&tag);
+                        TagName::ContentProtection.report_tag_close();
+                    }
+                    b"EssentialProperty" => {
+                        TagName::EssentialProperty.report_tag_open();
+                        attributes::report_scheme_attrs(&tag);
+                        TagName::EssentialProperty.report_tag_close();
+                    }
+                    b"InbandEventStream" => {
+                        TagName::InbandEventStream.report_tag_open();
+                        attributes::report_scheme_attrs(&tag);
+                        TagName::InbandEventStream.report_tag_close();
+                    }
+                    b"Role" => {
+                        TagName::Role.report_tag_open();
+                        attributes::report_scheme_attrs(&tag);
+                        TagName::Role.report_tag_close();
+                    }
+                    b"SupplementalProperty" => {
+                        TagName::SupplementalProperty.report_tag_open();
+                        attributes::report_scheme_attrs(&tag);
+                        TagName::SupplementalProperty.report_tag_close();
+                    }
+                    b"SegmentBase" => {
+                        TagName::SegmentBase.report_tag_open();
+                        attributes::report_segment_base_attrs(&tag);
+                        TagName::SegmentBase.report_tag_close();
+                    }
+                    b"Initialization" => {
+                        TagName::Initialization.report_tag_open();
+                        attributes::report_initialization_attrs(&tag);
+                        TagName::Initialization.report_tag_close();
+                    }
+                    b"SegmentTemplate" => {
+                        TagName::SegmentTemplate.report_tag_open();
+                        attributes::report_segment_template_attrs(&tag);
+                        TagName::SegmentTemplate.report_tag_close();
+                    }
+                    b"SegmentList" => {
+                        TagName::SegmentList.report_tag_open();
+                        attributes::report_segment_base_attrs(&tag);
+                        TagName::SegmentList.report_tag_close();
+                    }
+                    b"SegmentURL" => {
+                        TagName::SegmentUrl.report_tag_open();
+                        attributes::report_segment_url_attrs(&tag);
+                        TagName::SegmentUrl.report_tag_close();
+                    }
+                    b"UTCTiming" => {
+                        TagName::UtcTiming.report_tag_open();
+                        attributes::report_scheme_attrs(&tag);
+                        TagName::UtcTiming.report_tag_close();
+                    }
+                    b"BaseURL" => {
+                        TagName::BaseURL.report_tag_open();
+                        attributes::report_base_url_attrs(&tag);
+                        TagName::BaseURL.report_tag_close();
+                    }
+                    b"Label" => {
+                        TagName::Label.report_tag_open();
+                        TagName::Label.report_tag_close();
+                    }
+                    b"SegmentTimeline" => {
+                        AttributeName::SegmentTimeline.report(&[] as &[SegmentObject])
+                    }
+                    b"EventStream" => {
+                        TagName::EventStream.report_tag_open();
+                        attributes::report_event_stream_attrs(&tag);
+                        TagName::EventStream.report_tag_close();
+                    }
+                    // Empty Location and cenc:pssh elements have no content to report.
+                    _ => {}
+                },
+                Ok(Event::End(tag)) => match tag {
                     b"MPD" => TagName::MPD.report_tag_close(),
                     b"Period" => TagName::Period.report_tag_close(),
                     b"AdaptationSet" => TagName::AdaptationSet.report_tag_close(),
@@ -144,41 +247,25 @@ impl MPDProcessor {
                     b"SegmentList" => TagName::SegmentList.report_tag_close(),
                     b"SegmentURL" => TagName::SegmentUrl.report_tag_close(),
                     b"SegmentTemplate" => TagName::SegmentTemplate.report_tag_close(),
+                    b"Initialization" => TagName::Initialization.report_tag_close(),
                     b"UTCTiming" => TagName::UtcTiming.report_tag_close(),
                     _ => {}
                 },
                 Ok(Event::Eof) => {
                     break;
                 }
-                Err(e) => ParsingError::from(e).report_err(),
+                Err(e) => e.report_err(),
                 _ => (),
             }
         }
     }
 
-    /// Read the MPD document until an "Event" (@see quick-xml documentation)
-    /// is encountered.
-    ///
-    /// This method is always inlined for optimization reasons as it is both
-    /// short and generally used in loops.
-    #[inline(always)]
-    fn read_next_event<'a>(&'a mut self) -> quick_xml::Result<quick_xml::events::Event<'a>> {
-        if !self.reader_buf.is_empty() {
-            self.reader_buf.clear();
-        }
-        self.reader.read_event_into(&mut self.reader_buf)
-    }
-
     /// Loop over a SegmentTimeline's children (to call when a <SegmentTimeline>
     /// node just has been found).
     ///
     /// Report its children tag and attributes until either its corresponding
-    /// closing SegmentTemplate tag has been found or until EOF is encountered.
+    /// closing SegmentTimeline tag has been found or until EOF is encountered.
     fn process_segment_timeline_element(&mut self) {
-        // Count inner SegmentTimeline tags if it exists.
-        // Allowing to not close the current node when it is an inner that is closed
-        let mut inner_tag: u32 = 0;
-
         // Will store the ending timestamp of the previous <S> element, starting
         // at `0`.
         // Most subsequent <S> elements won't explicitly indicate a starting
@@ -187,8 +274,8 @@ impl MPDProcessor {
         let mut curr_time_base: f64 = 0.;
 
         loop {
-            match self.read_next_event() {
-                Ok(Event::Start(tag)) | Ok(Event::Empty(tag)) if tag.name().as_ref() == b"S" => {
+            match self.reader.read_event() {
+                Ok(Event::Start(tag)) | Ok(Event::Empty(tag)) if tag.name() == b"S" => {
                     match SegmentObject::from_s_element(&tag, curr_time_base) {
                         Ok(segment_obj) => {
                             if segment_obj.repeat_count == 0. {
@@ -203,16 +290,9 @@ impl MPDProcessor {
                         Err(err) => err.report_err(),
                     }
                 }
-                Ok(Event::Start(tag)) if tag.name().as_ref() == b"SegmentTimeline" => {
-                    inner_tag += 1
-                }
-                Ok(Event::End(tag)) if tag.name().as_ref() == b"SegmentTimeline" => {
-                    if inner_tag > 0 {
-                        inner_tag -= 1;
-                    } else {
-                        AttributeName::SegmentTimeline.report(self.segment_objs_buf.as_slice());
-                        break;
-                    }
+                Ok(Event::End(name)) if name == b"SegmentTimeline" => {
+                    AttributeName::SegmentTimeline.report(self.segment_objs_buf.as_slice());
+                    break;
                 }
                 Ok(Event::Eof) => {
                     ParsingError("Unexpected end of file in a SegmentTimeline.".to_owned())
@@ -220,7 +300,7 @@ impl MPDProcessor {
                     break;
                 }
                 Err(e) => {
-                    ParsingError::from(e).report_err();
+                    e.report_err();
                     break;
                 }
                 _ => (),
@@ -230,206 +310,109 @@ impl MPDProcessor {
     }
 
     fn process_location_element(&mut self) {
-        // Count inner Location tags if it exists.
-        // Allowing to not close the current node when it is an inner that is closed
-        let mut inner_tag: u32 = 0;
-
-        loop {
-            match self.read_next_event() {
-                Ok(Event::Text(t)) => {
-                    if t.len() > 0 {
-                        match t.unescape() {
-                            Ok(unescaped) => AttributeName::Location.report(unescaped),
-                            Err(err) => ParsingError::from(err).report_err(),
-                        }
-                    }
-                }
-                Ok(Event::Start(tag)) if tag.name().as_ref() == b"Location" => inner_tag += 1,
-                Ok(Event::End(tag)) if tag.name().as_ref() == b"Location" => {
-                    if inner_tag > 0 {
-                        inner_tag -= 1;
-                    } else {
-                        break;
-                    }
-                }
-                Ok(Event::Eof) => {
-                    ParsingError("Unexpected end of file in a Location tag.".to_owned())
-                        .report_err();
-                    break;
-                }
-                Err(e) => {
-                    ParsingError::from(e).report_err();
-                    break;
-                }
-                _ => (),
-            }
-            self.reader_buf.clear();
-        }
+        self.process_text_element(
+            b"Location",
+            AttributeName::Location,
+            None,
+            "Unexpected end of file in a Location tag.",
+        );
     }
 
     fn process_label_element(&mut self) {
-        // Count inner Label tags if it exists.
-        // Allowing to not close the current node when it is an inner that is closed
-        let mut inner_tag: u32 = 0;
-
-        loop {
-            match self.read_next_event() {
-                Ok(Event::Text(t)) => {
-                    if t.len() > 0 {
-                        match t.unescape() {
-                            Ok(unescaped) => AttributeName::Text.report(unescaped),
-                            Err(err) => ParsingError::from(err).report_err(),
-                        }
-                    }
-                }
-                Ok(Event::Start(tag)) if tag.name().as_ref() == b"Label" => inner_tag += 1,
-                Ok(Event::End(tag)) if tag.name().as_ref() == b"Label" => {
-                    if inner_tag > 0 {
-                        inner_tag -= 1;
-                    } else {
-                        TagName::Label.report_tag_close();
-                        break;
-                    }
-                }
-                Ok(Event::Eof) => {
-                    ParsingError("Unexpected end of file in a Label tag.".to_owned()).report_err();
-                    break;
-                }
-                Err(e) => {
-                    ParsingError::from(e).report_err();
-                    break;
-                }
-                _ => (),
-            }
-            self.reader_buf.clear();
-        }
+        self.process_text_element(
+            b"Label",
+            AttributeName::Text,
+            Some(TagName::Label),
+            "Unexpected end of file in a Label tag.",
+        );
     }
 
     fn process_base_url_element(&mut self) {
-        // Count inner BaseURL tags if it exists.
-        // Allowing to not close the current node when it is an inner that is closed
-        let mut inner_tag: u32 = 0;
-
-        loop {
-            match self.read_next_event() {
-                Ok(Event::Text(t)) => {
-                    if t.len() > 0 {
-                        match t.unescape() {
-                            Ok(unescaped) => AttributeName::Text.report(unescaped),
-                            Err(err) => ParsingError::from(err).report_err(),
-                        }
-                    }
-                }
-                Ok(Event::Start(tag)) if tag.name().as_ref() == b"BaseURL" => inner_tag += 1,
-                Ok(Event::End(tag)) if tag.name().as_ref() == b"BaseURL" => {
-                    if inner_tag > 0 {
-                        inner_tag -= 1;
-                    } else {
-                        TagName::BaseURL.report_tag_close();
-                        break;
-                    }
-                }
-                Ok(Event::Eof) => {
-                    ParsingError("Unexpected end of file in a BaseURL.".to_owned()).report_err();
-                    break;
-                }
-                Err(e) => {
-                    ParsingError::from(e).report_err();
-                    break;
-                }
-                _ => (),
-            }
-            self.reader_buf.clear();
-        }
+        self.process_text_element(
+            b"BaseURL",
+            AttributeName::Text,
+            Some(TagName::BaseURL),
+            "Unexpected end of file in a BaseURL.",
+        );
     }
 
-    fn process_cenc_element(&mut self) {
-        // Count inner cenc:pssh tags if it exists.
-        // Allowing to not close the current node when it is an inner that is closed
-        let mut inner_tag: u32 = 0;
+    fn process_cenc_pssh_element(&mut self) {
+        self.process_text_element(
+            b"cenc:pssh",
+            AttributeName::ContentProtectionCencPSSH,
+            None,
+            "Unexpected end of file in a cenc:pssh tag.",
+        );
+    }
 
+    fn process_text_element(
+        &mut self,
+        element_name: &[u8],
+        attribute_name: AttributeName,
+        reported_tag: Option<TagName>,
+        eof_error: &str,
+    ) {
         loop {
-            match self.read_next_event() {
-                Ok(Event::Text(t)) => {
-                    if t.len() > 0 {
-                        match t.unescape() {
-                            Ok(unescaped) =>
-                            // TODO parse from base64 here?
-                            {
-                                AttributeName::ContentProtectionCencPSSH.report(unescaped)
-                            }
-                            Err(err) => ParsingError::from(err).report_err(),
-                        }
-                    }
-                }
-                Ok(Event::Start(tag)) if tag.name().as_ref() == b"cenc:pssh" => inner_tag += 1,
-                Ok(Event::End(tag)) if tag.name().as_ref() == b"cenc:pssh" => {
-                    if inner_tag > 0 {
-                        inner_tag -= 1;
-                    } else {
-                        break;
+            match self.reader.read_event() {
+                Ok(Event::Text(text)) if text.len() > 0 => match text.unescape() {
+                    Ok(value) => attribute_name.report(value),
+                    Err(error) => error.report_err(),
+                },
+                Ok(Event::End(name)) if name == element_name => {
+                    if let Some(tag_name) = reported_tag {
+                        tag_name.report_tag_close();
                     }
+                    break;
                 }
                 Ok(Event::Eof) => {
-                    ParsingError("Unexpected end of file in a cenc:pssh tag.".to_owned())
-                        .report_err();
+                    ParsingError(eof_error.to_owned()).report_err();
                     break;
                 }
-                Err(e) => {
-                    ParsingError::from(e).report_err();
+                Err(error) => {
+                    error.report_err();
                     break;
                 }
-                _ => (),
+                _ => {}
             }
-            self.reader_buf.clear();
         }
     }
 
     fn process_event_stream_element(&mut self) {
         // Count inner EventStream tags if it exists.
         // Allowing to not close the current node when it is an inner that is closed
-        let mut inner_tag = 0u32;
+        // A foreign namespace may reuse the EventStream local name inside this element.
+        let mut nested_event_streams = 0u32;
 
         loop {
-            // We need to keep the XML as-is in the JS-side when it comes to
-            // EventStream's `<Event> elements, as this is part of its public API.
-            //
-            // That means that we have to communicate in some way this exact data.
-            // Sadly, quick_xml doesn't seem to have corresponding APIs that would
-            // make this easy.
-            // In the meantime, we will just return the first and last position
-            // in bytes of `<Event>` elements (by recording the position just before
-            // it's opening tag is encountered and just after the closing one is).
-            // It will then be up to the JS-side to slice and decode the
-            // corresponding XML.
-            let initial_buffer_pos = self.reader.buffer_position();
+            // Event contents are exposed through the public API as XML. Report their byte range
+            // so JavaScript can retain the original serialization, including namespaces.
+            let event_start_position = self.reader.position();
 
-            let evt = self.read_next_event();
-            match evt {
-                Ok(Event::Start(tag)) if tag.name().as_ref() == b"Event" => {
+            match self.reader.read_event() {
+                Ok(Event::Start(tag)) if tag.name() == b"Event" => {
                     TagName::EventStreamElt.report_tag_open();
                     attributes::report_event_stream_event_attrs(&tag);
-                    match self.get_event_stream_event_ending_position() {
-                        Ok(ending_pos) => {
+                    match self.read_event_end_position() {
+                        Ok(event_end_position) => {
                             AttributeName::EventStreamEltRange
-                                .report((initial_buffer_pos as f64, ending_pos as f64));
+                                .report((event_start_position as f64, event_end_position as f64));
                         }
                         Err(e) => e.report_err(),
                     }
                     TagName::EventStreamElt.report_tag_close();
                 }
-                Ok(Event::Empty(tag)) if tag.name().as_ref() == b"Event" => {
+                Ok(Event::Empty(tag)) if tag.name() == b"Event" => {
                     TagName::EventStreamElt.report_tag_open();
                     attributes::report_event_stream_event_attrs(&tag);
-                    let curr_pos = self.reader.buffer_position();
+                    let event_end_position = self.reader.position();
                     AttributeName::EventStreamEltRange
-                        .report((initial_buffer_pos as f64, curr_pos as f64));
+                        .report((event_start_position as f64, event_end_position as f64));
                     TagName::EventStreamElt.report_tag_close();
                 }
-                Ok(Event::Start(tag)) if tag.name().as_ref() == b"EventStream" => inner_tag += 1,
-                Ok(Event::End(tag)) if tag.name().as_ref() == b"EventStream" => {
-                    if inner_tag > 0 {
-                        inner_tag -= 1;
+                Ok(Event::Start(tag)) if tag.name() == b"EventStream" => nested_event_streams += 1,
+                Ok(Event::End(tag)) if tag == b"EventStream" => {
+                    if nested_event_streams > 0 {
+                        nested_event_streams -= 1;
                     } else {
                         TagName::EventStream.report_tag_close();
                         break;
@@ -441,27 +424,26 @@ impl MPDProcessor {
                     break;
                 }
                 Err(e) => {
-                    ParsingError::from(e).report_err();
+                    e.report_err();
                     break;
                 }
                 _ => (),
             }
-            self.reader_buf.clear();
         }
     }
 
-    /// Returns the ending position (not included), in bytes in the whole parsed MPD, where the
-    /// current `<Event>` element ends.
-    fn get_event_stream_event_ending_position(&mut self) -> Result<usize, ParsingError> {
-        let mut inner_event_tag = 0u32;
+    /// Read through the current Event and return the position just after its closing tag.
+    fn read_event_end_position(&mut self) -> Result<usize, ParsingError> {
+        // A foreign namespace may reuse the Event local name inside the DASH Event.
+        let mut nested_events = 0u32;
         loop {
-            match self.read_next_event()? {
-                Event::Start(tag) if tag.name().as_ref() == b"Event" => inner_event_tag += 1,
-                Event::End(tag) if tag.name().as_ref() == b"Event" => {
-                    if inner_event_tag > 0 {
-                        inner_event_tag -= 1;
+            match self.reader.read_event()? {
+                Event::Start(tag) if tag.name() == b"Event" => nested_events += 1,
+                Event::End(tag) if tag == b"Event" => {
+                    if nested_events > 0 {
+                        nested_events -= 1;
                     } else {
-                        return Ok(self.reader.buffer_position());
+                        return Ok(self.reader.position());
                     }
                 }
                 Event::Eof => {

package/src/parsers/manifest/dash/wasm-parser/rs/processor/s_element.rs

@@ -1,4 +1,4 @@
-use crate::errors::{ParsingError, Result};
+use crate::errors::Result;
 use crate::utils;
 
 /// Represents a parsed <S> node, itself in a <SegmentTimeline> node from an
@@ -35,33 +35,30 @@ impl SegmentObject {
     /// This function is called very very often on the more large MPDs based
     /// on a SegmentTimeline segment indexing scheme.
     #[inline(always)]
-    pub fn from_s_element(
-        e: &quick_xml::events::BytesStart,
-        time_base: f64,
-    ) -> Result<SegmentObject> {
+    pub fn from_s_element(element: &crate::xml::Element, time_base: f64) -> Result<SegmentObject> {
         let mut segment_obj = SegmentObject::default();
         let mut has_t = false;
 
-        for res_attr in e.attributes() {
+        for res_attr in element.attributes() {
             match res_attr {
                 Ok(attr) => {
                     let key = attr.key;
-                    match key.as_ref() {
+                    match key {
                         b"t" => {
-                            segment_obj.start = utils::parse_u64(&attr.value)? as f64;
+                            segment_obj.start = utils::parse_u64(attr.value)? as f64;
                             has_t = true;
                         }
                         b"d" => {
-                            segment_obj.duration = utils::parse_u64(&attr.value)? as f64;
+                            segment_obj.duration = utils::parse_u64(attr.value)? as f64;
                         }
                         b"r" => {
                             // Note i64 instead of u64 as r can be equal to "-1"
-                            segment_obj.repeat_count = utils::parse_i64(&attr.value)? as f64;
+                            segment_obj.repeat_count = utils::parse_i64(attr.value)? as f64;
                         }
                         _ => {}
                     }
                 }
-                Err(err) => ParsingError::from(err).report_err(),
+                Err(err) => err.report_err(),
             };
         }
         if !has_t {

package/src/parsers/manifest/dash/wasm-parser/rs/reader.rs

@@ -1,6 +1,6 @@
 use std::io::{self, Read};
 
-pub struct MPDReader {}
+pub struct MPDReader;
 
 impl Read for MPDReader {
     #[inline]