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

package/src/core/stream/representation/utils/get_needed_segments.ts

@@ -493,8 +493,8 @@ function doesEndSeemGarbageCollected(
       currentSeg.end - currentSeg.bufferedEnd > MAX_TIME_MISSING_FROM_COMPLETE_SEGMENT)
   {
     log.info("Stream: The end of the wanted segment has been garbage collected",
-             currentSeg.start,
-             currentSeg.bufferedStart);
+             currentSeg.end,
+             currentSeg.bufferedEnd);
     return true;
   }
 

package/src/default_config.ts

@@ -23,6 +23,11 @@ const DEFAULT_CONFIG = {
      */
   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
@@ -158,6 +163,23 @@ const DEFAULT_CONFIG = {
   } as Partial<Record<"audio"|"video"|"text", number>>,
     /* 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,
+  } as Partial<Record<"audio"|"video"|"image"|"text", number>>,
+  /* 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
@@ -231,23 +253,6 @@ const DEFAULT_CONFIG = {
      */
   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/src/experimental/tools/VideoThumbnailLoader/video_thumbnail_loader.ts

@@ -177,7 +177,9 @@ export default class VideoThumbnailLoader {
         { baseDelay: 0,
           maxDelay: 0,
           maxRetry: 0,
-          requestTimeout: config.getCurrent().DEFAULT_REQUEST_TIMEOUT }
+          requestTimeout: config.getCurrent().DEFAULT_REQUEST_TIMEOUT,
+          connectionTimeout: config.getCurrent().DEFAULT_CONNECTION_TIMEOUT,
+        }
       ) as ISegmentFetcher<ArrayBuffer | Uint8Array>;
       const initSegment = content.representation.index.getInitSegment();
       const initSegmentUniqueId = initSegment !== null ?

package/src/experimental/tools/createMetaplaylist/get_duration_from_manifest.ts

@@ -83,6 +83,7 @@ async function getDurationFromManifest(
       url,
       responseType: "document",
       timeout: config.getCurrent().DEFAULT_REQUEST_TIMEOUT,
+      connectionTimeout: config.getCurrent().DEFAULT_CONNECTION_TIMEOUT,
       // We won't cancel
       cancelSignal: new TaskCanceller().signal,
     });
@@ -122,6 +123,7 @@ async function getDurationFromManifest(
     url,
     responseType: "text",
     timeout: config.getCurrent().DEFAULT_REQUEST_TIMEOUT,
+    connectionTimeout: config.getCurrent().DEFAULT_CONNECTION_TIMEOUT,
     // We won't cancel
     cancelSignal: new TaskCanceller().signal,
   });

package/src/manifest/adaptation.ts

