rx-player 4.0.0-beta.2 → 4.0.0-beta.3

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

@@ -1,8 +1,8 @@
-use core::mem;
-use std::borrow::Cow;
 use crate::events::AttributeName;
-use crate::processor::SegmentObject;
 use crate::onAttribute;
+use crate::processor::SegmentObject;
+use core::mem;
+use std::borrow::Cow;
 
 /// Trait implemented for values that can be "reported" as an attribute to the
 /// JS-side.
@@ -37,10 +37,12 @@ impl ReportableAttribute for bool {
     fn report_as_attr(&self, attr_name: AttributeName) {
         debug_assert!(attr_name as u64 <= u8::MAX as u64);
 
-        let val : u8 = if *self { 1 } else { 0 };
+        let val: u8 = if *self { 1 } else { 0 };
         // UNSAFE: We're using FFI, so we don't know how the pointer is used.
         // Hopefully, the JavaScript-side should clone that value synchronously.
-        unsafe { onAttribute(attr_name, &val, 1); };
+        unsafe {
+            onAttribute(attr_name, &val, 1);
+        };
     }
 }
 
@@ -52,12 +54,14 @@ impl ReportableAttribute for f64 {
         // UNSAFE: We're using FFI, so we don't know how the pointer is used.
         // Hopefully, the JavaScript-side should clone that value synchronously.
         //
-        // Also, we're transmuting so that &f64 (reference to f64) is actually
-        // treated like a *const u8 (immutable raw pointer to an u8) as it's what
-        // the JS callback expects.
+        // Also, we're casting so that the f64 value is actually treated as if it
+        // was a *const u8 (immutable raw pointer to an u8) as it's what the JS
+        // callback expects.
         // This should not matter: Rust types are not communicated to
         // JavaScript anyway.
-        unsafe { onAttribute(attr_name, mem::transmute(self), 8); };
+        unsafe {
+            onAttribute(attr_name, self as *const f64 as *const u8, 8);
+        };
     }
 }
 
@@ -69,11 +73,14 @@ impl ReportableAttribute for (f64, f64) {
         // UNSAFE: We're using FFI, so we don't know how the pointer is used.
         // Hopefully, the JavaScript-side should clone that value synchronously.
         //
-        // Also, we're transmuting so that &(f64, f64) is actually treated like
-        // a *const u8 (immutable raw pointer to an u8) as it's what the JS
-        // callback expects.  This should not matter: Rust types are not
-        // communicated to JavaScript anyway.
-        unsafe { onAttribute(attr_name, mem::transmute(self), 16); };
+        // Also, we're transmuting so that &(f64, f64) is actually treated as if it
+        // was a *const u8 (immutable raw pointer to an u8) as it's what the JS
+        // callback expects.
+        // This should not matter: Rust types are not communicated to
+        // JavaScript anyway.
+        unsafe {
+            onAttribute(attr_name, self as *const (f64, f64) as *const u8, 16);
+        };
     }
 }
 
@@ -92,7 +99,7 @@ impl ReportableAttribute for &[SegmentObject] {
 }
 
 // For key-value couples (such as XML namespaces)
-impl<'a> ReportableAttribute for (&'a [u8], Cow<'a, [u8]>) {
+impl<'a> ReportableAttribute for (&'a [u8], Cow<'a, str>) {
     #[inline(always)]
     fn report_as_attr(&self, attr_name: AttributeName) {
         use crate::utils;
@@ -103,11 +110,13 @@ impl<'a> ReportableAttribute for (&'a [u8], Cow<'a, [u8]>) {
         msg.extend(utils::u32_to_u8_slice_be(len_key));
         msg.extend(self.0);
         msg.extend(utils::u32_to_u8_slice_be(len_val));
-        msg.extend(self.1.to_vec());
+        msg.extend(self.1.as_bytes());
 
         // UNSAFE: We're using FFI, so we don't know how the pointer is used.
         // Hopefully, the JavaScript-side should clone that value synchronously.
-        unsafe { onAttribute(attr_name, msg.as_ptr(), msg.len()); };
+        unsafe {
+            onAttribute(attr_name, msg.as_ptr(), msg.len());
+        };
     }
 }
 
