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

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

@@ -20,16 +20,6 @@ import getMonotonicTimeStamp from "../../../../utils/monotonic_timestamp";
  * This class allows to easily calculate the first and last available positions
  * in a content at any time.
  *
- * That task can be an hard for dynamic DASH contents: it depends on a
- * `timeShiftBufferDepth` defined in the MPD and on the maximum possible
- * position.
- *
- * The latter can come from either a clock synchronization mechanism or the
- * indexing schemes (e.g. SegmentTemplate, SegmentTimeline etc.) of the last
- * Periods.
- * As such, it might only be known once a large chunk of the MPD has already
- * been parsed.
- *
  * By centralizing the manifest bounds calculation in this class and by giving
  * an instance of it to each parsed elements which might depend on it, we
  * ensure that we can provide it once it is known to every one of those
@@ -37,8 +27,18 @@ import getMonotonicTimeStamp from "../../../../utils/monotonic_timestamp";
  * @class ManifestBoundsCalculator
  */
 export default class ManifestBoundsCalculator {
-  /** Value of MPD@timeShiftBufferDepth. */
+  /**
+   * Value of MPD@timeShiftBufferDepth.
+   * `null` if not defined.
+   */
   private _timeShiftBufferDepth : number | null;
+  /**
+   * Value of MPD@availabilityStartTime as an unix timestamp in seconds.
+   * `0` if it wasn't defined.
+   */
+  private _availabilityStartTime : number;
+  /** `true` if MPD@type is equal to "dynamic". */
+  private _isDynamic : boolean;
   /**
    * Monotonically-raising timestamp (the one used by the RxPlayer) when
    * `lastPosition` was calculated.
@@ -46,20 +46,30 @@ export default class ManifestBoundsCalculator {
   private _positionTime : number | undefined;
   /** Last position calculated at a given moment (itself indicated by `_positionTime`. */
   private _lastPosition : number | undefined;
-  /** `true` if MPD@type is equal to "dynamic". */
-  private _isDynamic : boolean;
+  /**
+   * Offset to add to `performance.now` to obtain a good estimation of the
+   * server-side unix timestamp.
+   *
+   * `undefined` if unknown.
+   */
+  private _serverTimestampOffset : number | undefined;
 
   /**
    * @param {Object} args
    */
-  constructor(args : { timeShiftBufferDepth : number | undefined;
-                       isDynamic : boolean; }
-  ) {
+  constructor(args : {
+    availabilityStartTime : number;
+    timeShiftBufferDepth : number | undefined;
+    isDynamic : boolean;
+    serverTimestampOffset: number | undefined;
+  }) {
     this._isDynamic = args.isDynamic;
     this._timeShiftBufferDepth = !args.isDynamic ||
                                  args.timeShiftBufferDepth === undefined ?
                                    null :
                                    args.timeShiftBufferDepth;
+    this._serverTimestampOffset = args.serverTimestampOffset;
+    this._availabilityStartTime = args.availabilityStartTime;
   }
 
   /**
@@ -102,11 +112,12 @@ export default class ManifestBoundsCalculator {
    * Consider that it is only an estimation, not the real value.
    * @return {number|undefined}
    */
-  estimateMinimumBound(): number | undefined {
+  getEstimatedMinimumSegmentTime(): number | undefined {
     if (!this._isDynamic || this._timeShiftBufferDepth === null) {
       return 0;
     }
-    const maximumBound = this.estimateMaximumBound();
+    const maximumBound = this.getEstimatedLiveEdge() ??
+                         this.getEstimatedMaximumPosition(0);
     if (maximumBound === undefined) {
       return undefined;
     }
@@ -115,15 +126,42 @@ export default class ManifestBoundsCalculator {
   }
 
   /**
-   * 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 {
-    if (this._isDynamic &&
-        this._positionTime != null &&
-        this._lastPosition != null)
-    {
+  getEstimatedLiveEdge() : number | undefined {
+    if (!this._isDynamic || this._serverTimestampOffset === undefined) {
+      return undefined;
+    }
+    return (getMonotonicTimeStamp() + this._serverTimestampOffset) / 1000 -
+      this._availabilityStartTime;
+  }
+
+  /**
+   * Produce a rough estimate of the ending time of the last requestable segment
+   * in that content.
+   *
+   * This value is only an estimate and may be far from reality.
+   *
+   * The `availabilityTimeOffset` in argument is the corresponding
+   * `availabilityTimeOffset` that applies to the current wanted segment, or `0`
+   * if none exist. It will be applied on live content to deduce the maximum
+   * segment time available.
+   */
+  getEstimatedMaximumPosition(availabilityTimeOffset: number) : number | undefined {
+    if (!this._isDynamic) {
+      return this._lastPosition;
+    }
+
+    const liveEdge = this.getEstimatedLiveEdge();
+    if (liveEdge !== undefined && availabilityTimeOffset !== Infinity) {
+      return liveEdge + availabilityTimeOffset;
+    } else if (this._positionTime !== undefined && this._lastPosition !== undefined) {
       return Math.max((this._lastPosition - this._positionTime) +
                         (getMonotonicTimeStamp() / 1000),
                       0);

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

@@ -281,12 +281,19 @@ export default function parseAdaptationSets(
       roles.some((role) => role.schemeIdUri === "urn:mpeg:dash:role:2011");
 
     const representationsIR = adaptation.children.representations;
+
     const availabilityTimeComplete =
       adaptation.attributes.availabilityTimeComplete ??
       context.availabilityTimeComplete;
-    const availabilityTimeOffset =
-      (adaptation.attributes.availabilityTimeOffset ?? 0) +
-      context.availabilityTimeOffset;
+
+    let availabilityTimeOffset;
+    if (
+      adaptation.attributes.availabilityTimeOffset !== undefined ||
+      context.availabilityTimeOffset !== undefined
+    ) {
+      availabilityTimeOffset = (adaptation.attributes.availabilityTimeOffset ?? 0) +
+                               (context.availabilityTimeOffset ?? 0);
+    }
 
     const adaptationMimeType = adaptation.attributes.mimeType;
     const adaptationCodecs = adaptation.attributes.codecs;
@@ -327,7 +334,6 @@ export default function parseAdaptationSets(
       parentSegmentTemplates,
       receivedTime: context.receivedTime,
       start: context.start,
-      timeShiftBufferDepth: context.timeShiftBufferDepth,
       unsafelyBaseOnPreviousAdaptation: null,
     };
 

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

@@ -30,6 +30,7 @@ import { IResponseData } from "../parsers_types";
 import getClockOffset from "./get_clock_offset";
 import getHTTPUTCTimingURL from "./get_http_utc-timing_url";
 import getMinimumAndMaximumPositions from "./get_minimum_and_maximum_positions";
+import ManifestBoundsCalculator from "./manifest_bounds_calculator";
 import parseAvailabilityStartTime from "./parse_availability_start_time";
 import parsePeriods, {
   IXLinkInfos,
@@ -252,11 +253,19 @@ function parseCompleteIntermediateRepresentation(
   const { externalClockOffset: clockOffset,
           unsafelyBaseOnPreviousManifest } = args;
 
+  const { externalClockOffset } = args;
+  const manifestBoundsCalculator = new ManifestBoundsCalculator({
+    availabilityStartTime,
+    isDynamic,
+    timeShiftBufferDepth,
+    serverTimestampOffset: externalClockOffset,
+  });
   const manifestInfos = { availabilityStartTime,
                           baseURLs: mpdBaseUrls,
                           clockOffset,
                           duration: rootAttributes.duration,
                           isDynamic,
+                          manifestBoundsCalculator,
                           manifestProfiles: mpdIR.attributes.profiles,
                           receivedTime: args.manifestReceivedTime,
                           timeShiftBufferDepth,
@@ -313,31 +322,33 @@ function parseCompleteIntermediateRepresentation(
                         livePosition: undefined,
                         time: now };
   } else {
-    minimumTime = minimumSafePosition;
-    timeshiftDepth = timeShiftBufferDepth ?? null;
+    // Determine the maximum seekable position
     let finalMaximumSafePosition : number;
-    let livePosition;
-
-    if (maximumUnsafePosition !== undefined) {
-      livePosition = maximumUnsafePosition;
-    }
-
     if (maximumSafePosition !== undefined) {
       finalMaximumSafePosition = maximumSafePosition;
     } else {
-      const ast = availabilityStartTime ?? 0;
-      const { externalClockOffset } = args;
       if (externalClockOffset === undefined) {
         log.warn("DASH Parser: use system clock to define maximum position");
-        finalMaximumSafePosition = (Date.now() / 1000) - ast;
+        finalMaximumSafePosition = (Date.now() / 1000) - availabilityStartTime;
       } else {
         const serverTime = getMonotonicTimeStamp() + externalClockOffset;
-        finalMaximumSafePosition = (serverTime / 1000) - ast;
+        finalMaximumSafePosition = (serverTime / 1000) - availabilityStartTime;
       }
     }
+
+    // Determine live edge (what position corresponds to live content, can be
+    // inferior or superior to the maximum anounced position in some specific
+    // scenarios). However, the `timeShiftBufferDepth` should be based on it.
+    let livePosition = manifestBoundsCalculator.getEstimatedLiveEdge();
     if (livePosition === undefined) {
-      livePosition = finalMaximumSafePosition;
+      if (maximumUnsafePosition !== undefined) {
+        livePosition = maximumUnsafePosition;
+      } else {
+        livePosition = finalMaximumSafePosition;
+      }
+      // manifestBoundsCalculator.forceLiveEdge(livePosition);
     }
+
     maximumTimeData = { isLinear: true,
                         maximumSafePosition: finalMaximumSafePosition,
                         livePosition,
@@ -345,10 +356,12 @@ function parseCompleteIntermediateRepresentation(
 
     // if the minimum calculated time is even below the buffer depth, perhaps we
     // can go even lower in terms of depth
+    minimumTime = minimumSafePosition;
+    timeshiftDepth = timeShiftBufferDepth ?? null;
     if (timeshiftDepth !== null && minimumTime !== undefined &&
-        finalMaximumSafePosition - minimumTime > timeshiftDepth)
+        livePosition - minimumTime > timeshiftDepth)
     {
-      timeshiftDepth = finalMaximumSafePosition - minimumTime;
+      timeshiftDepth = livePosition - minimumTime;
     }
   }
 

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

@@ -18,6 +18,7 @@ import log from "../../../../log";
 import Manifest from "../../../../manifest";
 import flatMap from "../../../../utils/flat_map";
 import idGenerator from "../../../../utils/id_generator";
+import isNullOrUndefined from "../../../../utils/is_null_or_undefined";
 import getMonotonicTimeStamp from "../../../../utils/monotonic_timestamp";
 import objectValues from "../../../../utils/object_values";
 import { utf8ToStr } from "../../../../utils/string_parsing";
@@ -34,7 +35,6 @@ import {
 // eslint-disable-next-line max-len
 import flattenOverlappingPeriods from "./flatten_overlapping_periods";
 import getPeriodsTimeInformation from "./get_periods_time_infos";
-import ManifestBoundsCalculator from "./manifest_bounds_calculator";
 import parseAdaptationSets, {
   IAdaptationSetContext,
 } from "./parse_adaptation_sets";
@@ -68,12 +68,9 @@ export default function parsePeriods(
     throw new Error("MPD parsing error: the time information are incoherent.");
   }
 
-  const { isDynamic,
-          timeShiftBufferDepth } = context;
-  const manifestBoundsCalculator = new ManifestBoundsCalculator({ isDynamic,
-                                                                  timeShiftBufferDepth });
+  const { isDynamic, manifestBoundsCalculator } = context;
 
-  if (!isDynamic && context.duration != null) {
+  if (!isDynamic && !isNullOrUndefined(context.duration)) {
     manifestBoundsCalculator.setLastPosition(context.duration);
   }
 
@@ -91,7 +88,7 @@ export default function parsePeriods(
             periodEnd } = periodsTimeInformation[i];
 
     let periodID : string;
-    if (periodIR.attributes.id == null) {
+    if (isNullOrUndefined(periodIR.attributes.id)) {
       log.warn("DASH: No usable id found in the Period. Generating one.");
       periodID = "gen-dash-period-" + generatePeriodID();
     } else {
@@ -109,8 +106,8 @@ export default function parsePeriods(
     const unsafelyBaseOnPreviousPeriod = context
       .unsafelyBaseOnPreviousManifest?.getPeriod(periodID) ?? null;
 
-    const availabilityTimeComplete = periodIR.attributes.availabilityTimeComplete ?? true;
-    const availabilityTimeOffset = periodIR.attributes.availabilityTimeOffset ?? 0;
+    const availabilityTimeComplete = periodIR.attributes.availabilityTimeComplete;
+    const availabilityTimeOffset = periodIR.attributes.availabilityTimeOffset;
     const { manifestProfiles } = context;
     const { segmentTemplate } = periodIR.children;
     const adapCtxt : IAdaptationSetContext = { availabilityTimeComplete,
@@ -124,7 +121,6 @@ export default function parsePeriods(
                                                receivedTime,
                                                segmentTemplate,
                                                start: periodStart,
-                                               timeShiftBufferDepth,
                                                unsafelyBaseOnPreviousPeriod };
     const adaptations = parseAdaptationSets(periodIR.children.adaptations, adapCtxt);
 
@@ -208,7 +204,7 @@ function guessLastPositionFromClock(
   context : IPeriodContext,
   minimumTime : number
 ) : [number, number] | undefined {
-  if (context.clockOffset != null) {
+  if (!isNullOrUndefined(context.clockOffset)) {
     const lastPosition = context.clockOffset / 1000 -
       context.availabilityStartTime;
     const positionTime = getMonotonicTimeStamp() / 1000;
@@ -245,7 +241,7 @@ function getMaximumLastPosition(
   let maxEncounteredPosition : number | null = null;
   let allIndexAreEmpty = true;
   const adaptationsVal = objectValues(adaptationsPerType)
-    .filter((ada) : ada is IParsedAdaptation[] => ada != null);
+    .filter((ada) : ada is IParsedAdaptation[] => !isNullOrUndefined(ada));
   const allAdaptations = flatMap(adaptationsVal,
                                  (adaptationsForType) => adaptationsForType);
   for (const adaptation of allAdaptations) {
@@ -256,15 +252,15 @@ function getMaximumLastPosition(
         allIndexAreEmpty = false;
         if (typeof position === "number") {
           maxEncounteredPosition =
-            maxEncounteredPosition == null ? position :
-                                             Math.max(maxEncounteredPosition,
-                                                      position);
+            isNullOrUndefined(maxEncounteredPosition) ? position :
+                                                        Math.max(maxEncounteredPosition,
+                                                                 position);
         }
       }
     }
   }
 
-  if (maxEncounteredPosition != null) {
+  if (!isNullOrUndefined(maxEncounteredPosition)) {
     return maxEncounteredPosition;
   } else if (allIndexAreEmpty) {
     return null;
@@ -369,6 +365,5 @@ type IInheritedAdaptationContext = Omit<IAdaptationSetContext,
                                         "availabilityTimeOffset" |
                                         "duration" |
                                         "isLastPeriod" |
-                                        "manifestBoundsCalculator" |
                                         "start" |
                                         "unsafelyBaseOnPreviousPeriod">;

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

@@ -31,6 +31,10 @@ import {
   ListRepresentationIndex,
   TemplateRepresentationIndex,
   TimelineRepresentationIndex,
+  IBaseIndexContextArgument,
+  IListIndexContextArgument,
+  ITemplateIndexContextArgument,
+  ITimelineIndexContextArgument,
 } from "./indexes";
 import ManifestBoundsCalculator from "./manifest_bounds_calculator";
 import { IResolvedBaseUrl } from "./resolve_base_urls";
@@ -52,7 +56,6 @@ export default function parseRepresentationIndex(
           end: periodEnd,
           start: periodStart,
           receivedTime,
-          timeShiftBufferDepth,
           unsafelyBaseOnPreviousRepresentation,
           inbandEventStreams,
           isLastPeriod } = context;
@@ -64,19 +67,24 @@ export default function parseRepresentationIndex(
     return inbandEventStreams
       .some(({ schemeIdUri }) => schemeIdUri === inbandEvent.schemeIdUri);
   };
-  const reprIndexCtxt = { availabilityTimeComplete: true,
-                          availabilityTimeOffset,
-                          unsafelyBaseOnPreviousRepresentation,
-                          isEMSGWhitelisted,
-                          isLastPeriod,
-                          manifestBoundsCalculator,
-                          isDynamic,
-                          periodEnd,
-                          periodStart,
-                          receivedTime,
-                          representationBitrate: representation.attributes.bitrate,
-                          representationId: representation.attributes.id,
-                          timeShiftBufferDepth };
+  const reprIndexCtxt: ITimelineIndexContextArgument |
+                       ITemplateIndexContextArgument |
+                       IListIndexContextArgument |
+                       IBaseIndexContextArgument =
+    {
+      availabilityTimeComplete: undefined,
+      availabilityTimeOffset,
+      unsafelyBaseOnPreviousRepresentation,
+      isEMSGWhitelisted,
+      isLastPeriod,
+      manifestBoundsCalculator,
+      isDynamic,
+      periodEnd,
+      periodStart,
+      receivedTime,
+      representationBitrate: representation.attributes.bitrate,
+      representationId: representation.attributes.id,
+    };
   let representationIndex : IRepresentationIndex;
   if (representation.children.segmentBase !== undefined) {
     const { segmentBase } = representation.children;
@@ -97,12 +105,15 @@ export default function parseRepresentationIndex(
                    ...segmentTemplates as [
                      ISegmentTemplateIntermediateRepresentation
                    ] /* Ugly TS Hack */);
-    reprIndexCtxt.availabilityTimeComplete =
-      segmentTemplate.availabilityTimeComplete ??
-      context.availabilityTimeComplete;
-    reprIndexCtxt.availabilityTimeOffset =
-      (segmentTemplate.availabilityTimeOffset ?? 0) +
-      context.availabilityTimeOffset;
+    if (
+      segmentTemplate.availabilityTimeOffset !== undefined ||
+      context.availabilityTimeOffset !== undefined
+    ) {
+      reprIndexCtxt.availabilityTimeOffset =
+        (segmentTemplate.availabilityTimeOffset ?? 0) +
+        (context.availabilityTimeOffset ?? 0);
+    }
+
     representationIndex = TimelineRepresentationIndex
       .isTimelineIndexArgument(segmentTemplate) ?
         new TimelineRepresentationIndex(segmentTemplate, reprIndexCtxt) :
@@ -131,10 +142,25 @@ export default function parseRepresentationIndex(
 export interface IRepresentationIndexContext {
   /** Parsed AdaptationSet which contains the Representation. */
   adaptation : IAdaptationSetIntermediateRepresentation;
-  /** If false, declared segments in the MPD might still be not completely generated. */
-  availabilityTimeComplete : boolean;
-  /** availability time offset of the concerned Adaptation. */
-  availabilityTimeOffset : number;
+  /**
+   * 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;
   /** Eventual URLs from which every relative URL will be based on. */
   baseURLs : IResolvedBaseUrl[];
   /** End time of the current Period, in seconds. */
@@ -163,8 +189,6 @@ export interface IRepresentationIndexContext {
   receivedTime? : number | undefined;
   /** Start time of the current period, in seconds. */
   start : number;
-  /** Depth of the buffer for the whole content, in seconds. */
-  timeShiftBufferDepth? : number | undefined;
   /**
    * The parser should take this Representation - which is the same as this one
    * parsed at an earlier time - as a base to speed-up the parsing process.

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

@@ -153,9 +153,15 @@ export default function parseRepresentations(
     const availabilityTimeComplete =
       representation.attributes.availabilityTimeComplete ??
       context.availabilityTimeComplete;
-    const availabilityTimeOffset =
-      (representation.attributes.availabilityTimeOffset ?? 0) +
-      context.availabilityTimeOffset;
+
+    let availabilityTimeOffset: number | undefined;
+    if (
+      representation.attributes.availabilityTimeOffset !== undefined ||
+      context.availabilityTimeOffset !== undefined
+    ) {
+      availabilityTimeOffset = (representation.attributes.availabilityTimeOffset ?? 0) +
+                               (context.availabilityTimeOffset ?? 0);
+    }
     const reprIndexCtxt = objectAssign({},
                                        context,
                                        { availabilityTimeOffset,

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

@@ -149,7 +149,7 @@ export default class LocalRepresentationIndex implements IRepresentationIndex {
    * @returns {boolean|undefined}
    */
   awaitSegmentBetween(start: number, end: number): boolean | undefined {
-    if (this.isFinished()) {
+    if (this.isStillAwaitingFutureSegments()) {
       return false;
     }
     if (this._index.incomingRanges === undefined) {
@@ -173,8 +173,8 @@ export default class LocalRepresentationIndex implements IRepresentationIndex {
     return true;
   }
 
-  isFinished() : boolean {
-    return this._index.isFinished;
+  isStillAwaitingFutureSegments() : boolean {
+    return !this._index.isFinished;
   }
 
   /**

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

@@ -203,8 +203,8 @@ export default class MetaRepresentationIndex implements IRepresentationIndex {
   /**
    * @returns {Boolean}
    */
-  public isFinished() : boolean {
-    return this._wrappedIndex.isFinished();
+  public isStillAwaitingFutureSegments() : boolean {
+    return this._wrappedIndex.isStillAwaitingFutureSegments();
   }
 
   /**

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

@@ -27,7 +27,6 @@ import {
   checkDiscontinuity,
   getIndexSegmentEnd,
 } from "../utils/index_helpers";
-import isSegmentStillAvailable from "../utils/is_segment_still_available";
 import SharedSmoothSegmentTimeline, {
   IIndexSegment,
 } from "./shared_smooth_segment_timeline";
@@ -423,7 +422,7 @@ export default class SmoothRepresentationIndex implements IRepresentationIndex {
    */
   awaitSegmentBetween(start: number, end: number): boolean | undefined {
     assert(start <= end);
-    if (this.isFinished()) {
+    if (this.isStillAwaitingFutureSegments()) {
       return false;
     }
     const lastAvailablePosition = this.getLastAvailablePosition();
@@ -462,7 +461,22 @@ export default class SmoothRepresentationIndex implements IRepresentationIndex {
     }
     this._refreshTimeline();
     const { timeline, timescale } = this._sharedSmoothTimeline;
-    return isSegmentStillAvailable(segment, timeline, timescale, 0);
+    for (let i = 0; i < timeline.length; i++) {
+      const tSegment = timeline[i];
+      const tSegmentTime = tSegment.start / timescale;
+      if (tSegmentTime > segment.time) {
+        return false; // We went over it without finding it
+      } else if (tSegmentTime === segment.time) {
+        return true;
+      } 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 <= tSegment.repeatCount;
+        }
+      }
+    }
+    return false;
   }
 
   /**
@@ -500,9 +514,9 @@ export default class SmoothRepresentationIndex implements IRepresentationIndex {
   }
 
   /**
-   * 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.
-   * 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.
    *
    * For Smooth, it should only depend on whether the content is a live content
@@ -510,8 +524,8 @@ export default class SmoothRepresentationIndex implements IRepresentationIndex {
    * TODO What about Smooth live content that finishes at some point?
    * @returns {boolean}
    */
-  isFinished() : boolean {
-    return !this._isLive;
+  isStillAwaitingFutureSegments() : boolean {
+    return this._isLive;
   }
 
   /**
@@ -529,8 +543,8 @@ export default class SmoothRepresentationIndex implements IRepresentationIndex {
    * Add segments to a `SharedSmoothSegmentTimeline` that were predicted to come
    * after `currentSegment`.
    * @param {Array.<Object>} nextSegments - The segment information parsed.
-   * @param {Object} segment - Information on the segment which contained that
-   * new segment information.
+   * @param {Object} currentSegment - Information on the segment which contained
+   * that new segment information.
    */
   addPredictedSegments(
     nextSegments : Array<{ duration : number; time : number; timescale : number }>,

package/src/parsers/manifest/utils/__tests__/get_first_time_from_adaptations.test.ts

@@ -30,7 +30,7 @@ function generateRepresentationIndex(
     awaitSegmentBetween() : undefined { return ; },
     checkDiscontinuity() : number | null { return null; },
     isSegmentStillAvailable() : undefined { return ; },
-    isFinished() { return false; },
+    isStillAwaitingFutureSegments() { return true; },
     canBeOutOfSyncError() : true { return true; },
     isInitialized() : true { return true; },
     initialize() : void { return ; },

package/src/parsers/manifest/utils/__tests__/get_last_time_from_adaptation.test.ts

@@ -30,7 +30,7 @@ function generateRepresentationIndex(
     awaitSegmentBetween() : undefined { return ; },
     checkDiscontinuity() : number | null { return null; },
     isSegmentStillAvailable() : undefined { return ; },
-    isFinished() { return false; },
+    isStillAwaitingFutureSegments() { return true; },
     isInitialized() : true { return true; },
     initialize() : void { return ; },
     addPredictedSegments() : void { return ; },

package/src/parsers/manifest/utils/index_helpers.ts

@@ -136,7 +136,7 @@ export function getTimescaledRange(
  * timescaled time.
  * Returns -1 if the given time is lower than the start of the first available
  * segment.
- * @param {Object} index
+ * @param {Object} timeline
  * @param {Number} timeTScaled
  * @returns {Number}
  */