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

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

@@ -27,6 +27,8 @@ import ManifestBoundsCalculator from "../../manifest_bounds_calculator";
 export interface ITimelineIndex {
     /** If `false`, the last segment anounced might be still incomplete. */
     availabilityTimeComplete: boolean;
+    /** Minimum availabilityTimeOffset concerning the segments of this Representation. */
+    availabilityTimeOffset: number;
     /** Byte range for a possible index of segments in the server. */
     indexRange?: [number, number] | undefined;
     /**
@@ -123,8 +125,25 @@ export interface ITimelineIndexIndexArgument {
 }
 /** Aditional context needed by a SegmentTimeline RepresentationIndex. */
 export interface ITimelineIndexContextArgument {
-    /** If `false`, the last segment anounced might be still incomplete. */
-    availabilityTimeComplete: boolean;
+    /**
+     * If `false`, declared segments in the MPD might still be not completely generated.
+     * If `true`, they are completely generated.
+     *
+     * If `undefined`, the corresponding property was not set in the MPD and it is
+     * thus assumed that they are all generated.
+     * It might however be semantically different than `true` in the RxPlayer as it
+     * means that the packager didn't include that information in the MPD.
+     */
+    availabilityTimeComplete: boolean | undefined;
+    /**
+     * availability time offset of the concerned Adaptation.
+     *
+     * If `undefined`, the corresponding property was not set in the MPD and it is
+     * thus assumed to be equal to `0`.
+     * It might however be semantically different than `0` in the RxPlayer as it
+     * means that the packager didn't include that information in the MPD.
+     */
+    availabilityTimeOffset: number | undefined;
     /** Allows to obtain the minimum and maximum positions of a content. */
     manifestBoundsCalculator: ManifestBoundsCalculator;
     /** Start of the period linked to this RepresentationIndex, in seconds. */
@@ -164,6 +183,11 @@ export interface ILastSegmentInformation {
     /** Defines the time at which `lastPosition` was last calculated. */
     time: number;
 }
+/**
+ * `IRepresentationIndex` implementation for a DASH `SegmentTimeline` segment
+ * indexing scheme.
+ * @class TimelineRepresentationIndex
+ */
 export default class TimelineRepresentationIndex implements IRepresentationIndex {
     /** Underlying structure to retrieve segment information. */
     protected _index: ITimelineIndex;
@@ -287,12 +311,12 @@ export default class TimelineRepresentationIndex implements IRepresentationIndex
      */
     _update(newIndex: TimelineRepresentationIndex): void;
     /**
-     * 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(): boolean;
+    isStillAwaitingFutureSegments(): boolean;
     /**
      * @returns {Boolean}
      */
@@ -311,7 +335,6 @@ export default class TimelineRepresentationIndex implements IRepresentationIndex
      * available due to timeshifting.
      */
     private _refreshTimeline;
-    static getIndexEnd(timeline: IIndexSegment[], scaledPeriodEnd: number | undefined): number | null;
     /**
      * Allows to generate the "timeline" for this RepresentationIndex.
      * Call this function when the timeline is unknown.
@@ -336,3 +359,73 @@ export default class TimelineRepresentationIndex implements IRepresentationIndex
      */
     private _getTimeline;
 }
+/**
+ * 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 declare function isSegmentStillAvailable(segment: ISegment, index: {
+    availabilityTimeOffset: number;
+    timeline: IIndexSegment[];
+    indexTimeOffset: number;
+    timescale: number;
+}, manifestBoundsCalculator: ManifestBoundsCalculator, scaledPeriodEnd: number | undefined): boolean | undefined;
+/**
+ * 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 declare function getLastRequestableSegmentInfo(index: {
+    availabilityTimeOffset: number;
+    timeline: IIndexSegment[];
+    timescale: number;
+}, manifestBoundsCalculator: ManifestBoundsCalculator, scaledPeriodEnd: number | undefined): ILastRequestableSegmentInfo | null;
+/**
+ * Information on the last requestable segment deduced from a timeline array of
+ * segment information.
+ */
+export interface ILastRequestableSegmentInfo {
+    /**
+     * If `true`, we know that the last requestable segment is equal to the last
+     * segment that can be deduced from the corresponding given timeline.
+     * Written another way, there seem to be no segment announced in the timeline
+     * that are not yet requestable.
+     *
+     * If `false`, we know that the last requestable segment is not the last
+     * segment that can be deduced from the corresponding timeline.
+     * Written another way, there are supplementary segments in the timeline which
+     * are not yet requestable.
+     *
+     * Note that if the last requestable segment has its information from the last
+     * element from the timeline but it's not the last segment that would be
+     * deduced from the `repeatCount` property, then this value is set to `false`.
+     */
+    isLastOfTimeline: boolean;
+    /**
+     * End time at which the last requestable segment ends, in the corresponding
+     * index timescale (__NOT__ in seconds).
+     */
+    end: number;
+    /**
+     * The index in `timeline` of the last requestable segment.
+     * Note that its `repeatCount` may be updated and put as `newRepeatCount`.
+     */
+    timelineIdx: number;
+    /**
+     * The new `repeatCount` value for that last segment. May be equal or
+     * different from the timeline element found at `timelineIdx`.
+     */
+    newRepeatCount: number;
+}

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;
 }