rx-player 3.26.2 → 3.26.3-dev.2022021400

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

@@ -34,91 +34,55 @@ import {
 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 resolveBaseURLs, {
-  IResolvedBaseUrl,
-} from "./resolve_base_urls";
+import parseAdaptationSets, {
+  IAdaptationSetContext,
+} from "./parse_adaptation_sets";
+import resolveBaseURLs from "./resolve_base_urls";
 
 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;
-  availabilityStartTime : number;
-  baseURLs : IResolvedBaseUrl[];
-  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;
-
-  /**
-   * 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; }>;
-}
-
 /**
  * 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,
@@ -139,30 +103,32 @@ export default function parsePeriods(
     }
 
     const receivedTime = xlinkInfos !== undefined ? xlinkInfos.receivedTime :
-                                                    contextInfos.receivedTime;
+                                                    context.receivedTime;
 
-    const unsafelyBaseOnPreviousPeriod = contextInfos
+    const unsafelyBaseOnPreviousPeriod = context
       .unsafelyBaseOnPreviousManifest?.getPeriod(periodID) ?? null;
 
     const availabilityTimeComplete = periodIR.attributes.availabilityTimeComplete ?? true;
     const availabilityTimeOffset = periodIR.attributes.availabilityTimeOffset ?? 0;
-    const periodInfos = { aggressiveMode: contextInfos.aggressiveMode,
-                          availabilityTimeComplete,
-                          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 { 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 = (contextInfos.xmlNamespaces ?? [])
+    const namespaces = (context.xmlNamespaces ?? [])
       .concat(periodIR.attributes.namespaces ?? []);
     const streamEvents = generateStreamEvents(periodIR.children.eventStreams,
                                               periodStart,
@@ -187,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;
@@ -199,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);
@@ -233,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) {
@@ -254,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];
     }
@@ -366,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

@@ -37,61 +37,18 @@ import resolveBaseURLs, {
   IResolvedBaseUrl,
 } 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;
-  availabilityTimeComplete : boolean;
-  /** availability time offset of the concerned Adaptation. */
-  availabilityTimeOffset : number;
-  /** Eventual URLs from which every relative URL will be based on. */
-  baseURLs : IResolvedBaseUrl[];
-  /** 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;
-}
-
 /**
  * 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,
@@ -102,7 +59,8 @@ export default function parseRepresentationIndex(
           receivedTime,
           timeShiftBufferDepth,
           unsafelyBaseOnPreviousRepresentation,
-          inbandEventStreams } = representationInfos;
+          inbandEventStreams,
+          isLastPeriod } = context;
 
   const isEMSGWhitelisted = (inbandEvent: IEMSG): boolean => {
     if (inbandEventStreams === undefined) {
@@ -111,31 +69,32 @@ export default function parseRepresentationIndex(
     return inbandEventStreams
       .some(({ schemeIdUri }) => schemeIdUri === inbandEvent.schemeIdUri);
   };
-  const context = { aggressiveMode,
-                    availabilityTimeComplete: true,
-                    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;
-    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);
@@ -145,32 +104,81 @@ export default function parseRepresentationIndex(
                    ...segmentTemplates as [
                      ISegmentTemplateIntermediateRepresentation
                    ] /* Ugly TS Hack */);
-    context.availabilityTimeComplete =
+    reprIndexCtxt.availabilityTimeComplete =
       segmentTemplate.availabilityTimeComplete ??
-      representationInfos.availabilityTimeComplete;
-    context.availabilityTimeOffset =
+      context.availabilityTimeComplete;
+    reprIndexCtxt.availabilityTimeOffset =
       (segmentTemplate.availabilityTimeOffset ?? 0) +
-      representationInfos.availabilityTimeOffset;
+      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;
+}

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

