rx-player 3.28.0 → 3.28.1-dev.2022083000

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

@@ -19,15 +19,16 @@ import {
   IRepresentationIndex,
   ISegment,
 } from "../../../../../manifest";
+import assert from "../../../../../utils/assert";
 import { IEMSG } from "../../../../containers/isobmff";
 import ManifestBoundsCalculator from "../manifest_bounds_calculator";
 import { IResolvedBaseUrl } from "../resolve_base_urls";
 import getInitSegment from "./get_init_segment";
-import isPeriodFulfilled from "./is_period_fulfilled";
 import {
   createDashUrlDetokenizer,
   createIndexURLs,
 } from "./tokens";
+import { getSegmentTimeRoundingError } from "./utils";
 
 
 /**
@@ -59,6 +60,7 @@ export interface ITemplateIndex {
   /**
    * URL base to access any segment.
    * Can contain token to replace to convert it to real URLs.
+   * `null` if no URL exists.
    */
   mediaURLs : string[] | null;
   /**
@@ -150,7 +152,7 @@ export default class TemplateRepresentationIndex implements IRepresentationIndex
   /** Absolute start of the Period, in seconds. */
   private _periodStart : number;
   /** Difference between the end time of the Period and its start time, in timescale. */
-  private _scaledPeriodEnd : number | undefined;
+  private _scaledRelativePeriodEnd : number | undefined;
   /** Minimum availabilityTimeOffset concerning the segments of this Representation. */
   private _availabilityTimeOffset : number | undefined;
   /** Whether the corresponding Manifest can be updated and changed. */
@@ -218,7 +220,7 @@ export default class TemplateRepresentationIndex implements IRepresentationIndex
                     startNumber: index.startNumber };
     this._isDynamic = isDynamic;
     this._periodStart = periodStart;
-    this._scaledPeriodEnd = periodEnd === undefined ?
+    this._scaledRelativePeriodEnd = periodEnd === undefined ?
       undefined :
       (periodEnd - periodStart) * timescale;
     this._isEMSGWhitelisted = isEMSGWhitelisted;
@@ -245,7 +247,7 @@ export default class TemplateRepresentationIndex implements IRepresentationIndex
             mediaURLs } = index;
 
     const scaledStart = this._periodStart * timescale;
-    const scaledEnd = this._scaledPeriodEnd;
+    const scaledEnd = this._scaledRelativePeriodEnd;
 
     // Convert the asked position to the right timescales, and consider them
     // relatively to the Period's start.
@@ -315,7 +317,7 @@ export default class TemplateRepresentationIndex implements IRepresentationIndex
    * Returns first possible position in the index, in seconds.
    * @returns {number|null|undefined}
    */
