rx-player 3.26.2 → 3.26.3-dev.2022021400

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

@@ -58,7 +58,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 +77,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 +117,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 +138,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 +150,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 +160,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 +176,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 +231,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 +249,7 @@ export default class TimelineRepresentationIndex implements IRepresentationIndex
     const { availabilityTimeComplete,
             manifestBoundsCalculator,
             isDynamic,
+            isLastPeriod,
             representationBaseURLs,
             representationId,
             representationBitrate,
@@ -257,6 +268,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 +466,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 +481,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 +500,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 +555,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[],

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

@@ -31,52 +31,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 +79,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 +108,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 +128,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,12 +228,12 @@ 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 trickModeAdaptations: Array<{ adaptation: IParsedAdaptation;
@@ -306,10 +270,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;
@@ -331,26 +295,27 @@ export default function parseAdaptationSets(
     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,
     };
 
@@ -377,11 +342,11 @@ export default function parseAdaptationSets(
       // Add to the already existing main video adaptation
       // TODO remove that ugly custom logic?
       const videoMainAdaptation = parsedAdaptations.video[lastMainAdaptationIndex.video];
-      adaptationInfos.unsafelyBaseOnPreviousAdaptation = periodInfos
+      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 +395,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,
@@ -528,3 +493,26 @@ export default function parseAdaptationSets(
   attachTrickModeTrack(parsedAdaptations, trickModeAdaptations);
   return parsedAdaptations;
 }
+
+/** 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">;

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

@@ -47,11 +47,11 @@ export interface IMPDParserArguments {
    * If set, offset to add to `performance.now()` to obtain the current server's
    * time.
    */
-  externalClockOffset? : number;
+  externalClockOffset? : number | undefined;
   /** Time, in terms of `performance.now` at which this MPD was received. */
-  manifestReceivedTime? : number;
+  manifestReceivedTime? : number | undefined;
   /** Default base time, in seconds. */
-  referenceDateTime? : number;
+  referenceDateTime? : 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
@@ -62,13 +62,13 @@ export interface IMPDParserArguments {
    */
   unsafelyBaseOnPreviousManifest : Manifest | null;
   /** URL of the manifest (post-redirection if one). */
-  url? : string;
+  url? : string | undefined;
 }
 
 export interface ILoadedXlinkData {
-  url? : string;
-  sendingTime? : number;
-  receivedTime? : number;
+  url? : string | undefined;
+  sendingTime? : number | undefined;
+  receivedTime? : number | undefined;
   parsed : IPeriodIntermediateRepresentation[];
   warnings : Error[];
 }
@@ -127,7 +127,7 @@ export default function parseMpdIr(
   mpdIR : IMPDIntermediateRepresentation,
   args : IMPDParserArguments,
   warnings : Error[],
-  hasLoadedClock? : boolean,
+  hasLoadedClock? : boolean | undefined,
   xlinkInfos : IXLinkInfos = new WeakMap()
 ) : IIrParserResponse {
   const { children: rootChildren,