rx-player 3.27.0 → 3.27.1-dev.2022041500

package/src/manifest/manifest.ts

@@ -248,10 +248,13 @@ export default class Manifest extends EventEmitter<IManifestEvents> {
    */
   private _timeBounds : {
     /**
-     * The minimum time, in seconds, that was available the last time the
-     * Manifest was fetched.
+     * This is the theoretical minimum playable position on the content
+     * regardless of the current Adaptation chosen, as estimated at parsing
+     * time.
+     * `undefined` if unknown.
      *
-     * `undefined` if that value is unknown.
+     * More technically, the `minimumSafePosition` is the maximum between all
+     * the minimum positions reachable in any of the audio and video Adaptation.
      *
      * Together with `timeshiftDepth` and the `maximumTimeData` object, this
      * value allows to compute at any time the minimum seekable time:
@@ -259,17 +262,17 @@ export default class Manifest extends EventEmitter<IManifestEvents> {
      *   - if `timeshiftDepth` is not set, the minimum seekable time is a
      *     constant that corresponds to this value.
      *
-     *    - if `timeshiftDepth` is set, `absoluteMinimumTime` will act as the
+     *    - if `timeshiftDepth` is set, `minimumSafePosition` will act as the
      *      absolute minimum seekable time we can never seek below, even when
      *      `timeshiftDepth` indicates a possible lower position.
      *      This becomes useful for example when playing live contents which -
      *      despite having a large window depth - just begun and as such only
      *      have a few segment available for now.
-     *      Here, `absoluteMinimumTime` would be the start time of the initial
+     *      Here, `minimumSafePosition` would be the start time of the initial
      *      segment, and `timeshiftDepth` would be the whole depth that will
      *      become available once enough segments have been generated.
      */
-    absoluteMinimumTime? : number | undefined;
+    minimumSafePosition? : number | undefined;
     /**
      * Some dynamic contents have the concept of a "window depth" (or "buffer
      * depth") which allows to set a minimum position for all reachable
@@ -287,29 +290,46 @@ export default class Manifest extends EventEmitter<IManifestEvents> {
      * If set to `null`, this content has no concept of a "window depth".
      */
     timeshiftDepth : number | null;
-    /** Data allowing to calculate the maximum position at any given time. */
+    /** Data allowing to calculate the maximum playable position at any given time. */
     maximumTimeData : {
-      /** Maximum seekable time in milliseconds calculated at `time`. */
-      value : number;
       /**
-       * `Performance.now()` output at the time `value` was calculated.
-       * This can be used to retrieve the maximum position from `value` when it
-       * linearly evolves over time (see `isLinear` property).
+       * Current position representing live content.
+       * Only makes sense for un-ended live contents.
+       *
+       * `undefined` if unknown or if it doesn't make sense in the current context.
        */
-      time : number;
+      livePosition : number | undefined;
       /**
-       * Whether the maximum seekable position evolves linearly over time.
-       *
-       * If set to `false`, `value` indicates the constant maximum position.
+       * Whether the maximum positions should evolve linearly over time.
        *
-       * If set to `true`, the maximum seekable time continuously increase at
+       * If set to `true`, the maximum seekable position continuously increase at
        * the same rate than the time since `time` does.
-       * For example, a `value` of 50000 (50 seconds) will indicate a maximum time
-       * of 51 seconds after 1 second have passed, of 56 seconds after 6 seconds
-       * have passed (we know how many seconds have passed since the initial
-       * calculation of value by checking the `time` property) etc.
        */
       isLinear: boolean;
+      /**
+       * This is the theoretical maximum playable position on the content,
+       * regardless of the current Adaptation chosen, as estimated at parsing
+       * time.
+       *
+       * More technically, the `maximumSafePosition` is the minimum between all
+       * attributes indicating the duration of the content in the Manifest.
+       *
+       * That is the minimum between:
+       *   - The Manifest original attributes relative to its duration
+       *   - The minimum between all known maximum audio positions
+       *   - The minimum between all known maximum video positions
+       *
+       * This can for example be understood as the safe maximum playable
+       * position through all possible tacks.
+       */
+      maximumSafePosition : number;
+      /**
+       * `Performance.now()` output at the time both `maximumSafePosition` and
+       * `livePosition` were calculated.
+       * This can be used to retrieve a new maximum position from them when they
+       * linearly evolves over time (see `isLinear` property).
+       */
+      time : number;
     };
   };
 
@@ -459,38 +479,58 @@ export default class Manifest extends EventEmitter<IManifestEvents> {
   }
 
   /**
-   * Get the minimum position currently defined by the Manifest, in seconds.
+   * Returns the theoretical minimum playable position on the content
+   * regardless of the current Adaptation chosen, as estimated at parsing
+   * time.
    * @returns {number}
    */
-  public getMinimumPosition() : number {
+  public getMinimumSafePosition() : number {
     const windowData = this._timeBounds;
     if (windowData.timeshiftDepth === null) {
-      return windowData.absoluteMinimumTime ?? 0;
+      return windowData.minimumSafePosition ?? 0;
     }
 
     const { maximumTimeData } = windowData;
     let maximumTime : number;
     if (!windowData.maximumTimeData.isLinear) {
-      maximumTime = maximumTimeData.value;
+      maximumTime = maximumTimeData.maximumSafePosition;
     } else {
       const timeDiff = performance.now() - maximumTimeData.time;
-      maximumTime = maximumTimeData.value + timeDiff / 1000;
+      maximumTime = maximumTimeData.maximumSafePosition + timeDiff / 1000;
     }
     const theoricalMinimum = maximumTime - windowData.timeshiftDepth;
-    return Math.max(windowData.absoluteMinimumTime ?? 0, theoricalMinimum);
+    return Math.max(windowData.minimumSafePosition ?? 0, theoricalMinimum);
   }
 
   /**
-   * Get the maximum position currently defined by the Manifest, in seconds.
-   * @returns {number}
+   * Get the position of the live edge - that is, the position of what is
+   * currently being broadcasted, in seconds.
+   * @returns {number|undefined}
+   */
+  public getLivePosition() : number | undefined {
+    const { maximumTimeData } = this._timeBounds;
+    if (!this.isLive || maximumTimeData.livePosition === undefined) {
+      return undefined;
+    }
+    if (!maximumTimeData.isLinear) {
+      return maximumTimeData.livePosition;
+    }
+    const timeDiff = performance.now() - maximumTimeData.time;
+    return maximumTimeData.livePosition + timeDiff / 1000;
+  }
+
+  /**
+   * Returns the theoretical maximum playable position on the content
+   * regardless of the current Adaptation chosen, as estimated at parsing
+   * time.
    */
-  public getMaximumPosition() : number {
+  public getMaximumSafePosition() : number {
     const { maximumTimeData } = this._timeBounds;
     if (!maximumTimeData.isLinear) {
-      return maximumTimeData.value;
+      return maximumTimeData.maximumSafePosition;
     }
     const timeDiff = performance.now() - maximumTimeData.time;
-    return maximumTimeData.value + timeDiff / 1000;
+    return maximumTimeData.maximumSafePosition + timeDiff / 1000;
   }
 
   /**
@@ -690,7 +730,7 @@ export default class Manifest extends EventEmitter<IManifestEvents> {
       // Partial updates do not remove old Periods.
       // This can become a memory problem when playing a content long enough.
       // Let's clean manually Periods behind the minimum possible position.
-      const min = this.getMinimumPosition();
+      const min = this.getMinimumSafePosition();
       while (this.periods.length > 0) {
         const period = this.periods[0];
         if (period.end === undefined || period.end > min) {

package/src/manifest/period.ts

@@ -185,4 +185,14 @@ export default class Period {
       return ada.isSupported;
     });
   }
+
+  /**
+   * Returns true if the give time is in the time boundaries of this `Period`.
+   * @param {number} time
+   * @returns {boolean}
+   */
+  containsTime(time : number) : boolean {
+    return time >= this.start && (this.end === undefined ||
+                                  time < this.end);
+  }
 }

package/src/manifest/representation_index/types.ts

@@ -268,10 +268,15 @@ export interface IRepresentationIndex {
   getFirstPosition() : number | null | undefined;
 
   /**
-   * Returns the ending time, in seconds, of the last segment currently
-   * available in this index.
+   * Returns the ending time, in seconds, of the last playable position
+   * currently available in this index.
    * Returns `null` if nothing is in the index
    * Returns `undefined` if we cannot know this value.
+   *
+   * The last playable position is generally equivalent to the end of the last
+   * segment associated to this index, excepted when it goes over the end limit
+   * of the corresponding `Period`, in which case it will be equal to this end
+   * instead.
    * @returns {Number|null|undefined}
    */
   getLastPosition() : number | null | undefined;

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

@@ -15,20 +15,25 @@
  */
 
 import { IParsedPeriod } from "../../types";
-import getMaximumPosition from "../../utils/get_maximum_position";
+import getMaximumPositions from "../../utils/get_maximum_positions";
 import getMinimumPosition from "../../utils/get_minimum_position";
 
 /**
  * @param {Object} periods
  * @returns {Array.<number>}
  */
-export default function getMinimumAndMaximumPosition(
+export default function getMinimumAndMaximumPositions(
   periods: IParsedPeriod[]
-) : [number|undefined, number|undefined] {
+) : { minimumSafePosition : number | undefined;
+      maximumSafePosition : number | undefined;
+      maximumUnsafePosition : number | undefined; } {
   if (periods.length === 0) {
     throw new Error("DASH Parser: no period available for a dynamic content");
   }
 
-  return [ getMinimumPosition(periods),
-           getMaximumPosition(periods) ];
+  const minimumSafePosition = getMinimumPosition(periods);
+  const maxPositions = getMaximumPositions(periods);
+  return { minimumSafePosition,
+           maximumSafePosition: maxPositions.safe,
+           maximumUnsafePosition: maxPositions.unsafe };
 }

package/src/parsers/manifest/dash/common/indexes/base.ts

@@ -288,9 +288,10 @@ export default class BaseRepresentationIndex implements IRepresentationIndex {
       return null;
     }
     const lastTimelineElement = timeline[timeline.length - 1];
-    const lastTime = getIndexSegmentEnd(lastTimelineElement,
-                                        null,
-                                        this._scaledPeriodEnd);
+    const lastTime = Math.min(getIndexSegmentEnd(lastTimelineElement,
+                                                 null,
+                                                 this._scaledPeriodEnd),
+                              this._scaledPeriodEnd ?? Infinity);
     return fromIndexTime(lastTime, this._index);
   }
 

package/src/parsers/manifest/dash/common/indexes/list.ts

@@ -106,6 +106,8 @@ export interface IListIndexIndexArgument {
 export interface IListIndexContextArgument {
   /** Start of the period concerned by this RepresentationIndex, in seconds. */
   periodStart : number;
+  /** End of the period concerned by this RepresentationIndex, in seconds. */
+  periodEnd : number | undefined;
   /** Base URL for the Representation concerned. */
   representationBaseURLs : IResolvedBaseUrl[];
   /** ID of the Representation concerned. */
@@ -121,6 +123,8 @@ export default class ListRepresentationIndex implements IRepresentationIndex {
   private _index : IListIndex;
   /** Start of the period concerned by this RepresentationIndex, in seconds. */
   protected _periodStart : number;
+  /** End of the period concerned by this RepresentationIndex, in seconds. */
+  protected _periodEnd : number | undefined;
   /* Function that tells if an EMSG is whitelisted by the manifest */
   private _isEMSGWhitelisted: (inbandEvent: IEMSG) => boolean;
 
@@ -134,12 +138,14 @@ export default class ListRepresentationIndex implements IRepresentationIndex {
     }
 
     const { periodStart,
+            periodEnd,
             representationBaseURLs,
             representationId,
             representationBitrate,
             isEMSGWhitelisted } = context;
     this._isEMSGWhitelisted = isEMSGWhitelisted;
     this._periodStart = periodStart;
+    this._periodEnd = periodEnd;
     const presentationTimeOffset =
       index.presentationTimeOffset != null ? index.presentationTimeOffset :
                                              0;
@@ -248,7 +254,8 @@ export default class ListRepresentationIndex implements IRepresentationIndex {
   getLastPosition() : number {
     const index = this._index;
     const { duration, list } = index;
-    return ((list.length * duration) / index.timescale) + this._periodStart;
+    return Math.min(((list.length * duration) / index.timescale) + this._periodStart,
+                    this._periodEnd ?? Infinity);
   }
 
   /**

package/src/parsers/manifest/dash/common/indexes/template.ts

@@ -218,8 +218,9 @@ export default class TemplateRepresentationIndex implements IRepresentationIndex
                     startNumber: index.startNumber };
     this._isDynamic = isDynamic;
     this._periodStart = periodStart;
-    this._scaledPeriodEnd = periodEnd == null ? undefined :
-                                                (periodEnd - periodStart) * timescale;
+    this._scaledPeriodEnd = periodEnd === undefined ?
+      undefined :
+      (periodEnd - periodStart) * timescale;
     this._isEMSGWhitelisted = isEMSGWhitelisted;
   }
 
@@ -334,7 +335,11 @@ export default class TemplateRepresentationIndex implements IRepresentationIndex
       // the two functions. So, we return the result of the latter.
       return lastSegmentStart;
     }
-    const lastSegmentEnd = lastSegmentStart + this._index.duration;
+
+    const lastSegmentEnd = Math.min(
+      lastSegmentStart + this._index.duration,
+      this._scaledPeriodEnd ?? Infinity
+    );
     return (lastSegmentEnd / this._index.timescale) + this._periodStart;
   }
 

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";
 
-
 /**
  * Index property defined for a SegmentTimeline RepresentationIndex
  * This object contains every property needed to generate an ISegment for a
@@ -307,8 +306,8 @@ export default class TimelineRepresentationIndex implements IRepresentationIndex
                     timeline: index.timeline ?? null,
                     timescale };
     this._scaledPeriodStart = toIndexTime(periodStart, this._index);
-    this._scaledPeriodEnd = periodEnd == null ? undefined :
-                                                toIndexTime(periodEnd, this._index);
+    this._scaledPeriodEnd = periodEnd === undefined ? undefined :
+                                                      toIndexTime(periodEnd, this._index);
   }
 
   /**
@@ -389,7 +388,7 @@ export default class TimelineRepresentationIndex implements IRepresentationIndex
       this._index.timeline = this._getTimeline();
     }
     const lastTime = TimelineRepresentationIndex.getIndexEnd(this._index.timeline,
-                                                             this._scaledPeriodStart);
+                                                             this._scaledPeriodEnd);
     return lastTime === null ? null :
                                fromIndexTime(lastTime, this._index);
   }
@@ -566,9 +565,10 @@ export default class TimelineRepresentationIndex implements IRepresentationIndex
     if (timeline.length <= 0) {
       return null;
     }
-    return getIndexSegmentEnd(timeline[timeline.length - 1],
-                              null,
-                              scaledPeriodEnd);
+    return Math.min(getIndexSegmentEnd(timeline[timeline.length - 1],
+                                       null,
+                                       scaledPeriodEnd),
+                    scaledPeriodEnd ?? Infinity);
   }
 
   /**

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

@@ -28,7 +28,7 @@ import { IResponseData } from "../parsers_types";
 // eslint-disable-next-line max-len
 import getClockOffset from "./get_clock_offset";
 import getHTTPUTCTimingURL from "./get_http_utc-timing_url";
-import getMinimumAndMaximumPosition from "./get_minimum_and_maximum_positions";
+import getMinimumAndMaximumPositions from "./get_minimum_and_maximum_positions";
 import parseAvailabilityStartTime from "./parse_availability_start_time";
 import parsePeriods, {
   IXLinkInfos,
@@ -270,7 +270,10 @@ function parseCompleteIntermediateRepresentation(
   let lifetime : number | undefined;
   let minimumTime : number | undefined;
   let timeshiftDepth : number | null = null;
-  let maximumTimeData : { isLinear : boolean; value : number; time : number };
+  let maximumTimeData : { isLinear : boolean;
+                          maximumSafePosition : number;
+                          livePosition : number | undefined;
+                          time : number; };
 
   if (rootAttributes.minimumUpdatePeriod !== undefined &&
       rootAttributes.minimumUpdatePeriod >= 0)
@@ -280,58 +283,73 @@ function parseCompleteIntermediateRepresentation(
       rootAttributes.minimumUpdatePeriod;
   }
 
-  const [contentStart, contentEnd] = getMinimumAndMaximumPosition(parsedPeriods);
+  const { minimumSafePosition,
+          maximumSafePosition,
+          maximumUnsafePosition } = getMinimumAndMaximumPositions(parsedPeriods);
   const now = performance.now();
 
   if (!isDynamic) {
-    minimumTime = contentStart !== undefined            ? contentStart :
+    minimumTime = minimumSafePosition !== undefined     ? minimumSafePosition :
                   parsedPeriods[0]?.start !== undefined ? parsedPeriods[0].start :
                                                           0;
-    let maximumTime = mediaPresentationDuration ?? Infinity;
+    let finalMaximumSafePosition = mediaPresentationDuration ?? Infinity;
     if (parsedPeriods[parsedPeriods.length - 1] !== undefined) {
       const lastPeriod = parsedPeriods[parsedPeriods.length - 1];
       const lastPeriodEnd = lastPeriod.end ??
                             (lastPeriod.duration !== undefined ?
                               lastPeriod.start + lastPeriod.duration :
                               undefined);
-      if (lastPeriodEnd !== undefined && lastPeriodEnd < maximumTime) {
-        maximumTime = lastPeriodEnd;
+      if (lastPeriodEnd !== undefined && lastPeriodEnd < finalMaximumSafePosition) {
+        finalMaximumSafePosition = lastPeriodEnd;
       }
     }
-    if (contentEnd !== undefined && contentEnd < maximumTime) {
-      maximumTime = contentEnd;
+    if (maximumSafePosition !== undefined &&
+        maximumSafePosition < finalMaximumSafePosition)
+    {
+      finalMaximumSafePosition = maximumSafePosition;
     }
 
     maximumTimeData = { isLinear: false,
-                        value: maximumTime,
+                        maximumSafePosition: finalMaximumSafePosition,
+                        livePosition: undefined,
                         time: now };
   } else {
-    minimumTime = contentStart;
+    minimumTime = minimumSafePosition;
     timeshiftDepth = timeShiftBufferDepth ?? null;
-    let maximumTime : number;
-    if (contentEnd !== undefined) {
-      maximumTime = contentEnd;
+    let finalMaximumSafePosition : number;
+    let livePosition;
+
+    if (maximumUnsafePosition !== undefined) {
+      livePosition = maximumUnsafePosition;
+    }
+
+    if (maximumSafePosition !== undefined) {
+      finalMaximumSafePosition = maximumSafePosition;
     } else {
       const ast = availabilityStartTime ?? 0;
       const { externalClockOffset } = args;
       if (externalClockOffset === undefined) {
         log.warn("DASH Parser: use system clock to define maximum position");
-        maximumTime = (Date.now() / 1000) - ast;
+        finalMaximumSafePosition = (Date.now() / 1000) - ast;
       } else {
         const serverTime = performance.now() + externalClockOffset;
-        maximumTime = (serverTime / 1000) - ast;
+        finalMaximumSafePosition = (serverTime / 1000) - ast;
       }
     }
+    if (livePosition === undefined) {
+      livePosition = finalMaximumSafePosition;
+    }
     maximumTimeData = { isLinear: true,
-                        value: maximumTime,
+                        maximumSafePosition: finalMaximumSafePosition,
+                        livePosition,
                         time: now };
 
     // if the minimum calculated time is even below the buffer depth, perhaps we
     // can go even lower in terms of depth
     if (timeshiftDepth !== null && minimumTime !== undefined &&
-        maximumTime - minimumTime > timeshiftDepth)
+        finalMaximumSafePosition - minimumTime > timeshiftDepth)
     {
-      timeshiftDepth = maximumTime - minimumTime;
+      timeshiftDepth = finalMaximumSafePosition - minimumTime;
     }
   }
 
@@ -358,7 +376,7 @@ function parseCompleteIntermediateRepresentation(
     publishTime: rootAttributes.publishTime,
     suggestedPresentationDelay: rootAttributes.suggestedPresentationDelay,
     transportType: "dash",
-    timeBounds: { absoluteMinimumTime: minimumTime,
+    timeBounds: { minimumSafePosition: minimumTime,
                   timeshiftDepth,
                   maximumTimeData },
     lifetime,

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

@@ -61,10 +61,11 @@ export default function parseLocalManifest(
            isLastPeriodKnown: isFinished,
            isLive: false,
            uris: [],
-           timeBounds: { absoluteMinimumTime: minimumPosition ?? 0,
+           timeBounds: { minimumSafePosition: minimumPosition ?? 0,
                          timeshiftDepth: null,
                          maximumTimeData: { isLinear: false,
-                                            value: maximumPosition,
+                                            maximumSafePosition: maximumPosition,
+                                            livePosition: undefined,
                                             time: performance.now() } },
            periods: parsedPeriods };
 }

package/src/parsers/manifest/metaplaylist/metaplaylist_parser.ts

@@ -308,11 +308,16 @@ function createManifest(
                      isLastPeriodKnown,
                      uris: url == null ? [] :
                                          [url],
-                     timeBounds: { minimumTime,
+
+                     // TODO more precize time bounds?
+                     timeBounds: { minimumSafePosition: minimumTime,
                                    timeshiftDepth: null,
-                                   maximumTimeData: { isLinear: false,
-                                                      value: maximumTime,
-                                                      time } },
+                                   maximumTimeData: {
+                                     isLinear: false,
+                                     maximumSafePosition: maximumTime,
+                                     livePosition: undefined,
+                                     time,
+                                   } },
                      lifetime: mplData.pollInterval };
 
   return manifest;

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

@@ -533,7 +533,10 @@ function createSmoothStreamingParser(
     let availabilityStartTime : number|undefined;
     let minimumTime : number | undefined;
     let timeshiftDepth : number | null = null;
-    let maximumTimeData : { isLinear : boolean; value : number; time : number };
+    let maximumTimeData : { isLinear : boolean;
+                            maximumSafePosition: number;
+                            livePosition : number | undefined;
+                            time : number; };
 
     const firstVideoAdaptation = adaptations.video !== undefined ?
       adaptations.video[0] :
@@ -541,8 +544,15 @@ function createSmoothStreamingParser(
     const firstAudioAdaptation = adaptations.audio !== undefined ?
       adaptations.audio[0] :
       undefined;
-    let firstTimeReference : number|undefined;
-    let lastTimeReference : number|undefined;
+
+    /** Minimum time that can be reached regardless of the StreamIndex chosen. */
+    let safeMinimumTime : number|undefined;
+
+    /** Maximum time that can be reached regardless of the StreamIndex chosen. */
+    let safeMaximumTime : number|undefined;
+
+    /** Maximum time that can be reached in absolute on the content. */
+    let unsafeMaximumTime : number|undefined;
 
     if (firstVideoAdaptation !== undefined || firstAudioAdaptation !== undefined) {
       const firstTimeReferences : number[] = [];
@@ -585,44 +595,52 @@ function createSmoothStreamingParser(
       }
 
       if (firstTimeReferences.length > 0) {
-        firstTimeReference = Math.max(...firstTimeReferences);
+        safeMinimumTime = Math.max(...firstTimeReferences);
       }
 
       if (lastTimeReferences.length > 0) {
-        lastTimeReference = Math.min(...lastTimeReferences);
+        safeMaximumTime = Math.min(...lastTimeReferences);
+        unsafeMaximumTime = Math.max(...lastTimeReferences);
       }
     }
 
     const manifestDuration = root.getAttribute("Duration");
-    const duration = (manifestDuration != null && +manifestDuration !== 0) ?
+    const duration = (manifestDuration !== null && +manifestDuration !== 0) ?
       (+manifestDuration / timescale) : undefined;
 
     if (isLive) {
       suggestedPresentationDelay = parserOptions.suggestedPresentationDelay;
       availabilityStartTime = referenceDateTime;
 
-      minimumTime = firstTimeReference ?? availabilityStartTime;
-      const maximumTime = lastTimeReference != null ?
-        lastTimeReference :
-        (Date.now() / 1000 - availabilityStartTime);
+      minimumTime = safeMinimumTime ?? availabilityStartTime;
+      let livePosition = unsafeMaximumTime;
+      if (livePosition === undefined) {
+        livePosition = (Date.now() / 1000 - availabilityStartTime);
+      }
+      let maximumSafePosition = safeMaximumTime;
+      if (maximumSafePosition === undefined) {
+        maximumSafePosition = livePosition;
+      }
       maximumTimeData = { isLinear: true,
-                          value: maximumTime,
+                          maximumSafePosition,
+                          livePosition,
                           time: performance.now() };
       timeshiftDepth = timeShiftBufferDepth ?? null;
     } else {
-      minimumTime = firstTimeReference ?? 0;
-      const maximumTime = lastTimeReference !== undefined ? lastTimeReference :
-                          duration !== undefined ? minimumTime + duration :
-                                                   Infinity;
+      minimumTime = safeMinimumTime ?? 0;
+      const maximumTime = safeMaximumTime !== undefined ? safeMaximumTime :
+                          duration !== undefined        ? minimumTime + duration :
+                                                          Infinity;
       maximumTimeData = { isLinear: false,
-                          value: maximumTime,
+                          maximumSafePosition: maximumTime,
+                          livePosition: undefined,
                           time: performance.now() };
     }
 
     const periodStart = isLive ? 0 :
                                  minimumTime;
     const periodEnd = isLive ? undefined :
-                               maximumTimeData.value;
+                               maximumTimeData.maximumSafePosition;
     const manifest = {
       availabilityStartTime: availabilityStartTime === undefined ?
         0 :
@@ -631,7 +649,7 @@ function createSmoothStreamingParser(
       isLive,
       isDynamic: isLive,
       isLastPeriodKnown: true,
-      timeBounds: { absoluteMinimumTime: minimumTime,
+      timeBounds: { minimumSafePosition: minimumTime,
                     timeshiftDepth,
                     maximumTimeData },
       periods: [{ adaptations,