rx-player 3.26.2 → 3.27.0-dev.20220317

package/src/parsers/manifest/dash/common/indexes/timeline/timeline_representation_index.ts

@@ -47,7 +47,6 @@ import constructTimelineFromElements from "./construct_timeline_from_elements";
 // eslint-disable-next-line max-len
 import constructTimelineFromPreviousTimeline from "./construct_timeline_from_previous_timeline";
 
-const { MIN_DASH_S_ELEMENTS_TO_PARSE_UNSAFELY } = config;
 
 /**
  * Index property defined for a SegmentTimeline RepresentationIndex
@@ -58,7 +57,7 @@ export interface ITimelineIndex {
   /** If `false`, the last segment anounced might be still incomplete. */
   availabilityTimeComplete : boolean;
   /** Byte range for a possible index of segments in the server. */
-  indexRange?: [number, number];
+  indexRange?: [number, number] | undefined;
   /**
    * Temporal offset, in the current timescale (see timescale), to add to the
    * presentation time (time a segment has at decoding time) to obtain the
@@ -77,15 +76,15 @@ export interface ITimelineIndex {
     /** URLs to access the initialization segment. */
     mediaURLs: string[] | null;
     /** possible byte range to request it. */
-    range?: [number, number];
-  };
+    range?: [number, number] | undefined;
+  } | undefined;
   /**
    * Base URL(s) to access any segment. Can contain tokens to replace to convert
    * it to real URLs.
    */
   mediaURLs : string[] | null ;
   /** Number from which the first segments in this index starts with. */
-  startNumber? : number;
+  startNumber? : number | undefined;
   /**
    * Every segments defined in this index.
    * `null` at the beginning as this property is parsed lazily (only when first
@@ -117,11 +116,13 @@ export interface ITimelineIndex {
  * Most of the properties here are already defined in ITimelineIndex.
  */
 export interface ITimelineIndexIndexArgument {
-  indexRange?: [number, number];
-  initialization? : { media? : string; range?: [number, number] };
-  media? : string;
-  startNumber? : number;
-  timescale? : number;
+  indexRange?: [number, number] | undefined;
+  initialization? : { media? : string | undefined;
+                      range?: [number, number] | undefined; } |
+                    undefined;
+  media? : string | undefined;
+  startNumber? : number | undefined;
+  timescale? : number | undefined;
   /**
    * Offset present in the index to convert from the mediaTime (time declared in
    * the media segments and in this index) to the presentationTime (time wanted
@@ -136,10 +137,10 @@ export interface ITimelineIndexIndexArgument {
    * The time given here is in the current
    * timescale (see timescale)
    */
-  presentationTimeOffset? : number;
+  presentationTimeOffset? : number | undefined;
 
-  timelineParser? : () => HTMLCollection;
-  timeline? : ISegmentTimelineElement[];
+  timelineParser? : (() => HTMLCollection) | undefined;
+  timeline? : ISegmentTimelineElement[] | undefined;
 }
 
 /** Aditional context needed by a SegmentTimeline RepresentationIndex. */
