rx-player 3.26.1 → 3.26.2

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

@@ -162,7 +162,7 @@ export default class DashWasmParser {
         memoryBase: 0,
         tableBase: 0,
         memory: new WebAssembly.Memory({ initial: 10 }),
-        table: new WebAssembly.Table({ initial: 2, element: "anyfunc" }),
+        table: new WebAssembly.Table({ initial: 1, element: "anyfunc" }),
         onTagOpen,
         onCustomEvent,
         onAttribute,
@@ -391,7 +391,7 @@ export default class DashWasmParser {
 
     try {
       // TODO better type this
-      (this._instance.instance.exports.parse_xlink as () => void)();
+      (this._instance.instance.exports.parse as () => void)();
     } catch (err) {
       this._parsersStack.reset();
       this._warnings = [];
@@ -441,12 +441,15 @@ export default class DashWasmParser {
       ) : IDashParserResponse<string> | IDashParserResponse<ArrayBuffer> => {
         const resourceInfos : ILoadedXlinkData[] = [];
         for (let i = 0; i < loadedXlinks.length; i++) {
-          const { responseData: xlinkData,
+          const { responseData: xlinkResp,
                   receivedTime,
                   sendingTime,
                   url } = loadedXlinks[i];
+          if (!xlinkResp.success) {
+            throw xlinkResp.error;
+          }
           const [periodsIr,
-                 periodsIRWarnings] = this._parseXlink(xlinkData);
+                 periodsIRWarnings] = this._parseXlink(xlinkResp.data);
           resourceInfos.push({ url,
                                receivedTime,
                                sendingTime,

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

@@ -200,6 +200,13 @@ export function generateAdaptationSetChildrenParser(
                                  generateSegmentTemplateAttrParser(stObj, linearMemory));
         break;
       }
+
+      default:
+        // Allows to make sure we're not mistakenly closing a re-opened
+        // tag.
+        parsersStack.pushParsers(nodeId, noop, noop);
+        break;
+
     }
   };
 }
@@ -313,6 +320,12 @@ export function generateAdaptationSetAttrParser(
       case AttributeName.MaxSAPPeriod:
         adaptationAttrs.maximumSAPPeriod = dataView.getFloat64(ptr, true);
         break;
+      case AttributeName.AvailabilityTimeOffset:
+        adaptationAttrs.availabilityTimeOffset = dataView.getFloat64(ptr, true);
+        break;
+      case AttributeName.AvailabilityTimeComplete:
+        adaptationAttrs.availabilityTimeComplete = dataView.getUint8(0) === 0;
+        break;
 
       // TODO
       // case AttributeName.StartsWithSap:

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

@@ -37,10 +37,17 @@ export function generateBaseUrlAttrParser(
         baseUrlAttrs.value = parseString(textDecoder, linearMemory.buffer, ptr, len);
         break;
 
-      case AttributeName.AvailabilityTimeOffset:
+      case AttributeName.AvailabilityTimeOffset: {
         dataView = new DataView(linearMemory.buffer);
         baseUrlAttrs.attributes.availabilityTimeOffset = dataView.getFloat64(ptr, true);
         break;
+      }
+
+      case AttributeName.AvailabilityTimeComplete: {
+        baseUrlAttrs.attributes.availabilityTimeComplete =
+          new DataView(linearMemory.buffer).getUint8(0) === 0;
+        break;
+      }
     }
   };
 }

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

@@ -53,6 +53,12 @@ export function generateEventStreamChildrenParser(
         parsersStack.pushParsers(nodeId, noop, attrParser);
         break;
       }
+
+      default:
+        // Allows to make sure we're not mistakenly closing a re-opened
+        // tag.
+        parsersStack.pushParsers(nodeId, noop, noop);
+        break;
     }
   };
 }

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

@@ -86,6 +86,12 @@ export function generateMPDChildrenParser(
         parsersStack.pushParsers(nodeId, childrenParser, attributeParser);
         break;
       }
+
+      default:
+        // Allows to make sure we're not mistakenly closing a re-opened
+        // tag.
+        parsersStack.pushParsers(nodeId, noop, noop);
+        break;
     }
   };
 }

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

@@ -103,6 +103,12 @@ export function generatePeriodChildrenParser(
                                  generateSegmentTemplateAttrParser(stObj, linearMemory));
         break;
       }
+
+      default:
+        // Allows to make sure we're not mistakenly closing a re-opened
+        // tag.
+        parsersStack.pushParsers(nodeId, noop, noop);
+        break;
     }
   };
 }
@@ -141,6 +147,14 @@ export function generatePeriodAttrParser(
                                                ptr,
                                                len);
         break;
