rx-player 3.25.2 → 3.26.3-dev.2022021400

package/src/parsers/manifest/dash/common/parse_periods.ts

@@ -31,11 +31,12 @@ import {
   IPeriodIntermediateRepresentation,
 } from "../node_parser_types";
 // eslint-disable-next-line max-len
-import extractMinimumAvailabilityTimeOffset from "./extract_minimum_availability_time_offset";
 import flattenOverlappingPeriods from "./flatten_overlapping_periods";
 import getPeriodsTimeInformation from "./get_periods_time_infos";
 import ManifestBoundsCalculator from "./manifest_bounds_calculator";
-import parseAdaptationSets from "./parse_adaptation_sets";
+import parseAdaptationSets, {
+  IAdaptationSetContext,
+} from "./parse_adaptation_sets";
 import resolveBaseURLs from "./resolve_base_urls";
 
 const generatePeriodID = idGenerator();
@@ -43,74 +44,45 @@ const generatePeriodID = idGenerator();
 /** Information about each linked Xlink. */
 export type IXLinkInfos = WeakMap<IPeriodIntermediateRepresentation, {
   /** Real URL (post-redirection) used to download this xlink. */
-  url? : string;
+  url? : string | undefined;
   /** Time at which the request was sent (since the time origin), in ms. */
-  sendingTime? : number;
+  sendingTime? : number | undefined;
   /** Time at which the request was received (since the time origin), in ms. */
-  receivedTime? : number;
+  receivedTime? : number | undefined;
 }>;
 
-/** Context needed when calling `parsePeriods`. */
-export interface IPeriodsContextInfos {
-  /** Whether we should request new segments even if they are not yet finished. */
-  aggressiveMode : boolean;
-  availabilityTimeOffset: number;
-  availabilityStartTime : number;
-  baseURLs : string[];
-  clockOffset? : number;
-  duration? : number;
-  isDynamic : boolean;
-  manifestProfiles?: string;
-  /**
-   * Time (in terms of `performance.now`) at which the XML file containing this
-   * Period was received.
-   */
-  receivedTime? : number;
-  /** Depth of the buffer for the whole content, in seconds. */
-  timeShiftBufferDepth? : number;
-  /**
-   * The parser should take this Manifest - which is a previously parsed
-   * Manifest for the same dynamic content - as a base to speed-up the parsing
-   * process.
-   * /!\ If unexpected differences exist between the two, there is a risk of
-   * de-synchronization with what is actually on the server,
-   * Use with moderation.
-   */
-  unsafelyBaseOnPreviousManifest : Manifest | null;
-  xlinkInfos : IXLinkInfos;
-}
-
 /**
  * Process intermediate periods to create final parsed periods.
  * @param {Array.<Object>} periodsIR
- * @param {Object} contextInfos
+ * @param {Object} context
  * @returns {Array.<Object>}
  */
 export default function parsePeriods(
   periodsIR : IPeriodIntermediateRepresentation[],
-  contextInfos : IPeriodsContextInfos
+  context : IPeriodContext
 ): IParsedPeriod[] {
   const parsedPeriods : IParsedPeriod[] = [];
-  const periodsTimeInformation = getPeriodsTimeInformation(periodsIR, contextInfos);
+  const periodsTimeInformation = getPeriodsTimeInformation(periodsIR, context);
   if (periodsTimeInformation.length !== periodsIR.length) {
     throw new Error("MPD parsing error: the time information are incoherent.");
   }
 
   const { isDynamic,
-          timeShiftBufferDepth } = contextInfos;
+          timeShiftBufferDepth } = context;
   const manifestBoundsCalculator = new ManifestBoundsCalculator({ isDynamic,
                                                                   timeShiftBufferDepth });
 
