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

package/dist/commonjs/core/stream/period/period_stream.js

@@ -134,7 +134,7 @@ function PeriodStream(_a, callbacks, parentCancelSignal) {
     adaptationRef.onUpdate(function (choice) {
         // As an IIFE to profit from async/await while respecting onUpdate's signature
         (function () { return __awaiter(_this, void 0, void 0, function () {
-            var streamCanceller, segmentBufferStatus, periodEnd, DELTA_POSITION_AFTER_RELOAD, relativePosAfterSwitch, adaptation, representations, readyState, segmentBuffer, playbackInfos, strategy, _a, _b, _c, start, end, e_1_1;
+            var streamCanceller, segmentBufferStatus, periodEnd, DELTA_POSITION_AFTER_RELOAD, relativePosAfterSwitch, adaptation, representations, segmentBuffer, strategy, _a, _b, _c, start, end, e_1_1;
             var e_1, _d;
             var _e;
             return __generator(this, function (_f) {
@@ -235,10 +235,8 @@ function PeriodStream(_a, callbacks, parentCancelSignal) {
                         if (streamCanceller.isUsed()) {
                             return [2 /*return*/]; // Previous call has provoken cancellation by side-effect
                         }
-                        readyState = playbackObserver.getReadyState();
                         segmentBuffer = createOrReuseSegmentBuffer(segmentBuffersStore, bufferType, adaptation, options);
-                        playbackInfos = { currentTime: playbackObserver.getCurrentTime(), readyState: readyState };
-                        strategy = (0, get_adaptation_switch_strategy_1.default)(segmentBuffer, period, adaptation, choice.switchingMode, playbackInfos, options);
+                        strategy = (0, get_adaptation_switch_strategy_1.default)(segmentBuffer, period, adaptation, choice.switchingMode, playbackObserver, options);
                         if (strategy.type === "needs-reload") {
                             return [2 /*return*/, askForMediaSourceReload(relativePosAfterSwitch, true, streamCanceller.signal)];
                         }
@@ -415,7 +413,7 @@ function createAdaptationStreamPlaybackObserver(initialPlaybackObserver, segment
         function constructAdaptationStreamPlaybackObservation() {
             var baseObservation = observationRef.getValue();
             var buffered = segmentBuffer.getBufferedRanges();
-            var bufferGap = (0, ranges_1.getLeftSizeOfBufferedTimeRange)(buffered, baseObservation.position.last);
+            var bufferGap = (0, ranges_1.getLeftSizeOfBufferedTimeRange)(buffered, baseObservation.position.getWanted());
             return (0, object_assign_1.default)({}, baseObservation, { bufferGap: bufferGap });
         }
         function emitAdaptationStreamPlaybackObservation() {
@@ -443,12 +441,11 @@ function createEmptyAdaptationStream(playbackObserver, wantedBufferAhead, buffer
     function sendStatus() {
         var observation = playbackObserver.getReference().getValue();
         var wba = wantedBufferAhead.getValue();
-        var position = observation.position.last;
+        var position = observation.position.getWanted();
         if (period.end !== undefined && position + wba >= period.end) {
             log_1.default.debug("Stream: full \"empty\" AdaptationStream", bufferType);
             hasFinishedLoading = true;
         }
-        callbacks.streamStatusUpdate({ period: period, bufferType: bufferType, position: position, imminentDiscontinuity: null,
-            isEmptyStream: true, hasFinishedLoading: hasFinishedLoading, neededSegments: [] });
+        callbacks.streamStatusUpdate({ period: period, bufferType: bufferType, imminentDiscontinuity: null, position: position, isEmptyStream: true, hasFinishedLoading: hasFinishedLoading, neededSegments: [] });
     }
 }

package/dist/commonjs/core/stream/period/types.d.ts

@@ -3,11 +3,10 @@ import SharedReference, { IReadOnlySharedReference } from "../../../utils/refere
 import { CancellationSignal } from "../../../utils/task_canceller";
 import WeakMapMemory from "../../../utils/weak_map_memory";
 import { IRepresentationEstimator } from "../../adaptive";
-import { IReadOnlyPlaybackObserver } from "../../api";
+import { IObservationPosition, IReadOnlyPlaybackObserver } from "../../api";
 import { SegmentFetcherCreator } from "../../fetchers";
 import SegmentBuffersStore, { IBufferType, ITextTrackSegmentBufferOptions, SegmentBuffer } from "../../segment_buffers";
 import { IAdaptationChoice, IAdaptationStreamCallbacks, IAdaptationStreamOptions, IPausedPlaybackObservation } from "../adaptation";
-import { IPositionPlaybackObservation } from "../representation";
 /** Callbacks called by the `AdaptationStream` on various events. */
 export interface IPeriodStreamCallbacks extends IAdaptationStreamCallbacks {
     /**
@@ -65,7 +64,7 @@ export interface IPeriodStreamPlaybackObservation {
      * Information on the current media position in seconds at the time of the
      * Observation.
      */
-    position: IPositionPlaybackObservation;
+    position: IObservationPosition;
     /** `duration` property of the HTMLMediaElement. */
     duration: number;
     /** `readyState` property of the HTMLMediaElement. */

package/dist/commonjs/core/stream/period/utils/get_adaptation_switch_strategy.d.ts

@@ -14,8 +14,10 @@
  * limitations under the License.
  */
 import { Adaptation, Period } from "../../../../manifest";
+import { IReadOnlyPlaybackObserver } from "../../../api";
 import { SegmentBuffer } from "../../../segment_buffers";
 import { ITrackSwitchingMode } from "../../adaptation";
+import { IPeriodStreamPlaybackObservation } from "../types";
 export type IAdaptationSwitchStrategy = 
 /** Do nothing special. */
 {
@@ -59,10 +61,7 @@ export interface IAdaptationSwitchOptions {
  * @param {Object} segmentBuffer
  * @param {Object} period
  * @param {Object} adaptation
- * @param {Object} playbackInfo
+ * @param {Object} playbackObserver
  * @returns {Object}
  */
-export default function getAdaptationSwitchStrategy(segmentBuffer: SegmentBuffer, period: Period, adaptation: Adaptation, switchingMode: ITrackSwitchingMode, playbackInfo: {
-    currentTime: number;
-    readyState: number;
-}, options: IAdaptationSwitchOptions): IAdaptationSwitchStrategy;
+export default function getAdaptationSwitchStrategy(segmentBuffer: SegmentBuffer, period: Period, adaptation: Adaptation, switchingMode: ITrackSwitchingMode, playbackObserver: IReadOnlyPlaybackObserver<IPeriodStreamPlaybackObservation>, options: IAdaptationSwitchOptions): IAdaptationSwitchStrategy;

package/dist/commonjs/core/stream/period/utils/get_adaptation_switch_strategy.js

@@ -25,10 +25,10 @@ var segment_buffers_1 = require("../../../segment_buffers");
  * @param {Object} segmentBuffer
  * @param {Object} period
  * @param {Object} adaptation
- * @param {Object} playbackInfo
+ * @param {Object} playbackObserver
  * @returns {Object}
  */
-function getAdaptationSwitchStrategy(segmentBuffer, period, adaptation, switchingMode, playbackInfo, options) {
+function getAdaptationSwitchStrategy(segmentBuffer, period, adaptation, switchingMode, playbackObserver, options) {
     if (segmentBuffer.codec !== undefined &&
         options.onCodecSwitch === "reload" &&
         !hasCompatibleCodec(adaptation, segmentBuffer.codec)) {
@@ -64,16 +64,20 @@ function getAdaptationSwitchStrategy(segmentBuffer, period, adaptation, switchin
     if (unwantedRange.length === 0) {
         return { type: "continue", value: undefined };
     }
-    var currentTime = playbackInfo.currentTime;
-    if (switchingMode === "reload" &&
-        // We're playing the current Period
-        (0, ranges_1.isTimeInRange)({ start: start, end: end }, currentTime) &&
-        // There is data for the current position or the codecs are differents
-        (playbackInfo.readyState > 1 || !adaptation.getPlayableRepresentations()
-            .some(function (rep) { var _a; return (0, are_codecs_compatible_1.default)(rep.getMimeTypeString(), (_a = segmentBuffer.codec) !== null && _a !== void 0 ? _a : ""); })) &&
-        // We're not playing the current wanted video Adaptation
-        !(0, ranges_1.isTimeInRanges)(adaptationInBuffer, currentTime)) {
-        return { type: "needs-reload", value: undefined };
+    var currentTime = playbackObserver.getCurrentTime();
+    var readyState = playbackObserver.getReadyState();
+    if (switchingMode === "reload" && readyState > 1) {
+        var lastObservation = playbackObserver.getReference().getValue();
+        if (lastObservation.position.isAwaitingFuturePosition()) {
+            // We are not at the position we want to reach (e.g. initial seek, tizen
+            // seek-back...), just reload as checks here would be too complex
+            return { type: "needs-reload", value: undefined };
+        }
+        else if ((0, ranges_1.isTimeInRange)({ start: start, end: end }, currentTime) &&
+            // We're not playing the current wanted video Adaptation
+            !(0, ranges_1.isTimeInRanges)(adaptationInBuffer, currentTime)) {
+            return { type: "needs-reload", value: undefined };
+        }
     }
     // From here, clean-up data from the previous Adaptation, if one
     var shouldCleanAll = switchingMode === "direct";
@@ -144,7 +148,7 @@ function hasCompatibleCodec(adaptation, segmentBufferCodec) {
 /**
  * Returns buffered ranges of what we know correspond to the given `adaptation`
  * in the SegmentBuffer.
- * @param {Object} segmentBuffer
+ * @param {Array.<Object>} inventory
  * @param {Object} period
  * @param {Object} adaptation
  * @returns {Array.<Object>}

package/dist/commonjs/core/stream/representation/representation_stream.js

@@ -197,12 +197,11 @@ function RepresentationStream(_a, callbacks, parentCancelSignal) {
      * issues at the current time, calling the right callbacks if necessary.
      */
     function checkStatus() {
-        var _a, _b;
         if (segmentsLoadingCanceller.isUsed()) {
             return; // Stop all buffer status checking if load operations are stopped
         }
         var observation = playbackObserver.getReference().getValue();
-        var initialWantedTime = (_a = observation.position.pending) !== null && _a !== void 0 ? _a : observation.position.last;
+        var initialWantedTime = observation.position.getWanted();
         var status = (0, get_buffer_status_1.default)(content, initialWantedTime, playbackObserver, fastSwitchThreshold.getValue(), bufferGoal.getValue(), maxBufferSize.getValue(), segmentBuffer);
         var neededSegments = status.neededSegments;
         var neededInitSegment = null;
@@ -216,7 +215,7 @@ function RepresentationStream(_a, callbacks, parentCancelSignal) {
                     "initialization segment");
             }
             else {
-                var wantedStart = (_b = observation.position.pending) !== null && _b !== void 0 ? _b : observation.position.last;
+                var wantedStart = observation.position.getWanted();
                 neededInitSegment = { segment: initSegmentState.segment,
                     priority: (0, get_segment_priority_1.default)(period.start, wantedStart) };
             }
@@ -266,7 +265,7 @@ function RepresentationStream(_a, callbacks, parentCancelSignal) {
                 return;
             }
         }
-        callbacks.streamStatusUpdate({ period: period, position: observation.position.last, bufferType: bufferType, imminentDiscontinuity: status.imminentDiscontinuity,
+        callbacks.streamStatusUpdate({ period: period, position: observation.position.getWanted(), bufferType: bufferType, imminentDiscontinuity: status.imminentDiscontinuity,
             isEmptyStream: false,
             hasFinishedLoading: status.hasFinishedLoading,
             neededSegments: status.neededSegments });

package/dist/commonjs/core/stream/representation/types.d.ts

@@ -2,7 +2,7 @@ import Manifest, { Adaptation, ISegment, Period, Representation } from "../../..
 import { IEMSG } from "../../../parsers/containers/isobmff";
 import { IAudioRepresentationsSwitchingMode, IPlayerError, IVideoRepresentationsSwitchingMode } from "../../../public_types";
 import { IReadOnlySharedReference } from "../../../utils/reference";
-import { IReadOnlyPlaybackObserver } from "../../api";
+import { IObservationPosition, IReadOnlyPlaybackObserver } from "../../api";
 import { IContentProtection } from "../../decrypt";
 import { IPrioritizedSegmentFetcher } from "../../fetchers";
 import { IBufferType, SegmentBuffer } from "../../segment_buffers";
@@ -163,7 +163,7 @@ export interface IRepresentationStreamPlaybackObservation {
      * Information on the current media position in seconds at the time of a
      * Playback Observation.
      */
-    position: IPositionPlaybackObservation;
+    position: IObservationPosition;
 }
 /** Position-related information linked to an emitted Playback observation. */
 export interface IPositionPlaybackObservation {

package/dist/commonjs/core/stream/representation/utils/append_segment_to_buffer.js

@@ -68,19 +68,18 @@ var force_garbage_collection_1 = require("./force_garbage_collection");
  * @returns {Promise}
  */
 function appendSegmentToBuffer(playbackObserver, segmentBuffer, dataInfos, cancellationSignal) {
-    var _a;
     return __awaiter(this, void 0, void 0, function () {
         var appendError_1, reason, position, currentPos, err2_1, reason;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
                 case 0:
-                    _b.trys.push([0, 2, , 8]);
+                    _a.trys.push([0, 2, , 8]);
                     return [4 /*yield*/, segmentBuffer.pushChunk(dataInfos, cancellationSignal)];
                 case 1:
-                    _b.sent();
+                    _a.sent();
                     return [3 /*break*/, 8];
                 case 2:
-                    appendError_1 = _b.sent();
+                    appendError_1 = _a.sent();
                     if (cancellationSignal.isCancelled() && appendError_1 instanceof task_canceller_1.CancellationError) {
                         throw appendError_1;
                     }
@@ -92,19 +91,19 @@ function appendSegmentToBuffer(playbackObserver, segmentBuffer, dataInfos, cance
                         throw new errors_1.MediaError("BUFFER_APPEND_ERROR", reason, { adaptations: [dataInfos.inventoryInfos.adaptation] });
                     }
                     position = playbackObserver.getReference().getValue().position;
-                    currentPos = (_a = position.pending) !== null && _a !== void 0 ? _a : position.last;
-                    _b.label = 3;
+                    currentPos = position.getWanted();
+                    _a.label = 3;
                 case 3:
-                    _b.trys.push([3, 6, , 7]);
+                    _a.trys.push([3, 6, , 7]);
                     return [4 /*yield*/, (0, force_garbage_collection_1.default)(currentPos, segmentBuffer, cancellationSignal)];
                 case 4:
-                    _b.sent();
+                    _a.sent();
                     return [4 /*yield*/, segmentBuffer.pushChunk(dataInfos, cancellationSignal)];
                 case 5:
-                    _b.sent();
+                    _a.sent();
                     return [3 /*break*/, 7];
                 case 6:
-                    err2_1 = _b.sent();
+                    err2_1 = _a.sent();
                     reason = err2_1 instanceof Error ? err2_1.toString() :
                         "Could not clean the buffer";
                     throw new errors_1.MediaError("BUFFER_FULL_ERROR", reason, { adaptations: [dataInfos.inventoryInfos.adaptation] });

package/dist/commonjs/core/stream/representation/utils/get_buffer_status.js

@@ -96,7 +96,7 @@ function getBufferStatus(content, initialWantedTime, playbackObserver, fastSwitc
      * needed segments for this Representation until the end of the Period.
      */
     var hasFinishedLoading = representation.index.isInitialized() &&
-        representation.index.isFinished() &&
+        !representation.index.isStillAwaitingFutureSegments() &&
         neededRange.hasReachedPeriodEnd &&
         prioritizedNeededSegments.length === 0 &&
         segmentsOnHold.length === 0;
@@ -147,7 +147,7 @@ function getRangeOfNeededSegments(content, initialWantedTime, bufferGoal) {
         segment_buffers_1.default.isNative(content.adaptation.type) &&
         initialWantedTime >= lastIndexPosition &&
         representationIndex.isInitialized() &&
-        representationIndex.isFinished() &&
+        !representationIndex.isStillAwaitingFutureSegments() &&
         isPeriodTheCurrentAndLastOne(manifest, period, initialWantedTime)) {
         wantedStartPosition = lastIndexPosition - 1;
     }
@@ -157,7 +157,7 @@ function getRangeOfNeededSegments(content, initialWantedTime, bufferGoal) {
     var wantedEndPosition = wantedStartPosition + bufferGoal;
     var hasReachedPeriodEnd;
     if (!representation.index.isInitialized() ||
-        !representation.index.isFinished() ||
+        representation.index.isStillAwaitingFutureSegments() ||
         period.end === undefined) {
         hasReachedPeriodEnd = false;
     }
@@ -212,7 +212,7 @@ function getPlayableBufferedSegments(neededRange, segmentInventory) {
     for (var i = segmentInventory.length - 1; i >= 0; i--) {
         var eltInventory = segmentInventory[i];
         var representation = eltInventory.infos.representation;
-        if (!eltInventory.partiallyPushed &&
+        if (eltInventory.status === 1 /* ChunkStatus.Complete */ &&
             representation.decipherable !== false &&
             representation.isSupported) {
             var inventorySegment = eltInventory.infos.segment;

package/dist/commonjs/core/stream/representation/utils/get_needed_segments.js

@@ -324,7 +324,7 @@ function doesEndSeemGarbageCollected(currentSeg, nextSeg, minimumEndTime) {
     }
     if (minimumEndTime > currentSeg.bufferedEnd &&
         currentSeg.end - currentSeg.bufferedEnd > MAX_TIME_MISSING_FROM_COMPLETE_SEGMENT) {
-        log_1.default.info("Stream: The end of the wanted segment has been garbage collected", currentSeg.start, currentSeg.bufferedStart);
+        log_1.default.info("Stream: The end of the wanted segment has been garbage collected", currentSeg.end, currentSeg.bufferedEnd);
         return true;
     }
     return false;

package/dist/commonjs/default_config.d.ts

@@ -21,6 +21,11 @@ declare const DEFAULT_CONFIG: {
      * @type {Number}
      */
     DEFAULT_REQUEST_TIMEOUT: number;
+    /**
+     * Default connection time after which a request will timeout, in ms.
+     * @type {Number}
+     */
+    DEFAULT_CONNECTION_TIMEOUT: number;
     /**
      * Can be either:
      *   - "native": Subtitles are all displayed in a <track> element
@@ -141,6 +146,13 @@ declare const DEFAULT_CONFIG: {
      * @type {Object}
      */
     MAXIMUM_MAX_BUFFER_AHEAD: Partial<Record<"audio" | "video" | "text", number>>;
+    /**
+     * Minimum possible buffer ahead for each type of buffer, to avoid Garbage
+     * Collecting too much data when it would have adverse effects.
+     * Equal to `0` if not defined here.
+     * @type {Object}
+     */
+    MINIMUM_MAX_BUFFER_AHEAD: Partial<Record<"audio" | "video" | "image" | "text", number>>;
     /**
      * Maximum possible buffer behind for each type of buffer, to avoid too much
      * memory usage when playing for a long time.
@@ -203,22 +215,6 @@ declare const DEFAULT_CONFIG: {
      * @type {Number}
      */
     BUFFER_DISCONTINUITY_THRESHOLD: number;
-    /**
-     * When encountering small discontinuities, the RxPlayer may want, in specific
-     * conditions, ignore those and let the browser seek over them iself (this
-     * allows for example to avoid conflicts when both the browser and the
-     * RxPlayer want to seek at a different position, sometimes leading to a
-     * seeking loop).
-     * In this case, we however still want to seek it ourselves if the browser
-     * doesn't take the opportunity soon enough.
-     *
-     * This value specifies a delay after which a discontinuity ignored by the
-     * RxPlayer is finally considered.
-     * We want to maintain high enough to be sure the browser will not seek yet
-     * small enough so this (arguably rare) situation won't lead to too much
-     * waiting time.
-     */
-    FORCE_DISCONTINUITY_SEEK_DELAY: number;
     /**
      * Ratio used to know if an already loaded segment should be re-buffered.
      * We re-load the given segment if the current one times that ratio is

package/dist/commonjs/default_config.js

@@ -23,6 +23,11 @@ var DEFAULT_CONFIG = {
      * @type {Number}
      */
     DEFAULT_REQUEST_TIMEOUT: 30 * 1000,
+    /**
+     * Default connection time after which a request will timeout, in ms.
+     * @type {Number}
+     */
+    DEFAULT_CONNECTION_TIMEOUT: 15 * 1000,
     /**
      * Can be either:
      *   - "native": Subtitles are all displayed in a <track> element
@@ -146,6 +151,22 @@ var DEFAULT_CONFIG = {
     },
     /* eslint-enable @typescript-eslint/consistent-type-assertions */
     /* eslint-disable @typescript-eslint/consistent-type-assertions */
+    /**
+     * Minimum possible buffer ahead for each type of buffer, to avoid Garbage
+     * Collecting too much data when it would have adverse effects.
+     * Equal to `0` if not defined here.
+     * @type {Object}
+     */
+    MINIMUM_MAX_BUFFER_AHEAD: {
+        // Text segments are both much lighter on resources and might
+        // actually be much larger than other types of segments in terms
+        // of duration. Let's make an exception here by authorizing a
+        // larger text buffer ahead, to avoid unnecesarily reloading the
+        // same text track.
+        text: 2 * 60,
+    },
+    /* eslint-enable @typescript-eslint/consistent-type-assertions */
+    /* eslint-disable @typescript-eslint/consistent-type-assertions */
     /**
      * Maximum possible buffer behind for each type of buffer, to avoid too much
      * memory usage when playing for a long time.
@@ -211,22 +232,6 @@ var DEFAULT_CONFIG = {
      * @type {Number}
      */
     BUFFER_DISCONTINUITY_THRESHOLD: 0.2,
-    /**
-     * When encountering small discontinuities, the RxPlayer may want, in specific
-     * conditions, ignore those and let the browser seek over them iself (this
-     * allows for example to avoid conflicts when both the browser and the
-     * RxPlayer want to seek at a different position, sometimes leading to a
-     * seeking loop).
-     * In this case, we however still want to seek it ourselves if the browser
-     * doesn't take the opportunity soon enough.
-     *
-     * This value specifies a delay after which a discontinuity ignored by the
-     * RxPlayer is finally considered.
-     * We want to maintain high enough to be sure the browser will not seek yet
-     * small enough so this (arguably rare) situation won't lead to too much
-     * waiting time.
-     */
-    FORCE_DISCONTINUITY_SEEK_DELAY: 5000,
     /**
      * Ratio used to know if an already loaded segment should be re-buffered.
      * We re-load the given segment if the current one times that ratio is

package/dist/commonjs/experimental/tools/VideoThumbnailLoader/video_thumbnail_loader.js

@@ -181,7 +181,9 @@ var VideoThumbnailLoader = /** @class */ (function () {
             {}, { baseDelay: 0,
                 maxDelay: 0,
                 maxRetry: 0,
-                requestTimeout: config_1.default.getCurrent().DEFAULT_REQUEST_TIMEOUT });
+                requestTimeout: config_1.default.getCurrent().DEFAULT_REQUEST_TIMEOUT,
+                connectionTimeout: config_1.default.getCurrent().DEFAULT_CONNECTION_TIMEOUT,
+            });
             var initSegment_1 = content.representation.index.getInitSegment();
             var initSegmentUniqueId_1 = initSegment_1 !== null ?
                 content.representation.uniqueId :

package/dist/commonjs/experimental/tools/createMetaplaylist/get_duration_from_manifest.js

@@ -112,6 +112,7 @@ function getDurationFromManifest(url, transport) {
                             url: url,
                             responseType: "document",
                             timeout: config_1.default.getCurrent().DEFAULT_REQUEST_TIMEOUT,
+                            connectionTimeout: config_1.default.getCurrent().DEFAULT_CONNECTION_TIMEOUT,
                             // We won't cancel
                             cancelSignal: new task_canceller_1.default().signal,
                         })];
@@ -148,6 +149,7 @@ function getDurationFromManifest(url, transport) {
                         url: url,
                         responseType: "text",
                         timeout: config_1.default.getCurrent().DEFAULT_REQUEST_TIMEOUT,
+                        connectionTimeout: config_1.default.getCurrent().DEFAULT_CONNECTION_TIMEOUT,
                         // We won't cancel
                         cancelSignal: new task_canceller_1.default().signal,
                     })];

package/dist/commonjs/manifest/adaptation.js

@@ -82,7 +82,8 @@ var Adaptation = /** @class */ (function () {
                 var reprObject = {
                     id: representation.id,
                     bitrate: representation.bitrate,
-                    codec: representation.codec,
+                    codecs: representation.codec === undefined ? [] :
+                        [representation.codec],
                     height: representation.height,
                     width: representation.width,
                     frameRate: representation.frameRate,

package/dist/commonjs/manifest/representation_index/static.d.ts

@@ -89,7 +89,7 @@ export default class StaticRepresentationIndex implements IRepresentationIndex {
     /**
      * @returns {Boolean}
      */
-    isFinished(): true;
+    isStillAwaitingFutureSegments(): false;
     /**
      * @returns {Boolean}
      */

package/dist/commonjs/manifest/representation_index/static.js

@@ -117,8 +117,8 @@ var StaticRepresentationIndex = /** @class */ (function () {
     /**
      * @returns {Boolean}
      */
-    StaticRepresentationIndex.prototype.isFinished = function () {
-        return true;
+    StaticRepresentationIndex.prototype.isStillAwaitingFutureSegments = function () {
+        return false;
     };
     /**
      * @returns {Boolean}

package/dist/commonjs/manifest/representation_index/types.d.ts

@@ -304,7 +304,7 @@ export interface IRepresentationIndex {
     getLastAvailablePosition(): number | null | undefined;
     /**
      * Returns the ending time, in seconds, of the Representation once it is
-     * "finished" (@see isFinished).
+     * "finished" (@see isStillAwaitingFutureSegments).
      * Should thus be equivalent to `getLastAvailablePosition` once finished.
      *
      * Returns `null` if nothing is in the index
@@ -352,13 +352,13 @@ export interface IRepresentationIndex {
      */
     checkDiscontinuity(time: number): number | null;
     /**
-     * Returns `true` if the last segments in this index have already been
+     * Returns `false` if the last segments in this index have already been
      * generated so that we can freely go to the next period.
-     * Returns `false` if the index is still waiting on future segments to be
+     * Returns `true` if the index is still waiting on future segments to be
      * generated.
      * @returns {boolean}
      */
-    isFinished(): boolean;
+    isStillAwaitingFutureSegments(): boolean;
     /**
      * Returns `true` if this index has all the data it needs to give the list
      * of available segments.

package/dist/commonjs/parsers/manifest/dash/common/indexes/base.d.ts

@@ -17,6 +17,7 @@ import { IRepresentationIndex, ISegment } from "../../../../../manifest";
 import { ISegmentInformation } from "../../../../../transports";
 import { IEMSG } from "../../../../containers/isobmff";
 import { IIndexSegment } from "../../../utils/index_helpers";
+import ManifestBoundsCalculator from "../manifest_bounds_calculator";
 /**
  * Index property defined for a SegmentBase RepresentationIndex
  * This object contains every property needed to generate an ISegment for a
@@ -108,6 +109,8 @@ export interface IBaseIndexContextArgument {
     representationId?: string | undefined;
     /** Bitrate of the Representation concerned. */
     representationBitrate?: number | undefined;
+    /** Allows to obtain the minimum and maximum positions of a content. */
+    manifestBoundsCalculator: ManifestBoundsCalculator;
     isEMSGWhitelisted: (inbandEvent: IEMSG) => boolean;
 }
 export default class BaseRepresentationIndex implements IRepresentationIndex {
@@ -124,6 +127,8 @@ export default class BaseRepresentationIndex implements IRepresentationIndex {
     private _scaledPeriodStart;
     /** Absolute end of the period, timescaled and converted to index time. */
     private _scaledPeriodEnd;
+    /** Allows to obtain the minimum and maximum positions of a content. */
+    private _manifestBoundsCalculator;
     private _isEMSGWhitelisted;
     /**
      * @param {Object} index
@@ -205,7 +210,7 @@ export default class BaseRepresentationIndex implements IRepresentationIndex {
      * should become available in the future.
      * @returns {Boolean}
      */
-    isFinished(): true;
+    isStillAwaitingFutureSegments(): false;
     /**
      * No segment in a `BaseRepresentationIndex` are known initially.
      * It is only defined generally in an "index segment" that will thus need to

package/dist/commonjs/parsers/manifest/dash/common/indexes/base.js

@@ -80,6 +80,7 @@ var BaseRepresentationIndex = /** @class */ (function () {
         this._index = { indexRange: index.indexRange, indexTimeOffset: indexTimeOffset, initialization: { url: initializationUrl, range: range }, segmentUrlTemplate: segmentUrlTemplate, startNumber: index.startNumber,
             endNumber: index.endNumber,
             timeline: (_c = index.timeline) !== null && _c !== void 0 ? _c : [], timescale: timescale };
+        this._manifestBoundsCalculator = context.manifestBoundsCalculator;
         this._scaledPeriodStart = (0, index_helpers_1.toIndexTime)(periodStart, this._index);
         this._scaledPeriodEnd = periodEnd == null ? undefined :
             (0, index_helpers_1.toIndexTime)(periodEnd, this._index);
@@ -108,7 +109,7 @@ var BaseRepresentationIndex = /** @class */ (function () {
      * @returns {Array.<Object>}
      */
     BaseRepresentationIndex.prototype.getSegments = function (from, dur) {
-        return (0, get_segments_from_timeline_1.default)(this._index, from, dur, this._isEMSGWhitelisted, this._scaledPeriodEnd);
+        return (0, get_segments_from_timeline_1.default)(this._index, from, dur, this._manifestBoundsCalculator, this._scaledPeriodEnd, this._isEMSGWhitelisted);
     };
     /**
      * Returns false as no Segment-Base based index should need to be refreshed.
@@ -192,8 +193,8 @@ var BaseRepresentationIndex = /** @class */ (function () {
      * should become available in the future.
      * @returns {Boolean}
      */
-    BaseRepresentationIndex.prototype.isFinished = function () {
-        return true;
+    BaseRepresentationIndex.prototype.isStillAwaitingFutureSegments = function () {
+        return false;
     };
     /**
      * No segment in a `BaseRepresentationIndex` are known initially.

package/dist/commonjs/parsers/manifest/dash/common/indexes/get_segments_from_timeline.d.ts

@@ -16,21 +16,24 @@
 import { ISegment } from "../../../../../manifest";
 import { IEMSG } from "../../../../containers/isobmff";
 import { IIndexSegment } from "../../../utils/index_helpers";
+import ManifestBoundsCalculator from "../manifest_bounds_calculator";
 /**
  * Get a list of Segments for the time range wanted.
  * @param {Object} index - index object, constructed by parsing the manifest.
  * @param {number} from - starting timestamp wanted, in seconds
  * @param {number} durationWanted - duration wanted, in seconds
+ * @param {Object} manifestBoundsCalculator
+ * @param {number|undefined} scaledPeriodEnd
  * @param {function} isEMSGWhitelisted
- * @param {number|undefined} maximumTime
  * @returns {Array.<Object>}
  */
 export default function getSegmentsFromTimeline(index: {
     availabilityTimeComplete?: boolean | undefined;
+    availabilityTimeOffset?: number | undefined;
     segmentUrlTemplate: string | null;
     startNumber?: number | undefined;
     endNumber?: number | undefined;
     timeline: IIndexSegment[];
     timescale: number;
     indexTimeOffset: number;
-}, from: number, durationWanted: number, isEMSGWhitelisted: (inbandEvent: IEMSG) => boolean, maximumTime?: number): ISegment[];
+}, from: number, durationWanted: number, manifestBoundsCalculator: ManifestBoundsCalculator, scaledPeriodEnd: number | undefined, isEMSGWhitelisted: (inbandEvent: IEMSG) => boolean): ISegment[];

package/dist/commonjs/parsers/manifest/dash/common/indexes/get_segments_from_timeline.js

@@ -36,13 +36,17 @@ function getWantedRepeatIndex(segmentStartTime, segmentDuration, wantedTime) {
  * @param {Object} index - index object, constructed by parsing the manifest.
  * @param {number} from - starting timestamp wanted, in seconds
  * @param {number} durationWanted - duration wanted, in seconds
+ * @param {Object} manifestBoundsCalculator
+ * @param {number|undefined} scaledPeriodEnd
  * @param {function} isEMSGWhitelisted
- * @param {number|undefined} maximumTime
  * @returns {Array.<Object>}
  */
-function getSegmentsFromTimeline(index, from, durationWanted, isEMSGWhitelisted, maximumTime) {
+function getSegmentsFromTimeline(index, from, durationWanted, manifestBoundsCalculator, scaledPeriodEnd, isEMSGWhitelisted) {
+    var _a;
+    var maximumTime = manifestBoundsCalculator.getEstimatedMaximumPosition((_a = index.availabilityTimeOffset) !== null && _a !== void 0 ? _a : 0);
+    var wantedMaximum = Math.min(from + durationWanted, maximumTime !== null && maximumTime !== void 0 ? maximumTime : Infinity);
     var scaledUp = (0, index_helpers_1.toIndexTime)(from, index);
-    var scaledTo = (0, index_helpers_1.toIndexTime)(from + durationWanted, index);
+    var scaledTo = (0, index_helpers_1.toIndexTime)(wantedMaximum, index);
     var timeline = index.timeline, timescale = index.timescale, segmentUrlTemplate = index.segmentUrlTemplate, startNumber = index.startNumber, endNumber = index.endNumber;
     var currentNumber = startNumber !== null && startNumber !== void 0 ? startNumber : 1;
     var segments = [];
@@ -50,7 +54,14 @@ function getSegmentsFromTimeline(index, from, durationWanted, isEMSGWhitelisted,
     for (var i = 0; i < timelineLength; i++) {
         var timelineItem = timeline[i];
         var duration = timelineItem.duration, start = timelineItem.start, range = timelineItem.range;
-        var repeat = (0, index_helpers_1.calculateRepeat)(timelineItem, timeline[i + 1], maximumTime);
+        var maxRepeatTime = void 0;
+        if (maximumTime === undefined) {
+            maxRepeatTime = scaledPeriodEnd;
+        }
+        else {
+            maxRepeatTime = Math.min(maximumTime * timescale, scaledPeriodEnd !== null && scaledPeriodEnd !== void 0 ? scaledPeriodEnd : Infinity);
+        }
+        var repeat = (0, index_helpers_1.calculateRepeat)(timelineItem, timeline[i + 1], maxRepeatTime);
         var complete = index.availabilityTimeComplete !== false ||
             i !== timelineLength - 1 &&
                 repeat !== 0;