@@ -26,14 +26,13 @@ import {
 import {
   IAdaptationSetIntermediateRepresentation,
   IRepresentationIntermediateRepresentation,
-  ISegmentTemplateIntermediateRepresentation,
   IScheme,
   IContentProtectionIntermediateRepresentation,
 } from "../node_parser_types";
 import { getWEBMHDRInformation } from "./get_hdr_information";
-import ManifestBoundsCalculator from "./manifest_bounds_calculator";
-import parseRepresentationIndex from "./parse_representation_index";
-import { IResolvedBaseUrl } from "./resolve_base_urls";
+import parseRepresentationIndex, {
+  IRepresentationIndexContext,
+} from "./parse_representation_index";
 
 /**
  * Combine inband event streams from representation and
@@ -59,49 +58,6 @@ function combineInbandEventStreams(
   return newSchemeId;
 }
 
-/** Supplementary context needed to parse a Representation. */
-export interface IAdaptationInfos {
-  /** Whether we should request new segments even if they are not yet finished. */
-  aggressiveMode : boolean;
-  availabilityTimeComplete: boolean;
-  /** availability time offset of the concerned Adaptation. */
-  availabilityTimeOffset: number;
-  /** Eventual URLs from which every relative URL will be based on. */
-  baseURLs : IResolvedBaseUrl[];
-  /** 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;
-  /** Manifest DASH profiles used for signalling some features */
-  manifestProfiles?: string;
-  /**
-   * 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 Adaptation - which is from a previously parsed
-   * Manifest for the same dynamic content - 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,
-   * Use with moderation.
-   */
-  unsafelyBaseOnPreviousAdaptation : Adaptation | null;
-}
-
 /**
  * Extract HDR information from manifest and codecs.
  * @param {Object}
@@ -111,9 +67,9 @@ function getHDRInformation(
   { adaptationProfiles,
     manifestProfiles,
     codecs,
-  }: { adaptationProfiles?: string;
-       manifestProfiles?: string;
-       codecs?: string; }
+  }: { adaptationProfiles?: string | undefined;
+       manifestProfiles?: string | undefined;
+       codecs?: string | undefined; }
 ): undefined | IHDRInformation {
   const profiles = (adaptationProfiles ?? "") + (manifestProfiles ?? "");
   if (codecs === undefined) {
@@ -138,13 +94,13 @@ function getHDRInformation(
 /**
  * Process intermediate representations to create final parsed representations.
  * @param {Array.<Object>} representationsIR
- * @param {Object} adaptationInfos
+ * @param {Object} context
  * @returns {Array.<Object>}
  */
 export default function parseRepresentations(
   representationsIR : IRepresentationIntermediateRepresentation[],
   adaptation : IAdaptationSetIntermediateRepresentation,
-  adaptationInfos : IAdaptationInfos
+  context : IRepresentationContext
 ): IParsedRepresentation[] {
   const parsedRepresentations : IParsedRepresentation[] = [];
   for (const representation of representationsIR) {
@@ -171,7 +127,7 @@ export default function parseRepresentations(
     }
 
     // Retrieve previous version of the Representation, if one.
-    const unsafelyBaseOnPreviousRepresentation = adaptationInfos
+    const unsafelyBaseOnPreviousRepresentation = context
       .unsafelyBaseOnPreviousAdaptation?.getRepresentation(representationID) ??
       null;
 
@@ -180,18 +136,19 @@ export default function parseRepresentations(
 
     const availabilityTimeComplete =
       representation.attributes.availabilityTimeComplete ??
-      adaptationInfos.availabilityTimeComplete;
+      context.availabilityTimeComplete;
     const availabilityTimeOffset =
       (representation.attributes.availabilityTimeOffset ?? 0) +
-      adaptationInfos.availabilityTimeOffset;
-    const representationInfos = objectAssign({}, adaptationInfos,
-                                             { availabilityTimeOffset,
-                                               availabilityTimeComplete,
-                                               unsafelyBaseOnPreviousRepresentation,
-                                               adaptation,
-                                               inbandEventStreams });
+      context.availabilityTimeOffset;
+    const reprIndexCtxt = objectAssign({},
+                                       context,
+                                       { availabilityTimeOffset,
+                                         availabilityTimeComplete,
+                                         unsafelyBaseOnPreviousRepresentation,
+                                         adaptation,
+                                         inbandEventStreams });
     const representationIndex = parseRepresentationIndex(representation,
-                                                         representationInfos);
+                                                         reprIndexCtxt);
 
     // Find bitrate
     let representationBitrate : number;
@@ -297,10 +254,34 @@ export default function parseRepresentations(
 
     parsedRepresentation.hdrInfo =
       getHDRInformation({ adaptationProfiles: adaptation.attributes.profiles,
-                          manifestProfiles: adaptationInfos.manifestProfiles,
+                          manifestProfiles: context.manifestProfiles,
                           codecs });
 
     parsedRepresentations.push(parsedRepresentation);
   }
   return parsedRepresentations;
 }
+
+/** Supplementary context needed to parse a Representation. */
+export interface IRepresentationContext extends IInheritedRepresentationIndexContext {
+  /** Manifest DASH profiles used for signalling some features */
+  manifestProfiles?: string | undefined;
+  /**
+   * The parser should take this Adaptation - which is from a previously parsed
+   * Manifest for the same dynamic content - 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,
+   * Use with moderation.
+   */
+  unsafelyBaseOnPreviousAdaptation : Adaptation | null;
+}
+
+/**
+ * Supplementary context needed to parse a Representation common with
+ * `IRepresentationIndexContext`.
+ */
+type IInheritedRepresentationIndexContext = Omit<IRepresentationIndexContext,
+                                                 "adaptation" |
+                                                 "unsafelyBaseOnPreviousRepresentation" |
+                                                 "inbandEventStreams">;