-  if (!isDynamic && contextInfos.duration != null) {
-    manifestBoundsCalculator.setLastPosition(contextInfos.duration);
+  if (!isDynamic && context.duration != null) {
+    manifestBoundsCalculator.setLastPosition(context.duration);
   }
 
   // We parse it in reverse because we might need to deduce the buffer depth from
   // the last Periods' indexes
   for (let i = periodsIR.length - 1; i >= 0; i--) {
+    const isLastPeriod = i === periodsIR.length - 1;
     const periodIR = periodsIR[i];
-    const xlinkInfos = contextInfos.xlinkInfos.get(periodIR);
-    const periodBaseURLs = resolveBaseURLs(contextInfos.baseURLs,
+    const xlinkInfos = context.xlinkInfos.get(periodIR);
+    const periodBaseURLs = resolveBaseURLs(context.baseURLs,
                                            periodIR.children.baseURLs);
 
     const { periodStart,
@@ -131,31 +103,36 @@ export default function parsePeriods(
     }
 
     const receivedTime = xlinkInfos !== undefined ? xlinkInfos.receivedTime :
-                                                    contextInfos.receivedTime;
-
-    const availabilityTimeOffset =
-      extractMinimumAvailabilityTimeOffset(periodIR.children.baseURLs) +
-      contextInfos.availabilityTimeOffset;
+                                                    context.receivedTime;
 
-    const unsafelyBaseOnPreviousPeriod = contextInfos
+    const unsafelyBaseOnPreviousPeriod = context
       .unsafelyBaseOnPreviousManifest?.getPeriod(periodID) ?? null;
 
-    const periodInfos = { aggressiveMode: contextInfos.aggressiveMode,
-                          availabilityTimeOffset,
-                          baseURLs: periodBaseURLs,
-                          manifestBoundsCalculator,
-                          end: periodEnd,
-                          isDynamic,
-                          manifestProfiles: contextInfos.manifestProfiles,
-                          receivedTime,
-                          segmentTemplate: periodIR.children.segmentTemplate,
-                          start: periodStart,
-                          timeShiftBufferDepth,
-                          unsafelyBaseOnPreviousPeriod };
-    const adaptations = parseAdaptationSets(periodIR.children.adaptations,
-                                            periodInfos);
+    const availabilityTimeComplete = periodIR.attributes.availabilityTimeComplete ?? true;
+    const availabilityTimeOffset = periodIR.attributes.availabilityTimeOffset ?? 0;
+    const { aggressiveMode, manifestProfiles } = context;
+    const { segmentTemplate } = periodIR.children;
+    const adapCtxt : IAdaptationSetContext = { aggressiveMode,
+                                               availabilityTimeComplete,
+                                               availabilityTimeOffset,
+                                               baseURLs: periodBaseURLs,
+                                               manifestBoundsCalculator,
+                                               end: periodEnd,
+                                               isDynamic,
+                                               isLastPeriod,
+                                               manifestProfiles,
+                                               receivedTime,
+                                               segmentTemplate,
+                                               start: periodStart,
+                                               timeShiftBufferDepth,
+                                               unsafelyBaseOnPreviousPeriod };
+    const adaptations = parseAdaptationSets(periodIR.children.adaptations, adapCtxt);
+
+    const namespaces = (context.xmlNamespaces ?? [])
+      .concat(periodIR.attributes.namespaces ?? []);
     const streamEvents = generateStreamEvents(periodIR.children.eventStreams,
-                                              periodStart);
+                                              periodStart,
+                                              namespaces);
     const parsedPeriod : IParsedPeriod = { id: periodID,
                                            start: periodStart,
                                            end: periodEnd,
@@ -176,7 +153,7 @@ export default function parsePeriods(
           manifestBoundsCalculator.setLastPosition(lastPosition, positionTime);
         } else {
           const guessedLastPositionFromClock =
-            guessLastPositionFromClock(contextInfos, periodStart);
+            guessLastPositionFromClock(context, periodStart);
           if (guessedLastPositionFromClock !== undefined) {
             const [guessedLastPosition, guessedPositionTime] =
               guessedLastPositionFromClock;
@@ -188,9 +165,9 @@ export default function parsePeriods(
     }
   }
 
-  if (contextInfos.isDynamic && !manifestBoundsCalculator.lastPositionIsKnown()) {
+  if (context.isDynamic && !manifestBoundsCalculator.lastPositionIsKnown()) {
     // Guess a last time the last position
-    const guessedLastPositionFromClock = guessLastPositionFromClock(contextInfos, 0);
+    const guessedLastPositionFromClock = guessLastPositionFromClock(context, 0);
     if (guessedLastPositionFromClock !== undefined) {
       const [lastPosition, positionTime] = guessedLastPositionFromClock;
       manifestBoundsCalculator.setLastPosition(lastPosition, positionTime);
@@ -222,17 +199,17 @@ export default function parsePeriods(
  * the live time more directly from that previous one, we might be better off
  * than just using the clock.
  *
- * @param {Object} contextInfos
+ * @param {Object} context
  * @param {number} minimumTime
  * @returns {Array.<number|undefined>}
  */
 function guessLastPositionFromClock(
-  contextInfos : IPeriodsContextInfos,
+  context : IPeriodContext,
   minimumTime : number
 ) : [number, number] | undefined {
-  if (contextInfos.clockOffset != null) {
-    const lastPosition = contextInfos.clockOffset / 1000 -
-      contextInfos.availabilityStartTime;
+  if (context.clockOffset != null) {
+    const lastPosition = context.clockOffset / 1000 -
+      context.availabilityStartTime;
     const positionTime = performance.now() / 1000;
     const timeInSec = positionTime + lastPosition;
     if (timeInSec >= minimumTime) {
@@ -243,7 +220,7 @@ function guessLastPositionFromClock(
     if (now >= minimumTime) {
       log.warn("DASH Parser: no clock synchronization mechanism found." +
                " Using the system clock instead.");
-      const lastPosition = now - contextInfos.availabilityStartTime;
+      const lastPosition = now - context.availabilityStartTime;
       const positionTime = performance.now() / 1000;
       return [lastPosition, positionTime];
     }
@@ -270,10 +247,9 @@ function getMaximumLastPosition(
     .filter((ada) : ada is IParsedAdaptation[] => ada != null);
   const allAdaptations = flatMap(adaptationsVal,
                                  (adaptationsForType) => adaptationsForType);
-  for (let adapIndex = 0; adapIndex < allAdaptations.length; adapIndex++) {
-    const representations = allAdaptations[adapIndex].representations;
-    for (let repIndex = 0; repIndex < representations.length; repIndex++) {
-      const representation = representations[repIndex];
+  for (const adaptation of allAdaptations) {
+    const representations = adaptation.representations;
+    for (const representation of representations) {
       const position = representation.index.getLastPosition();
       if (position !== null) {
         allIndexAreEmpty = false;
@@ -306,27 +282,44 @@ function getMaximumLastPosition(
  */
 function generateStreamEvents(
   baseIr : IEventStreamIntermediateRepresentation[],
-  periodStart : number
+  periodStart : number,
+  xmlNamespaces : Array<{ key : string; value : string }>
 ) : IManifestStreamEvent[] {
   const res : IManifestStreamEvent[] = [];
-  for (let i = 0; i < baseIr.length; i++) {
-    const eventStreamIr = baseIr[i];
+  for (const eventStreamIr of baseIr) {
     const { schemeIdUri = "",
             timescale = 1 } = eventStreamIr.attributes;
+    const allNamespaces = xmlNamespaces
+      .concat(eventStreamIr.attributes.namespaces ?? []);
 
-    for (let j = 0; j < eventStreamIr.children.events.length; j++) {
-      const eventIr = eventStreamIr.children.events[j];
+    for (const eventIr of eventStreamIr.children.events) {
       if (eventIr.eventStreamData !== undefined) {
         const start = ((eventIr.presentationTime ?? 0) / timescale) + periodStart;
         const end = eventIr.duration === undefined ?
           undefined :
           start + (eventIr.duration / timescale);
 
-        const element = eventIr.eventStreamData instanceof Element ?
-          eventIr.eventStreamData :
-          new DOMParser()
-            .parseFromString(utf8ToStr(new Uint8Array(eventIr.eventStreamData)),
-                             "application/xml").documentElement;
+        let element;
+        if (eventIr.eventStreamData instanceof Element) {
+          element = eventIr.eventStreamData;
+        } else {
+          // First, we will create a parent Element defining all namespaces that
+          // should have been encountered until know.
+          // This is needed because the DOMParser API might throw when
+          // encountering unknown namespaced attributes or elements in the given
+          // `<Event>` xml subset.
+          let parentNode = allNamespaces.reduce((acc, ns) => {
+            return acc + "xmlns:" + ns.key + "=\"" + ns.value + "\" ";
+          }, "<toremove ");
+          parentNode += ">";
+
+          const elementToString = utf8ToStr(new Uint8Array(eventIr.eventStreamData));
+          element = new DOMParser()
+            .parseFromString(parentNode + elementToString + "</toremove>",
+                             "application/xml")
+            .documentElement
+            .childNodes[0] as Element; // unwrap from the `<toremove>` element
+        }
         res.push({ start,
                    end,
                    id: eventIr.id,
@@ -339,3 +332,38 @@ function generateStreamEvents(
   }
   return res;
 }
+
+/** Context needed when calling `parsePeriods`. */
+export interface IPeriodContext extends IInheritedAdaptationContext {
+  availabilityStartTime : number;
+  clockOffset? : number | undefined;
+  /** Duration (mediaPresentationDuration) of the whole MPD, in seconds. */
+  duration? : number | undefined;
+  /**
+   * The parser should take this Manifest - which is a previously parsed
+   * Manifest for the same dynamic content - as a base to speed-up the parsing
+   * process.
+   * /!\ If unexpected differences exist between the two, there is a risk of
+   * de-synchronization with what is actually on the server,
+   * Use with moderation.
+   */
+  unsafelyBaseOnPreviousManifest : Manifest | null;
+  xlinkInfos : IXLinkInfos;
+
+  /**
+   * XML namespaces linked to the `<MPD>` element.
+   * May be needed to convert EventStream's Event elements back into the
+   * Document form.
+   */
+  xmlNamespaces? : Array<{ key : string;
+                           value : string; }> | undefined;
+}
+
+type IInheritedAdaptationContext = Omit<IAdaptationSetContext,
+                                        "availabilityTimeComplete" |
+                                        "availabilityTimeOffset" |
+                                        "duration" |
+                                        "isLastPeriod" |
+                                        "manifestBoundsCalculator" |
+                                        "start" |
+                                        "unsafelyBaseOnPreviousPeriod">;

package/src/parsers/manifest/dash/common/parse_representation_index.ts

@@ -26,8 +26,6 @@ import {
   ISegmentTemplateIntermediateRepresentation,
   IScheme,
 } from "../node_parser_types";
-// eslint-disable-next-line max-len
-import extractMinimumAvailabilityTimeOffset from "./extract_minimum_availability_time_offset";
 import {
   BaseRepresentationIndex,
   ListRepresentationIndex,
@@ -35,62 +33,22 @@ import {
   TimelineRepresentationIndex,
 } from "./indexes";
 import ManifestBoundsCalculator from "./manifest_bounds_calculator";
-import resolveBaseURLs from "./resolve_base_urls";
-
-/** Supplementary context needed to parse a RepresentationIndex. */
-export interface IRepresentationInfos {
-  /** Parsed AdaptationSet which contains the Representation. */
-  adaptation : IAdaptationSetIntermediateRepresentation;
-  /** Whether we should request new segments even if they are not yet finished. */
-  aggressiveMode : boolean;
-  /** availability time offset of the concerned Adaptation. */
-  availabilityTimeOffset: number;
-  /** Eventual URLs from which every relative URL will be based on. */
-  baseURLs : string[];
-  /** Allows to obtain the first/last available position of a dynamic content. */
-  manifestBoundsCalculator : ManifestBoundsCalculator;
-  /** End time of the current period, in seconds. */
-  end? : number;
-  /** Whether the Manifest can evolve with time. */
-  isDynamic : boolean;
-  /**
-   * Parent parsed SegmentTemplate elements.
-   * Sorted by provenance from higher level (e.g. Period) to lower-lever (e.g.
-   * AdaptationSet).
-   */
-  parentSegmentTemplates : ISegmentTemplateIntermediateRepresentation[];
-  /**
-   * Time (in terms of `performance.now`) at which the XML file containing this
-   * Representation was received.
-   */
-  receivedTime? : number;
-  /** Start time of the current period, in seconds. */
-  start : number;
-  /** Depth of the buffer for the whole content, in seconds. */
-  timeShiftBufferDepth? : number;
-  /**
-   * The parser should take this Representation - which is the same as this one
-   * parsed at an earlier time - as a base to speed-up the parsing process.
-   * /!\ If unexpected differences exist between both, there is a risk of
-   * de-synchronization with what is actually on the server.
-   */
-  unsafelyBaseOnPreviousRepresentation : Representation | null;
-  /** List of inband event streams that are present on the representation */
-  inbandEventStreams: IScheme[] | undefined;
-}
+import resolveBaseURLs, {
+  IResolvedBaseUrl,
+} from "./resolve_base_urls";
 
 /**
  * Parse the specific segment indexing information found in a representation
  * into a IRepresentationIndex implementation.
  * @param {Array.<Object>} representation
- * @param {Object} representationInfos
+ * @param {Object} context
  * @returns {Array.<Object>}
  */
 export default function parseRepresentationIndex(
   representation : IRepresentationIntermediateRepresentation,
-  representationInfos : IRepresentationInfos
+  context : IRepresentationIndexContext
 ) : IRepresentationIndex {
-  const representationBaseURLs = resolveBaseURLs(representationInfos.baseURLs,
+  const representationBaseURLs = resolveBaseURLs(context.baseURLs,
                                                  representation.children.baseURLs);
   const { aggressiveMode,
           availabilityTimeOffset,
@@ -101,7 +59,8 @@ export default function parseRepresentationIndex(
           receivedTime,
           timeShiftBufferDepth,
           unsafelyBaseOnPreviousRepresentation,
-          inbandEventStreams } = representationInfos;
+          inbandEventStreams,
+          isLastPeriod } = context;
 
   const isEMSGWhitelisted = (inbandEvent: IEMSG): boolean => {
     if (inbandEventStreams === undefined) {
@@ -110,34 +69,32 @@ export default function parseRepresentationIndex(
     return inbandEventStreams
       .some(({ schemeIdUri }) => schemeIdUri === inbandEvent.schemeIdUri);
   };
-  const context = { aggressiveMode,
-                    availabilityTimeOffset,
-                    unsafelyBaseOnPreviousRepresentation,
-                    isEMSGWhitelisted,
-                    manifestBoundsCalculator,
-                    isDynamic,
-                    periodEnd,
-                    periodStart,
-                    receivedTime,
-                    representationBaseURLs,
-                    representationBitrate: representation.attributes.bitrate,
-                    representationId: representation.attributes.id,
-                    timeShiftBufferDepth };
+  const reprIndexCtxt = { aggressiveMode,
+                          availabilityTimeComplete: true,
+                          availabilityTimeOffset,
+                          unsafelyBaseOnPreviousRepresentation,
+                          isEMSGWhitelisted,
+                          isLastPeriod,
+                          manifestBoundsCalculator,
+                          isDynamic,
+                          periodEnd,
+                          periodStart,
+                          receivedTime,
+                          representationBaseURLs,
+                          representationBitrate: representation.attributes.bitrate,
+                          representationId: representation.attributes.id,
+                          timeShiftBufferDepth };
   let representationIndex : IRepresentationIndex;
   if (representation.children.segmentBase !== undefined) {
     const { segmentBase } = representation.children;
-    context.availabilityTimeOffset =
-      representationInfos.availabilityTimeOffset +
-      extractMinimumAvailabilityTimeOffset(representation.children.baseURLs) +
-      (segmentBase.availabilityTimeOffset ?? 0);
-    representationIndex = new BaseRepresentationIndex(segmentBase, context);
+    representationIndex = new BaseRepresentationIndex(segmentBase, reprIndexCtxt);
   } else if (representation.children.segmentList !== undefined) {
     const { segmentList } = representation.children;
-    representationIndex = new ListRepresentationIndex(segmentList, context);
+    representationIndex = new ListRepresentationIndex(segmentList, reprIndexCtxt);
   } else if (representation.children.segmentTemplate !== undefined ||
-             representationInfos.parentSegmentTemplates.length > 0)
+             context.parentSegmentTemplates.length > 0)
   {
-    const segmentTemplates = representationInfos.parentSegmentTemplates.slice();
+    const segmentTemplates = context.parentSegmentTemplates.slice();
     const childSegmentTemplate = representation.children.segmentTemplate;
     if (childSegmentTemplate !== undefined) {
       segmentTemplates.push(childSegmentTemplate);
@@ -147,30 +104,81 @@ export default function parseRepresentationIndex(
                    ...segmentTemplates as [
                      ISegmentTemplateIntermediateRepresentation
                    ] /* Ugly TS Hack */);
-    context.availabilityTimeOffset =
-      representationInfos.availabilityTimeOffset +
-      extractMinimumAvailabilityTimeOffset(representation.children.baseURLs) +
-      (segmentTemplate.availabilityTimeOffset ?? 0);
+    reprIndexCtxt.availabilityTimeComplete =
+      segmentTemplate.availabilityTimeComplete ??
+      context.availabilityTimeComplete;
+    reprIndexCtxt.availabilityTimeOffset =
+      (segmentTemplate.availabilityTimeOffset ?? 0) +
+      context.availabilityTimeOffset;
     representationIndex = TimelineRepresentationIndex
       .isTimelineIndexArgument(segmentTemplate) ?
-        new TimelineRepresentationIndex(segmentTemplate, context) :
-        new TemplateRepresentationIndex(segmentTemplate, context);
+        new TimelineRepresentationIndex(segmentTemplate, reprIndexCtxt) :
+        new TemplateRepresentationIndex(segmentTemplate, reprIndexCtxt);
   } else {
-    const adaptationChildren = representationInfos.adaptation.children;
+    const adaptationChildren = context.adaptation.children;
     if (adaptationChildren.segmentBase !== undefined) {
       const { segmentBase } = adaptationChildren;
-      representationIndex = new BaseRepresentationIndex(segmentBase, context);
+      representationIndex = new BaseRepresentationIndex(segmentBase, reprIndexCtxt);
     } else if (adaptationChildren.segmentList !== undefined) {
       const { segmentList } = adaptationChildren;
-      representationIndex = new ListRepresentationIndex(segmentList, context);
+      representationIndex = new ListRepresentationIndex(segmentList, reprIndexCtxt);
     } else {
       representationIndex = new TemplateRepresentationIndex({
         duration: Number.MAX_VALUE,
         timescale: 1,
         startNumber: 0,
         media: "",
-      }, context);
+      }, reprIndexCtxt);
     }
   }
   return representationIndex;
 }
+
+/** Supplementary context needed to parse a RepresentationIndex. */
+export interface IRepresentationIndexContext {
+  /** Parsed AdaptationSet which contains the Representation. */
+  adaptation : IAdaptationSetIntermediateRepresentation;
+  /** Whether we should request new segments even if they are not yet finished. */
+  aggressiveMode : boolean;
+  /** If false, declared segments in the MPD might still be not completely generated. */
+  availabilityTimeComplete : boolean;
+  /** availability time offset of the concerned Adaptation. */
+  availabilityTimeOffset : number;
+  /** Eventual URLs from which every relative URL will be based on. */
+  baseURLs : IResolvedBaseUrl[];
+  /** End time of the current Period, in seconds. */
+  end? : number | undefined;
+  /** List of inband event streams that are present on the representation */
+  inbandEventStreams: IScheme[] | undefined;
+  /**
+   * Set to `true` if the linked Period is the chronologically last one in the
+   * Manifest.
+   */
+  isLastPeriod : boolean;
+  /** Allows to obtain the first/last available position of a dynamic content. */
+  manifestBoundsCalculator : ManifestBoundsCalculator;
+  /** Whether the Manifest can evolve with time. */
+  isDynamic : boolean;
+  /**
+   * Parent parsed SegmentTemplate elements.
+   * Sorted by provenance from higher level (e.g. Period) to lower-lever (e.g.
+   * AdaptationSet).
+   */
+  parentSegmentTemplates : ISegmentTemplateIntermediateRepresentation[];
+  /**
+   * Time (in terms of `performance.now`) at which the XML file containing this
+   * Representation was received.
+   */
+  receivedTime? : number | undefined;
+  /** Start time of the current period, in seconds. */
+  start : number;
+  /** Depth of the buffer for the whole content, in seconds. */
+  timeShiftBufferDepth? : number | undefined;
+  /**
+   * The parser should take this Representation - which is the same as this one
+   * parsed at an earlier time - as a base to speed-up the parsing process.
+   * /!\ If unexpected differences exist between both, there is a risk of
+   * de-synchronization with what is actually on the server.
+   */
+  unsafelyBaseOnPreviousRepresentation : Representation | null;
+}