rx-player 3.25.2 → 3.26.3-dev.2022021400

package/src/parsers/manifest/utils/index_helpers.ts

@@ -14,25 +14,35 @@
  * limitations under the License.
  */
 
-// Generic way to representat segments in an index of segments
-export interface IIndexSegment { start: number; // start time
-                                 duration: number; // duration
-                                 repeatCount: number; // repeat counter
-                                 range?: [number, number]; } // possible
-                                                             // byte-range
+import isNullOrUndefined from "../../../utils/is_null_or_undefined";
+
+/** Generic way to represent segments in an index of segments. */
+export interface IIndexSegment {
+  /** The segment starting presentation time. */
+  start: number;
+  /** Difference between the last and first presentation time. */
+  duration: number;
+  /**
+   * Repeat counter.
+   * 1 === Repeat 1 time == 2 consecutive segments of this same duration.
+   */
+  repeatCount: number;
+  /** Optional byte-range the segment is available at when requested. */
+  range?: [number, number] | undefined;
+}
 
 /**
  * Calculate the number of times a timeline element repeats based on the next
  * element.
  * @param {Object} element
- * @param {Object} nextElement
- * @param {number} maxPosition
+ * @param {Object|null|undefined} nextElement
+ * @param {number|undefined} maxPosition
  * @returns {Number}
  */
 export function calculateRepeat(
   element : IIndexSegment,
-  nextElement? : IIndexSegment|null,
-  maxPosition? : number
+  nextElement? : IIndexSegment | null | undefined,
+  maxPosition? : number | undefined
 ) : number {
   const { repeatCount } = element;
 
@@ -45,9 +55,9 @@ export function calculateRepeat(
   // start of the next S element, the end of the Period or until the
   // next MPD update.
   let segmentEnd : number;
-  if (nextElement != null) {
+  if (!isNullOrUndefined(nextElement)) {
     segmentEnd = nextElement.start;
-  } else if (maxPosition != null) {
+  } else if (maxPosition !== undefined) {
     segmentEnd = maxPosition;
   } else {
     segmentEnd = Number.MAX_VALUE;

package/src/parsers/manifest/utils/is_segment_still_available.ts

@@ -16,6 +16,7 @@
 
 import { ISegment } from "../../../manifest";
 import { IIndexSegment } from "./index_helpers";
+
 /**
  * Returns true if a Segment returned by the corresponding index is still
  * considered available.
@@ -39,17 +40,14 @@ export default function isSegmentStillAvailable(
     if (tSegmentTime > segment.time) {
       return false;
     } else if (tSegmentTime === segment.time) {
-      if ((tSegment.duration / timescale) !== segment.duration) {
-        return false;
-      }
-      if (tSegment.range == null) {
-        return segment.range == null;
+      if (tSegment.range === undefined) {
+        return segment.range === undefined;
       }
       return segment.range != null &&
              tSegment.range[0] === segment.range[0] &&
              tSegment.range[1] === segment.range[1];
     } else { // tSegment.start < segment.time
-      if (tSegment.repeatCount >= 0 && tSegment.duration != null) {
+      if (tSegment.repeatCount >= 0 && tSegment.duration !== undefined) {
         const timeDiff = tSegmentTime - tSegment.start;
         const repeat = (timeDiff / tSegment.duration) - 1;
         return repeat % 1 === 0 && repeat <= tSegment.repeatCount;

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

@@ -24,22 +24,31 @@ import {
 /**
  * Update a complete array of segments in a given timeline with a [generally]
  * smaller but [generally] newer set of segments.
+ *
+ * Returns a boolean:
+ *   - If set to `true`, the old timeline was emptied and completely replaced by
+ *     the content of the newer timeline.
+ *     This could happen either if a problem happened while trying to update or
+ *     when the update is actually bigger than what it is updating.
+ *   - If set to `false`, the older timeline was either updated to add the newer
+ *     segments, or untouched.
+ *
  * @param {Array.<Object>} oldTimeline
  * @param {Array.<Object>} newTimeline
+ * @returns {boolean}
  */
 export default function updateSegmentTimeline(
   oldTimeline : IIndexSegment[],
   newTimeline : IIndexSegment[]
-) : void {
-  const prevTimelineLength = oldTimeline.length;
+) : boolean {
   if (oldTimeline.length === 0) {
-    oldTimeline.splice(0, prevTimelineLength, ...newTimeline);
-    return;
-  }
-  if (newTimeline.length === 0) {
-    return;
+    oldTimeline.push(...newTimeline);
+    return true;
+  } else if (newTimeline.length === 0) {
+    return false;
   }
 
+  const prevTimelineLength = oldTimeline.length;
   const newIndexStart = newTimeline[0].start;
 
   const oldLastElt = oldTimeline[prevTimelineLength - 1];
@@ -53,29 +62,31 @@ export default function updateSegmentTimeline(
     const currStart = oldTimeline[i].start;
     if (currStart === newIndexStart) {
       // replace that one and those after it
-      oldTimeline.splice(i, prevTimelineLength - i, ...newTimeline);
-      return;
+      const nbEltsToRemove = prevTimelineLength - i;
+      oldTimeline.splice(i, nbEltsToRemove, ...newTimeline);
+      return false;
     } else if (currStart < newIndexStart) { // first to be before
       const currElt = oldTimeline[i];
       if (currElt.start + currElt.duration > newIndexStart) {
-        // the new Manifest overlaps a previous segment (weird). Remove the latter.
-        log.warn("RepresentationIndex: Manifest update removed previous segments");
-        oldTimeline.splice(i, prevTimelineLength - i, ...newTimeline);
-        return;
+        // The new Manifest overlaps a previous segment (weird)
+        // In that improbable case, we'll just completely replace segments
+        log.warn("RepresentationIndex: Manifest update removed all previous segments");
+        oldTimeline.splice(0, prevTimelineLength, ...newTimeline);
+        return true;
       } else if (currElt.repeatCount === undefined || currElt.repeatCount <= 0) {
         if (currElt.repeatCount < 0) {
           currElt.repeatCount = Math.floor((newIndexStart - currElt.start) /
                                               currElt.duration) - 1;
         }
         oldTimeline.splice(i + 1, prevTimelineLength - (i + 1), ...newTimeline);
-        return;
+        return false;
       }
       // else, there is a positive repeat we might want to update
       const eltLastTime = currElt.start + currElt.duration * (currElt.repeatCount + 1);
       if (eltLastTime <= newIndexStart) { // our new index comes directly after
         // put it after this one
         oldTimeline.splice(i + 1, prevTimelineLength - (i + 1), ...newTimeline);
-        return;
+        return false;
       }
 
       const newCurrRepeat = ((newIndexStart - currElt.start) / currElt.duration) - 1;
@@ -88,14 +99,14 @@ export default function updateSegmentTimeline(
         oldTimeline.splice(i, prevTimelineLength - i, ...newTimeline);
         oldTimeline[i].start = currElt.start;
         oldTimeline[i].repeatCount = newRepeatCount;
-        return;
+        return false;
       }
       log.warn("RepresentationIndex: Manifest update removed previous segments");
       oldTimeline[i].repeatCount = Math.floor(newCurrRepeat);
 
       // put it after this one
       oldTimeline.splice(i + 1, prevTimelineLength - (i + 1), ...newTimeline);
-      return;
+      return false;
     }
   }
 
@@ -107,11 +118,11 @@ export default function updateSegmentTimeline(
   if (prevLastElt.repeatCount !== undefined && prevLastElt.repeatCount < 0) {
     if (prevLastElt.start > newLastElt.start) {
       log.warn("RepresentationIndex: The new index is older than the previous one");
-      return; // the old comes after
+      return false;
     } else { // the new has more depth
       log.warn("RepresentationIndex: The new index is \"bigger\" than the previous one");
       oldTimeline.splice(0, prevTimelineLength, ...newTimeline);
-      return;
+      return true;
     }
   }
   const prevLastTime = prevLastElt.start + prevLastElt.duration *
@@ -120,11 +131,11 @@ export default function updateSegmentTimeline(
                       (newLastElt.repeatCount + 1);
   if (prevLastTime >= newLastTime) {
     log.warn("RepresentationIndex: The new index is older than the previous one");
-    return; // the old comes after
+    return false;
   }
 
   // the new one has more depth. full update
   log.warn("RepresentationIndex: The new index is \"bigger\" than the previous one");
   oldTimeline.splice(0, prevTimelineLength, ...newTimeline);
-  return;
+  return true;
 }

package/src/parsers/texttracks/sami/html.ts

@@ -90,7 +90,7 @@ function getCSSProperty(str : string, name : string) : string|null {
  */
 function decodeEntities(text : string) : string {
   return text
-    .replace(HTML_ENTITIES, (_, $1) => String.fromCharCode($1));
+    .replace(HTML_ENTITIES, (_, $1) => String.fromCharCode(Number($1)));
 }
 
 /**

package/src/parsers/texttracks/sami/native.ts

@@ -94,7 +94,7 @@ function getCSSProperty(str : string, name : string) : string|null {
 function decodeEntities(text : string) : string {
   return text
     .replace(BR, "\n")
-    .replace(HTML_ENTITIES, (_, $1) => String.fromCharCode($1));
+    .replace(HTML_ENTITIES, (_, $1) => String.fromCharCode(Number($1)));
 }
 
 /**

package/src/parsers/texttracks/srt/html.ts

@@ -151,18 +151,12 @@ function generateSpansFromSRTText(text : string) : HTMLElement {
         const spanChild = _loop(currentNode);
         spanChild.style.textDecoration = "underline";
         span.appendChild(spanChild);
-      } else if (
-        currentNode.nodeName === "FONT" &&
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-        (currentNode as any).color != null
-      ) {
+      } else if (isNodeFontWithColorProp(currentNode) &&
+                 typeof currentNode.color === "string")
+      {
         // TODO loop through attributes to find color?
-        /* eslint-disable @typescript-eslint/no-unsafe-assignment */
-        /* eslint-disable @typescript-eslint/no-unsafe-member-access */
         const spanChild = _loop(currentNode);
-        spanChild.style.color = (currentNode as any).color;
-        /* eslint-enable @typescript-eslint/no-unsafe-assignment */
-        /* eslint-enable @typescript-eslint/no-unsafe-member-access */
+        spanChild.style.color = currentNode.color;
         span.appendChild(spanChild);
       } else {
         const spanChild = _loop(currentNode);
@@ -174,3 +168,15 @@ function generateSpansFromSRTText(text : string) : HTMLElement {
 
   return _loop(secureDiv);
 }
+
+/**
+ * Returns `true` if the given node is a `<font>` element which contains a
+ * `color` attribute.
+ * @param {Node} node
+ * @returns {boolean}
+ */
+function isNodeFontWithColorProp(
+  node : Node
+) : node is Node & { color : unknown } {
+  return node.nodeName === "FONT" && "color" in node;
+}

package/src/parsers/texttracks/ttml/html/apply_font_size.ts

@@ -38,7 +38,6 @@ export default function applyFontSize(
   }
 
   if (firstFontSize[2] === "px" ||
-      firstFontSize[2] === "%" ||
       firstFontSize[2] === "em")
   {
     element.style.fontSize = firstFontSize[1] + firstFontSize[2];
@@ -46,6 +45,17 @@ export default function applyFontSize(
     element.style.position = "relative";
     addClassName(element, "proportional-style");
     element.setAttribute("data-proportional-font-size", firstFontSize[1]);
+  } else if (firstFontSize[2] === "%") {
+    const toNum = Number(firstFontSize[1]);
+    if (isNaN(toNum)) {
+      log.warn("TTML Parser: could not parse fontSize value \"" +
+               firstFontSize[1] +
+               "\" into a number");
+    } else {
+      element.style.position = "relative";
+      addClassName(element, "proportional-style");
+      element.setAttribute("data-proportional-font-size", String(toNum / 100));
+    }
   } else {
     log.warn("TTML Parser: unhandled fontSize unit:", firstFontSize[2]);
   }

package/src/parsers/texttracks/ttml/nodes.ts

@@ -19,7 +19,8 @@
  * @returns {Element}
  */
 function getBodyNode(tt : Element) : Element|null {
-  return tt.getElementsByTagName("body")[0];
+  const bodyNodes = tt.getElementsByTagName("body");
+  return bodyNodes.length > 0 ? bodyNodes[0] : null;
 }
 
 /**

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

@@ -26,6 +26,9 @@ describe("parsers - webvtt - convertPayloadToHTML", () => {
     jest.resetModules();
   });
 
+  const win = window as {
+    DOMParser : unknown;
+  };
   it("should return empty payload when input text is empty", () => {
     const spyParseFromString = jest.fn(() => {
       return {
@@ -35,8 +38,8 @@ describe("parsers - webvtt - convertPayloadToHTML", () => {
       };
     });
 
-    const origDOMParser = (window as any).DOMParser;
-    (window as any).DOMParser = class MockDOMParser {
+    const origDOMParser = win.DOMParser;
+    win.DOMParser = class MockDOMParser {
       constructor() {
         // Useless constructor in mock
       }
@@ -55,7 +58,7 @@ describe("parsers - webvtt - convertPayloadToHTML", () => {
     expect(convertPayloadToHTML("", {})).toEqual([]);
     expect(spyParseFromString).toHaveBeenCalledTimes(1);
     expect(spy).not.toHaveBeenCalled();
-    (window as any).DOMParser = origDOMParser;
+    win.DOMParser = origDOMParser;
   });
 
   it("should convert normal input text with no style", () => {
@@ -84,8 +87,8 @@ describe("parsers - webvtt - convertPayloadToHTML", () => {
       default: spyCreateStyledElement,
     }));
 
-    const origDOMParser = (window as any).DOMParser;
-    (window as any).DOMParser = class MockDOMParser {
+    const origDOMParser = win.DOMParser;
+    win.DOMParser = class MockDOMParser {
       constructor() {
         // Useless constructor in mock
       }
@@ -98,6 +101,6 @@ describe("parsers - webvtt - convertPayloadToHTML", () => {
     expect(convertPayloadToHTML(innerText, {})).toEqual([bNode, span]);
     expect(spyParseFromString).toHaveBeenCalledTimes(1);
     expect(spyCreateStyledElement).toHaveBeenCalledTimes(2);
-    (window as any).DOMParser = origDOMParser;
+    win.DOMParser = origDOMParser;
   });
 });

package/src/parsers/texttracks/webvtt/html/to_html.ts

@@ -39,10 +39,10 @@ export default function toHTML(
   cueObj : { start : number;
              end : number;
              settings: Partial<Record<string, string>>;
-             header? : string;
+             header? : string | undefined;
              payload : string[]; },
   styling : { classes : IStyleElements;
-              global? : string; }
+              global? : string | undefined; }
 ) : IVTTHTMLCue {
   const { start, end, settings, header, payload } = cueObj;
 

package/src/parsers/texttracks/webvtt/parse_cue_block.ts

@@ -78,7 +78,7 @@ function parseTimeAndSettings(
 
 export interface IVTTCueObject { start : number;
                                  end : number;
-                                 header? : string;
+                                 header : string | undefined;
                                  settings: Partial<Record<string, string>>;
                                  payload : string[]; }
 

package/src/public_types.ts

@@ -48,3 +48,21 @@ export {
   IStreamEvent,
   IStreamEventData,
 } from "./core/api";
+export {
+  IPersistentSessionInfo,
+  IPersistentSessionStorage,
+} from "./core/eme";
+export { ICustomError as IPlayerError } from "./errors";
+export {
+  IExposedAdaptation as IAdaptation,
+  IExposedManifest as IManifest,
+  IExposedPeriod as IPeriod,
+  IExposedRepresentation as IRepresentation,
+  IExposedSegment as ISegment,
+  IRepresentationFilter,
+  IRepresentationInfos,
+} from "./manifest";
+export {
+  ICustomSegmentLoader as ISegmentLoader,
+  ICustomManifestLoader as IManifestLoader,
+} from "./transports";

package/src/transports/README.md

@@ -130,12 +130,16 @@ Its concept can be illustrated as such:
                              +--------+
 ```
 
-The parser returns an Observable which will emit the parsed resource when done.
+Depending on the type of parser (e.g. Manifest parser or segment parser), that
+task can be synchronous or asynchronous.
 
-This Observable will throw if the resource is corrupted or miss crucial
-information.
+In asynchronous cases, the parser will return an Observable emitting a unique
+time the result when done and throwing if an error is encountered.
 
-[1] the parser could also need to perform requests (e.g. it needs to fetch the
+In synchronous cases, the parser returns directly the result, and can throw
+directly when/if an error is encountered.
+
+[1] a parser could also need to perform requests (e.g. it needs to fetch the
 current time from a server).
 In such cases, the parser is given a special callback, which allows it to
 receive the same error-handling perks than a loader, such as multiple retries,

package/src/transports/dash/add_segment_integrity_checks_to_loader.ts

@@ -14,39 +14,80 @@
  * limitations under the License.
  */
 
-import { tap } from "rxjs/operators";
-import {
-  ISegmentLoader,
-} from "../types";
+import PPromise from "../../utils/promise";
+import TaskCanceller, {
+  CancellationError,
+} from "../../utils/task_canceller";
+import { ISegmentLoader } from "../types";
 import checkISOBMFFIntegrity from "../utils/check_isobmff_integrity";
 import inferSegmentContainer from "../utils/infer_segment_container";
 
 /**
  * Add multiple checks on the response given by the `segmentLoader` in argument.
- * If the response appear to be corrupted, this Observable will throw an error
- * with an `INTEGRITY_ERROR` code.
+ * If the response appear to be corrupted, the returned Promise will reject with
+ * an error with an `INTEGRITY_ERROR` code.
  * @param {Function} segmentLoader
  * @returns {Function}
  */
-export default function addSegmentIntegrityChecks(
-  segmentLoader : ISegmentLoader<ArrayBuffer | Uint8Array | null>
-) : ISegmentLoader<ArrayBuffer | Uint8Array | null>;
-export default function addSegmentIntegrityChecks(
-  segmentLoader : ISegmentLoader<ArrayBuffer | Uint8Array | string | null>
-) : ISegmentLoader< ArrayBuffer | Uint8Array | string | null>;
-export default function addSegmentIntegrityChecks(
-  segmentLoader : ISegmentLoader< ArrayBuffer | Uint8Array | string | null >
-) : ISegmentLoader< ArrayBuffer | Uint8Array | string | null >
-{
-  return (content) => segmentLoader(content).pipe(tap((res) => {
-    if ((res.type === "data-loaded" || res.type === "data-chunk") &&
-        res.value.responseData !== null &&
-        typeof res.value.responseData !== "string" &&
-        inferSegmentContainer(content.adaptation.type,
-                              content.representation) === "mp4")
-    {
-      checkISOBMFFIntegrity(new Uint8Array(res.value.responseData),
-                            content.segment.isInit);
-    }
-  }));
+export default function addSegmentIntegrityChecks<T>(
+  segmentLoader : ISegmentLoader<T>
+) : ISegmentLoader<T> {
+  return (url, content, initialCancelSignal, callbacks) => {
+    return new PPromise((res, rej) => {
+      const canceller = new TaskCanceller();
+      const unregisterCancelLstnr = initialCancelSignal
+        .register(function onCheckCancellation(err : CancellationError) {
+          canceller.cancel();
+          rej(err);
+        });
+
+      /**
+       * If the data's seems to be corrupted, cancel the loading task and reject
+       * with an `INTEGRITY_ERROR` error.
+       * @param {*} data
+       */
+      function cancelAndRejectOnBadIntegrity(data : T) : void {
+        if (!(data instanceof Array) && !(data instanceof Uint8Array) ||
+            inferSegmentContainer(content.adaptation.type,
+                                  content.representation) !== "mp4")
+        {
+          return;
+        }
+        try {
+          checkISOBMFFIntegrity(new Uint8Array(data), content.segment.isInit);
+        } catch (err) {
+          unregisterCancelLstnr();
+          canceller.cancel();
+          rej(err);
+        }
+      }
+
+      segmentLoader(url, content, canceller.signal, {
+        ...callbacks,
+        onNewChunk(data) {
+          cancelAndRejectOnBadIntegrity(data);
+          if (!canceller.isUsed) {
+            callbacks.onNewChunk(data);
+          }
+        },
+      }).then((info) => {
+        if (canceller.isUsed) {
+          return;
+        }
+        unregisterCancelLstnr();
+
+        if (info.resultType === "segment-loaded") {
+          cancelAndRejectOnBadIntegrity(info.resultData.responseData);
+        }
+        res(info);
+
+      }, (error : unknown) => {
+        // The segmentLoader's cancellations cases are all handled here
+        if (!TaskCanceller.isCancellationError(error)) {
+          unregisterCancelLstnr();
+          rej(error);
+        }
+      });
+    });
+  };
 }