rx-player 3.27.0 → 3.27.1-dev.2022041500

package/dist/_esm5.processed/core/stream/representation/get_buffer_status.js

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 import config from "../../../config";
+import isNullOrUndefined from "../../../utils/is_null_or_undefined";
 import { SegmentBufferOperation, } from "../../segment_buffers";
 import checkForDiscontinuity from "./check_for_discontinuity";
 import getNeededSegments from "./get_needed_segments";
@@ -26,20 +27,19 @@ import getSegmentPriority from "./get_segment_priority";
  * be filled by any segment, even in the future.
  *
  * @param {Object} content
- * @param {Object} playbackInfo
+ * @param {number} initialWantedTime
+ * @param {Object} playbackObserver
  * @param {number|undefined} fastSwitchThreshold
  * @param {number} bufferGoal
+ * @param {number} maxBufferSize
  * @param {Object} segmentBuffer
  * @returns {Object}
  */
-export default function getBufferStatus(content, wantedStartPosition, playbackObserver, fastSwitchThreshold, bufferGoal, maxBufferSize, segmentBuffer) {
-    var _a;
-    var period = content.period, representation = content.representation;
+export default function getBufferStatus(content, initialWantedTime, playbackObserver, fastSwitchThreshold, bufferGoal, maxBufferSize, segmentBuffer) {
     segmentBuffer.synchronizeInventory();
-    var wantedEndPosition = wantedStartPosition + bufferGoal;
-    var neededRange = { start: Math.max(wantedStartPosition, period.start),
-        end: Math.min(wantedEndPosition, (_a = period.end) !== null && _a !== void 0 ? _a : Infinity) };
-    var shouldRefreshManifest = representation.index.shouldRefresh(wantedStartPosition, wantedEndPosition);
+    var representation = content.representation;
+    var neededRange = getRangeOfNeededSegments(content, initialWantedTime, bufferGoal);
+    var shouldRefreshManifest = representation.index.shouldRefresh(neededRange.start, neededRange.end);
     /**
      * Every segment awaiting an "EndOfSegment" operation, which indicates that a
      * completely-loaded segment is still being pushed to the SegmentBuffer.
@@ -55,47 +55,18 @@ export default function getBufferStatus(content, wantedStartPosition, playbackOb
     /** Callback allowing to retrieve a segment's history in the buffer. */
     var getBufferedHistory = segmentBuffer.getSegmentHistory.bind(segmentBuffer);
     /** List of segments we will need to download. */
-    var _b = getNeededSegments({ content: content, bufferedSegments: bufferedSegments, currentPlaybackTime: currentPlaybackTime, fastSwitchThreshold: fastSwitchThreshold, getBufferedHistory: getBufferedHistory, neededRange: neededRange, segmentsBeingPushed: segmentsBeingPushed, maxBufferSize: maxBufferSize }), segmentsToLoad = _b.segmentsToLoad, segmentsOnHold = _b.segmentsOnHold, isBufferFull = _b.isBufferFull;
+    var _a = getNeededSegments({ content: content, bufferedSegments: bufferedSegments, currentPlaybackTime: currentPlaybackTime, fastSwitchThreshold: fastSwitchThreshold, getBufferedHistory: getBufferedHistory, neededRange: neededRange, segmentsBeingPushed: segmentsBeingPushed, maxBufferSize: maxBufferSize }), segmentsToLoad = _a.segmentsToLoad, segmentsOnHold = _a.segmentsOnHold, isBufferFull = _a.isBufferFull;
     var prioritizedNeededSegments = segmentsToLoad.map(function (segment) { return ({
-        priority: getSegmentPriority(segment.time, wantedStartPosition),
+        priority: getSegmentPriority(segment.time, initialWantedTime),
         segment: segment,
     }); });
     /**
      * `true` if the current `RepresentationStream` has loaded all the
      * needed segments for this Representation until the end of the Period.
      */
-    var hasFinishedLoading;
-    var lastPosition = representation.index.getLastPosition();
-    if (!representation.index.isInitialized() ||
-        period.end === undefined ||
-        prioritizedNeededSegments.length > 0 ||
-        segmentsOnHold.length > 0) {
-        hasFinishedLoading = false;
-    }
-    else {
-        if (lastPosition === undefined) {
-            // We do not know the end of this index.
-            // If we reached the end of the period, check that all segments are
-            // available.
-            hasFinishedLoading = neededRange.end >= period.end &&
-                representation.index.isFinished();
-        }
-        else if (lastPosition === null) {
-            // There is no available segment in the index currently. If the index
-            // tells us it has finished generating new segments, we're done.
-            hasFinishedLoading = representation.index.isFinished();
-        }
-        else {
-            // We have a declared end. Check that our range went until the last
-            // position available in the index. If that's the case and we're left
-            // with no segments after filtering them, it means we already have
-            // downloaded the last segments and have nothing left to do: full.
-            var endOfRange = period.end !== undefined ? Math.min(period.end, lastPosition) :
-                lastPosition;
-            hasFinishedLoading = neededRange.end >= endOfRange &&
-                representation.index.isFinished();
-        }
-    }
+    var hasFinishedLoading = neededRange.hasReachedPeriodEnd &&
+        prioritizedNeededSegments.length === 0 &&
+        segmentsOnHold.length === 0;
     var imminentDiscontinuity;
     if (!representation.index.isInitialized() ||
         // TODO better handle contents not chronologically generated
@@ -127,6 +98,78 @@ export default function getBufferStatus(content, wantedStartPosition, playbackOb
     }
     return { imminentDiscontinuity: imminentDiscontinuity, hasFinishedLoading: hasFinishedLoading, neededSegments: prioritizedNeededSegments, isBufferFull: isBufferFull, shouldRefreshManifest: shouldRefreshManifest };
 }
+/**
+ * Returns both the time range of segments that should be loaded (from a
+ * starting position to an ending position) and whether the end of the Period is
+ * reached by that range.
+ * @param {Object} content
+ * @param {number} initialWantedTime
+ * @param {number} bufferGoal
+ * @returns {Object}
+ */
+function getRangeOfNeededSegments(content, initialWantedTime, bufferGoal) {
+    var _a;
+    var wantedStartPosition;
+    var manifest = content.manifest, period = content.period, representation = content.representation;
+    var lastIndexPosition = representation.index.getLastPosition();
+    var representationIndex = representation.index;
+    // There is an exception for when the current initially wanted time is already
+    // after the last position with segments AND when we're playing the absolute
+    // last Period in the Manifest.
+    // In that case, we want to actually request at least the last segment to
+    // avoid ending the last Period - and by extension the content - with a
+    // segment which isn't the last one.
+    if (!isNullOrUndefined(lastIndexPosition) &&
+        initialWantedTime >= lastIndexPosition &&
+        representationIndex.isInitialized() &&
+        representationIndex.isFinished() &&
+        isPeriodTheCurrentAndLastOne(manifest, period, initialWantedTime)) {
+        wantedStartPosition = lastIndexPosition - 1;
+    }
+    else {
+        wantedStartPosition = initialWantedTime;
+    }
+    var wantedEndPosition = wantedStartPosition + bufferGoal;
+    var hasReachedPeriodEnd;
+    if (!representation.index.isInitialized() ||
+        !representation.index.isFinished() ||
+        period.end === undefined) {
+        hasReachedPeriodEnd = false;
+    }
+    else if (lastIndexPosition === undefined) {
+        // We do not know the end of this index.
+        hasReachedPeriodEnd = wantedEndPosition >= period.end;
+    }
+    else if (lastIndexPosition === null) {
+        // There is no available segment in the index currently.
+        hasReachedPeriodEnd = true;
+    }
+    else {
+        // We have a declared end. Check that our range went until the last
+        // position available in the index. If that's the case and we're left
+        // with no segments after filtering them, it means we already have
+        // downloaded the last segments and have nothing left to do: full.
+        hasReachedPeriodEnd = wantedEndPosition >= lastIndexPosition;
+    }
+    return { start: Math.max(wantedStartPosition, period.start),
+        end: Math.min(wantedEndPosition, (_a = period.end) !== null && _a !== void 0 ? _a : Infinity), hasReachedPeriodEnd: hasReachedPeriodEnd };
+}
+/**
+ * Returns `true` if the given Period is both:
+ *   - the one being played (the current position is known from `time`)
+ *   - the absolute last one in the Manifest (that is, there will never be a
+ *     Period after it).
+ * @param {Object} manifest
+ * @param {Object} period
+ * @param {number} time
+ * @returns {boolean}
+ */
+function isPeriodTheCurrentAndLastOne(manifest, period, time) {
+    var _a;
+    return period.containsTime(time) &&
+        manifest.isLastPeriodKnown &&
+        period.id === ((_a = manifest.periods[manifest.periods.length - 1]) === null || _a === void 0 ? void 0 : _a.id);
+}
 /**
  * From the given SegmentInventory, filters the "playable" (in a supported codec
  * and not known to be undecipherable) buffered Segment Objects which overlap

package/dist/_esm5.processed/core/stream/representation/representation_stream.js

@@ -99,8 +99,8 @@ export default function RepresentationStream(_a) {
         reCheckNeededSegments$.pipe(startWith(undefined)),
     ]).pipe(withLatestFrom(fastSwitchThreshold$), mergeMap(function (_a) {
         var _b = _a[0], observation = _b[0], bufferGoal = _b[1], maxBufferSize = _b[2], terminate = _b[3], fastSwitchThreshold = _a[1];
-        var wantedStartPosition = observation.position + observation.wantedTimeOffset;
-        var status = getBufferStatus(content, wantedStartPosition, playbackObserver, fastSwitchThreshold, bufferGoal, maxBufferSize, segmentBuffer);
+        var initialWantedTime = observation.position + observation.wantedTimeOffset;
+        var status = getBufferStatus(content, initialWantedTime, playbackObserver, fastSwitchThreshold, bufferGoal, maxBufferSize, segmentBuffer);
         var neededSegments = status.neededSegments;
         var neededInitSegment = null;
         // Add initialization segment if required
@@ -165,7 +165,7 @@ export default function RepresentationStream(_a) {
         var bufferRemoval = EMPTY;
         var UPTO_CURRENT_POSITION_CLEANUP = config.getCurrent().UPTO_CURRENT_POSITION_CLEANUP;
         if (status.isBufferFull) {
-            var gcedPosition = Math.max(0, wantedStartPosition - UPTO_CURRENT_POSITION_CLEANUP);
+            var gcedPosition = Math.max(0, initialWantedTime - UPTO_CURRENT_POSITION_CLEANUP);
             if (gcedPosition > 0) {
                 bufferRemoval = segmentBuffer
                     .removeBuffer(0, gcedPosition)

package/dist/_esm5.processed/manifest/manifest.d.ts

@@ -254,15 +254,24 @@ export default class Manifest extends EventEmitter<IManifestEvents> {
      */
     update(newManifest: Manifest): void;
     /**
-     * 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}
      */
-    getMinimumPosition(): number;
+    getMinimumSafePosition(): number;
     /**
-     * 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}
+     */
+    getLivePosition(): number | undefined;
+    /**
+     * Returns the theoretical maximum playable position on the content
+     * regardless of the current Adaptation chosen, as estimated at parsing
+     * time.
      */
-    getMaximumPosition(): number;
+    getMaximumSafePosition(): number;
     /**
      * Look in the Manifest for Representations linked to the given key ID,
      * and mark them as being impossible to decrypt.

package/dist/_esm5.processed/manifest/manifest.js

@@ -194,38 +194,57 @@ var Manifest = /** @class */ (function (_super) {
         this._performUpdate(newManifest, MANIFEST_UPDATE_TYPE.Partial);
     };
     /**
-     * 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}
      */
-    Manifest.prototype.getMinimumPosition = function () {
+    Manifest.prototype.getMinimumSafePosition = function () {
         var _a, _b;
         var windowData = this._timeBounds;
         if (windowData.timeshiftDepth === null) {
-            return (_a = windowData.absoluteMinimumTime) !== null && _a !== void 0 ? _a : 0;
+            return (_a = windowData.minimumSafePosition) !== null && _a !== void 0 ? _a : 0;
         }
         var maximumTimeData = windowData.maximumTimeData;
         var maximumTime;
         if (!windowData.maximumTimeData.isLinear) {
-            maximumTime = maximumTimeData.value;
+            maximumTime = maximumTimeData.maximumSafePosition;
         }
         else {
             var timeDiff = performance.now() - maximumTimeData.time;
-            maximumTime = maximumTimeData.value + timeDiff / 1000;
+            maximumTime = maximumTimeData.maximumSafePosition + timeDiff / 1000;
         }
         var theoricalMinimum = maximumTime - windowData.timeshiftDepth;
-        return Math.max((_b = windowData.absoluteMinimumTime) !== null && _b !== void 0 ? _b : 0, theoricalMinimum);
+        return Math.max((_b = windowData.minimumSafePosition) !== null && _b !== void 0 ? _b : 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}
+     */
+    Manifest.prototype.getLivePosition = function () {
+        var maximumTimeData = this._timeBounds.maximumTimeData;
+        if (!this.isLive || maximumTimeData.livePosition === undefined) {
+            return undefined;
+        }
+        if (!maximumTimeData.isLinear) {
+            return maximumTimeData.livePosition;
+        }
+        var 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.
      */
-    Manifest.prototype.getMaximumPosition = function () {
+    Manifest.prototype.getMaximumSafePosition = function () {
         var maximumTimeData = this._timeBounds.maximumTimeData;
         if (!maximumTimeData.isLinear) {
-            return maximumTimeData.value;
+            return maximumTimeData.maximumSafePosition;
         }
         var timeDiff = performance.now() - maximumTimeData.time;
-        return maximumTimeData.value + timeDiff / 1000;
+        return maximumTimeData.maximumSafePosition + timeDiff / 1000;
     };
     /**
      * Look in the Manifest for Representations linked to the given key ID,
@@ -403,7 +422,7 @@ var Manifest = /** @class */ (function (_super) {
             // 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.
-            var min = this.getMinimumPosition();
+            var min = this.getMinimumSafePosition();
             while (this.periods.length > 0) {
                 var period = this.periods[0];
                 if (period.end === undefined || period.end > min) {

package/dist/_esm5.processed/manifest/period.d.ts

@@ -80,4 +80,10 @@ export default class Period {
      * @returns {Array.<Adaptation>}
      */
     getSupportedAdaptations(type?: IAdaptationType): Adaptation[];
+    /**
+     * Returns true if the give time is in the time boundaries of this `Period`.
+     * @param {number} time
+     * @returns {boolean}
+     */
+    containsTime(time: number): boolean;
 }

package/dist/_esm5.processed/manifest/period.js

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

package/dist/_esm5.processed/manifest/representation_index/types.d.ts

@@ -248,10 +248,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/dist/_esm5.processed/parsers/manifest/dash/common/get_minimum_and_maximum_positions.d.ts

@@ -18,4 +18,8 @@ import { IParsedPeriod } from "../../types";
  * @param {Object} periods
  * @returns {Array.<number>}
  */
-export default function getMinimumAndMaximumPosition(periods: IParsedPeriod[]): [number | undefined, number | undefined];
+export default function getMinimumAndMaximumPositions(periods: IParsedPeriod[]): {
+    minimumSafePosition: number | undefined;
+    maximumSafePosition: number | undefined;
+    maximumUnsafePosition: number | undefined;
+};

package/dist/_esm5.processed/parsers/manifest/dash/common/get_minimum_and_maximum_positions.js

@@ -13,16 +13,18 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-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(periods) {
+export default function getMinimumAndMaximumPositions(periods) {
     if (periods.length === 0) {
         throw new Error("DASH Parser: no period available for a dynamic content");
     }
-    return [getMinimumPosition(periods),
-        getMaximumPosition(periods)];
+    var minimumSafePosition = getMinimumPosition(periods);
+    var maxPositions = getMaximumPositions(periods);
+    return { minimumSafePosition: minimumSafePosition, maximumSafePosition: maxPositions.safe,
+        maximumUnsafePosition: maxPositions.unsafe };
 }

package/dist/_esm5.processed/parsers/manifest/dash/common/indexes/base.js

@@ -129,12 +129,13 @@ var BaseRepresentationIndex = /** @class */ (function () {
      * @returns {Number|null}
      */
     BaseRepresentationIndex.prototype.getLastPosition = function () {
+        var _a;
         var timeline = this._index.timeline;
         if (timeline.length === 0) {
             return null;
         }
         var lastTimelineElement = timeline[timeline.length - 1];
-        var lastTime = getIndexSegmentEnd(lastTimelineElement, null, this._scaledPeriodEnd);
+        var lastTime = Math.min(getIndexSegmentEnd(lastTimelineElement, null, this._scaledPeriodEnd), (_a = this._scaledPeriodEnd) !== null && _a !== void 0 ? _a : Infinity);
         return fromIndexTime(lastTime, this._index);
     };
     /**

package/dist/_esm5.processed/parsers/manifest/dash/common/indexes/list.d.ts

@@ -84,6 +84,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. */
@@ -97,6 +99,8 @@ export default class ListRepresentationIndex implements IRepresentationIndex {
     private _index;
     /** 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;
     private _isEMSGWhitelisted;
     /**
      * @param {Object} index

package/dist/_esm5.processed/parsers/manifest/dash/common/indexes/list.js

@@ -27,9 +27,10 @@ var ListRepresentationIndex = /** @class */ (function () {
         if (index.duration === undefined) {
             throw new Error("Invalid SegmentList: no duration");
         }
-        var periodStart = context.periodStart, representationBaseURLs = context.representationBaseURLs, representationId = context.representationId, representationBitrate = context.representationBitrate, isEMSGWhitelisted = context.isEMSGWhitelisted;
+        var periodStart = context.periodStart, periodEnd = context.periodEnd, representationBaseURLs = context.representationBaseURLs, representationId = context.representationId, representationBitrate = context.representationBitrate, isEMSGWhitelisted = context.isEMSGWhitelisted;
         this._isEMSGWhitelisted = isEMSGWhitelisted;
         this._periodStart = periodStart;
+        this._periodEnd = periodEnd;
         var presentationTimeOffset = index.presentationTimeOffset != null ? index.presentationTimeOffset :
             0;
         var timescale = (_a = index.timescale) !== null && _a !== void 0 ? _a : 1;
@@ -111,9 +112,10 @@ var ListRepresentationIndex = /** @class */ (function () {
      * @returns {Number}
      */
     ListRepresentationIndex.prototype.getLastPosition = function () {
+        var _a;
         var index = this._index;
         var duration = index.duration, list = index.list;
-        return ((list.length * duration) / index.timescale) + this._periodStart;
+        return Math.min(((list.length * duration) / index.timescale) + this._periodStart, (_a = this._periodEnd) !== null && _a !== void 0 ? _a : Infinity);
     };
     /**
      * Returns true if a Segment returned by this index is still considered

package/dist/_esm5.processed/parsers/manifest/dash/common/indexes/template.js

@@ -55,7 +55,8 @@ var TemplateRepresentationIndex = /** @class */ (function () {
             mediaURLs: createIndexURLs(urlSources, index.media, representationId, representationBitrate), presentationTimeOffset: presentationTimeOffset, startNumber: index.startNumber };
         this._isDynamic = isDynamic;
         this._periodStart = periodStart;
-        this._scaledPeriodEnd = periodEnd == null ? undefined :
+        this._scaledPeriodEnd = periodEnd === undefined ?
+            undefined :
             (periodEnd - periodStart) * timescale;
         this._isEMSGWhitelisted = isEMSGWhitelisted;
     }
@@ -143,6 +144,7 @@ var TemplateRepresentationIndex = /** @class */ (function () {
      * @returns {number|null}
      */
     TemplateRepresentationIndex.prototype.getLastPosition = function () {
+        var _a;
         var lastSegmentStart = this._getLastSegmentStart();
         if (lastSegmentStart == null) {
             // In that case (null or undefined), getLastPosition should reflect
@@ -150,7 +152,7 @@ var TemplateRepresentationIndex = /** @class */ (function () {
             // the two functions. So, we return the result of the latter.
             return lastSegmentStart;
         }
-        var lastSegmentEnd = lastSegmentStart + this._index.duration;
+        var lastSegmentEnd = Math.min(lastSegmentStart + this._index.duration, (_a = this._scaledPeriodEnd) !== null && _a !== void 0 ? _a : Infinity);
         return (lastSegmentEnd / this._index.timescale) + this._periodStart;
     };
     /**

package/dist/_esm5.processed/parsers/manifest/dash/common/indexes/timeline/timeline_representation_index.js

@@ -74,7 +74,7 @@ var TimelineRepresentationIndex = /** @class */ (function () {
             startNumber: index.startNumber,
             timeline: (_c = index.timeline) !== null && _c !== void 0 ? _c : null, timescale: timescale };
         this._scaledPeriodStart = toIndexTime(periodStart, this._index);
-        this._scaledPeriodEnd = periodEnd == null ? undefined :
+        this._scaledPeriodEnd = periodEnd === undefined ? undefined :
             toIndexTime(periodEnd, this._index);
     }
     /**
@@ -136,7 +136,7 @@ var TimelineRepresentationIndex = /** @class */ (function () {
         if (this._index.timeline === null) {
             this._index.timeline = this._getTimeline();
         }
-        var lastTime = TimelineRepresentationIndex.getIndexEnd(this._index.timeline, this._scaledPeriodStart);
+        var lastTime = TimelineRepresentationIndex.getIndexEnd(this._index.timeline, this._scaledPeriodEnd);
         return lastTime === null ? null :
             fromIndexTime(lastTime, this._index);
     };
@@ -293,7 +293,7 @@ var TimelineRepresentationIndex = /** @class */ (function () {
         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 !== null && scaledPeriodEnd !== void 0 ? scaledPeriodEnd : Infinity);
     };
     /**
      * Allows to generate the "timeline" for this RepresentationIndex.

package/dist/_esm5.processed/parsers/manifest/dash/common/parse_mpd.js

@@ -29,7 +29,7 @@ import { normalizeBaseURL } from "../../../../utils/resolve_url";
 // 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 from "./parse_periods";
 import resolveBaseURLs from "./resolve_base_urls";
@@ -159,56 +159,64 @@ function parseCompleteIntermediateRepresentation(mpdIR, args, warnings, xlinkInf
             config.getCurrent().DASH_FALLBACK_LIFETIME_WHEN_MINIMUM_UPDATE_PERIOD_EQUAL_0 :
             rootAttributes.minimumUpdatePeriod;
     }
-    var _d = getMinimumAndMaximumPosition(parsedPeriods), contentStart = _d[0], contentEnd = _d[1];
+    var _d = getMinimumAndMaximumPositions(parsedPeriods), minimumSafePosition = _d.minimumSafePosition, maximumSafePosition = _d.maximumSafePosition, maximumUnsafePosition = _d.maximumUnsafePosition;
     var now = performance.now();
     if (!isDynamic) {
-        minimumTime = contentStart !== undefined ? contentStart :
+        minimumTime = minimumSafePosition !== undefined ? minimumSafePosition :
             ((_a = parsedPeriods[0]) === null || _a === void 0 ? void 0 : _a.start) !== undefined ? parsedPeriods[0].start :
                 0;
-        var maximumTime = mediaPresentationDuration !== null && mediaPresentationDuration !== void 0 ? mediaPresentationDuration : Infinity;
+        var finalMaximumSafePosition = mediaPresentationDuration !== null && mediaPresentationDuration !== void 0 ? mediaPresentationDuration : Infinity;
         if (parsedPeriods[parsedPeriods.length - 1] !== undefined) {
             var lastPeriod = parsedPeriods[parsedPeriods.length - 1];
             var lastPeriodEnd = (_b = lastPeriod.end) !== null && _b !== void 0 ? _b : (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 && timeShiftBufferDepth !== void 0 ? timeShiftBufferDepth : null;
-        var maximumTime = void 0;
-        if (contentEnd !== undefined) {
-            maximumTime = contentEnd;
+        var finalMaximumSafePosition = void 0;
+        var livePosition = void 0;
+        if (maximumUnsafePosition !== undefined) {
+            livePosition = maximumUnsafePosition;
+        }
+        if (maximumSafePosition !== undefined) {
+            finalMaximumSafePosition = maximumSafePosition;
         }
         else {
             var ast = availabilityStartTime !== null && availabilityStartTime !== void 0 ? availabilityStartTime : 0;
             var externalClockOffset = args.externalClockOffset;
             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 {
                 var serverTime = performance.now() + externalClockOffset;
-                maximumTime = (serverTime / 1000) - ast;
+                finalMaximumSafePosition = (serverTime / 1000) - ast;
             }
         }
+        if (livePosition === undefined) {
+            livePosition = finalMaximumSafePosition;
+        }
         maximumTimeData = { isLinear: true,
-            value: maximumTime,
-            time: now };
+            maximumSafePosition: finalMaximumSafePosition, livePosition: 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) {
-            timeshiftDepth = maximumTime - minimumTime;
+            finalMaximumSafePosition - minimumTime > timeshiftDepth) {
+            timeshiftDepth = finalMaximumSafePosition - minimumTime;
         }
     }
     // `isLastPeriodKnown` should be `true` in two cases for DASH contents:
@@ -232,7 +240,7 @@ function parseCompleteIntermediateRepresentation(mpdIR, args, warnings, xlinkInf
         publishTime: rootAttributes.publishTime,
         suggestedPresentationDelay: rootAttributes.suggestedPresentationDelay,
         transportType: "dash",
-        timeBounds: { absoluteMinimumTime: minimumTime, timeshiftDepth: timeshiftDepth, maximumTimeData: maximumTimeData },
+        timeBounds: { minimumSafePosition: minimumTime, timeshiftDepth: timeshiftDepth, maximumTimeData: maximumTimeData },
         lifetime: lifetime,
         uris: args.url == null ?
             rootChildren.locations : __spreadArray([args.url], rootChildren.locations, true),

package/dist/_esm5.processed/parsers/manifest/local/parse_local_manifest.js

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

package/dist/_esm5.processed/parsers/manifest/metaplaylist/metaplaylist_parser.js

@@ -230,9 +230,15 @@ function createManifest(mplData, manifests, parserOptions) {
     var manifest = { availabilityStartTime: 0, clockOffset: clockOffset, suggestedPresentationDelay: 10, periods: periods, transportType: "metaplaylist",
         isLive: isDynamic, isDynamic: isDynamic, isLastPeriodKnown: isLastPeriodKnown, uris: url == null ? [] :
             [url],
-        timeBounds: { minimumTime: minimumTime, timeshiftDepth: null,
-            maximumTimeData: { isLinear: false,
-                value: maximumTime, time: time } },
+        // TODO more precize time bounds?
+        timeBounds: { minimumSafePosition: minimumTime,
+            timeshiftDepth: null,
+            maximumTimeData: {
+                isLinear: false,
+                maximumSafePosition: maximumTime,
+                livePosition: undefined,
+                time: time,
+            } },
         lifetime: mplData.pollInterval };
     return manifest;
 }