rx-player 4.0.0-dev.2023111400 → 4.0.0-dev.2023121900

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

@@ -26,6 +26,7 @@ var __assign = (this && this.__assign) || function () {
     return __assign.apply(this, arguments);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLastRequestableSegmentInfo = exports.isSegmentStillAvailable = void 0;
 var config_1 = require("../../../../../../config");
 var errors_1 = require("../../../../../../errors");
 var log_1 = require("../../../../../../log");
@@ -33,7 +34,6 @@ var assert_1 = require("../../../../../../utils/assert");
 var monotonic_timestamp_1 = require("../../../../../../utils/monotonic_timestamp");
 var clear_timeline_from_position_1 = require("../../../../utils/clear_timeline_from_position");
 var index_helpers_1 = require("../../../../utils/index_helpers");
-var is_segment_still_available_1 = require("../../../../utils/is_segment_still_available");
 var update_segment_timeline_1 = require("../../../../utils/update_segment_timeline");
 var get_init_segment_1 = require("../get_init_segment");
 var get_segments_from_timeline_1 = require("../get_segments_from_timeline");
@@ -42,6 +42,11 @@ var utils_1 = require("../utils");
 var construct_timeline_from_elements_1 = require("./construct_timeline_from_elements");
 // eslint-disable-next-line max-len
 var construct_timeline_from_previous_timeline_1 = require("./construct_timeline_from_previous_timeline");
+/**
+ * `IRepresentationIndex` implementation for a DASH `SegmentTimeline` segment
+ * indexing scheme.
+ * @class TimelineRepresentationIndex
+ */
 var TimelineRepresentationIndex = /** @class */ (function () {
     /**
      * @param {Object} index
@@ -53,7 +58,7 @@ var TimelineRepresentationIndex = /** @class */ (function () {
             throw new Error("The given index is not compatible with a " +
                 "TimelineRepresentationIndex.");
         }
-        var availabilityTimeComplete = context.availabilityTimeComplete, manifestBoundsCalculator = context.manifestBoundsCalculator, isDynamic = context.isDynamic, isLastPeriod = context.isLastPeriod, representationId = context.representationId, representationBitrate = context.representationBitrate, periodStart = context.periodStart, periodEnd = context.periodEnd, isEMSGWhitelisted = context.isEMSGWhitelisted;
+        var availabilityTimeComplete = context.availabilityTimeComplete, availabilityTimeOffset = context.availabilityTimeOffset, manifestBoundsCalculator = context.manifestBoundsCalculator, isDynamic = context.isDynamic, isLastPeriod = context.isLastPeriod, representationId = context.representationId, representationBitrate = context.representationBitrate, periodStart = context.periodStart, periodEnd = context.periodEnd, isEMSGWhitelisted = context.isEMSGWhitelisted;
         var timescale = (_a = index.timescale) !== null && _a !== void 0 ? _a : 1;
         var presentationTimeOffset = index.presentationTimeOffset != null ?
             index.presentationTimeOffset :
@@ -84,7 +89,27 @@ var TimelineRepresentationIndex = /** @class */ (function () {
         var segmentUrlTemplate = index.media === undefined ?
             null :
             (0, tokens_1.constructRepresentationUrl)(index.media, representationId, representationBitrate);
-        this._index = { availabilityTimeComplete: availabilityTimeComplete, indexRange: index.indexRange, indexTimeOffset: indexTimeOffset, initialization: index.initialization == null ?
+        var actualAvailabilityTimeOffset;
+        // Technically, it seems (although it is not clear) that an MPD may contain
+        // future segments and it's the job of a player to not request segments later
+        // than the time at which they should be available.
+        // In practice, we don't do that for various reasons: precision issues,
+        // various DASH spec interpretations by packagers and players...
+        //
+        // So as a compromise, if nothing in the MPD indicates that future segments
+        // may be announced (see code below), we will act as if ALL segments in this
+        // TimelineRepresentationIndex are requestable
+        if (availabilityTimeOffset === undefined &&
+            availabilityTimeComplete === undefined) {
+            actualAvailabilityTimeOffset = Infinity; // Meaning: we can request
+            // everything in the index
+        }
+        else {
+            actualAvailabilityTimeOffset = availabilityTimeOffset !== null && availabilityTimeOffset !== void 0 ? availabilityTimeOffset : 0;
+        }
+        this._index = { availabilityTimeComplete: availabilityTimeComplete !== null && availabilityTimeComplete !== void 0 ? availabilityTimeComplete : true,
+            availabilityTimeOffset: actualAvailabilityTimeOffset,
+            indexRange: index.indexRange, indexTimeOffset: indexTimeOffset, initialization: index.initialization == null ?
                 undefined :
                 {
                     url: initializationUrl,
@@ -118,7 +143,7 @@ var TimelineRepresentationIndex = /** @class */ (function () {
         }
         // destructuring to please TypeScript
         var _a = this._index, segmentUrlTemplate = _a.segmentUrlTemplate, startNumber = _a.startNumber, endNumber = _a.endNumber, timeline = _a.timeline, timescale = _a.timescale, indexTimeOffset = _a.indexTimeOffset;
-        return (0, get_segments_from_timeline_1.default)({ segmentUrlTemplate: segmentUrlTemplate, startNumber: startNumber, endNumber: endNumber, timeline: timeline, timescale: timescale, indexTimeOffset: indexTimeOffset }, from, duration, this._isEMSGWhitelisted, this._scaledPeriodEnd);
+        return (0, get_segments_from_timeline_1.default)({ segmentUrlTemplate: segmentUrlTemplate, startNumber: startNumber, endNumber: endNumber, timeline: timeline, timescale: timescale, indexTimeOffset: indexTimeOffset }, from, duration, this._manifestBoundsCalculator, this._scaledPeriodEnd, this._isEMSGWhitelisted);
     };
     /**
      * Returns true if the index should be refreshed.
@@ -151,13 +176,19 @@ var TimelineRepresentationIndex = /** @class */ (function () {
      * @returns {Number|null}
      */
     TimelineRepresentationIndex.prototype.getLastAvailablePosition = function () {
+        var _a;
         this._refreshTimeline();
         if (this._index.timeline === null) {
             this._index.timeline = this._getTimeline();
         }
-        var lastTime = TimelineRepresentationIndex.getIndexEnd(this._index.timeline, this._scaledPeriodEnd);
-        return lastTime === null ? null :
-            (0, index_helpers_1.fromIndexTime)(lastTime, this._index);
+        var lastReqSegInfo = getLastRequestableSegmentInfo(
+        // Needed typecast for TypeScript
+        this._index, this._manifestBoundsCalculator, this._scaledPeriodEnd);
+        if (lastReqSegInfo === null) {
+            return null;
+        }
+        var lastScaledPosition = Math.min(lastReqSegInfo.end, (_a = this._scaledPeriodEnd) !== null && _a !== void 0 ? _a : Infinity);
+        return (0, index_helpers_1.fromIndexTime)(lastScaledPosition, this._index);
     };
     /**
      * Returns the absolute end in seconds this RepresentationIndex can reach once
@@ -165,10 +196,20 @@ var TimelineRepresentationIndex = /** @class */ (function () {
      * @returns {number|null|undefined}
      */
     TimelineRepresentationIndex.prototype.getEnd = function () {
-        if (!this._isDynamic || !this._isLastPeriod) { // @see isFinished
-            return this.getLastAvailablePosition();
+        var _a;
+        if (this._isDynamic && !this._isLastPeriod) {
+            return undefined;
+        }
+        this._refreshTimeline();
+        if (this._index.timeline === null) {
+            this._index.timeline = this._getTimeline();
+        }
+        if (this._index.timeline.length <= 0) {
+            return null;
         }
-        return undefined;
+        var lastSegment = this._index.timeline[this._index.timeline.length - 1];
+        var lastTime = Math.min((0, index_helpers_1.getIndexSegmentEnd)(lastSegment, null, this._scaledPeriodEnd), (_a = this._scaledPeriodEnd) !== null && _a !== void 0 ? _a : Infinity);
+        return (0, index_helpers_1.fromIndexTime)(lastTime, this._index);
     };
     /**
      * Returns:
@@ -182,33 +223,54 @@ var TimelineRepresentationIndex = /** @class */ (function () {
      * @returns {boolean|undefined}
      */
     TimelineRepresentationIndex.prototype.awaitSegmentBetween = function (start, end) {
-        var _a;
+        var _a, _b;
         (0, assert_1.default)(start <= end);
-        if (!this._isDynamic || !this._isLastPeriod) {
-            return false;
+        if (!this._isDynamic) {
+            return false; // No segment will be newly available in the future
         }
         this._refreshTimeline();
         if (this._index.timeline === null) {
             this._index.timeline = this._getTimeline();
         }
-        var _b = this._index, timeline = _b.timeline, timescale = _b.timescale;
+        var _c = this._index, timescale = _c.timescale, timeline = _c.timeline;
         var segmentTimeRounding = (0, utils_1.getSegmentTimeRoundingError)(timescale);
-        var scaledEnd = (0, index_helpers_1.toIndexTime)(end, this._index);
-        if (timeline.length > 0) {
-            var lastTimelineElement = timeline[timeline.length - 1];
-            var lastSegmentEnd = (0, index_helpers_1.getIndexSegmentEnd)(lastTimelineElement, null, this._scaledPeriodEnd);
-            var roundedEnd = lastSegmentEnd + segmentTimeRounding;
-            if (roundedEnd >= Math.min(scaledEnd, (_a = this._scaledPeriodEnd) !== null && _a !== void 0 ? _a : Infinity)) {
-                return false; // already loaded
+        var scaledWantedEnd = (0, index_helpers_1.toIndexTime)(end, this._index);
+        var lastReqSegInfo = getLastRequestableSegmentInfo(
+        // Needed typecast for TypeScript
+        this._index, this._manifestBoundsCalculator, this._scaledPeriodEnd);
+        if (lastReqSegInfo !== null) {
+            var lastReqSegmentEnd = Math.min(lastReqSegInfo.end, (_a = this._scaledPeriodEnd) !== null && _a !== void 0 ? _a : Infinity);
+            var roundedReqSegmentEnd = lastReqSegmentEnd + segmentTimeRounding;
+            if (roundedReqSegmentEnd >= Math.min(scaledWantedEnd, (_b = this._scaledPeriodEnd) !== null && _b !== void 0 ? _b : Infinity)) {
+                return false; // everything up to that point is already requestable
+            }
+        }
+        var scaledWantedStart = (0, index_helpers_1.toIndexTime)(start, this._index);
+        if (timeline.length > 0 &&
+            lastReqSegInfo !== null &&
+            !lastReqSegInfo.isLastOfTimeline) {
+            // There are some future segments already anounced in the MPD
+            var lastSegment = timeline[timeline.length - 1];
+            var lastSegmentEnd = (0, index_helpers_1.getIndexSegmentEnd)(lastSegment, null, this._scaledPeriodEnd);
+            var roundedLastSegEnd = lastSegmentEnd + segmentTimeRounding;
+            if (scaledWantedStart < roundedLastSegEnd + segmentTimeRounding) {
+                return true; // The MPD's timeline already contains one such element,
+                // It is just not requestable yet
             }
         }
+        if (!this._isLastPeriod) {
+            // Let's consider - perhaps wrongly, that Periods which aren't the last
+            // one have all of their segments announced.
+            return false;
+        }
         if (this._scaledPeriodEnd === undefined) {
-            return (scaledEnd + segmentTimeRounding) > this._scaledPeriodStart ? undefined :
-                false;
+            return (scaledWantedEnd + segmentTimeRounding) > this._scaledPeriodStart ?
+                undefined : // There may be future segments at this point
+                false; // Before the current Period
         }
-        var scaledStart = (0, index_helpers_1.toIndexTime)(start, this._index);
-        return (scaledStart - segmentTimeRounding) < this._scaledPeriodEnd &&
-            (scaledEnd + segmentTimeRounding) > this._scaledPeriodStart;
+        // `true` if within the boundaries of this Period. `false` otherwise.
+        return (scaledWantedStart - segmentTimeRounding) < this._scaledPeriodEnd &&
+            (scaledWantedEnd + segmentTimeRounding) > this._scaledPeriodStart;
     };
     /**
      * Returns true if a Segment returned by this index is still considered
@@ -226,8 +288,9 @@ var TimelineRepresentationIndex = /** @class */ (function () {
         if (this._index.timeline === null) {
             this._index.timeline = this._getTimeline();
         }
-        var _a = this._index, timeline = _a.timeline, timescale = _a.timescale, indexTimeOffset = _a.indexTimeOffset;
-        return (0, is_segment_still_available_1.default)(segment, timeline, timescale, indexTimeOffset);
+        return isSegmentStillAvailable(segment, 
+        // Needed typecast for TypeScript
+        this._index, this._manifestBoundsCalculator, this._scaledPeriodEnd);
     };
     /**
      * Checks if the time given is in a discontinuity. That is:
@@ -289,6 +352,8 @@ var TimelineRepresentationIndex = /** @class */ (function () {
         if (hasReplaced) {
             this._index.startNumber = newIndex._index.startNumber;
         }
+        this._index.availabilityTimeOffset = newIndex._index.availabilityTimeOffset;
+        this._index.availabilityTimeComplete = newIndex._index.availabilityTimeComplete;
         this._index.endNumber = newIndex._index.endNumber;
         this._isDynamic = newIndex._isDynamic;
         this._scaledPeriodStart = newIndex._scaledPeriodStart;
@@ -297,32 +362,67 @@ var TimelineRepresentationIndex = /** @class */ (function () {
         this._isLastPeriod = newIndex._isLastPeriod;
     };
     /**
-     * Returns `true` if this RepresentationIndex currently contains its last
+     * Returns `false` if this RepresentationIndex currently contains its last
      * segment.
-     * Returns `false` if it's still pending.
+     * Returns `true` if it's still pending.
      * @returns {Boolean}
      */
-    TimelineRepresentationIndex.prototype.isFinished = function () {
-        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;
+    TimelineRepresentationIndex.prototype.isStillAwaitingFutureSegments = function () {
+        var _a;
+        if (!this._isDynamic) {
+            return false;
         }
+        this._refreshTimeline();
         if (this._index.timeline === null) {
             this._index.timeline = this._getTimeline();
         }
         var timeline = this._index.timeline;
-        if (this._scaledPeriodEnd === undefined || timeline.length === 0) {
-            return false;
+        if (timeline.length === 0) {
+            // No segment announced in this Period
+            if (this._scaledPeriodEnd !== undefined) {
+                var liveEdge = this._manifestBoundsCalculator.getEstimatedLiveEdge();
+                if (liveEdge !== undefined &&
+                    (0, index_helpers_1.toIndexTime)(liveEdge, this._index) > this._scaledPeriodEnd) {
+                    // This Period is over, we're not awaiting anything
+                    return false;
+                }
+            }
+            // Let's just consider that we're awaiting only for when this is the last Period.
+            return this._isLastPeriod;
         }
-        var lastTimelineElement = timeline[timeline.length - 1];
-        var lastTime = (0, index_helpers_1.getIndexSegmentEnd)(lastTimelineElement, null, this._scaledPeriodEnd);
         var segmentTimeRounding = (0, utils_1.getSegmentTimeRoundingError)(this._index.timescale);
-        return (lastTime + segmentTimeRounding) >= this._scaledPeriodEnd;
+        var lastReqSegInfo = getLastRequestableSegmentInfo(
+        // Needed typecast for TypeScript
+        this._index, this._manifestBoundsCalculator, this._scaledPeriodEnd);
+        if (lastReqSegInfo !== null && !lastReqSegInfo.isLastOfTimeline) {
+            // There might be non-yet requestable segments in the manifest
+            var lastReqSegmentEnd = Math.min(lastReqSegInfo.end, (_a = this._scaledPeriodEnd) !== null && _a !== void 0 ? _a : Infinity);
+            if (this._scaledPeriodEnd !== undefined &&
+                lastReqSegmentEnd + segmentTimeRounding >= this._scaledPeriodEnd) {
+                // The last requestable segment ends after the end of the Period anyway
+                return false;
+            }
+            return true; // There are not-yet requestable segments
+        }
+        if (!this._isLastPeriod) {
+            // This index is not linked to the current last Period in the MPD, in
+            // which case it is inferred that all segments have been announced.
+            //
+            // Note that this 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 false;
+        }
+        if (this._scaledPeriodEnd === undefined) {
+            // This is the last Period of a dynamic content whose end is unknown.
+            // Just return true.
+            return true;
+        }
+        var lastSegment = timeline[timeline.length - 1];
+        var lastSegmentEnd = (0, index_helpers_1.getIndexSegmentEnd)(lastSegment, null, this._scaledPeriodEnd);
+        // We're awaiting future segments only if the current end is before the end
+        // of the Period
+        return (lastSegmentEnd + segmentTimeRounding) < this._scaledPeriodEnd;
     };
     /**
      * @returns {Boolean}
@@ -357,7 +457,8 @@ var TimelineRepresentationIndex = /** @class */ (function () {
         if (!this._isDynamic) {
             return;
         }
-        var firstPosition = this._manifestBoundsCalculator.estimateMinimumBound();
+        var firstPosition = this._manifestBoundsCalculator
+            .getEstimatedMinimumSegmentTime();
         if (firstPosition == null) {
             return; // we don't know yet
         }
@@ -370,12 +471,6 @@ var TimelineRepresentationIndex = /** @class */ (function () {
             this._index.startNumber = nbEltsRemoved + 1;
         }
     };
-    TimelineRepresentationIndex.getIndexEnd = function (timeline, scaledPeriodEnd) {
-        if (timeline.length <= 0) {
-            return null;
-        }
-        return Math.min((0, index_helpers_1.getIndexSegmentEnd)(timeline[timeline.length - 1], null, scaledPeriodEnd), scaledPeriodEnd !== null && scaledPeriodEnd !== void 0 ? scaledPeriodEnd : Infinity);
-    };
     /**
      * Allows to generate the "timeline" for this RepresentationIndex.
      * Call this function when the timeline is unknown.
@@ -465,3 +560,107 @@ function updateTimelineFromEndNumber(timeline, startNumber, endNumber) {
     }
     return timeline;
 }
+/**
+ * Returns true if a Segment returned by the corresponding index is still
+ * considered available.
+ * Returns false if it is not available anymore.
+ * Returns undefined if we cannot know whether it is still available or not.
+ * /!\ We do not check the mediaURLs of the segment.
+ * @param {Object} segment
+ * @param {Object} index
+ * @param {Object} manifestBoundsCalculator
+ * @param {number|undefined} scaledPeriodEnd
+ * @returns {Boolean|undefined}
+ */
+function isSegmentStillAvailable(segment, index, manifestBoundsCalculator, scaledPeriodEnd) {
+    var lastReqSegInfo = getLastRequestableSegmentInfo(index, manifestBoundsCalculator, scaledPeriodEnd);
+    if (lastReqSegInfo === null) {
+        return false;
+    }
+    for (var i = 0; i < index.timeline.length; i++) {
+        if (lastReqSegInfo.timelineIdx < i) {
+            return false;
+        }
+        var tSegment = index.timeline[i];
+        var tSegmentTime = (tSegment.start - index.indexTimeOffset) / index.timescale;
+        if (tSegmentTime > segment.time) {
+            return false; // We went over it without finding it
+        }
+        else if (tSegmentTime === segment.time) {
+            if (tSegment.range === undefined) {
+                return segment.range === undefined;
+            }
+            return segment.range != null &&
+                tSegment.range[0] === segment.range[0] &&
+                tSegment.range[1] === segment.range[1];
+        }
+        else { // tSegment.start < segment.time
+            if (tSegment.repeatCount >= 0 && tSegment.duration !== undefined) {
+                var timeDiff = tSegmentTime - tSegment.start;
+                var repeat = (timeDiff / tSegment.duration) - 1;
+                return repeat % 1 === 0 && repeat <= lastReqSegInfo.newRepeatCount;
+            }
+        }
+    }
+    return false;
+}
+exports.isSegmentStillAvailable = isSegmentStillAvailable;
+/**
+ * Returns from the given RepresentationIndex information on the last segment
+ * that may be requested currently.
+ *
+ * Returns `null` if there's no such segment.
+ * @param {Object} index
+ * @param {Object} manifestBoundsCalculator
+ * @param {number|undefined} scaledPeriodEnd
+ * @returns {number|null}
+ */
+function getLastRequestableSegmentInfo(index, manifestBoundsCalculator, scaledPeriodEnd) {
+    if (index.timeline.length <= 0) {
+        return null;
+    }
+    if (index.availabilityTimeOffset === Infinity) {
+        // availabilityTimeOffset to Infinity == Everything is requestable in the timeline.
+        var lastIndex = index.timeline.length - 1;
+        var lastElem = index.timeline[lastIndex];
+        return { isLastOfTimeline: true,
+            timelineIdx: lastIndex,
+            newRepeatCount: lastElem.repeatCount,
+            end: (0, index_helpers_1.getIndexSegmentEnd)(lastElem, null, scaledPeriodEnd) };
+    }
+    var adjustedMaxSeconds = manifestBoundsCalculator.getEstimatedMaximumPosition(index.availabilityTimeOffset);
+    if (adjustedMaxSeconds === undefined) {
+        var lastIndex = index.timeline.length - 1;
+        var lastElem = index.timeline[lastIndex];
+        return { isLastOfTimeline: true,
+            timelineIdx: lastIndex,
+            newRepeatCount: lastElem.repeatCount,
+            end: (0, index_helpers_1.getIndexSegmentEnd)(lastElem, null, scaledPeriodEnd) };
+    }
+    for (var i = index.timeline.length - 1; i >= index.timeline.length; i--) {
+        var element = index.timeline[i];
+        var endOfFirstOccurence = element.start + element.duration;
+        if ((0, index_helpers_1.fromIndexTime)(endOfFirstOccurence, index) <= adjustedMaxSeconds) {
+            var endTime = (0, index_helpers_1.getIndexSegmentEnd)(element, index.timeline[i + 1], scaledPeriodEnd);
+            if ((0, index_helpers_1.fromIndexTime)(endTime, index) <= adjustedMaxSeconds) {
+                return { isLastOfTimeline: i === index.timeline.length - 1,
+                    timelineIdx: i,
+                    newRepeatCount: element.repeatCount,
+                    end: endOfFirstOccurence };
+            }
+            else {
+                // We have to find the right repeatCount
+                var maxIndexTime = (0, index_helpers_1.toIndexTime)(adjustedMaxSeconds, index);
+                var diffToSegStart = maxIndexTime - element.start;
+                var nbOfSegs = Math.floor(diffToSegStart / element.duration);
+                (0, assert_1.default)(nbOfSegs >= 1);
+                return { isLastOfTimeline: false,
+                    timelineIdx: i,
+                    newRepeatCount: nbOfSegs - 1,
+                    end: element.start + nbOfSegs * element.duration };
+            }
+        }
+    }
+    return null;
+}
+exports.getLastRequestableSegmentInfo = getLastRequestableSegmentInfo;

package/dist/commonjs/parsers/manifest/dash/common/manifest_bounds_calculator.d.ts

@@ -17,16 +17,6 @@
  * This class allows to easily calculate the first and last available positions
  * in a content at any time.
  *
- * That task can be an hard for dynamic DASH contents: it depends on a
- * `timeShiftBufferDepth` defined in the MPD and on the maximum possible
- * position.
- *
- * The latter can come from either a clock synchronization mechanism or the
- * indexing schemes (e.g. SegmentTemplate, SegmentTimeline etc.) of the last
- * Periods.
- * As such, it might only be known once a large chunk of the MPD has already
- * been parsed.
- *
  * By centralizing the manifest bounds calculation in this class and by giving
  * an instance of it to each parsed elements which might depend on it, we
  * ensure that we can provide it once it is known to every one of those
@@ -34,8 +24,18 @@
  * @class ManifestBoundsCalculator
  */
 export default class ManifestBoundsCalculator {
-    /** Value of MPD@timeShiftBufferDepth. */
+    /**
+     * Value of MPD@timeShiftBufferDepth.
+     * `null` if not defined.
+     */
     private _timeShiftBufferDepth;
+    /**
+     * Value of MPD@availabilityStartTime as an unix timestamp in seconds.
+     * `0` if it wasn't defined.
+     */
+    private _availabilityStartTime;
+    /** `true` if MPD@type is equal to "dynamic". */
+    private _isDynamic;
     /**
      * Monotonically-raising timestamp (the one used by the RxPlayer) when
      * `lastPosition` was calculated.
@@ -43,14 +43,21 @@ export default class ManifestBoundsCalculator {
     private _positionTime;
     /** Last position calculated at a given moment (itself indicated by `_positionTime`. */
     private _lastPosition;
-    /** `true` if MPD@type is equal to "dynamic". */
-    private _isDynamic;
+    /**
+     * Offset to add to `performance.now` to obtain a good estimation of the
+     * server-side unix timestamp.
+     *
+     * `undefined` if unknown.
+     */
+    private _serverTimestampOffset;
     /**
      * @param {Object} args
      */
     constructor(args: {
+        availabilityStartTime: number;
         timeShiftBufferDepth: number | undefined;
         isDynamic: boolean;
+        serverTimestampOffset: number | undefined;
     });
     /**
      * Set the last position and the position time (the value of the RxPlayer's
@@ -82,11 +89,27 @@ export default class ManifestBoundsCalculator {
      * Consider that it is only an estimation, not the real value.
      * @return {number|undefined}
      */
-    estimateMinimumBound(): number | undefined;
+    getEstimatedMinimumSegmentTime(): number | undefined;
     /**
-     * Estimate a maximum bound for the content from the last set segment time.
-     * Consider that it is only an estimation, not the real value.
+     * Estimate the segment time in seconds that corresponds to what could be
+     * considered the live edge (or `undefined` for non-live contents).
+     *
+     * Note that for some contents which just anounce segments in advance, this
+     * value might be very different than the maximum position that is
+     * requestable.
      * @return {number|undefined}
      */
-    estimateMaximumBound(): number | undefined;
+    getEstimatedLiveEdge(): number | undefined;
+    /**
+     * Produce a rough estimate of the ending time of the last requestable segment
+     * in that content.
+     *
+     * This value is only an estimate and may be far from reality.
+     *
+     * The `availabilityTimeOffset` in argument is the corresponding
+     * `availabilityTimeOffset` that applies to the current wanted segment, or `0`
+     * if none exist. It will be applied on live content to deduce the maximum
+     * segment time available.
+     */
+    getEstimatedMaximumPosition(availabilityTimeOffset: number): number | undefined;
 }

package/dist/commonjs/parsers/manifest/dash/common/manifest_bounds_calculator.js

@@ -20,16 +20,6 @@ var monotonic_timestamp_1 = require("../../../../utils/monotonic_timestamp");
  * This class allows to easily calculate the first and last available positions
  * in a content at any time.
  *
- * That task can be an hard for dynamic DASH contents: it depends on a
- * `timeShiftBufferDepth` defined in the MPD and on the maximum possible
- * position.
- *
- * The latter can come from either a clock synchronization mechanism or the
- * indexing schemes (e.g. SegmentTemplate, SegmentTimeline etc.) of the last
- * Periods.
- * As such, it might only be known once a large chunk of the MPD has already
- * been parsed.
- *
  * By centralizing the manifest bounds calculation in this class and by giving
  * an instance of it to each parsed elements which might depend on it, we
  * ensure that we can provide it once it is known to every one of those
@@ -46,6 +36,8 @@ var ManifestBoundsCalculator = /** @class */ (function () {
             args.timeShiftBufferDepth === undefined ?
             null :
             args.timeShiftBufferDepth;
+        this._serverTimestampOffset = args.serverTimestampOffset;
+        this._availabilityStartTime = args.availabilityStartTime;
     }
     /**
      * Set the last position and the position time (the value of the RxPlayer's
@@ -85,11 +77,12 @@ var ManifestBoundsCalculator = /** @class */ (function () {
      * Consider that it is only an estimation, not the real value.
      * @return {number|undefined}
      */
-    ManifestBoundsCalculator.prototype.estimateMinimumBound = function () {
+    ManifestBoundsCalculator.prototype.getEstimatedMinimumSegmentTime = function () {
+        var _a;
         if (!this._isDynamic || this._timeShiftBufferDepth === null) {
             return 0;
         }
-        var maximumBound = this.estimateMaximumBound();
+        var maximumBound = (_a = this.getEstimatedLiveEdge()) !== null && _a !== void 0 ? _a : this.getEstimatedMaximumPosition(0);
         if (maximumBound === undefined) {
             return undefined;
         }
@@ -97,14 +90,41 @@ var ManifestBoundsCalculator = /** @class */ (function () {
         return minimumBound;
     };
     /**
-     * Estimate a maximum bound for the content from the last set segment time.
-     * Consider that it is only an estimation, not the real value.
+     * Estimate the segment time in seconds that corresponds to what could be
+     * considered the live edge (or `undefined` for non-live contents).
+     *
+     * Note that for some contents which just anounce segments in advance, this
+     * value might be very different than the maximum position that is
+     * requestable.
      * @return {number|undefined}
      */
-    ManifestBoundsCalculator.prototype.estimateMaximumBound = function () {
-        if (this._isDynamic &&
-            this._positionTime != null &&
-            this._lastPosition != null) {
+    ManifestBoundsCalculator.prototype.getEstimatedLiveEdge = function () {
+        if (!this._isDynamic || this._serverTimestampOffset === undefined) {
+            return undefined;
+        }
+        return ((0, monotonic_timestamp_1.default)() + this._serverTimestampOffset) / 1000 -
+            this._availabilityStartTime;
+    };
+    /**
+     * Produce a rough estimate of the ending time of the last requestable segment
+     * in that content.
+     *
+     * This value is only an estimate and may be far from reality.
+     *
+     * The `availabilityTimeOffset` in argument is the corresponding
+     * `availabilityTimeOffset` that applies to the current wanted segment, or `0`
+     * if none exist. It will be applied on live content to deduce the maximum
+     * segment time available.
+     */
+    ManifestBoundsCalculator.prototype.getEstimatedMaximumPosition = function (availabilityTimeOffset) {
+        if (!this._isDynamic) {
+            return this._lastPosition;
+        }
+        var liveEdge = this.getEstimatedLiveEdge();
+        if (liveEdge !== undefined && availabilityTimeOffset !== Infinity) {
+            return liveEdge + availabilityTimeOffset;
+        }
+        else if (this._positionTime !== undefined && this._lastPosition !== undefined) {
             return Math.max((this._lastPosition - this._positionTime) +
                 ((0, monotonic_timestamp_1.default)() / 1000), 0);
         }