@@ -157,7 +157,8 @@ export default class Adaptation {
         const reprObject : IRepresentationFilterRepresentation = {
           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/src/manifest/representation_index/static.ts

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

package/src/manifest/representation_index/types.ts

@@ -329,7 +329,7 @@ export interface IRepresentationIndex {
 
   /**
    * 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
@@ -381,13 +381,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

package/src/parsers/manifest/dash/common/__tests__/manifest_bounds_calculator.test.ts

@@ -18,39 +18,46 @@ import ManifestBoundsCalculator from "../manifest_bounds_calculator";
 
 describe("DASH parsers - ManifestBoundsCalculator", () => {
   /* eslint-disable max-len */
-  it("should return undefined through `estimateMinimumBound` if the live edge was never set for a dynamic content with a timeShiftBufferDepth", () => {
+  it("should return undefined through `getEstimatedMinimumSegmentTime` if the live edge was never set for a dynamic content with a timeShiftBufferDepth", () => {
   /* eslint-enable max-len */
     const manifestBoundsCalculator = new ManifestBoundsCalculator({
       isDynamic: true,
       timeShiftBufferDepth: 5,
+      availabilityStartTime: 0,
+      serverTimestampOffset: undefined,
     });
-    expect(manifestBoundsCalculator.estimateMinimumBound()).toEqual(undefined);
-    expect(manifestBoundsCalculator.estimateMinimumBound()).toEqual(undefined);
-    expect(manifestBoundsCalculator.estimateMinimumBound()).toEqual(undefined);
+    expect(manifestBoundsCalculator.getEstimatedMinimumSegmentTime()).toEqual(undefined);
+    expect(manifestBoundsCalculator.getEstimatedMinimumSegmentTime()).toEqual(undefined);
+    expect(manifestBoundsCalculator.getEstimatedMinimumSegmentTime()).toEqual(undefined);
   });
 
   /* eslint-disable max-len */
-  it("should return 0 through `estimateMinimumBound` if the live edge was never set for a static content", () => {
+  it("should return 0 through `getEstimatedMinimumSegmentTime` for a static content", () => {
   /* eslint-enable max-len */
     const manifestBoundsCalculator = new ManifestBoundsCalculator({
       isDynamic: false,
       timeShiftBufferDepth: 5,
+      availabilityStartTime: 0,
+      serverTimestampOffset: 555555,
     });
-    expect(manifestBoundsCalculator.estimateMinimumBound()).toEqual(0);
-    expect(manifestBoundsCalculator.estimateMinimumBound()).toEqual(0);
-    expect(manifestBoundsCalculator.estimateMinimumBound()).toEqual(0);
+    expect(manifestBoundsCalculator.getEstimatedMinimumSegmentTime()).toEqual(0);
+    manifestBoundsCalculator.setLastPosition(5555, 2135);
+    expect(manifestBoundsCalculator.getEstimatedMinimumSegmentTime()).toEqual(0);
+    expect(manifestBoundsCalculator.getEstimatedMinimumSegmentTime()).toEqual(0);
   });
 
   /* eslint-disable max-len */
-  it("should return 0 through `estimateMinimumBound` if the live edge was never set for a dynamic content with no timeShiftBufferDepth", () => {
+  it("should return 0 through `getEstimatedMinimumSegmentTime` if the `serverTimestampOffset` was never set nor the last position for a dynamic content with no timeShiftBufferDepth", () => {
   /* eslint-enable max-len */
     const manifestBoundsCalculator = new ManifestBoundsCalculator({
       isDynamic: false,
       timeShiftBufferDepth: undefined,
+      availabilityStartTime: 0,
+      serverTimestampOffset: undefined,
     });
-    expect(manifestBoundsCalculator.estimateMinimumBound()).toEqual(0);
-    expect(manifestBoundsCalculator.estimateMinimumBound()).toEqual(0);
-    expect(manifestBoundsCalculator.estimateMinimumBound()).toEqual(0);
+    expect(manifestBoundsCalculator.getEstimatedMinimumSegmentTime()).toEqual(0);
+    expect(manifestBoundsCalculator.getEstimatedMinimumSegmentTime()).toEqual(0);
+    expect(manifestBoundsCalculator.getEstimatedMinimumSegmentTime()).toEqual(0);
   });
 
   /* eslint-disable max-len */
@@ -59,9 +66,11 @@ describe("DASH parsers - ManifestBoundsCalculator", () => {
     const manifestBoundsCalculator = new ManifestBoundsCalculator({
       isDynamic: true,
       timeShiftBufferDepth: 5,
+      availabilityStartTime: 0,
+      serverTimestampOffset: undefined,
     });
     expect(manifestBoundsCalculator.lastPositionIsKnown()).toEqual(false);
-    expect(manifestBoundsCalculator.estimateMinimumBound()).toEqual(undefined);
+    expect(manifestBoundsCalculator.getEstimatedMinimumSegmentTime()).toEqual(undefined);
     expect(manifestBoundsCalculator.lastPositionIsKnown()).toEqual(false);
   });
 
@@ -71,6 +80,8 @@ describe("DASH parsers - ManifestBoundsCalculator", () => {
     const manifestBoundsCalculator = new ManifestBoundsCalculator({
       isDynamic: true,
       timeShiftBufferDepth: 5,
+      availabilityStartTime: 0,
+      serverTimestampOffset: undefined,
     });
     manifestBoundsCalculator.setLastPosition(1000, 0);
     expect(manifestBoundsCalculator.lastPositionIsKnown()).toEqual(true);
@@ -82,63 +93,198 @@ describe("DASH parsers - ManifestBoundsCalculator", () => {
     const manifestBoundsCalculator = new ManifestBoundsCalculator({
       isDynamic: false,
       timeShiftBufferDepth: 5,
+      availabilityStartTime: 0,
+      serverTimestampOffset: undefined,
     });
     manifestBoundsCalculator.setLastPosition(1000, 0);
     expect(manifestBoundsCalculator.lastPositionIsKnown()).toEqual(true);
   });
 
   /* eslint-disable max-len */
-  it("should return how much time has elapsed through `estimateMinimumBound` since the live edge was set for a dynamic content", () => {
+  it("should return how much time has elapsed through `getEstimatedMinimumSegmentTime` since the last position was set for a dynamic content", () => {
   /* eslint-enable max-len */
-    let date = 5000;
+    let performanceNow = 5000;
     const mockPerformanceNow = jest.spyOn(performance, "now")
-      .mockImplementation(jest.fn(() => date));
+      .mockImplementation(jest.fn(() => performanceNow));
     const manifestBoundsCalculator = new ManifestBoundsCalculator({
       isDynamic: true,
       timeShiftBufferDepth: 5,
+      availabilityStartTime: 0,
+      serverTimestampOffset: undefined,
     });
     manifestBoundsCalculator.setLastPosition(1000, 10);
-    date = 25000;
-    expect(manifestBoundsCalculator.estimateMinimumBound()).toEqual(1010);
-    date = 35000;
-    expect(manifestBoundsCalculator.estimateMinimumBound()).toEqual(1020);
+    performanceNow = 25000;
+    expect(manifestBoundsCalculator.getEstimatedMinimumSegmentTime()).toEqual(1010);
+    performanceNow = 35000;
+    expect(manifestBoundsCalculator.getEstimatedMinimumSegmentTime()).toEqual(1020);
     mockPerformanceNow.mockRestore();
   });
 
   /* eslint-disable max-len */
-  it("should return 0 even when a last position has been set for a static content", () => {
+  it("should prefer relying on the live edge for `getEstimatedMinimumSegmentTime` if it was set", () => {
   /* eslint-enable max-len */
-    let date = 5000;
+    let performanceNow = 5000;
     const mockPerformanceNow = jest.spyOn(performance, "now")
-      .mockImplementation(jest.fn(() => date));
+      .mockImplementation(jest.fn(() => performanceNow));
     const manifestBoundsCalculator = new ManifestBoundsCalculator({
-      isDynamic: false,
-      timeShiftBufferDepth: 5,
+      isDynamic: true,
+      timeShiftBufferDepth: 3,
+      availabilityStartTime: 4,
+      serverTimestampOffset: 7000,
     });
-    manifestBoundsCalculator.setLastPosition(1000, 0);
-    date = 25000;
-    expect(manifestBoundsCalculator.estimateMinimumBound()).toEqual(0);
-    date = 35000;
-    expect(manifestBoundsCalculator.estimateMinimumBound()).toEqual(0);
+    manifestBoundsCalculator.setLastPosition(3000, 10);
+    expect(manifestBoundsCalculator.getEstimatedMinimumSegmentTime())
+      .toEqual(7 + 5 - 4 - 3);
+    performanceNow = 25000;
+    expect(manifestBoundsCalculator.getEstimatedMinimumSegmentTime())
+      .toEqual(7 + 25 - 4 - 3);
+    performanceNow = 35000;
+    manifestBoundsCalculator.setLastPosition(84546464, 5642);
+    expect(manifestBoundsCalculator.getEstimatedMinimumSegmentTime())
+      .toEqual(7 + 35 - 4 - 3);
     mockPerformanceNow.mockRestore();
   });
 
   /* eslint-disable max-len */
   it("should authorize and handle multiple `setLastPositionOffset` calls for dynamic contents", () => {
   /* eslint-enable max-len */
-    let date = 5000;
+    let performanceNow = 5000;
     const mockPerformanceNow = jest.spyOn(performance, "now")
-      .mockImplementation(jest.fn(() => date));
+      .mockImplementation(jest.fn(() => performanceNow));
     const manifestBoundsCalculator = new ManifestBoundsCalculator({
       isDynamic: true,
       timeShiftBufferDepth: 5,
+      availabilityStartTime: 0,
+      serverTimestampOffset: undefined,
     });
     manifestBoundsCalculator.setLastPosition(1000, 0);
-    date = 50000;
-    expect(manifestBoundsCalculator.estimateMinimumBound()).toEqual(1045);
+    performanceNow = 50000;
+    expect(manifestBoundsCalculator.getEstimatedMinimumSegmentTime()).toEqual(1045);
     manifestBoundsCalculator.setLastPosition(0, 0);
-    date = 55000;
-    expect(manifestBoundsCalculator.estimateMinimumBound()).toEqual(50);
+    performanceNow = 55000;
+    expect(manifestBoundsCalculator.getEstimatedMinimumSegmentTime()).toEqual(50);
+    mockPerformanceNow.mockRestore();
+  });
+
+  /* eslint-disable max-len */
+  it("`getEstimatedMaximumPosition` should be based on the last position on on-dynamic manifest", () => {
+  /* eslint-enable max-len */
+    let performanceNow = 5000;
+    const mockPerformanceNow = jest.spyOn(performance, "now")
+      .mockImplementation(jest.fn(() => performanceNow));
+    const manifestBoundsCalculator1 = new ManifestBoundsCalculator({
+      isDynamic: false,
+      timeShiftBufferDepth: 5,
+      availabilityStartTime: 0,
+      serverTimestampOffset: undefined,
+    });
+    const manifestBoundsCalculator2 = new ManifestBoundsCalculator({
+      isDynamic: false,
+      timeShiftBufferDepth: 5,
+      availabilityStartTime: 0,
+      serverTimestampOffset: 10,
+    });
+    manifestBoundsCalculator1.setLastPosition(1000, 0);
+    manifestBoundsCalculator2.setLastPosition(1000, 0);
+    performanceNow = 50000;
+    expect(manifestBoundsCalculator1.getEstimatedMaximumPosition(10)).toEqual(1000);
+    expect(manifestBoundsCalculator2.getEstimatedMaximumPosition(19)).toEqual(1000);
+    performanceNow = 55000;
+    expect(manifestBoundsCalculator1.getEstimatedMaximumPosition(98)).toEqual(1000);
+    expect(manifestBoundsCalculator2.getEstimatedMaximumPosition(93)).toEqual(1000);
+    manifestBoundsCalculator1.setLastPosition(0, 0);
+    manifestBoundsCalculator2.setLastPosition(0, 0);
+    expect(manifestBoundsCalculator1.getEstimatedMaximumPosition(43)).toEqual(0);
+    expect(manifestBoundsCalculator2.getEstimatedMaximumPosition(421)).toEqual(0);
+    mockPerformanceNow.mockRestore();
+  });
+
+  /* eslint-disable max-len */
+  it("`getEstimatedMaximumPosition` should evolve based on the last position on dynamic manifest without `serverTimestampOffset`", () => {
+  /* eslint-enable max-len */
+    let performanceNow = 5000;
+    const mockPerformanceNow = jest.spyOn(performance, "now")
+      .mockImplementation(jest.fn(() => performanceNow));
+    const manifestBoundsCalculator = new ManifestBoundsCalculator({
+      isDynamic: true,
+      timeShiftBufferDepth: 5,
+      availabilityStartTime: 7,
+      serverTimestampOffset: undefined,
+    });
+    manifestBoundsCalculator.setLastPosition(1050, 0);
+    performanceNow = 50000;
+    expect(manifestBoundsCalculator.getEstimatedMaximumPosition(10)).toEqual(1050 + 50);
+    performanceNow = 55000;
+    expect(manifestBoundsCalculator.getEstimatedMaximumPosition(98)).toEqual(1050 + 55);
+    manifestBoundsCalculator.setLastPosition(0, 10);
+    expect(manifestBoundsCalculator.getEstimatedMaximumPosition(43)).toEqual(0 + 55 - 10);
+    mockPerformanceNow.mockRestore();
+  });
+
+  it("should not return a live edge if `serverTimestampOffset` isn't set", () => {
+    const manifestBoundsCalculator = new ManifestBoundsCalculator({
+      isDynamic: true,
+      timeShiftBufferDepth: 5,
+      availabilityStartTime: 0,
+      serverTimestampOffset: undefined,
+    });
+    manifestBoundsCalculator.setLastPosition(1000, 0);
+    expect(manifestBoundsCalculator.getEstimatedLiveEdge()).toEqual(undefined);
+  });
+
+  it("should not return a live edge if the manifest is not dynamic", () => {
+    const manifestBoundsCalculator = new ManifestBoundsCalculator({
+      isDynamic: false,
+      timeShiftBufferDepth: 5,
+      availabilityStartTime: 0,
+      serverTimestampOffset: 100,
+    });
+    manifestBoundsCalculator.setLastPosition(1000, 0);
+    expect(manifestBoundsCalculator.getEstimatedLiveEdge()).toEqual(undefined);
+  });
+
+  it("should rely on `serverTimestampOffset` to produce live edge if set", () => {
+    let performanceNow = 3000;
+    const mockPerformanceNow = jest.spyOn(performance, "now")
+      .mockImplementation(jest.fn(() => performanceNow));
+    const manifestBoundsCalculator = new ManifestBoundsCalculator({
+      isDynamic: true,
+      timeShiftBufferDepth: 5,
+      availabilityStartTime: 2,
+      serverTimestampOffset: 5000,
+    });
+    expect(manifestBoundsCalculator.getEstimatedLiveEdge()).toEqual(3 + 5 - 2);
+    manifestBoundsCalculator.setLastPosition(1000, 0);
+    expect(manifestBoundsCalculator.getEstimatedLiveEdge()).toEqual(3 + 5 - 2);
+    performanceNow = 9000;
+    expect(manifestBoundsCalculator.getEstimatedLiveEdge()).toEqual(9 + 5 - 2);
+    mockPerformanceNow.mockRestore();
+  });
+
+  /* eslint-disable max-len */
+  it("`getEstimatedMaximumPosition` should evolve based on the live edge position on dynamic manifest with `serverTimestampOffset`", () => {
+  /* eslint-enable max-len */
+    let performanceNow = 5000;
+    const mockPerformanceNow = jest.spyOn(performance, "now")
+      .mockImplementation(jest.fn(() => performanceNow));
+    const manifestBoundsCalculator = new ManifestBoundsCalculator({
+      isDynamic: true,
+      timeShiftBufferDepth: 3,
+      availabilityStartTime: 7,
+      serverTimestampOffset: 1000,
+    });
+    expect(manifestBoundsCalculator.getEstimatedMaximumPosition(4))
+      .toEqual(5 + 1 - 7 + 4);
+    manifestBoundsCalculator.setLastPosition(1050, 0);
+    performanceNow = 70000;
+    expect(manifestBoundsCalculator.getEstimatedMaximumPosition(11))
+      .toEqual(5 + 1 - 7 + 11 + 70 - 5);
+    performanceNow = 85000;
+    expect(manifestBoundsCalculator.getEstimatedMaximumPosition(98))
+      .toEqual(5 + 1 - 7 + 98 + 85 - 5);
+    manifestBoundsCalculator.setLastPosition(0, 10);
+    expect(manifestBoundsCalculator.getEstimatedMaximumPosition(43))
+      .toEqual(5 + 1 - 7 + 43 + 85 - 5);
     mockPerformanceNow.mockRestore();
   });
 });

package/src/parsers/manifest/dash/common/indexes/base.ts

@@ -27,6 +27,7 @@ import {
   IIndexSegment,
   toIndexTime,
 } from "../../../utils/index_helpers";
+import ManifestBoundsCalculator from "../manifest_bounds_calculator";
 import getInitSegment from "./get_init_segment";
 import getSegmentsFromTimeline from "./get_segments_from_timeline";
 import { constructRepresentationUrl } from "./tokens";
@@ -121,6 +122,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;
   /* Function that tells if an EMSG is whitelisted by the manifest */
   isEMSGWhitelisted: (inbandEvent: IEMSG) => boolean;
 }
@@ -180,6 +183,9 @@ export default class BaseRepresentationIndex implements IRepresentationIndex {
   /** Absolute end of the period, timescaled and converted to index time. */
   private _scaledPeriodEnd : number | undefined;
 
+  /** Allows to obtain the minimum and maximum positions of a content. */
+  private _manifestBoundsCalculator : ManifestBoundsCalculator;
+
   /* Function that tells if an EMSG is whitelisted by the manifest */
   private _isEMSGWhitelisted: (inbandEvent: IEMSG) => boolean;
 
@@ -229,6 +235,7 @@ export default class BaseRepresentationIndex implements IRepresentationIndex {
                     endNumber: index.endNumber,
                     timeline: index.timeline ?? [],
                     timescale };
+    this._manifestBoundsCalculator = context.manifestBoundsCalculator;
     this._scaledPeriodStart = toIndexTime(periodStart, this._index);
     this._scaledPeriodEnd = periodEnd == null ? undefined :
                                                 toIndexTime(periodEnd, this._index);
@@ -262,8 +269,9 @@ export default class BaseRepresentationIndex implements IRepresentationIndex {
     return getSegmentsFromTimeline(this._index,
                                    from,
                                    dur,
-                                   this._isEMSGWhitelisted,
-                                   this._scaledPeriodEnd);
+                                   this._manifestBoundsCalculator,
+                                   this._scaledPeriodEnd,
+                                   this._isEMSGWhitelisted);
   }
 
   /**
@@ -360,8 +368,8 @@ export default class BaseRepresentationIndex implements IRepresentationIndex {
    * should become available in the future.
    * @returns {Boolean}
    */
-  isFinished() : true {
-    return true;
+  isStillAwaitingFutureSegments() : false {
+    return false;
   }
 
   /**

package/src/parsers/manifest/dash/common/indexes/get_segments_from_timeline.ts

@@ -21,6 +21,7 @@ import {
   IIndexSegment,
   toIndexTime,
 } from "../../../utils/index_helpers";
+import ManifestBoundsCalculator from "../manifest_bounds_calculator";
 import { createDashUrlDetokenizer } from "./tokens";
 
 /**
@@ -47,12 +48,14 @@ function getWantedRepeatIndex(
  * @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;
@@ -61,11 +64,16 @@ export default function getSegmentsFromTimeline(
             indexTimeOffset : number; },
   from : number,
   durationWanted : number,
-  isEMSGWhitelisted: (inbandEvent: IEMSG) => boolean,
-  maximumTime? : number
+  manifestBoundsCalculator : ManifestBoundsCalculator,
+  scaledPeriodEnd : number | undefined,
+  isEMSGWhitelisted: (inbandEvent: IEMSG) => boolean
 ) : ISegment[] {
+  const maximumTime = manifestBoundsCalculator.getEstimatedMaximumPosition(
+    index.availabilityTimeOffset ?? 0
+  );
+  const wantedMaximum = Math.min(from + durationWanted, maximumTime ?? Infinity);
   const scaledUp = toIndexTime(from, index);
-  const scaledTo = toIndexTime(from + durationWanted, index);
+  const scaledTo = toIndexTime(wantedMaximum, index);
   const { timeline, timescale, segmentUrlTemplate, startNumber, endNumber } = index;
 
   let currentNumber = startNumber ?? 1;
@@ -77,7 +85,13 @@ export default function getSegmentsFromTimeline(
     const timelineItem = timeline[i];
     const { duration, start, range } = timelineItem;
 
-    const repeat = calculateRepeat(timelineItem, timeline[i + 1], maximumTime);
+    let maxRepeatTime;
+    if (maximumTime === undefined) {
+      maxRepeatTime = scaledPeriodEnd;
+    } else {
+      maxRepeatTime = Math.min(maximumTime * timescale, scaledPeriodEnd ?? Infinity);
+    }
+    const repeat = calculateRepeat(timelineItem, timeline[i + 1], maxRepeatTime);
     const complete = index.availabilityTimeComplete !== false ||
                      i !== timelineLength - 1 &&
                      repeat !== 0;

package/src/parsers/manifest/dash/common/indexes/index.ts

@@ -14,14 +14,26 @@
  * limitations under the License.
  */
 
-import BaseRepresentationIndex from "./base";
-import ListRepresentationIndex from "./list";
-import TemplateRepresentationIndex from "./template";
-import TimelineRepresentationIndex from "./timeline";
+import BaseRepresentationIndex, {
+  IBaseIndexContextArgument,
+} from "./base";
+import ListRepresentationIndex, {
+  IListIndexContextArgument,
+} from "./list";
+import TemplateRepresentationIndex, {
+  ITemplateIndexContextArgument,
+} from "./template";
+import TimelineRepresentationIndex, {
+  ITimelineIndexContextArgument,
+} from "./timeline";
 
 export {
   BaseRepresentationIndex,
   ListRepresentationIndex,
   TemplateRepresentationIndex,
   TimelineRepresentationIndex,
+  IBaseIndexContextArgument,
+  IListIndexContextArgument,
+  ITemplateIndexContextArgument,
+  ITimelineIndexContextArgument,
 };

package/src/parsers/manifest/dash/common/indexes/list.ts

@@ -314,8 +314,8 @@ export default class ListRepresentationIndex implements IRepresentationIndex {
   /**
    * @returns {Boolean}
    */
-  isFinished() : true {
-    return true;
+  isStillAwaitingFutureSegments() : false {
+    return false;
   }
 
   /**