rx-player 4.0.0-dev.2023110700 → 4.0.0-dev.2023120600

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

@@ -20,7 +20,6 @@ import assert from "../../../../../../utils/assert";
 import getMonotonicTimeStamp from "../../../../../../utils/monotonic_timestamp";
 import clearTimelineFromPosition from "../../../../utils/clear_timeline_from_position";
 import { checkDiscontinuity, fromIndexTime, getIndexSegmentEnd, toIndexTime, } from "../../../../utils/index_helpers";
-import isSegmentStillAvailable from "../../../../utils/is_segment_still_available";
 import updateSegmentTimeline from "../../../../utils/update_segment_timeline";
 import getInitSegment from "../get_init_segment";
 import getSegmentsFromTimeline from "../get_segments_from_timeline";
@@ -29,6 +28,11 @@ import { getSegmentTimeRoundingError } from "../utils";
 import constructTimelineFromElements from "./construct_timeline_from_elements";
 // eslint-disable-next-line max-len
 import constructTimelineFromPreviousTimeline from "./construct_timeline_from_previous_timeline";
+/**
+ * `IRepresentationIndex` implementation for a DASH `SegmentTimeline` segment
+ * indexing scheme.
+ * @class TimelineRepresentationIndex
+ */
 export default class TimelineRepresentationIndex {
     /**
      * @param {Object} index
@@ -40,7 +44,7 @@ export default class TimelineRepresentationIndex {
             throw new Error("The given index is not compatible with a " +
                 "TimelineRepresentationIndex.");
         }
-        const { availabilityTimeComplete, manifestBoundsCalculator, isDynamic, isLastPeriod, representationId, representationBitrate, periodStart, periodEnd, isEMSGWhitelisted } = context;
+        const { availabilityTimeComplete, availabilityTimeOffset, manifestBoundsCalculator, isDynamic, isLastPeriod, representationId, representationBitrate, periodStart, periodEnd, isEMSGWhitelisted } = context;
         const timescale = (_a = index.timescale) !== null && _a !== void 0 ? _a : 1;
         const presentationTimeOffset = index.presentationTimeOffset != null ?
             index.presentationTimeOffset :
@@ -71,7 +75,26 @@ export default class TimelineRepresentationIndex {
         const segmentUrlTemplate = index.media === undefined ?
             null :
             constructRepresentationUrl(index.media, representationId, representationBitrate);
-        this._index = { availabilityTimeComplete,
+        let 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,
             initialization: index.initialization == null ?
@@ -116,7 +139,7 @@ export default class TimelineRepresentationIndex {
             endNumber,
             timeline,
             timescale,
-            indexTimeOffset }, from, duration, this._isEMSGWhitelisted, this._scaledPeriodEnd);
+            indexTimeOffset }, from, duration, this._manifestBoundsCalculator, this._scaledPeriodEnd, this._isEMSGWhitelisted);
     }
     /**
      * Returns true if the index should be refreshed.
@@ -149,13 +172,19 @@ export default class TimelineRepresentationIndex {
      * @returns {Number|null}
      */
     getLastAvailablePosition() {
+        var _a;
         this._refreshTimeline();
         if (this._index.timeline === null) {
             this._index.timeline = this._getTimeline();
         }
-        const lastTime = TimelineRepresentationIndex.getIndexEnd(this._index.timeline, this._scaledPeriodEnd);
-        return lastTime === null ? null :
-            fromIndexTime(lastTime, this._index);
+        const lastReqSegInfo = getLastRequestableSegmentInfo(
+        // Needed typecast for TypeScript
+        this._index, this._manifestBoundsCalculator, this._scaledPeriodEnd);
+        if (lastReqSegInfo === null) {
+            return null;
+        }
+        const lastScaledPosition = Math.min(lastReqSegInfo.end, (_a = this._scaledPeriodEnd) !== null && _a !== void 0 ? _a : Infinity);
+        return fromIndexTime(lastScaledPosition, this._index);
     }
     /**
      * Returns the absolute end in seconds this RepresentationIndex can reach once
@@ -163,10 +192,20 @@ export default class TimelineRepresentationIndex {
      * @returns {number|null|undefined}
      */
     getEnd() {
-        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;
+        const lastSegment = this._index.timeline[this._index.timeline.length - 1];
+        const lastTime = Math.min(getIndexSegmentEnd(lastSegment, null, this._scaledPeriodEnd), (_a = this._scaledPeriodEnd) !== null && _a !== void 0 ? _a : Infinity);
+        return fromIndexTime(lastTime, this._index);
     }
     /**
      * Returns:
@@ -180,33 +219,54 @@ export default class TimelineRepresentationIndex {
      * @returns {boolean|undefined}
      */
     awaitSegmentBetween(start, end) {
-        var _a;
+        var _a, _b;
         assert(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();
         }
-        const { timeline, timescale } = this._index;
+        const { timescale, timeline } = this._index;
         const segmentTimeRounding = getSegmentTimeRoundingError(timescale);
-        const scaledEnd = toIndexTime(end, this._index);
-        if (timeline.length > 0) {
-            const lastTimelineElement = timeline[timeline.length - 1];
-            const lastSegmentEnd = getIndexSegmentEnd(lastTimelineElement, null, this._scaledPeriodEnd);
-            const roundedEnd = lastSegmentEnd + segmentTimeRounding;
-            if (roundedEnd >= Math.min(scaledEnd, (_a = this._scaledPeriodEnd) !== null && _a !== void 0 ? _a : Infinity)) {
-                return false; // already loaded
+        const scaledWantedEnd = toIndexTime(end, this._index);
+        const lastReqSegInfo = getLastRequestableSegmentInfo(
+        // Needed typecast for TypeScript
+        this._index, this._manifestBoundsCalculator, this._scaledPeriodEnd);
+        if (lastReqSegInfo !== null) {
+            const lastReqSegmentEnd = Math.min(lastReqSegInfo.end, (_a = this._scaledPeriodEnd) !== null && _a !== void 0 ? _a : Infinity);
+            const 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
+            }
+        }
+        const scaledWantedStart = toIndexTime(start, this._index);
+        if (timeline.length > 0 &&
+            lastReqSegInfo !== null &&
+            !lastReqSegInfo.isLastOfTimeline) {
+            // There are some future segments already anounced in the MPD
+            const lastSegment = timeline[timeline.length - 1];
+            const lastSegmentEnd = getIndexSegmentEnd(lastSegment, null, this._scaledPeriodEnd);
+            const 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
         }
-        const scaledStart = 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
@@ -224,8 +284,9 @@ export default class TimelineRepresentationIndex {
         if (this._index.timeline === null) {
             this._index.timeline = this._getTimeline();
         }
-        const { timeline, timescale, indexTimeOffset } = this._index;
-        return isSegmentStillAvailable(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:
@@ -288,6 +349,8 @@ export default class TimelineRepresentationIndex {
         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;
@@ -296,32 +359,67 @@ export default class TimelineRepresentationIndex {
         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}
      */
-    isFinished() {
-        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;
+    isStillAwaitingFutureSegments() {
+        var _a;
+        if (!this._isDynamic) {
+            return false;
         }
+        this._refreshTimeline();
         if (this._index.timeline === null) {
             this._index.timeline = this._getTimeline();
         }
         const { timeline } = this._index;
-        if (this._scaledPeriodEnd === undefined || timeline.length === 0) {
-            return false;
+        if (timeline.length === 0) {
+            // No segment announced in this Period
+            if (this._scaledPeriodEnd !== undefined) {
+                const liveEdge = this._manifestBoundsCalculator.getEstimatedLiveEdge();
+                if (liveEdge !== undefined &&
+                    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;
         }
-        const lastTimelineElement = timeline[timeline.length - 1];
-        const lastTime = getIndexSegmentEnd(lastTimelineElement, null, this._scaledPeriodEnd);
         const segmentTimeRounding = getSegmentTimeRoundingError(this._index.timescale);
-        return (lastTime + segmentTimeRounding) >= this._scaledPeriodEnd;
+        const 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
+            const 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;
+        }
+        const lastSegment = timeline[timeline.length - 1];
+        const lastSegmentEnd = 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}
@@ -356,7 +454,8 @@ export default class TimelineRepresentationIndex {
         if (!this._isDynamic) {
             return;
         }
-        const firstPosition = this._manifestBoundsCalculator.estimateMinimumBound();
+        const firstPosition = this._manifestBoundsCalculator
+            .getEstimatedMinimumSegmentTime();
         if (firstPosition == null) {
             return; // we don't know yet
         }
@@ -369,12 +468,6 @@ export default class TimelineRepresentationIndex {
             this._index.startNumber = nbEltsRemoved + 1;
         }
     }
-    static getIndexEnd(timeline, scaledPeriodEnd) {
-        if (timeline.length <= 0) {
-            return null;
-        }
-        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.
      * Call this function when the timeline is unknown.
@@ -462,3 +555,105 @@ 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}
+ */
+export function isSegmentStillAvailable(segment, index, manifestBoundsCalculator, scaledPeriodEnd) {
+    const lastReqSegInfo = getLastRequestableSegmentInfo(index, manifestBoundsCalculator, scaledPeriodEnd);
+    if (lastReqSegInfo === null) {
+        return false;
+    }
+    for (let i = 0; i < index.timeline.length; i++) {
+        if (lastReqSegInfo.timelineIdx < i) {
+            return false;
+        }
+        const tSegment = index.timeline[i];
+        const 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) {
+                const timeDiff = tSegmentTime - tSegment.start;
+                const repeat = (timeDiff / tSegment.duration) - 1;
+                return repeat % 1 === 0 && repeat <= lastReqSegInfo.newRepeatCount;
+            }
+        }
+    }
+    return false;
+}
+/**
+ * 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}
+ */
+export 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.
+        const lastIndex = index.timeline.length - 1;
+        const lastElem = index.timeline[lastIndex];
+        return { isLastOfTimeline: true,
+            timelineIdx: lastIndex,
+            newRepeatCount: lastElem.repeatCount,
+            end: getIndexSegmentEnd(lastElem, null, scaledPeriodEnd) };
+    }
+    const adjustedMaxSeconds = manifestBoundsCalculator.getEstimatedMaximumPosition(index.availabilityTimeOffset);
+    if (adjustedMaxSeconds === undefined) {
+        const lastIndex = index.timeline.length - 1;
+        const lastElem = index.timeline[lastIndex];
+        return { isLastOfTimeline: true,
+            timelineIdx: lastIndex,
+            newRepeatCount: lastElem.repeatCount,
+            end: getIndexSegmentEnd(lastElem, null, scaledPeriodEnd) };
+    }
+    for (let i = index.timeline.length - 1; i >= index.timeline.length; i--) {
+        const element = index.timeline[i];
+        const endOfFirstOccurence = element.start + element.duration;
+        if (fromIndexTime(endOfFirstOccurence, index) <= adjustedMaxSeconds) {
+            const endTime = getIndexSegmentEnd(element, index.timeline[i + 1], scaledPeriodEnd);
+            if (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
+                const maxIndexTime = toIndexTime(adjustedMaxSeconds, index);
+                const diffToSegStart = maxIndexTime - element.start;
+                const nbOfSegs = Math.floor(diffToSegStart / element.duration);
+                assert(nbOfSegs >= 1);
+                return { isLastOfTimeline: false,
+                    timelineIdx: i,
+                    newRepeatCount: nbOfSegs - 1,
+                    end: element.start + nbOfSegs * element.duration };
+            }
+        }
+    }
+    return null;
+}

package/dist/es2017/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/es2017/parsers/manifest/dash/common/manifest_bounds_calculator.js

@@ -18,16 +18,6 @@ import getMonotonicTimeStamp from "../../../../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
@@ -44,6 +34,8 @@ export default class ManifestBoundsCalculator {
             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
@@ -83,11 +75,12 @@ export default class ManifestBoundsCalculator {
      * Consider that it is only an estimation, not the real value.
      * @return {number|undefined}
      */
-    estimateMinimumBound() {
+    getEstimatedMinimumSegmentTime() {
+        var _a;
         if (!this._isDynamic || this._timeShiftBufferDepth === null) {
             return 0;
         }
-        const maximumBound = this.estimateMaximumBound();
+        const maximumBound = (_a = this.getEstimatedLiveEdge()) !== null && _a !== void 0 ? _a : this.getEstimatedMaximumPosition(0);
         if (maximumBound === undefined) {
             return undefined;
         }
@@ -95,14 +88,41 @@ export default class ManifestBoundsCalculator {
         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}
      */
-    estimateMaximumBound() {
-        if (this._isDynamic &&
-            this._positionTime != null &&
-            this._lastPosition != null) {
+    getEstimatedLiveEdge() {
+        if (!this._isDynamic || this._serverTimestampOffset === undefined) {
+            return undefined;
+        }
+        return (getMonotonicTimeStamp() + 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.
+     */
+    getEstimatedMaximumPosition(availabilityTimeOffset) {
+        if (!this._isDynamic) {
+            return this._lastPosition;
+        }
+        const 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) +
                 (getMonotonicTimeStamp() / 1000), 0);
         }

package/dist/es2017/parsers/manifest/dash/common/parse_adaptation_sets.js

@@ -154,7 +154,7 @@ function getAdaptationSetSwitchingIDs(adaptation) {
  * @returns {Array.<Object>}
  */
 export default function parseAdaptationSets(adaptationsIR, context) {
-    var _a, _b, _c, _d, _e, _f;
+    var _a, _b, _c, _d, _e, _f, _g;
     const parsedAdaptations = { video: [],
         audio: [],
         text: [] };
@@ -170,8 +170,12 @@ export default function parseAdaptationSets(adaptationsIR, context) {
             roles.some((role) => role.schemeIdUri === "urn:mpeg:dash:role:2011");
         const representationsIR = adaptation.children.representations;
         const availabilityTimeComplete = (_a = adaptation.attributes.availabilityTimeComplete) !== null && _a !== void 0 ? _a : context.availabilityTimeComplete;
-        const availabilityTimeOffset = ((_b = adaptation.attributes.availabilityTimeOffset) !== null && _b !== void 0 ? _b : 0) +
-            context.availabilityTimeOffset;
+        let availabilityTimeOffset;
+        if (adaptation.attributes.availabilityTimeOffset !== undefined ||
+            context.availabilityTimeOffset !== undefined) {
+            availabilityTimeOffset = ((_b = adaptation.attributes.availabilityTimeOffset) !== null && _b !== void 0 ? _b : 0) +
+                ((_c = context.availabilityTimeOffset) !== null && _c !== void 0 ? _c : 0);
+        }
         const adaptationMimeType = adaptation.attributes.mimeType;
         const adaptationCodecs = adaptation.attributes.codecs;
         const type = inferAdaptationType(representationsIR, isNonEmptyString(adaptationMimeType) ?
@@ -184,7 +188,7 @@ export default function parseAdaptationSets(adaptationsIR, context) {
         if (type === undefined) {
             continue;
         }
-        const priority = (_c = adaptation.attributes.selectionPriority) !== null && _c !== void 0 ? _c : 1;
+        const priority = (_d = adaptation.attributes.selectionPriority) !== null && _d !== void 0 ? _d : 1;
         const originalID = adaptation.attributes.id;
         const adaptationSetSwitchingIDs = getAdaptationSetSwitchingIDs(adaptation);
         const parentSegmentTemplates = [];
@@ -206,14 +210,13 @@ export default function parseAdaptationSets(adaptationsIR, context) {
             parentSegmentTemplates,
             receivedTime: context.receivedTime,
             start: context.start,
-            timeShiftBufferDepth: context.timeShiftBufferDepth,
             unsafelyBaseOnPreviousAdaptation: null,
         };
         const trickModeProperty = Array.isArray(essentialProperties) ?
             arrayFind(essentialProperties, (scheme) => {
                 return scheme.schemeIdUri === "http://dashif.org/guidelines/trickmode";
             }) : undefined;
-        const trickModeAttachedAdaptationIds = (_d = trickModeProperty === null || trickModeProperty === void 0 ? void 0 : trickModeProperty.value) === null || _d === void 0 ? void 0 : _d.split(" ");
+        const trickModeAttachedAdaptationIds = (_e = trickModeProperty === null || trickModeProperty === void 0 ? void 0 : trickModeProperty.value) === null || _e === void 0 ? void 0 : _e.split(" ");
         const isTrickModeTrack = trickModeAttachedAdaptationIds !== undefined;
         const { accessibilities } = adaptationChildren;
         let isDub;
@@ -261,8 +264,8 @@ export default function parseAdaptationSets(adaptationsIR, context) {
         }
         const newID = adaptationID;
         parsedAdaptationsIDs.push(adaptationID);
-        reprCtxt.unsafelyBaseOnPreviousAdaptation = (_f = (_e = context
-            .unsafelyBaseOnPreviousPeriod) === null || _e === void 0 ? void 0 : _e.getAdaptation(adaptationID)) !== null && _f !== void 0 ? _f : null;
+        reprCtxt.unsafelyBaseOnPreviousAdaptation = (_g = (_f = context
+            .unsafelyBaseOnPreviousPeriod) === null || _f === void 0 ? void 0 : _f.getAdaptation(adaptationID)) !== null && _g !== void 0 ? _g : null;
         const representations = parseRepresentations(representationsIR, adaptation, reprCtxt);
         const parsedAdaptationSet = { id: adaptationID,
             representations,