+      case AttributeName.AvailabilityTimeOffset:
+        periodAttrs.availabilityTimeOffset =
+          new DataView(linearMemory.buffer).getFloat64(ptr, true);
+        break;
+      case AttributeName.AvailabilityTimeComplete:
+        periodAttrs.availabilityTimeComplete =
+          new DataView(linearMemory.buffer).getUint8(0) === 0;
+        break;
       case AttributeName.Namespace:
         const xmlNs = { key: "", value: "" };
         const dataView = new DataView(linearMemory.buffer);

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

@@ -30,6 +30,7 @@ import {
 } from "../types";
 import { parseString } from "../utils";
 import { generateBaseUrlAttrParser } from "./BaseURL";
+import { generateContentProtectionAttrParser } from "./ContentProtection";
 import { generateSchemeAttrParser } from "./Scheme";
 import { generateSegmentBaseAttrParser } from "./SegmentBase";
 import { generateSegmentListChildrenParser } from "./SegmentList";
@@ -59,6 +60,19 @@ export function generateRepresentationChildrenParser(
         break;
       }
 
+      case TagName.ContentProtection: {
+        const contentProtection = { children: { cencPssh: [] },
+                                    attributes: {} };
+        if (childrenObj.contentProtections === undefined) {
+          childrenObj.contentProtections = [];
+        }
+        childrenObj.contentProtections.push(contentProtection);
+        const contentProtAttrParser =
+          generateContentProtectionAttrParser(contentProtection, linearMemory);
+        parsersStack.pushParsers(nodeId, noop, contentProtAttrParser);
+        break;
+      }
+
       case TagName.InbandEventStream: {
         const inbandEvent = {};
         if (childrenObj.inbandEventStreams === undefined) {
@@ -102,6 +116,12 @@ export function generateRepresentationChildrenParser(
                                  generateSegmentTemplateAttrParser(stObj, linearMemory));
         break;
       }
+
+      default:
+        // Allows to make sure we're not mistakenly closing a re-opened
+        // tag.
+        parsersStack.pushParsers(nodeId, noop, noop);
+        break;
     }
   };
 }
@@ -168,6 +188,12 @@ export function generateRepresentationAttrParser(
         representationAttrs.segmentProfiles =
           parseString(textDecoder, linearMemory.buffer, ptr, len);
         break;
+      case AttributeName.AvailabilityTimeOffset:
+        representationAttrs.availabilityTimeOffset = dataView.getFloat64(ptr, true);
+        break;
+      case AttributeName.AvailabilityTimeComplete:
+        representationAttrs.availabilityTimeComplete = dataView.getUint8(0) === 0;
+        break;
     }
   };
 }

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

@@ -50,6 +50,12 @@ export function generateSegmentListChildrenParser(
         parsersStack.pushParsers(nodeId, noop, attrParser);
         break;
       }
+
+      default:
+        // Allows to make sure we're not mistakenly closing a re-opened
+        // tag.
+        parsersStack.pushParsers(nodeId, noop, noop);
+        break;
     }
   };
 }

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

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+import noop from "../../../../../../utils/noop";
 import { IPeriodIntermediateRepresentation } from "../../../node_parser_types";
 import ParsersStack, {
   IChildrenParser,
@@ -54,6 +55,12 @@ export function generateXLinkChildrenParser(
         parsersStack.pushParsers(nodeId, childrenParser, attributeParser);
         break;
       }
+
+      default:
+        // Allows to make sure we're not mistakenly closing a re-opened
+        // tag.
+        parsersStack.pushParsers(nodeId, noop, noop);
+        break;
     }
   };
 }

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

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+import noop from "../../../../../../utils/noop";
 import {
   IMPDIntermediateRepresentation,
 } from "../../../node_parser_types";
@@ -54,6 +55,12 @@ export function generateRootChildrenParser(
                                                       linearMemory);
         parsersStack.pushParsers(nodeId, childrenParser, attributeParser);
         break;
+
+      default:
+        // Allows to make sure we're not mistakenly closing a re-opened
+        // tag.
+        parsersStack.pushParsers(nodeId, noop, noop);
+        break;
     }
   };
 }

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