@@ -148,9 +149,9 @@ export interface ITimelineIndexContextArgument {
   availabilityTimeComplete : boolean;
   /** Allows to obtain the minimum and maximum positions of a content. */
   manifestBoundsCalculator : ManifestBoundsCalculator;
-  /** Start of the period concerned by this RepresentationIndex, in seconds. */
+  /** Start of the period linked to this RepresentationIndex, in seconds. */
   periodStart : number;
-  /** End of the period concerned by this RepresentationIndex, in seconds. */
+  /** End of the period linked to this RepresentationIndex, in seconds. */
   periodEnd : number|undefined;
   /** Whether the corresponding Manifest can be updated and changed. */
   isDynamic : boolean;
@@ -158,13 +159,13 @@ export interface ITimelineIndexContextArgument {
    * Time (in terms of `performance.now`) at which the XML file containing this
    * index was received
    */
-  receivedTime? : number;
+  receivedTime? : number | undefined;
   /** Base URL for the Representation concerned. */
   representationBaseURLs : IResolvedBaseUrl[];
   /** ID of the Representation concerned. */
-  representationId? : string;
+  representationId? : string | undefined;
   /** Bitrate of the Representation concerned. */
-  representationBitrate? : number;
+  representationBitrate? : number | undefined;
   /**
    * The parser should take this previous version of the
    * `TimelineRepresentationIndex` - which was from the same Representation
@@ -174,13 +175,18 @@ export interface ITimelineIndexContextArgument {
    * Use with moderation.
    */
   unsafelyBaseOnPreviousRepresentation : Representation | null;
-  /* Function that tells if an EMSG is whitelisted by the manifest */
+  /** Function that tells if an EMSG is whitelisted by the manifest */
   isEMSGWhitelisted: (inbandEvent: IEMSG) => boolean;
+  /**
+   * Set to `true` if the linked Period is the chronologically last one in the
+   * Manifest.
+   */
+  isLastPeriod : boolean;
 }
 
 export interface ILastSegmentInformation {
   /** End of the timeline on `time`, timescaled. */
-  lastPosition? : number;
+  lastPosition? : number | undefined;
 
   /** Defines the time at which `lastPosition` was last calculated. */
   time : number;
@@ -224,6 +230,9 @@ export default class TimelineRepresentationIndex implements IRepresentationIndex
   /* Function that tells if an EMSG is whitelisted by the manifest */
   private _isEMSGWhitelisted: (inbandEvent: IEMSG) => boolean;
 
+  /** `true` if the linked Period is the chronologically last one in the Manifest. */
+  private _isLastPeriod: boolean;
+
   /**
    * @param {Object} index
    * @param {Object} context
@@ -239,6 +248,7 @@ export default class TimelineRepresentationIndex implements IRepresentationIndex
     const { availabilityTimeComplete,
             manifestBoundsCalculator,
             isDynamic,
+            isLastPeriod,
             representationBaseURLs,
             representationId,
             representationBitrate,
@@ -257,6 +267,7 @@ export default class TimelineRepresentationIndex implements IRepresentationIndex
     this._manifestBoundsCalculator = manifestBoundsCalculator;
 
     this._isEMSGWhitelisted = isEMSGWhitelisted;
+    this._isLastPeriod = isLastPeriod;
     this._lastUpdate = context.receivedTime == null ?
                                  performance.now() :
                                  context.receivedTime;
@@ -454,6 +465,7 @@ export default class TimelineRepresentationIndex implements IRepresentationIndex
     this._scaledPeriodEnd = newIndex._scaledPeriodEnd;
     this._lastUpdate = newIndex._lastUpdate;
     this._manifestBoundsCalculator = newIndex._manifestBoundsCalculator;
+    this._isLastPeriod = newIndex._isLastPeriod;
   }
 
   /**
@@ -468,11 +480,16 @@ export default class TimelineRepresentationIndex implements IRepresentationIndex
     if (newIndex._index.timeline === null) {
       newIndex._index.timeline = newIndex._getTimeline();
     }
-    updateSegmentTimeline(this._index.timeline, newIndex._index.timeline);
+    const hasReplaced = updateSegmentTimeline(this._index.timeline,
+                                              newIndex._index.timeline);
+    if (hasReplaced) {
+      this._index.startNumber = newIndex._index.startNumber;
+    }
     this._isDynamic = newIndex._isDynamic;
     this._scaledPeriodStart = newIndex._scaledPeriodStart;
     this._scaledPeriodEnd = newIndex._scaledPeriodEnd;
     this._lastUpdate = newIndex._lastUpdate;
+    this._isLastPeriod = newIndex._isLastPeriod;
   }
 
   /**
@@ -482,7 +499,13 @@ export default class TimelineRepresentationIndex implements IRepresentationIndex
    * @returns {Boolean}
    */
   isFinished() : boolean {
-    if (!this._isDynamic) {
+    if (!this._isDynamic || !this._isLastPeriod) {
+      // Either the content is not dynamic, in which case no new segment will
+      // be generated, either it is but this index is not linked to the current
+      // last Period in the MPD, in which case it is inferred that it has been
+      // completely generated. Note that this second condition might break very
+      // very rare use cases where old Periods are still being generated, yet it
+      // should fix more cases than it breaks.
       return true;
     }
 
@@ -531,7 +554,11 @@ export default class TimelineRepresentationIndex implements IRepresentationIndex
       return; // we don't know yet
     }
     const scaledFirstPosition = toIndexTime(firstPosition, this._index);
-    clearTimelineFromPosition(this._index.timeline, scaledFirstPosition);
+    const nbEltsRemoved = clearTimelineFromPosition(this._index.timeline,
+                                                    scaledFirstPosition);
+    if (this._index.startNumber !== undefined) {
+      this._index.startNumber += nbEltsRemoved;
+    }
   }
 
   static getIndexEnd(timeline : IIndexSegment[],
@@ -578,6 +605,7 @@ export default class TimelineRepresentationIndex implements IRepresentationIndex
     const newElements = this._parseTimeline();
     this._parseTimeline = null; // Free memory
 
+    const { MIN_DASH_S_ELEMENTS_TO_PARSE_UNSAFELY } = config.getCurrent();
     if (this._unsafelyBaseOnPreviousIndex === null ||
         newElements.length < MIN_DASH_S_ELEMENTS_TO_PARSE_UNSAFELY)
     {

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

@@ -30,8 +30,8 @@ const SUPPORTED_TEXT_TYPES = ["subtitle", "caption"];
 
 /** Structure of a parsed "scheme-like" element in the MPD. */
 interface IScheme {
-  schemeIdUri? : string;
-  value? : string;
+  schemeIdUri? : string | undefined;
+  value? : string | undefined;
 }
 
 /**

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

@@ -47,7 +47,7 @@ export default class ManifestBoundsCalculator {
   /**
    * @param {Object} args
    */
-  constructor(args : { timeShiftBufferDepth? : number;
+  constructor(args : { timeShiftBufferDepth : number | undefined;
                        isDynamic : boolean; }
   ) {
     this._isDynamic = args.isDynamic;

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

@@ -15,14 +15,18 @@
  */
 
 import log from "../../../../log";
-import { Period } from "../../../../manifest";
+import {
+  IAdaptationType,
+  Period,
+  SUPPORTED_ADAPTATIONS_TYPE,
+} from "../../../../manifest";
 import arrayFind from "../../../../utils/array_find";
+import arrayFindIndex from "../../../../utils/array_find_index";
 import arrayIncludes from "../../../../utils/array_includes";
 import isNonEmptyString from "../../../../utils/is_non_empty_string";
 import {
   IParsedAdaptation,
   IParsedAdaptations,
-  IParsedAdaptationType,
 } from "../../types";
 import {
   IAdaptationSetIntermediateRepresentation,
@@ -31,52 +35,10 @@ import {
 import attachTrickModeTrack from "./attach_trickmode_track";
 // eslint-disable-next-line max-len
 import inferAdaptationType from "./infer_adaptation_type";
-import ManifestBoundsCalculator from "./manifest_bounds_calculator";
 import parseRepresentations, {
-  IAdaptationInfos,
+  IRepresentationContext,
 } from "./parse_representations";
-import resolveBaseURLs, {
-  IResolvedBaseUrl,
-} from "./resolve_base_urls";
-
-/** Context needed when calling `parseAdaptationSets`. */
-export interface IAdaptationSetsContextInfos {
-  /** Whether we should request new segments even if they are not yet finished. */
-  aggressiveMode : boolean;
-  availabilityTimeComplete: boolean;
-  /** availabilityTimeOffset of the concerned period. */
-  availabilityTimeOffset: number;
-  /** Eventual URLs from which every relative URL will be based on. */
-  baseURLs : IResolvedBaseUrl[];
-  /** Allows to obtain the first available position of a 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 signaling some features */
-  manifestProfiles?: string;
-  /**
-   * Time (in terms of `performance.now`) at which the XML file containing
-   * this AdaptationSet was received.
-   */
-  receivedTime? : number;
-  /** SegmentTemplate parsed in the Period, if found. */
-  segmentTemplate? : ISegmentTemplateIntermediateRepresentation;
-  /** 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 Period - 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.
-   */
-  unsafelyBaseOnPreviousPeriod : Period | null;
-}
+import resolveBaseURLs from "./resolve_base_urls";
 
 /**
  * Supplementary information for "switchable" AdaptationSets of the same Period.
@@ -121,9 +83,11 @@ interface IAdaptationSwitchingInfos  {
  * @returns {Boolean}
  */
 function isVisuallyImpaired(
-  accessibility? : { schemeIdUri? : string; value? : string }
+  accessibility : { schemeIdUri? : string | undefined;
+                    value? : string | undefined; } |
+                  undefined
 ) : boolean {
-  if (accessibility == null) {
+  if (accessibility === undefined) {
     return false;
   }
 
@@ -148,9 +112,11 @@ function isVisuallyImpaired(
  * @returns {Boolean}
  */
 function isHardOfHearing(
-  accessibility? : { schemeIdUri? : string; value? : string }
+  accessibility : { schemeIdUri? : string | undefined;
+                    value? : string | undefined; } |
+                  undefined
 ) : boolean {
-  if (accessibility == null) {
+  if (accessibility === undefined) {
     return false;
   }
 
@@ -166,9 +132,11 @@ function isHardOfHearing(
  * @returns {Boolean}
  */
 function hasSignLanguageInterpretation(
-  accessibility? : { schemeIdUri? : string; value? : string }
+  accessibility : { schemeIdUri? : string | undefined;
+                    value? : string | undefined; } |
+                  undefined
 ) : boolean {
-  if (accessibility == null) {
+  if (accessibility === undefined) {
     return false;
   }
 
@@ -264,37 +232,38 @@ function getAdaptationSetSwitchingIDs(
  * Note that the AdaptationSets returned are sorted by priority (from the most
  * priority to the least one).
  * @param {Array.<Object>} adaptationsIR
- * @param {Object} periodInfos
+ * @param {Object} context
  * @returns {Array.<Object>}
  */
 export default function parseAdaptationSets(
   adaptationsIR : IAdaptationSetIntermediateRepresentation[],
-  periodInfos : IAdaptationSetsContextInfos
+  context : IAdaptationSetContext
 ): IParsedAdaptations {
-  const parsedAdaptations : IParsedAdaptations = {};
+  const parsedAdaptations : Record<
+    IAdaptationType,
+    Array<[ IParsedAdaptation,
+            IAdaptationSetOrderingData ]>
+  > = { video: [],
+        audio: [],
+        text: [],
+        image: [] };
   const trickModeAdaptations: Array<{ adaptation: IParsedAdaptation;
                                       trickModeAttachedAdaptationIds: string[]; }> = [];
   const adaptationSwitchingInfos : IAdaptationSwitchingInfos = {};
+
   const parsedAdaptationsIDs : string[] = [];
 
   /**
-   * Index of the last parsed AdaptationSet with a Role set as "main" in
-   * `parsedAdaptations` for a given type.
-   * Not defined for a type with no main Adaptation inside.
-   * This is used to put main AdaptationSet first in the resulting array of
-   * Adaptation while still preserving the MPD order among them.
+   * Index of the last parsed Video AdaptationSet with a Role set as "main" in
+   * `parsedAdaptations.video`.
+   * `-1` if not yet encountered.
+   * Used as we merge all main video AdaptationSet due to a comprehension of the
+   * DASH-IF IOP.
    */
-  const lastMainAdaptationIndex : Partial<Record<IParsedAdaptationType, number>> = {};
-
-  // first sort AdaptationSets by absolute priority.
-  adaptationsIR.sort((a, b) => {
-    /* As of DASH-IF 4.3, `1` is the default value. */
-    const priority1 = a.attributes.selectionPriority ?? 1;
-    const priority2 = b.attributes.selectionPriority ?? 1;
-    return priority2 - priority1;
-  });
+  let lastMainVideoAdapIdx = -1;
 
-  for (const adaptation of adaptationsIR) {
+  for (let adaptationIdx = 0; adaptationIdx < adaptationsIR.length; adaptationIdx++) {
+    const adaptation = adaptationsIR[adaptationIdx];
     const adaptationChildren = adaptation.children;
     const { essentialProperties,
             roles } = adaptationChildren;
@@ -306,10 +275,10 @@ export default function parseAdaptationSets(
     const representationsIR = adaptation.children.representations;
     const availabilityTimeComplete =
       adaptation.attributes.availabilityTimeComplete ??
-      periodInfos.availabilityTimeComplete;
+      context.availabilityTimeComplete;
     const availabilityTimeOffset =
       (adaptation.attributes.availabilityTimeOffset ?? 0) +
-      periodInfos.availabilityTimeOffset;
+      context.availabilityTimeOffset;
 
     const adaptationMimeType = adaptation.attributes.mimeType;
     const adaptationCodecs = adaptation.attributes.codecs;
@@ -327,30 +296,32 @@ export default function parseAdaptationSets(
       continue;
     }
 
+    const priority = adaptation.attributes.selectionPriority ?? 1;
     const originalID = adaptation.attributes.id;
     let newID : string;
     const adaptationSetSwitchingIDs = getAdaptationSetSwitchingIDs(adaptation);
     const parentSegmentTemplates = [];
-    if (periodInfos.segmentTemplate !== undefined) {
-      parentSegmentTemplates.push(periodInfos.segmentTemplate);
+    if (context.segmentTemplate !== undefined) {
+      parentSegmentTemplates.push(context.segmentTemplate);
     }
     if (adaptation.children.segmentTemplate !== undefined) {
       parentSegmentTemplates.push(adaptation.children.segmentTemplate);
     }
 
-    const adaptationInfos : IAdaptationInfos = {
-      aggressiveMode: periodInfos.aggressiveMode,
+    const reprCtxt : IRepresentationContext = {
+      aggressiveMode: context.aggressiveMode,
       availabilityTimeComplete,
       availabilityTimeOffset,
-      baseURLs: resolveBaseURLs(periodInfos.baseURLs, adaptationChildren.baseURLs),
-      manifestBoundsCalculator: periodInfos.manifestBoundsCalculator,
-      end: periodInfos.end,
-      isDynamic: periodInfos.isDynamic,
-      manifestProfiles: periodInfos.manifestProfiles,
+      baseURLs: resolveBaseURLs(context.baseURLs, adaptationChildren.baseURLs),
+      manifestBoundsCalculator: context.manifestBoundsCalculator,
+      end: context.end,
+      isDynamic: context.isDynamic,
+      isLastPeriod: context.isLastPeriod,
+      manifestProfiles: context.manifestProfiles,
       parentSegmentTemplates,
-      receivedTime: periodInfos.receivedTime,
-      start: periodInfos.start,
-      timeShiftBufferDepth: periodInfos.timeShiftBufferDepth,
+      receivedTime: context.receivedTime,
+      start: context.start,
+      timeShiftBufferDepth: context.timeShiftBufferDepth,
       unsafelyBaseOnPreviousAdaptation: null,
     };
 
@@ -369,19 +340,16 @@ export default function parseAdaptationSets(
 
     if (type === "video" &&
         isMainAdaptation &&
-        parsedAdaptations.video !== undefined &&
-        parsedAdaptations.video.length > 0 &&
-        lastMainAdaptationIndex.video !== undefined &&
+        lastMainVideoAdapIdx >= 0 &&
+        parsedAdaptations.video.length > lastMainVideoAdapIdx &&
         !isTrickModeTrack)
     {
-      // Add to the already existing main video adaptation
-      // TODO remove that ugly custom logic?
-      const videoMainAdaptation = parsedAdaptations.video[lastMainAdaptationIndex.video];
-      adaptationInfos.unsafelyBaseOnPreviousAdaptation = periodInfos
+      const videoMainAdaptation = parsedAdaptations.video[lastMainVideoAdapIdx][0];
+      reprCtxt.unsafelyBaseOnPreviousAdaptation = context
         .unsafelyBaseOnPreviousPeriod?.getAdaptation(videoMainAdaptation.id) ?? null;
       const representations = parseRepresentations(representationsIR,
                                                    adaptation,
-                                                   adaptationInfos);
+                                                   reprCtxt);
       videoMainAdaptation.representations.push(...representations);
       newID = videoMainAdaptation.id;
     } else {
@@ -430,12 +398,12 @@ export default function parseAdaptationSets(
       newID = adaptationID;
       parsedAdaptationsIDs.push(adaptationID);
 
-      adaptationInfos.unsafelyBaseOnPreviousAdaptation = periodInfos
+      reprCtxt.unsafelyBaseOnPreviousAdaptation = context
         .unsafelyBaseOnPreviousPeriod?.getAdaptation(adaptationID) ?? null;
 
       const representations = parseRepresentations(representationsIR,
                                                    adaptation,
-                                                   adaptationInfos);
+                                                   reprCtxt);
       const parsedAdaptationSet : IParsedAdaptation =
         { id: adaptationID,
           representations,
@@ -457,65 +425,56 @@ export default function parseAdaptationSets(
         parsedAdaptationSet.isSignInterpreted = true;
       }
 
-      const adaptationsOfTheSameType = parsedAdaptations[type];
       if (trickModeAttachedAdaptationIds !== undefined) {
         trickModeAdaptations.push({ adaptation: parsedAdaptationSet,
                                     trickModeAttachedAdaptationIds });
-      } else if (adaptationsOfTheSameType === undefined) {
-        parsedAdaptations[type] = [parsedAdaptationSet];
-        if (isMainAdaptation) {
-          lastMainAdaptationIndex[type] = 0;
-        }
       } else {
-        let mergedInto : IParsedAdaptation|null = null;
 
         // look if we have to merge this into another Adaptation
+        let mergedIntoIdx = -1;
         for (const id of adaptationSetSwitchingIDs) {
           const switchingInfos = adaptationSwitchingInfos[id];
-          if (switchingInfos != null &&
+          if (switchingInfos !== undefined &&
               switchingInfos.newID !== newID &&
               arrayIncludes(switchingInfos.adaptationSetSwitchingIDs, originalID))
           {
-            const adaptationToMergeInto = arrayFind(adaptationsOfTheSameType,
-                                                    (a) => a.id === id);
-            if (adaptationToMergeInto != null &&
-                adaptationToMergeInto.audioDescription ===
+            mergedIntoIdx = arrayFindIndex(parsedAdaptations[type],
+                                           (a) => a[0].id === id);
+            const mergedInto = parsedAdaptations[type][mergedIntoIdx];
+            if (mergedInto !== undefined &&
+                mergedInto[0].audioDescription ===
                   parsedAdaptationSet.audioDescription &&
-                adaptationToMergeInto.closedCaption ===
+                mergedInto[0].closedCaption ===
                   parsedAdaptationSet.closedCaption &&
-                adaptationToMergeInto.language === parsedAdaptationSet.language)
+                mergedInto[0].language === parsedAdaptationSet.language)
             {
               log.info("DASH Parser: merging \"switchable\" AdaptationSets",
                        originalID, id);
-              adaptationToMergeInto.representations
-                .push(...parsedAdaptationSet.representations);
-              mergedInto = adaptationToMergeInto;
+              mergedInto[0].representations.push(...parsedAdaptationSet.representations);
+              if (type === "video" &&
+                  isMainAdaptation &&
+                  !mergedInto[1].isMainAdaptation)
+              {
+                lastMainVideoAdapIdx = Math.max(lastMainVideoAdapIdx, mergedIntoIdx);
+              }
+              mergedInto[1] = {
+                priority: Math.max(priority, mergedInto[1].priority),
+                isMainAdaptation: isMainAdaptation ||
+                                  mergedInto[1].isMainAdaptation,
+                indexInMpd: Math.min(adaptationIdx, mergedInto[1].indexInMpd),
+              };
             }
           }
         }
 
-        if (isMainAdaptation) {
-          const oldLastMainIdx = lastMainAdaptationIndex[type];
-          const newLastMainIdx = oldLastMainIdx === undefined ? 0 :
-                                                                oldLastMainIdx + 1;
-          if (mergedInto === null) {
-            // put "main" Adaptation after all other Main Adaptations
-            adaptationsOfTheSameType.splice(newLastMainIdx, 0, parsedAdaptationSet);
-            lastMainAdaptationIndex[type] = newLastMainIdx;
-          } else {
-            const indexOf = adaptationsOfTheSameType.indexOf(mergedInto);
-            if (indexOf < 0) { // Weird, not found
-              adaptationsOfTheSameType.splice(newLastMainIdx, 0, parsedAdaptationSet);
-              lastMainAdaptationIndex[type] = newLastMainIdx;
-            } else if (oldLastMainIdx === undefined || indexOf > oldLastMainIdx) {
-              // Found but was not main
-              adaptationsOfTheSameType.splice(indexOf, 1);
-              adaptationsOfTheSameType.splice(newLastMainIdx, 0, mergedInto);
-              lastMainAdaptationIndex[type] = newLastMainIdx;
-            }
+        if (mergedIntoIdx < 0) {
+          parsedAdaptations[type].push([ parsedAdaptationSet,
+                                         { priority,
+                                           isMainAdaptation,
+                                           indexInMpd: adaptationIdx }]);
+          if (type === "video" && isMainAdaptation) {
+            lastMainVideoAdapIdx = parsedAdaptations.video.length - 1;
           }
-        } else if (mergedInto === null) {
-          adaptationsOfTheSameType.push(parsedAdaptationSet);
         }
       }
     }
@@ -525,6 +484,80 @@ export default function parseAdaptationSets(
                                                adaptationSetSwitchingIDs };
     }
   }
-  attachTrickModeTrack(parsedAdaptations, trickModeAdaptations);
-  return parsedAdaptations;
+
+  const adaptationsPerType = SUPPORTED_ADAPTATIONS_TYPE
+    .reduce((acc : IParsedAdaptations, adaptationType : IAdaptationType) => {
+      const adaptationsParsedForType = parsedAdaptations[adaptationType];
+      if (adaptationsParsedForType.length > 0) {
+        adaptationsParsedForType.sort(compareAdaptations);
+        acc[adaptationType] = adaptationsParsedForType
+          .map(([parsedAdaptation]) => parsedAdaptation);
+      }
+      return acc;
+    }, {});
+  parsedAdaptations.video.sort(compareAdaptations);
+  attachTrickModeTrack(adaptationsPerType, trickModeAdaptations);
+  return adaptationsPerType;
+}
+
+/** Metadata allowing to order AdaptationSets between one another. */
+interface IAdaptationSetOrderingData {
+  /**
+   * If `true`, this AdaptationSet is considered as a "main" one (e.g. it had a
+   * Role set to "main").
+   */
+  isMainAdaptation : boolean;
+  /**
+   * Set to the `selectionPriority` attribute of the corresponding AdaptationSet
+   * or to `1` by default.
+   */
+  priority : number;
+  /** Index of this AdaptationSet in the original MPD, starting from `0`. */
+  indexInMpd : number;
+}
+
+/**
+ * Compare groups of parsed AdaptationSet, alongside some ordering metadata,
+ * allowing to easily sort them through JavaScript's `Array.prototype.sort`
+ * method.
+ * @param {Array.<Object>} a
+ * @param {Array.<Object>} b
+ * @returns {number}
+ */
+function compareAdaptations(
+  a : [IParsedAdaptation, IAdaptationSetOrderingData],
+  b : [IParsedAdaptation, IAdaptationSetOrderingData]
+) : number {
+  const priorityDiff = b[1].priority - a[1].priority;
+  if (priorityDiff !== 0) {
+    return priorityDiff;
+  }
+  if (a[1].isMainAdaptation !== b[1].isMainAdaptation) {
+    return a[1].isMainAdaptation ? -1 :
+      1;
+  }
+  return a[1].indexInMpd - b[1].indexInMpd;
 }
+
+/** Context needed when calling `parseAdaptationSets`. */
+export interface IAdaptationSetContext extends IInheritedRepresentationContext {
+  /** SegmentTemplate parsed in the Period, if found. */
+  segmentTemplate? : ISegmentTemplateIntermediateRepresentation | undefined;
+  /**
+   * The parser should take this Period - 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.
+   */
+  unsafelyBaseOnPreviousPeriod : Period | null;
+}
+
+/**
+ * Supplementary context needed to parse a Representation common with
+ * `IRepresentationContext`.
+ */
+type IInheritedRepresentationContext = Omit<IRepresentationContext,
+                                            "unsafelyBaseOnPreviousAdaptation" |
+                                            "parentSegmentTemplates">;