-  getFirstPosition() : number | null | undefined {
+  getFirstAvailablePosition() : number | null | undefined {
     const firstSegmentStart = this._getFirstSegmentStart();
     if (firstSegmentStart == null) {
       return firstSegmentStart; // return undefined or null
@@ -327,22 +329,70 @@ export default class TemplateRepresentationIndex implements IRepresentationIndex
    * Returns last possible position in the index, in seconds.
    * @returns {number|null}
    */
-  getLastPosition() : number|null|undefined {
+  getLastAvailablePosition() : number|null|undefined {
     const lastSegmentStart = this._getLastSegmentStart();
     if (lastSegmentStart == null) {
-      // In that case (null or undefined), getLastPosition should reflect
+      // In that case (null or undefined), getLastAvailablePosition should reflect
       // the result of getLastSegmentStart, as the meaning is the same for
       // the two functions. So, we return the result of the latter.
       return lastSegmentStart;
     }
 
-    const lastSegmentEnd = Math.min(
-      lastSegmentStart + this._index.duration,
-      this._scaledPeriodEnd ?? Infinity
-    );
+    const lastSegmentEnd = Math.min(lastSegmentStart + this._index.duration,
+                                    this._scaledRelativePeriodEnd ?? Infinity);
     return (lastSegmentEnd / this._index.timescale) + this._periodStart;
   }
 
+  /**
+   * Returns the absolute end in seconds this RepresentationIndex can reach once
+   * all segments are available.
+   * @returns {number|null|undefined}
+   */
+  getEnd(): number | null | undefined {
+    if (!this._isDynamic) {
+      return this.getLastAvailablePosition();
+    }
+    if (this._scaledRelativePeriodEnd === undefined) {
+      return undefined;
+    }
+    const { timescale } = this._index;
+    const absoluteScaledPeriodEnd = (this._scaledRelativePeriodEnd +
+                                     this._periodStart * timescale);
+    return  absoluteScaledPeriodEnd / this._index.timescale;
+  }
+
+  /**
+   * Returns:
+   *   - `true` if in the given time interval, at least one new segment is
+   *     expected to be available in the future.
+   *   - `false` either if all segments in that time interval are already
+   *     available for download or if none will ever be available for it.
+   *   - `undefined` when it is not possible to tell.
+   *
+   * Always `false` in a `BaseRepresentationIndex` because all segments should
+   * be directly available.
+   * @returns {boolean}
+   */
+  awaitSegmentBetween(start: number, end: number): boolean | undefined {
+    assert(start <= end);
+    if (!this._isDynamic) {
+      return false;
+    }
+
+    const { timescale } = this._index;
+    const segmentTimeRounding = getSegmentTimeRoundingError(timescale);
+    const scaledPeriodStart = this._periodStart * timescale;
+    const scaledRelativeEnd = end * timescale - scaledPeriodStart;
+    if (this._scaledRelativePeriodEnd === undefined) {
+      return (scaledRelativeEnd + segmentTimeRounding) >= 0;
+    }
+
+    const scaledRelativePeriodEnd = this._scaledRelativePeriodEnd;
+    const scaledRelativeStart = start * timescale - scaledPeriodStart;
+    return (scaledRelativeStart - segmentTimeRounding) < scaledRelativePeriodEnd &&
+           (scaledRelativeEnd + segmentTimeRounding) >= 0;
+  }
+
   /**
    * Returns true if, based on the arguments, the index should be refreshed.
    * We never have to refresh a SegmentTemplate-based manifest.
@@ -360,13 +410,6 @@ export default class TemplateRepresentationIndex implements IRepresentationIndex
     return null;
   }
 
-  /**
-   * @returns {Boolean}
-   */
-  areSegmentsChronologicallyGenerated() : true {
-    return true;
-  }
-
   /**
    * Returns `true` if the given segment should still be available as of now
    * (not removed since and still request-able).
@@ -403,7 +446,7 @@ export default class TemplateRepresentationIndex implements IRepresentationIndex
     if (!this._isDynamic) {
       return true;
     }
-    if (this._scaledPeriodEnd === undefined) {
+    if (this._scaledRelativePeriodEnd === undefined) {
       return false;
     }
 
@@ -416,7 +459,8 @@ export default class TemplateRepresentationIndex implements IRepresentationIndex
       return false;
     }
     const lastSegmentEnd = lastSegmentStart + this._index.duration;
-    return isPeriodFulfilled(timescale, lastSegmentEnd, this._scaledPeriodEnd);
+    const segmentTimeRounding = getSegmentTimeRoundingError(timescale);
+    return (lastSegmentEnd + segmentTimeRounding) >= this._scaledRelativePeriodEnd;
   }
 
   /**
@@ -434,7 +478,7 @@ export default class TemplateRepresentationIndex implements IRepresentationIndex
     this._aggressiveMode = newIndex._aggressiveMode;
     this._isDynamic = newIndex._isDynamic;
     this._periodStart = newIndex._periodStart;
-    this._scaledPeriodEnd = newIndex._scaledPeriodEnd;
+    this._scaledRelativePeriodEnd = newIndex._scaledRelativePeriodEnd;
     this._manifestBoundsCalculator = newIndex._manifestBoundsCalculator;
   }
 
@@ -458,7 +502,9 @@ export default class TemplateRepresentationIndex implements IRepresentationIndex
     }
 
     // 1 - check that this index is already available
-    if (this._scaledPeriodEnd === 0 || this._scaledPeriodEnd === undefined) {
+    if (this._scaledRelativePeriodEnd === 0 ||
+        this._scaledRelativePeriodEnd === undefined)
+    {
       // /!\ The scaled max position augments continuously and might not
       // reflect exactly the real server-side value. As segments are
       // generated discretely.
@@ -499,13 +545,13 @@ export default class TemplateRepresentationIndex implements IRepresentationIndex
       }
       const agressiveModeOffset = this._aggressiveMode ? (duration / timescale) :
                                                          0;
-      if (this._scaledPeriodEnd != null &&
-          this._scaledPeriodEnd <
+      if (this._scaledRelativePeriodEnd != null &&
+          this._scaledRelativePeriodEnd <
             (lastPos + agressiveModeOffset - this._periodStart) * this._index.timescale) {
-        if (this._scaledPeriodEnd < duration) {
+        if (this._scaledRelativePeriodEnd < duration) {
           return null;
         }
-        return (Math.floor(this._scaledPeriodEnd / duration) - 1)  * duration;
+        return (Math.floor(this._scaledRelativePeriodEnd / duration) - 1)  * duration;
       }
       // /!\ The scaled last position augments continuously and might not
       // reflect exactly the real server-side value. As segments are
@@ -529,7 +575,7 @@ export default class TemplateRepresentationIndex implements IRepresentationIndex
                null :
                (numberOfSegmentsAvailable - 1) * duration;
     } else {
-      const maximumTime = this._scaledPeriodEnd ?? 0;
+      const maximumTime = this._scaledRelativePeriodEnd ?? 0;
       const numberIndexedToZero = Math.ceil(maximumTime / duration) - 1;
       const regularLastSegmentStart = numberIndexedToZero * duration;
 

package/src/parsers/manifest/dash/common/indexes/timeline/timeline_representation_index.ts

@@ -23,6 +23,7 @@ import {
   Representation,
 } from "../../../../../../manifest";
 import { IPlayerError } from "../../../../../../public_types";
+import assert from "../../../../../../utils/assert";
 import { IEMSG } from "../../../../../containers/isobmff";
 import clearTimelineFromPosition from "../../../../utils/clear_timeline_from_position";
 import {
@@ -39,8 +40,8 @@ import ManifestBoundsCalculator from "../../manifest_bounds_calculator";
 import { IResolvedBaseUrl } from "../../resolve_base_urls";
 import getInitSegment from "../get_init_segment";
 import getSegmentsFromTimeline from "../get_segments_from_timeline";
-import isPeriodFulfilled from "../is_period_fulfilled";
 import { createIndexURLs } from "../tokens";
+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";
@@ -363,7 +364,7 @@ export default class TimelineRepresentationIndex implements IRepresentationIndex
    * Returns null if nothing is in the index
    * @returns {Number|null}
    */
-  getFirstPosition() : number|null {
+  getFirstAvailablePosition(): number | null {
     this._refreshTimeline();
     if (this._index.timeline === null) {
       this._index.timeline = this._getTimeline();
@@ -381,7 +382,7 @@ export default class TimelineRepresentationIndex implements IRepresentationIndex
    * Returns null if nothing is in the index
    * @returns {Number|null}
    */
-  getLastPosition() : number|null {
+  getLastAvailablePosition(): number | null {
     this._refreshTimeline();
     if (this._index.timeline === null) {
       this._index.timeline = this._getTimeline();
@@ -392,6 +393,60 @@ export default class TimelineRepresentationIndex implements IRepresentationIndex
                                fromIndexTime(lastTime, this._index);
   }
 
+  /**
+   * Returns the absolute end in seconds this RepresentationIndex can reach once
+   * all segments are available.
+   * @returns {number|null|undefined}
+   */
+  getEnd(): number | undefined | null {
+    if (!this._isDynamic || !this._isLastPeriod) { // @see isFinished
+      return this.getLastAvailablePosition();
+    }
+    return undefined;
+  }
+
+  /**
+   * Returns:
+   *   - `true` if in the given time interval, at least one new segment is
+   *     expected to be available in the future.
+   *   - `false` either if all segments in that time interval are already
+   *     available for download or if none will ever be available for it.
+   *   - `undefined` when it is not possible to tell.
+   * @param {number} start
+   * @param {number} end
+   * @returns {boolean|undefined}
+   */
+  awaitSegmentBetween(start: number, end: number): boolean | undefined {
+    assert(start <= end);
+    if (!this._isDynamic || !this._isLastPeriod) {
+      return false;
+    }
+    this._refreshTimeline();
+    if (this._index.timeline === null) {
+      this._index.timeline = this._getTimeline();
+    }
+    const { timeline, timescale } = 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, this._scaledPeriodEnd ?? Infinity)) {
+        return false; // already loaded
+      }
+    }
+    if (this._scaledPeriodEnd === undefined) {
+      return (scaledEnd + segmentTimeRounding) > this._scaledPeriodStart ? undefined :
+                                                                           false;
+    }
+    const scaledStart = toIndexTime(start, this._index);
+    return (scaledStart - segmentTimeRounding) < this._scaledPeriodEnd &&
+           (scaledEnd + segmentTimeRounding) > this._scaledPeriodStart;
+  }
+
   /**
    * Returns true if a Segment returned by this index is still considered
    * available.
@@ -446,10 +501,6 @@ export default class TimelineRepresentationIndex implements IRepresentationIndex
            error.isHttpError(404);
   }
 
-  areSegmentsChronologicallyGenerated() : boolean {
-    return true;
-  }
-
   /**
    * Replace this RepresentationIndex with one from a new version of the
    * Manifest.
@@ -518,7 +569,8 @@ export default class TimelineRepresentationIndex implements IRepresentationIndex
     const lastTime = getIndexSegmentEnd(lastTimelineElement,
                                         null,
                                         this._scaledPeriodEnd);
-    return isPeriodFulfilled(this._index.timescale, lastTime, this._scaledPeriodEnd);
+    const segmentTimeRounding = getSegmentTimeRoundingError(this._index.timescale);
+    return (lastTime + segmentTimeRounding) >= this._scaledPeriodEnd;
   }
 
   /**

package/src/parsers/manifest/dash/common/indexes/{is_period_fulfilled.ts → utils.ts}

@@ -21,21 +21,12 @@ import config from "../../../../../config";
  * In Javascript, numbers are encoded in a way that a floating number may be
  * represented internally with a rounding error.
  *
- * As the period end is the result of a multiplication between a floating or integer
- * number (period end * timescale), this function takes into account the potential
- * rounding error to tell if the period is fulfilled with content.
+ * This function returns a small number allowing to accound for rounding many
+ * rounding errors.
  * @param {number} timescale
- * @param {number} lastSegmentEnd
- * @param {number} periodEnd
  * @returns {boolean}
  */
-export default function isPeriodFulfilled(
-  timescale: number,
-  lastSegmentEnd: number,
-  periodEnd: number
-): boolean {
-  const scaledRoundingError =
-    config.getCurrent().DEFAULT_MAXIMUM_TIME_ROUNDING_ERROR * timescale;
-  return (lastSegmentEnd + scaledRoundingError) >= periodEnd;
+export function getSegmentTimeRoundingError(timescale: number): number {
+  return config.getCurrent().DEFAULT_MAXIMUM_TIME_ROUNDING_ERROR * timescale;
 }
 

package/src/parsers/manifest/dash/common/parse_periods.ts

@@ -250,7 +250,7 @@ function getMaximumLastPosition(
   for (const adaptation of allAdaptations) {
     const representations = adaptation.representations;
     for (const representation of representations) {
-      const position = representation.index.getLastPosition();
+      const position = representation.index.getLastAvailablePosition();
       if (position !== null) {
         allIndexAreEmpty = false;
         if (typeof position === "number") {

package/src/parsers/manifest/local/parse_local_manifest.ts

@@ -51,14 +51,13 @@ export default function parseLocalManifest(
           maximumPosition,
           isFinished } = localManifest;
   const parsedPeriods = localManifest.periods
-    .map(period => parsePeriod(period, { periodIdGenerator,
-                                         isFinished }));
+    .map(period => parsePeriod(period, { periodIdGenerator }));
 
   return { availabilityStartTime: 0,
            expired: localManifest.expired,
            transportType: "local",
            isDynamic: !isFinished,
-           isLastPeriodKnown: isFinished,
+           isLastPeriodKnown: true,
            isLive: false,
            uris: [],
            timeBounds: { minimumSafePosition: minimumPosition ?? 0,
@@ -77,11 +76,8 @@ export default function parseLocalManifest(
  */
 function parsePeriod(
   period : ILocalPeriod,
-  ctxt : { periodIdGenerator : () => string; /* Generate next Period's id */
-           /** If true, the local Manifest has been fully downloaded. */
-           isFinished : boolean; }
+  ctxt : { periodIdGenerator : () => string /* Generate next Period's id */ }
 ) : IParsedPeriod {
-  const { isFinished } = ctxt;
   const adaptationIdGenerator = idGenerator();
   return {
     id: "period-" + ctxt.periodIdGenerator(),
@@ -97,8 +93,7 @@ function parsePeriod(
           adaps = [];
           acc[type] = adaps;
         }
-        adaps.push(parseAdaptation(ada, { adaptationIdGenerator,
-                                          isFinished }));
+        adaps.push(parseAdaptation(ada, { adaptationIdGenerator }));
         return acc;
       }, {}),
   };
@@ -111,11 +106,8 @@ function parsePeriod(
  */
 function parseAdaptation(
   adaptation : ILocalAdaptation,
-  ctxt : { adaptationIdGenerator : () => string; /* Generate next Adaptation's id */
-           /** If true, the local Manifest has been fully downloaded. */
-           isFinished : boolean; }
+  ctxt : { adaptationIdGenerator : () => string /* Generate next Adaptation's id */ }
 ) : IParsedAdaptation {
-  const { isFinished } = ctxt;
   const representationIdGenerator = idGenerator();
   return {
     id: "adaptation-" + ctxt.adaptationIdGenerator(),
@@ -124,8 +116,7 @@ function parseAdaptation(
     closedCaption: adaptation.closedCaption,
     language: adaptation.language,
     representations: adaptation.representations.map((representation) =>
-      parseRepresentation(representation, { representationIdGenerator,
-                                            isFinished })),
+      parseRepresentation(representation, { representationIdGenerator })),
   };
 }
 
@@ -135,11 +126,8 @@ function parseAdaptation(
  */
 function parseRepresentation(
   representation : ILocalRepresentation,
-  ctxt : { representationIdGenerator : () => string;
-           /** If true, the local Manifest has been fully downloaded. */
-           isFinished : boolean; }
+  ctxt : { representationIdGenerator : () => string }
 ) : IParsedRepresentation {
-  const { isFinished } = ctxt;
   const id = "representation-" + ctxt.representationIdGenerator();
   const contentProtections = representation.contentProtections === undefined ?
     undefined :
@@ -150,7 +138,7 @@ function parseRepresentation(
            width: representation.width,
            codecs: representation.codecs,
            mimeType: representation.mimeType,
-           index: new LocalRepresentationIndex(representation.index, id, isFinished),
+           index: new LocalRepresentationIndex(representation.index, id),
            contentProtections };
 }
 

package/src/parsers/manifest/local/representation_index.ts

@@ -27,11 +27,9 @@ import {
 export default class LocalRepresentationIndex implements IRepresentationIndex {
   private _index : ILocalIndex;
   private _representationId : string;
-  private _isFinished : boolean;
-  constructor(index : ILocalIndex, representationId : string, isFinished : boolean) {
+  constructor(index : ILocalIndex, representationId : string) {
     this._index = index;
     this._representationId = representationId;
-    this._isFinished = isFinished;
   }
 
   /**
@@ -96,7 +94,7 @@ export default class LocalRepresentationIndex implements IRepresentationIndex {
   /**
    * @returns {Number|undefined}
    */
-  getFirstPosition() : number|undefined {
+  getFirstAvailablePosition() : number|undefined {
     if (this._index.segments.length === 0) {
       return undefined;
     }
@@ -107,12 +105,58 @@ export default class LocalRepresentationIndex implements IRepresentationIndex {
   /**
    * @returns {Number|undefined}
    */
-  getLastPosition() : number|undefined {
+  getLastAvailablePosition() : number|undefined {
     if (this._index.segments.length === 0) {
       return undefined;
     }
     const lastSegment = this._index.segments[this._index.segments.length - 1];
-    return lastSegment.time;
+    return lastSegment.time + lastSegment.duration;
+  }
+
+  /**
+   * Returns the expected ending position of this RepresentationIndex.
+   * `undefined` if unknown.
+   * @returns {number|undefined}
+   */
+  getEnd() : number | undefined {
+    if (this._index.isFinished) {
+      return this.getLastAvailablePosition();
+    }
+
+    const { incomingRanges, segments } = this._index;
+    if (incomingRanges === undefined || incomingRanges.length === 0) {
+      // If incomingRanges is empty but not finished... It's ambiguous.
+      return undefined;
+    }
+    const lastIncomingRange = incomingRanges[incomingRanges.length - 1];
+    const futureEnd = lastIncomingRange.end;
+    if (segments.length === 0) {
+      return futureEnd;
+    }
+    const lastSegment = this._index.segments[this._index.segments.length - 1];
+    return Math.max(lastSegment.time + lastSegment.duration, futureEnd);
+  }
+
+  /**
+   * Returns:
+   *   - `true` if in the given time interval, at least one new segment is
+   *     expected to be available in the future.
+   *   - `false` either if all segments in that time interval are already
+   *     available for download or if none will ever be available for it.
+   *   - `undefined` when it is not possible to tell.
+   * @param {number} start
+   * @param {number} end
+   * @returns {boolean|undefined}
+   */
+  awaitSegmentBetween(start: number, end: number): boolean | undefined {
+    if (this.isFinished()) {
+      return false;
+    }
+    if (this._index.incomingRanges === undefined) {
+      return undefined;
+    }
+    return this._index.incomingRanges.some((range) =>
+      range.start < end && range.end > start);
   }
 
   /**
@@ -130,7 +174,7 @@ export default class LocalRepresentationIndex implements IRepresentationIndex {
   }
 
   isFinished() : boolean {
-    return this._isFinished;
+    return this._index.isFinished;
   }
 
   /**
@@ -147,13 +191,6 @@ export default class LocalRepresentationIndex implements IRepresentationIndex {
     return null;
   }
 
-  /**
-   * @returns {boolean}
-   */
-  areSegmentsChronologicallyGenerated() : boolean {
-    return false;
-  }
-
   /**
    * @returns {Boolean}
    */
@@ -162,14 +199,12 @@ export default class LocalRepresentationIndex implements IRepresentationIndex {
   }
 
   _replace(newIndex : LocalRepresentationIndex) : void {
-    this._isFinished = newIndex._isFinished;
     this._index.segments = newIndex._index.segments;
     this._index.loadSegment = newIndex._index.loadSegment;
     this._index.loadInitSegment = newIndex._index.loadInitSegment;
   }
 
   _update(newIndex : LocalRepresentationIndex) : void {
-    this._isFinished = newIndex._isFinished;
     const newSegments = newIndex._index.segments;
     if (newSegments.length <= 0) {
       return;

package/src/parsers/manifest/local/types.ts

@@ -153,6 +153,8 @@ export interface ILocalIndexSegment {
 
 /** "Index" of a `ILocalRepresentation`. Allow to declare available segments. */
 export interface ILocalIndex {
+  /** Every segments in that `ILocalIndex` has been downloaded. */
+  isFinished : boolean;
   /** Callback used to retrieve the initialization segment of a `ILocalRepresentation`. */
   loadInitSegment : ILocalManifestInitSegmentLoader;
   /** Callback used to retrieve a media segment of a `ILocalRepresentation`. */
@@ -162,6 +164,11 @@ export interface ILocalIndex {
    * Doesn't include the initialization segment.
    */
   segments : ILocalIndexSegment[];
+  /**
+   * List of not yet available time ranges, that should become available once
+   * the content is fully loaded.
+   */
+  incomingRanges?: Array<{ start : number; end : number }>;
 }
 
 /** A quality for a given "local" Manifest track (`ILocalAdaptation`). */
@@ -244,6 +251,12 @@ export interface ILocalManifest {
    *            `start` and `duration` from a ILocalPeriod and `time` and
    *            `duration` from a `ILocalIndexSegment` are now in seconds
    *            instead of milliseconds.
+   *
+   *   - "0.3": optional `futureSegments` has been added to `ILocalIndex`
+   *            `duration` has been removed.
+   *
+   *            A mandatory `isFinished` boolean should now be set on a
+   *            `ILocalIndex`.
    */
   version : string;
   /**

package/src/parsers/manifest/metaplaylist/representation_index.ts

@@ -112,8 +112,8 @@ export default class MetaRepresentationIndex implements IRepresentationIndex {
    * `undefined` if we do not know this value.
    * @return {Number|undefined}
    */
-  public getFirstPosition(): number|undefined {
-    const wrappedFirstPosition = this._wrappedIndex.getFirstPosition();
+  public getFirstAvailablePosition(): number|undefined {
+    const wrappedFirstPosition = this._wrappedIndex.getFirstAvailablePosition();
     return wrappedFirstPosition != null ? wrappedFirstPosition + this._timeOffset :
                                           undefined;
   }
@@ -123,12 +123,39 @@ export default class MetaRepresentationIndex implements IRepresentationIndex {
    * `undefined` if we do not know this value.
    * @return {Number|undefined}
    */
-  public getLastPosition(): number|undefined {
-    const wrappedLastPosition = this._wrappedIndex.getLastPosition();
+  public getLastAvailablePosition(): number|undefined {
+    const wrappedLastPosition = this._wrappedIndex.getLastAvailablePosition();
     return wrappedLastPosition != null ? wrappedLastPosition + this._timeOffset :
                                          undefined;
   }
 
+  /**
+   * Returns the absolute end in seconds this RepresentationIndex can reach once
+   * all segments are available.
+   * @returns {number|null|undefined}
+   */
+  public getEnd(): number|undefined|null {
+    const wrappedEnd = this._wrappedIndex.getEnd();
+    return wrappedEnd != null ? wrappedEnd + this._timeOffset :
+                                undefined;
+  }
+
+  /**
+   * Returns:
+   *   - `true` if in the given time interval, at least one new segment is
+   *     expected to be available in the future.
+   *   - `false` either if all segments in that time interval are already
+   *     available for download or if none will ever be available for it.
+   *   - `undefined` when it is not possible to tell.
+   * @param {number} start
+   * @param {number} end
+   * @returns {boolean|undefined}
+   */
+  public awaitSegmentBetween(start: number, end: number): boolean | undefined {
+    return this._wrappedIndex.awaitSegmentBetween(start - this._timeOffset,
+                                                  end - this._timeOffset);
+  }
+
   /**
    * Returns `false` if that segment is not currently available in the Manifest
    * (e.g. it corresponds to a segment which is before the current buffer
@@ -166,13 +193,6 @@ export default class MetaRepresentationIndex implements IRepresentationIndex {
     return this._wrappedIndex.checkDiscontinuity(time - this._timeOffset);
   }
 
-  /**
-   * @returns {Boolean}
-   */
-  public areSegmentsChronologicallyGenerated(): boolean {
-    return this._wrappedIndex.areSegmentsChronologicallyGenerated();
-  }
-
   /**
    * @returns {Boolean}
    */