@@ -118,6 +127,21 @@ impl<'a> ReportableAttribute for Cow<'a, [u8]> {
 
         // UNSAFE: We're using FFI, so we don't know how the pointer is used.
         // Hopefully, the JavaScript-side should clone that value synchronously.
-        unsafe { onAttribute(attr_name, self.as_ptr(), self.len()); };
+        unsafe {
+            onAttribute(attr_name, self.as_ptr(), self.len());
+        };
+    }
+}
+
+impl<'a> ReportableAttribute for Cow<'a, str> {
+    #[inline(always)]
+    fn report_as_attr(&self, attr_name: AttributeName) {
+        debug_assert!(attr_name as u64 <= u8::MAX as u64);
+
+        // UNSAFE: We're using FFI, so we don't know how the pointer is used.
+        // Hopefully, the JavaScript-side should clone that value synchronously.
+        unsafe {
+            onAttribute(attr_name, self.as_ptr(), self.len());
+        };
     }
 }

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

@@ -2,15 +2,15 @@ use crate::errors::{ParsingError, Result};
 
 /// Try to parse the given array of bytes into an f64, by first converting
 /// it to the corresponding ASCII (or even here, UTF-8) values.
-pub fn parse_f64(value : &[u8]) -> Result<f64> {
+pub fn parse_f64(value: &[u8]) -> Result<f64> {
     let res = std::str::from_utf8(value)?;
     let res_f64 = res.parse::<f64>()?;
-    Ok(res_f64 as f64)
+    Ok(res_f64)
 }
 
 /// Try to parse the given array of bytes into an i64, by first converting
 /// it to the corresponding ASCII (or even here, UTF-8) values.
-pub fn parse_i64(value : &[u8]) -> Result<i64> {
+pub fn parse_i64(value: &[u8]) -> Result<i64> {
     let res = std::str::from_utf8(value)?;
     let res_u64 = res.parse::<i64>()?;
     Ok(res_u64)
@@ -18,7 +18,7 @@ pub fn parse_i64(value : &[u8]) -> Result<i64> {
 
 /// Try to parse the given array of bytes into an u64, by first converting
 /// it to the corresponding ASCII (or even here, UTF-8) values.
-pub fn parse_u64(value : &[u8]) -> Result<u64> {
+pub fn parse_u64(value: &[u8]) -> Result<u64> {
     let res = std::str::from_utf8(value)?;
     let res_u64 = res.parse::<u64>()?;
     Ok(res_u64)
@@ -31,7 +31,7 @@ pub fn parse_u64(value : &[u8]) -> Result<u64> {
 ///     f64 form.
 ///
 /// Return an error in any other case.
-pub fn parse_u64_or_bool(value : &[u8]) -> Result<f64> {
+pub fn parse_u64_or_bool(value: &[u8]) -> Result<f64> {
     match value {
         b"true" => Ok(f64::INFINITY),
         b"false" => Ok(f64::NEG_INFINITY),
@@ -47,7 +47,7 @@ pub fn parse_u64_or_bool(value : &[u8]) -> Result<f64> {
 ///   - `false` if it represents `"false"` in ASCII
 ///
 /// Return an error in any other case.
-pub fn parse_bool(value : &[u8]) -> Result<bool> {
+pub fn parse_bool(value: &[u8]) -> Result<bool> {
     match value {
         b"true" => Ok(true),
         b"false" => Ok(false),
@@ -63,7 +63,7 @@ pub fn parse_bool(value : &[u8]) -> Result<bool> {
 // TODO Is something like 5- also valid here?
 // It seems to be but it's not yet handled here
 // (We could use e.g. the `INFINITY` float value)
-pub fn parse_byte_range(value : &[u8]) -> Result<(f64, f64)> {
+pub fn parse_byte_range(value: &[u8]) -> Result<(f64, f64)> {
     let mut cursor = 0usize;
     let start;
     loop {
@@ -87,7 +87,7 @@ pub fn parse_byte_range(value : &[u8]) -> Result<(f64, f64)> {
 /// This code could be much simpler if it was RegExp-based but I preferred not
 /// to, mainly because I didn't want to incur the size cost of importing regex
 /// code in here
-pub fn parse_iso_8601_duration(value : &[u8]) -> Result<f64> {
+pub fn parse_iso_8601_duration(value: &[u8]) -> Result<f64> {
     if value.is_empty() || value[0] != b'P' {
         let err = ParsingError("Unexpected duration. Should start with \"P\"".to_owned());
         return Err(err);
@@ -98,7 +98,8 @@ pub fn parse_iso_8601_duration(value : &[u8]) -> Result<f64> {
         loop {
             let (number, i) = read_next_float(value, base)?;
             if i == value.len() {
-                let e = ParsingError("Invalid ISO 8601 duration: end encountered too soon".to_owned());
+                let e =
+                    ParsingError("Invalid ISO 8601 duration: end encountered too soon".to_owned());
                 return Err(e);
             }
             let factor = match value[i] {
@@ -113,7 +114,7 @@ pub fn parse_iso_8601_duration(value : &[u8]) -> Result<f64> {
             result += number * (factor as f64);
             base = i + 1;
             if base == value.len() {
-                return Ok(result as f64);
+                return Ok(result);
             }
             if value[base] == b'T' {
                 break;
@@ -139,7 +140,7 @@ pub fn parse_iso_8601_duration(value : &[u8]) -> Result<f64> {
         result += number * (factor as f64);
         base = i + 1;
         if base == value.len() {
-            return Ok(result as f64);
+            return Ok(result);
         }
     }
 }
@@ -184,19 +185,14 @@ pub fn parse_maybe_division(value : &[u8]) -> Result<f64> {
 /// If it succeeds, returns both the floating point number as an f64 and the
 /// offset coming just after that float in `value` (or the length of `value` if
 /// it ended with a float).
-fn read_next_float(
-    value : &[u8],
-    base_offset : usize
-) -> Result<(f64, usize)> {
+fn read_next_float(value: &[u8], base_offset: usize) -> Result<(f64, usize)> {
     let mut i = base_offset;
     while i < value.len() && value[i] >= b'0' && value[i] <= b'9' {
         i += 1;
     }
     if i == value.len() || (value[i] != b'.' && value[i] != b',') {
         // UNSAFE: We already checked that this string represents a valid integer
-        let val_str = unsafe {
-            std::str::from_utf8_unchecked(&value[base_offset..i])
-        };
+        let val_str = unsafe { std::str::from_utf8_unchecked(&value[base_offset..i]) };
         let val_u64 = val_str.parse::<u64>()?;
         return Ok((val_u64 as f64, i));
     }
@@ -206,19 +202,17 @@ fn read_next_float(
         i += 1;
     }
     // UNSAFE: We already checked that this string represents a valid float
-    let val_str = unsafe {
-        std::str::from_utf8_unchecked(&value[base_offset..i])
-    };
+    let val_str = unsafe { std::str::from_utf8_unchecked(&value[base_offset..i]) };
     let val_f64 = val_str.parse::<f64>()?;
     Ok((val_f64, i))
 }
 
-pub fn u32_to_u8_slice_be(x:u32) -> [u8;4] {
-    let b1 : u8 = ((x >> 24) & 0xff) as u8;
-    let b2 : u8 = ((x >> 16) & 0xff) as u8;
-    let b3 : u8 = ((x >> 8) & 0xff) as u8;
-    let b4 : u8 = (x & 0xff) as u8;
-    return [b1, b2, b3, b4]
+pub fn u32_to_u8_slice_be(x: u32) -> [u8; 4] {
+    let b1: u8 = ((x >> 24) & 0xff) as u8;
+    let b2: u8 = ((x >> 16) & 0xff) as u8;
+    let b3: u8 = ((x >> 8) & 0xff) as u8;
+    let b4: u8 = (x & 0xff) as u8;
+    [b1, b2, b3, b4]
 }
 
 #[cfg(test)]
@@ -243,8 +237,14 @@ mod tests {
 
     #[test]
     fn test_parse_8601_duration() {
-        assert_eq!(parse_iso_8601_duration(b"P1Y10M43DT22H8M3S").unwrap(), 61250883.);
-        assert_eq!(parse_iso_8601_duration(b"P1Y10M43DT22H8M3S").unwrap(), 61250883.);
+        assert_eq!(
+            parse_iso_8601_duration(b"P1Y10M43DT22H8M3S").unwrap(),
+            61250883.
+        );
+        assert_eq!(
+            parse_iso_8601_duration(b"P1Y10M43DT22H8M3S").unwrap(),
+            61250883.
+        );
         assert_eq!(parse_iso_8601_duration(b"PT3S").unwrap(), 3.);
         assert_eq!(parse_iso_8601_duration(b"PT1M3.4S").unwrap(), 63.4);
 

package/src/parsers/manifest/dash/wasm-parser/ts/dash-wasm-parser.ts

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+import globalScope from "../../../../../compat/global_scope";
 import log from "../../../../../log";
 import assertUnreachable from "../../../../../utils/assert_unreachable";
 import noop from "../../../../../utils/noop";
@@ -318,7 +319,7 @@ export default class DashWasmParser {
   public isCompatible() : boolean {
     return typeof WebAssembly === "object" &&
            typeof WebAssembly.instantiate === "function" &&
-           typeof window.TextDecoder === "function";
+           typeof globalScope.TextDecoder === "function";
   }
 
   private _parseMpd(

package/src/parsers/manifest/dash/wasm-parser/ts/generators/BaseURL.ts

@@ -30,7 +30,7 @@ export function generateBaseUrlAttrParser(
   linearMemory : WebAssembly.Memory
 )  : IAttributeParser {
   const textDecoder = new TextDecoder();
-  return function onMPDAttribute(attr : number, ptr : number, len : number) {
+  return function onMPDAttribute(attr : AttributeName, ptr : number, len : number) {
     if (attr === AttributeName.Text) {
       baseUrlAttrs.value = parseString(textDecoder, linearMemory.buffer, ptr, len);
     }

package/src/parsers/manifest/dash/wasm-parser/ts/generators/Representation.ts

@@ -84,6 +84,18 @@ export function generateRepresentationChildrenParser(
         break;
       }
 
+      case TagName.SupplementalProperty: {
+        const supplementalProperty = {};
+        if (childrenObj.supplementalProperties === undefined) {
+          childrenObj.supplementalProperties = [];
+        }
+        childrenObj.supplementalProperties.push(supplementalProperty);
+        const attributeParser = generateSchemeAttrParser(supplementalProperty,
+                                                         linearMemory);
+        parsersStack.pushParsers(nodeId, noop, attributeParser);
+        break;
+      }
+
       case TagName.SegmentBase: {
         const segmentBaseObj = {};
         childrenObj.segmentBase = segmentBaseObj;

package/src/parsers/manifest/local/parse_local_manifest.ts

@@ -15,6 +15,7 @@
  */
 
 import idGenerator from "../../../utils/id_generator";
+import getMonotonicTimeStamp from "../../../utils/monotonic_timestamp";
 import {
   IContentProtections,
   IContentProtectionInitData,
@@ -65,7 +66,7 @@ export default function parseLocalManifest(
                          maximumTimeData: { isLinear: false,
                                             maximumSafePosition: maximumPosition,
                                             livePosition: undefined,
-                                            time: performance.now() } },
+                                            time: getMonotonicTimeStamp() } },
            periods: parsedPeriods };
 }
 
@@ -138,6 +139,7 @@ function parseRepresentation(
            height: representation.height,
            width: representation.width,
            codecs: representation.codecs,
+           isSpatialAudio: representation.isSpatialAudio,
            mimeType: representation.mimeType,
            index: new LocalRepresentationIndex(representation.index, id),
            contentProtections };

package/src/parsers/manifest/local/types.ts

@@ -193,6 +193,8 @@ export interface ILocalRepresentation {
   height? : number;
   /** Interface allowing to retrieve media segments for this quality. */
   index : ILocalIndex;
+  /** `true` if audio has Dolby Atmos. */
+  isSpatialAudio? : boolean;
 }
 
 /** A "track"" of a "local" Manifest. */

package/src/parsers/manifest/metaplaylist/metaplaylist_parser.ts

@@ -20,6 +20,7 @@ import Manifest, {
 } from "../../../manifest";
 import { ITrackType } from "../../../public_types";
 import idGenerator from "../../../utils/id_generator";
+import getMonotonicTimeStamp from "../../../utils/monotonic_timestamp";
 import { getFilenameIndexInUrl } from "../../../utils/resolve_url";
 import {
   IParsedAdaptation,
@@ -221,6 +222,7 @@ function createManifest(
                 mimeType: currentRepresentation.mimeType,
                 frameRate: currentRepresentation.frameRate,
                 codecs: currentRepresentation.codec,
+                isSpatialAudio: currentRepresentation.isSpatialAudio,
                 contentProtections: currentRepresentation.contentProtections,
               });
             }
@@ -299,7 +301,7 @@ function createManifest(
     periods.push(...manifestPeriods);
   }
 
-  const time = performance.now();
+  const time = getMonotonicTimeStamp();
   const isLastPeriodKnown = !isDynamic ||
                             mplData.pollInterval === undefined &&
                             (manifests.length <= 0 ||

package/src/parsers/manifest/smooth/create_parser.ts

@@ -23,6 +23,7 @@ import {
   itobe4,
 } from "../../../utils/byte_parsing";
 import isNonEmptyString from "../../../utils/is_non_empty_string";
+import getMonotonicTimeStamp from "../../../utils/monotonic_timestamp";
 import objectAssign from "../../../utils/object_assign";
 import { getFilenameIndexInUrl } from "../../../utils/resolve_url";
 import { hexToBytes } from "../../../utils/string_parsing";
@@ -294,7 +295,7 @@ function createSmoothStreamingParser(
     const UrlAttr = root.getAttribute("Url");
     const UrlPathWithTokens = UrlAttr === null ? "" :
                                                  UrlAttr;
-    if (__ENVIRONMENT__.CURRENT_ENV === __ENVIRONMENT__.DEV as number) {
+    if (__ENVIRONMENT__.CURRENT_ENV as number === __ENVIRONMENT__.DEV as number) {
       assert(UrlPathWithTokens !== "");
     }
 
@@ -618,7 +619,7 @@ function createSmoothStreamingParser(
       maximumTimeData = { isLinear: true,
                           maximumSafePosition,
                           livePosition,
-                          time: performance.now() };
+                          time: getMonotonicTimeStamp() };
       timeshiftDepth = timeShiftBufferDepth ?? null;
     } else {
       minimumTime = safeMinimumTime ?? 0;
@@ -628,7 +629,7 @@ function createSmoothStreamingParser(
       maximumTimeData = { isLinear: false,
                           maximumSafePosition: maximumTime,
                           livePosition: undefined,
-                          time: performance.now() };
+                          time: getMonotonicTimeStamp() };
     }
 
     const periodStart = isLive ? 0 :

package/src/parsers/manifest/smooth/representation_index.ts

@@ -22,6 +22,7 @@ import {
 } from "../../../manifest";
 import { IPlayerError } from "../../../public_types";
 import assert from "../../../utils/assert";
+import getMonotonicTimeStamp from "../../../utils/monotonic_timestamp";
 import {
   checkDiscontinuity,
   getIndexSegmentEnd,
@@ -160,9 +161,9 @@ export default class SmoothRepresentationIndex implements IRepresentationIndex {
   /**
    * Value only calculated for live contents.
    *
-   * Calculates the difference, in timescale, between the current time (as
-   * calculated via performance.now()) and the time of the last segment known
-   * to have been generated on the server-side.
+   * Calculates the difference, in timescale, between the monotonically-raising
+   * timestamp used by the RxPlayer and the time of the last segment known to
+   * have been generated on the server-side.
    * Useful to know if a segment present in the timeline has actually been
    * generated on the server-side
    */
@@ -266,7 +267,7 @@ export default class SmoothRepresentationIndex implements IRepresentationIndex {
 
     const maxPosition = this._scaledLiveGap === undefined ?
       undefined :
-      ((performance.now() / 1000) * timescale) - this._scaledLiveGap;
+      ((getMonotonicTimeStamp() / 1000) * timescale) - this._scaledLiveGap;
 
     for (let i = 0; i < timelineLength; i++) {
       const segmentRange = timeline[i];
@@ -384,7 +385,7 @@ export default class SmoothRepresentationIndex implements IRepresentationIndex {
 
     for (let i = timeline.length - 1; i >= 0; i--) {
       const timelineElt = timeline[i];
-      const timescaledNow = (performance.now() / 1000) * timescale;
+      const timescaledNow = (getMonotonicTimeStamp() / 1000) * timescale;
       const { start, duration, repeatCount } = timelineElt;
       for (let j = repeatCount; j >= 0; j--) {
         const end = start + (duration * (j + 1));

package/src/parsers/manifest/smooth/shared_smooth_segment_timeline.ts

@@ -16,6 +16,7 @@
 
 import log from "../../../log";
 import { ISegment } from "../../../manifest";
+import getMonotonicTimeStamp from "../../../utils/monotonic_timestamp";
 import clearTimelineFromPosition from "../utils/clear_timeline_from_position";
 import { getIndexSegmentEnd } from "../utils/index_helpers";
 import updateSegmentTimeline from "../utils/update_segment_timeline";
@@ -50,9 +51,9 @@ export default class SharedSmoothSegmentTimeline {
   public timescale : number;
 
   /**
-   * Defines the earliest time - in terms of `performance.now()` - when the
-   * timeline was known to be valid (that is, when all segments declared in it
-   * are available).
+   * Defines the earliest time - expressed in the RxPlayer's
+   * monotonically-raising timestamp unit - when the timeline was known to be
+   * valid (that is, when all segments declared in it are available).
    *
    * This is either:
    *   - the Manifest downloading time, if known
@@ -69,7 +70,7 @@ export default class SharedSmoothSegmentTimeline {
     const { timeline, timescale, timeShiftBufferDepth, manifestReceivedTime } = args;
     this.timeline = timeline;
     this.timescale = timescale;
-    const estimatedReceivedTime = manifestReceivedTime ?? performance.now();
+    const estimatedReceivedTime = manifestReceivedTime ?? getMonotonicTimeStamp();
     this.validityTime = estimatedReceivedTime;
     this._timeShiftBufferDepth = timeShiftBufferDepth;
 
@@ -91,7 +92,7 @@ export default class SharedSmoothSegmentTimeline {
       return;
     }
     const timeShiftBufferDepth = this._timeShiftBufferDepth;
-    const timeSinceLastRealUpdate = (performance.now() -
+    const timeSinceLastRealUpdate = (getMonotonicTimeStamp() -
                                      this.validityTime) / 1000;
     const lastPositionEstimate = timeSinceLastRealUpdate +
                                  this._initialScaledLastPosition / this.timescale;

package/src/parsers/manifest/types.ts

@@ -158,6 +158,8 @@ export interface IParsedRepresentation {
    * Information about the HDR characteristic of a content.
    */
   hdrInfo?: IHDRInformation | undefined;
+  /** `true` if audio has Dolby Atmos. */
+  isSpatialAudio?: boolean | undefined;
 }
 
 /** Every possible types an Adaptation can have. */
@@ -291,8 +293,8 @@ export interface IParsedManifest {
   /** Base time from which the segments are generated. */
   availabilityStartTime? : number | undefined;
   /**
-   * Offset, in milliseconds, the client's clock (in terms of `performance.now`)
-   * has relatively to the server's
+   * Difference between the server's clock, in milliseconds, and the
+   * monotonically-raising timestamp used by the RxPlayer.
    */
   clockOffset? : number | undefined;
   /** If set, the Manifest needs to be updated when that Promise resolves. */
@@ -371,8 +373,8 @@ export interface IParsedManifest {
        */
       maximumSafePosition : number;
       /**
-       * `Performance.now()` output at the time both `maximumSafePosition` and
-       * `maximumPositionWithMediaData` were calculated.
+       * Monotonically-raising timestamp at the time both `maximumSafePosition`
+       * and `maximumPositionWithMediaData` were calculated.
        * This can be used to retrieve a new maximum position from them when they
        * linearly evolves over time (see `isLinear` property).
        */

package/src/parsers/manifest/utils/__tests__/update_segment_timeline.test.ts

@@ -107,8 +107,7 @@ describe("Manifest Parsers utils - updateSegmentTimeline", () => {
     expect((err as { type? : string }).type).toEqual("MEDIA_ERROR");
     expect((err as { code? : string }).code).toEqual("MANIFEST_UPDATE_ERROR");
     expect(err.message)
-      .toEqual("MediaError (MANIFEST_UPDATE_ERROR) Cannot perform " +
-               "partial update: not enough data");
+      .toEqual("MANIFEST_UPDATE_ERROR: Cannot perform partial update: not enough data");
     expect(oldTimeline1).toEqual(oldTimeline1Cloned);
     expect(mockLogWarn).not.toHaveBeenCalled();
   });

package/src/parsers/texttracks/ttml/html/__tests__/__global__/html_ttml_parser.test.test.ts

@@ -15,6 +15,7 @@
  */
 
 import parseTTMLToDiv from "../../";
+import globalScope from "../../../../../../compat/global_scope";
 
 const testingText = `<?xml version="1.0" encoding="UTF-8"?>
 <tt xmlns="http://www.w3.org/ns/ttml">
@@ -181,7 +182,7 @@ describe("Global TTML HTML parsing tests", () => {
     for (let i = 0; i < textNodes.length; i++) {
       const parentElement = textNodes[i].parentElement;
       if (parentElement !== null) {
-        expect(window.getComputedStyle(parentElement).color).toEqual("yellow");
+        expect(globalScope.getComputedStyle(parentElement).color).toEqual("yellow");
         nbTextNodes++;
       }
     }

package/src/parsers/texttracks/webvtt/html/__tests__/convert_payload_to_html.test.ts

@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 
+import globalScope from "../../../../../compat/global_scope";
+
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
 /* eslint-disable @typescript-eslint/no-var-requires */
@@ -26,7 +28,7 @@ describe("parsers - webvtt - convertPayloadToHTML", () => {
     jest.resetModules();
   });
 
-  const win = window as {
+  const gs = globalScope as {
     DOMParser : unknown;
   };
   it("should return empty payload when input text is empty", () => {
@@ -38,8 +40,8 @@ describe("parsers - webvtt - convertPayloadToHTML", () => {
       };
     });
 
-    const origDOMParser = win.DOMParser;
-    win.DOMParser = class MockDOMParser {
+    const origDOMParser = gs.DOMParser;
+    gs.DOMParser = class MockDOMParser {
       constructor() {
         // Useless constructor in mock
       }
@@ -58,7 +60,7 @@ describe("parsers - webvtt - convertPayloadToHTML", () => {
     expect(convertPayloadToHTML("", {})).toEqual([]);
     expect(spyParseFromString).toHaveBeenCalledTimes(1);
     expect(spy).not.toHaveBeenCalled();
-    win.DOMParser = origDOMParser;
+    gs.DOMParser = origDOMParser;
   });
 
   it("should convert normal input text with no style", () => {
@@ -87,8 +89,8 @@ describe("parsers - webvtt - convertPayloadToHTML", () => {
       default: spyCreateStyledElement,
     }));
 
-    const origDOMParser = win.DOMParser;
-    win.DOMParser = class MockDOMParser {
+    const origDOMParser = gs.DOMParser;
+    gs.DOMParser = class MockDOMParser {
       constructor() {
         // Useless constructor in mock
       }
@@ -101,6 +103,6 @@ describe("parsers - webvtt - convertPayloadToHTML", () => {
     expect(convertPayloadToHTML(innerText, {})).toEqual([bNode, span]);
     expect(spyParseFromString).toHaveBeenCalledTimes(1);
     expect(spyCreateStyledElement).toHaveBeenCalledTimes(2);
-    win.DOMParser = origDOMParser;
+    gs.DOMParser = origDOMParser;
   });
 });