@@ -196,7 +196,7 @@ export const enum AttributeName {
   MaxSegmentDuration = 41, // f64
   MaxSubsegmentDuration = 42, // f64
 
-  // BaseURL + SegmentTemplate
+  // BaseURL + SegmentTemplate + Period + AdaptationSet + Representation
   AvailabilityTimeOffset = 43, // f64
 
   // BaseURL

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

@@ -46,6 +46,7 @@ export default class LocalRepresentationIndex implements IRepresentationIndex {
       duration: 0,
       timescale: 1,
       mediaURLs: null,
+      complete: true,
       privateInfos: {
         localManifestInitSegment: { load: this._index.loadInitSegment } },
     };
@@ -83,6 +84,7 @@ export default class LocalRepresentationIndex implements IRepresentationIndex {
           timescale: 1,
           timestampOffset: wantedSegment.timestampOffset,
           mediaURLs: null,
+          complete: true,
           privateInfos: {
             localManifestSegment: { load: this._index.loadSegment,
                                     segment: wantedSegment },

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

@@ -301,7 +301,7 @@ function createSmoothStreamingParser(
     const baseURLAttr = root.getAttribute("Url");
     const baseURL = baseURLAttr === null ? "" :
                                            baseURLAttr;
-    if (__DEV__) {
+    if (__ENVIRONMENT__.CURRENT_ENV === __ENVIRONMENT__.DEV as number) {
       assert(baseURL !== "");
     }
 

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

@@ -312,7 +312,8 @@ export default class SmoothRepresentationIndex implements IRepresentationIndex {
              time: 0,
              end: 0,
              duration: 0,
-             timescale: 1 };
+             timescale: 1,
+             complete: true };
   }
 
   /**
@@ -362,6 +363,7 @@ export default class SmoothRepresentationIndex implements IRepresentationIndex {
                           timescale: 1 as const,
                           number,
                           mediaURLs: [replaceSegmentSmoothTokens(media, time)],
+                          complete: true,
                           privateInfos: { smoothMediaSegment: { time,
                                                                 duration } } };
         segments.push(segment);

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

@@ -36,7 +36,7 @@ export default function clearTimelineFromPosition(
       timeline.shift();
     } else { // we have a segment repetition
       const nextElt = timeline[1];
-      if (nextElt != null && nextElt.start <= firstAvailablePosition) {
+      if (nextElt !== undefined && nextElt.start <= firstAvailablePosition) {
         timeline.shift();
       } else { // no next segment or next segment is available
         if (firstElt.duration <= 0) {

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

@@ -14,24 +14,34 @@
  * 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];
+}
 
 /**
  * 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,
+  nextElement? : IIndexSegment | null | undefined,
   maxPosition? : number
 ) : 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/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/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/transports/dash/image_pipelines.ts

@@ -27,8 +27,8 @@ import {
   ISegmentLoaderResultChunkedComplete,
   ISegmentLoaderResultSegmentCreated,
   ISegmentLoaderResultSegmentLoaded,
-  ISegmentParserParsedInitSegment,
-  ISegmentParserParsedSegment,
+  ISegmentParserParsedInitChunk,
+  ISegmentParserParsedMediaChunk,
 } from "../types";
 
 /**
@@ -70,8 +70,8 @@ export function imageParser(
   loadedSegment : { data : ArrayBuffer | Uint8Array | null;
                     isChunked : boolean; },
   content : ISegmentContext
-) : ISegmentParserParsedSegment< IImageTrackSegmentData | null > |
-    ISegmentParserParsedInitSegment< null > {
+) : ISegmentParserParsedMediaChunk< IImageTrackSegmentData | null > |
+    ISegmentParserParsedInitChunk< null > {
   const { segment, period } = content;
   const { data, isChunked } = loadedSegment;
 

package/src/transports/dash/init_segment_loader.ts

@@ -99,7 +99,7 @@ export default function initSegmentLoader(
                resultData: { url,
                              responseData: data,
                              size: initData.size + indexData.size,
-                             duration: receivedTime - sendingTime,
+                             requestDuration: receivedTime - sendingTime,
                              sendingTime,
                              receivedTime } };
 

package/src/transports/dash/manifest_parser.ts

@@ -15,10 +15,14 @@
  */
 
 import PPromise from "pinkie";
+import { formatError } from "../../errors";
 import features from "../../features";
 import log from "../../log";
 import Manifest from "../../manifest";
-import { IDashParserResponse } from "../../parsers/manifest/dash/parsers_types";
+import {
+  IDashParserResponse,
+  ILoadedResource,
+} from "../../parsers/manifest/dash/parsers_types";
 import objectAssign from "../../utils/object_assign";
 import request from "../../utils/request";
 import {
@@ -146,42 +150,112 @@ export default function generateManifestParser(
 
       const externalResources = value.urls.map(resourceUrl => {
         return scheduleRequest(() => {
-          const req = value.format === "string" ?
-            request({ url: resourceUrl,
-                      responseType: "text" as const,
-                      cancelSignal }) :
-            request({ url: resourceUrl,
-                      responseType: "arraybuffer" as const,
-                      cancelSignal });
-          return req;
-        });
-      });
+          return value.format === "string" ? request({ url: resourceUrl,
+                                                       responseType: "text",
+                                                       cancelSignal }) :
 
-      return PPromise.all(externalResources).then(loadedResources => {
-        if (value.format === "string") {
-          const resources = loadedResources.map(resource => {
-            if (typeof resource.responseData !== "string") {
+                                             request({ url: resourceUrl,
+                                                       responseType: "arraybuffer",
+                                                       cancelSignal });
+        }).then((res) => {
+          if (value.format === "string") {
+            if (typeof res.responseData !== "string") {
               throw new Error("External DASH resources should have been a string");
             }
-            // Normally not needed but TypeScript is just dumb here
-            return objectAssign(resource, { responseData: resource.responseData });
-          });
-          return processMpdParserResponse(value.continue(resources));
-        } else {
-          const resources = loadedResources.map(resource => {
-            if (!(resource.responseData instanceof ArrayBuffer)) {
+            return objectAssign(res, {
+              responseData: {
+                success: true as const,
+                data: res.responseData },
+            });
+          } else {
+            if (!(res.responseData instanceof ArrayBuffer)) {
               throw new Error("External DASH resources should have been ArrayBuffers");
             }
-            // Normally not needed but TypeScript is just dumb here
-            return objectAssign(resource, { responseData: resource.responseData });
+            return objectAssign(res, {
+              responseData: {
+                success: true as const,
+                data: res.responseData },
+            });
+          }
+        }, (err) => {
+          const error = formatError(err, {
+            defaultCode: "PIPELINE_PARSE_ERROR",
+            defaultReason: "An unknown error occured when parsing ressources.",
           });
-          return processMpdParserResponse(value.continue(resources));
+          return objectAssign({}, {
+            size: undefined,
+            requestDuration: undefined,
+            responseData: {
+              success: false as const,
+              error },
+          });
+        });
+      });
+
+      return PPromise.all(externalResources).then(loadedResources => {
+        if (value.format === "string") {
+          assertLoadedResourcesFormatString(loadedResources);
+          return processMpdParserResponse(value.continue(loadedResources));
+        } else {
+          assertLoadedResourcesFormatArrayBuffer(loadedResources);
+          return processMpdParserResponse(value.continue(loadedResources));
         }
       });
     }
   };
 }
 
+/**
+ * Throw if the given input is not in the expected format.
+ * Allows to enforce runtime type-checking as compile-time type-checking here is
+ * difficult to enforce.
+ *
+ * @param loadedResource
+ * @returns
+ */
+function assertLoadedResourcesFormatString(
+  loadedResources : Array<ILoadedResource<string | ArrayBuffer>>
+) : asserts loadedResources is Array<ILoadedResource<string>> {
+  if (__ENVIRONMENT__.CURRENT_ENV === __ENVIRONMENT__.PRODUCTION as number) {
+    return;
+  }
+  loadedResources.forEach((loadedResource) => {
+    const { responseData } = loadedResource;
+    if (responseData.success && typeof responseData.data === "string") {
+      return;
+    } else if (!responseData.success) {
+      return;
+    }
+    throw new Error("Invalid data given to the LoadedRessource");
+  });
+}
+
+/**
+ * Throw if the given input is not in the expected format.
+ * Allows to enforce runtime type-checking as compile-time type-checking here is
+ * difficult to enforce.
+ *
+ * @param loadedResource
+ * @returns
+ */
+function assertLoadedResourcesFormatArrayBuffer(
+  loadedResources : Array<ILoadedResource<string | ArrayBuffer>>
+) : asserts loadedResources is Array<ILoadedResource<ArrayBuffer>> {
+  if (__ENVIRONMENT__.CURRENT_ENV === __ENVIRONMENT__.PRODUCTION as number) {
+    return;
+  }
+
+  loadedResources.forEach((loadedResource) => {
+    const { responseData } = loadedResource;
+    if (responseData.success && responseData.data instanceof ArrayBuffer) {
+      return;
+    } else if (!responseData.success) {
+      return;
+    }
+    throw new Error("Invalid data given to the LoadedRessource");
+  });
+}
+
 /**
  * Try to convert a Manifest from an unknown format to a `Document` format.
  * Useful to exploit DOM-parsing APIs to quickly parse an XML Manifest.

package/src/transports/dash/segment_loader.ts

@@ -151,7 +151,7 @@ export default function generateSegmentLoader(
         res({ resultType: "segment-loaded",
               resultData: { responseData: _args.data,
                             size: _args.size,
-                            duration: _args.duration } });
+                            requestDuration: _args.duration } });
       };
 
       /**