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

package/src/core/api/public_api.ts

@@ -346,7 +346,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     // See: https://bugzilla.mozilla.org/show_bug.cgi?id=1194624
     videoElement.preload = "auto";
 
-    this.version = /* PLAYER_VERSION */"4.0.0-dev.2023111400";
+    this.version = /* PLAYER_VERSION */"4.0.0-dev.2023121900";
     this.log = log;
     this.state = "STOPPED";
     this.videoElement = videoElement;
@@ -610,6 +610,8 @@ class Player extends EventEmitter<IPublicAPIEvent> {
       const manifestRequestSettings = { lowLatencyMode,
                                         maxRetry : requestConfig.manifest?.maxRetry,
                                         requestTimeout:  requestConfig.manifest?.timeout,
+                                        connectionTimeout:
+                                          requestConfig.manifest?.connectionTimeout,
                                         minimumManifestUpdateInterval,
                                         initialManifest };
 
@@ -667,8 +669,9 @@ class Player extends EventEmitter<IPublicAPIEvent> {
 
       const segmentRequestOptions = { lowLatencyMode,
                                       maxRetry: requestConfig.segment?.maxRetry,
-                                      requestTimeout: requestConfig.segment?.timeout };
-
+                                      requestTimeout: requestConfig.segment?.timeout,
+                                      connectionTimeout:
+                                        requestConfig.segment?.connectionTimeout };
       initializer = new features.mediaSourceInit({
         adaptiveOptions,
         autoPlay,
@@ -811,12 +814,12 @@ class Player extends EventEmitter<IPublicAPIEvent> {
         case "ENDED":
           this._priv_reloadingMetadata.reloadInPause = true;
           this._priv_reloadingMetadata.reloadPosition =
-            playbackObserver.getReference().getValue().position;
+            playbackObserver.getReference().getValue().position.getPolled();
           break;
         default:
           const o = playbackObserver.getReference().getValue();
           this._priv_reloadingMetadata.reloadInPause = o.paused;
-          this._priv_reloadingMetadata.reloadPosition = o.position;
+          this._priv_reloadingMetadata.reloadPosition = o.position.getWanted();
           break;
       }
     };
@@ -1958,6 +1961,29 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     return null;
   }
 
+  /**
+   * Returns the current position for live contents.
+   *
+   * Returns `null` if no content is loaded or if the current loaded content is
+   * not considered as a live content.
+   * Returns `undefined` if that live position is currently unknown.
+   * @returns {number}
+   */
+  getLivePosition() : number | undefined |null {
+    if (this._priv_contentInfos === null) {
+      return null;
+    }
+
+    const { isDirectFile, manifest } = this._priv_contentInfos;
+    if (isDirectFile) {
+      return undefined;
+    }
+    if (manifest?.isLive !== true) {
+      return null;
+    }
+    return manifest.getLivePosition();
+  }
+
   /**
    * Get maximum seek-able position.
    * @returns {number}
@@ -2008,9 +2034,11 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     }
     const segmentBufferStatus = this._priv_contentInfos
       .segmentBuffersStore.getStatus(bufferType);
-    return segmentBufferStatus.type === "initialized" ?
-      segmentBufferStatus.value.getInventory() :
-      null;
+    if (segmentBufferStatus.type === "initialized") {
+      segmentBufferStatus.value.synchronizeInventory();
+      return segmentBufferStatus.value.getInventory();
+    }
+    return null;
   }
 
   /**
@@ -2562,7 +2590,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     const maximumPosition = manifest !== null ? manifest.getMaximumSafePosition() :
                                                 undefined;
     const positionData : IPositionUpdate = {
-      position: observation.position,
+      position: observation.position.getPolled(),
       duration: observation.duration,
       playbackRate: observation.playbackRate,
       maximumPosition,
@@ -2576,18 +2604,18 @@ class Player extends EventEmitter<IPublicAPIEvent> {
 
     if (manifest !== null &&
         manifest.isLive &&
-        observation.position > 0
+        observation.position.getPolled() > 0
     ) {
       const ast = manifest.availabilityStartTime ?? 0;
-      positionData.wallClockTime = observation.position + ast;
+      positionData.wallClockTime = observation.position.getPolled() + ast;
       const livePosition = manifest.getLivePosition();
       if (livePosition !== undefined) {
-        positionData.liveGap = livePosition - observation.position;
+        positionData.liveGap = livePosition - observation.position.getPolled();
       }
     } else if (isDirectFile && this.videoElement !== null) {
       const startDate = getStartDate(this.videoElement);
       if (startDate !== undefined) {
-        positionData.wallClockTime = startDate + observation.position;
+        positionData.wallClockTime = startDate + observation.position.getPolled();
       }
     }
     this.trigger("positionUpdate", positionData);
@@ -2784,7 +2812,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     }
   }
 }
-Player.version = /* PLAYER_VERSION */"4.0.0-dev.2023111400";
+Player.version = /* PLAYER_VERSION */"4.0.0-dev.2023121900";
 
 /** Every events sent by the RxPlayer's public API. */
 interface IPublicAPIEvent {

package/src/core/api/utils.ts

@@ -28,6 +28,7 @@ import {
 import {
   IPlaybackObservation,
   IReadOnlyPlaybackObserver,
+  SeekingState,
 } from "./playback_observer";
 
 /**
@@ -52,7 +53,8 @@ export function emitSeekEvents(
     return ;
   }
 
-  let wasSeeking = playbackObserver.getReference().getValue().seeking;
+  let wasSeeking =
+    playbackObserver.getReference().getValue().seeking === SeekingState.External;
   if (wasSeeking) {
     onSeeking();
     if (cancelSignal.isCancelled()) {

package/src/core/decrypt/get_media_keys.ts

@@ -39,15 +39,9 @@ import ServerCertificateStore from "./utils/server_certificate_store";
 function createPersistentSessionsStorage(
   keySystemOptions : IKeySystemOption
 ) : PersistentSessionsStore|null {
-  if (isNullOrUndefined(keySystemOptions.persistentLicenseConfig)) {
-    return null;
-  }
-
   const { persistentLicenseConfig } = keySystemOptions;
-  if (persistentLicenseConfig == null) {
-    throw new EncryptedMediaError("INVALID_KEY_SYSTEM",
-                                  "No `persistentLicenseConfig` found for " +
-                                  "persistent license.");
+  if (isNullOrUndefined(persistentLicenseConfig)) {
+    return null;
   }
 
   log.debug("DRM: Set the given license storage");

package/src/core/fetchers/manifest/manifest_fetcher.ts

@@ -29,7 +29,6 @@ import {
   ITransportPipelines,
 } from "../../../transports";
 import EventEmitter from "../../../utils/event_emitter";
-import isNullOrUndefined from "../../../utils/is_null_or_undefined";
 import getMonotonicTimeStamp from "../../../utils/monotonic_timestamp";
 import noop from "../../../utils/noop";
 import TaskCanceller from "../../../utils/task_canceller";
@@ -231,14 +230,27 @@ export default class ManifestFetcher extends EventEmitter<IManifestFetcherEvent>
     ) : Promise<IRequestedData<ILoadedManifestFormat>> {
       const { loadManifest } = pipelines;
       let requestTimeout : number | undefined =
-        isNullOrUndefined(settings.requestTimeout) ?
+        (settings.requestTimeout === undefined) ?
           config.getCurrent().DEFAULT_REQUEST_TIMEOUT :
           settings.requestTimeout;
+
+      let connectionTimeout: number | undefined =
+      (settings.connectionTimeout === undefined) ?
+        config.getCurrent().DEFAULT_CONNECTION_TIMEOUT :
+        settings.connectionTimeout;
+
       if (requestTimeout < 0) {
         requestTimeout = undefined;
       }
+
+      if (connectionTimeout < 0) {
+        connectionTimeout = undefined;
+      }
       const callLoader = () => loadManifest(manifestUrl,
-                                            { timeout: requestTimeout },
+                                            {
+                                              timeout: requestTimeout,
+                                              connectionTimeout,
+                                            },
                                             cancelSignal);
       return scheduleRequestPromise(callLoader, backoffSettings, cancelSignal);
     }
@@ -722,6 +734,12 @@ export interface IManifestFetcherSettings {
    * `undefined` will lead to a default, large, timeout being used.
    */
   requestTimeout : number | undefined;
+  /**
+   * Connection timeout, in milliseconds, after which the request is canceled
+   * if the responses headers has not being received.
+   * Do not set or set to "undefined" to disable it.
+   */
+  connectionTimeout: number | undefined;
   /** Limit the frequency of Manifest updates. */
   minimumManifestUpdateInterval : number;
   /**

package/src/core/fetchers/segment/segment_fetcher.ts

@@ -93,6 +93,8 @@ export default function createSegmentFetcher<TLoadedFormat, TSegmentDataType>(
   const requestOptions = {
     timeout: options.requestTimeout < 0 ? undefined :
                                           options.requestTimeout,
+    connectionTimeout: options.connectionTimeout === undefined ? undefined :
+                  options.connectionTimeout < 0 ? undefined : options.connectionTimeout,
   };
 
   /**
@@ -457,6 +459,12 @@ export interface ISegmentFetcherOptions {
    * To set to `-1` for no timeout.
    */
   requestTimeout : number;
+  /**
+   * Connection timeout, in milliseconds, after which the request is canceled
+   * if the responses headers has not being received.
+   * Do not set or set to "undefined" to disable it.
+   */
+  connectionTimeout: number | undefined;
 }
 
 /**
@@ -467,12 +475,15 @@ export interface ISegmentFetcherOptions {
 export function getSegmentFetcherOptions(
   { maxRetry,
     lowLatencyMode,
-    requestTimeout } : { maxRetry? : number | undefined;
-                         requestTimeout? : number | undefined;
-                         lowLatencyMode : boolean; }
+    requestTimeout,
+    connectionTimeout } : { maxRetry? : number | undefined;
+                            requestTimeout? : number | undefined;
+                            connectionTimeout? : number | undefined;
+                            lowLatencyMode : boolean; }
 ) : ISegmentFetcherOptions {
   const { DEFAULT_MAX_REQUESTS_RETRY_ON_ERROR,
           DEFAULT_REQUEST_TIMEOUT,
+          DEFAULT_CONNECTION_TIMEOUT,
           INITIAL_BACKOFF_DELAY_BASE,
           MAX_BACKOFF_DELAY_BASE } = config.getCurrent();
   return { maxRetry: maxRetry ?? DEFAULT_MAX_REQUESTS_RETRY_ON_ERROR,
@@ -480,6 +491,9 @@ export function getSegmentFetcherOptions(
                                        INITIAL_BACKOFF_DELAY_BASE.REGULAR,
            maxDelay: lowLatencyMode ? MAX_BACKOFF_DELAY_BASE.LOW_LATENCY :
                                       MAX_BACKOFF_DELAY_BASE.REGULAR,
-           requestTimeout: isNullOrUndefined(requestTimeout) ? DEFAULT_REQUEST_TIMEOUT :
-                                                               requestTimeout };
+           requestTimeout: (requestTimeout === undefined) ? DEFAULT_REQUEST_TIMEOUT :
+                                                            requestTimeout,
+           connectionTimeout: (connectionTimeout === undefined) ?
+              DEFAULT_CONNECTION_TIMEOUT : connectionTimeout,
+  };
 }

package/src/core/fetchers/segment/segment_fetcher_creator.ts

@@ -124,4 +124,5 @@ export interface ISegmentFetcherCreatorBackoffOptions {
    * `undefined` will lead to a default, large, timeout being used.
    */
   requestTimeout : number | undefined;
+  connectionTimeout : number | undefined;
 }

package/src/core/fetchers/utils/schedule_request.ts

@@ -352,7 +352,7 @@ export async function scheduleRequestWithCdns<T>(
    * attempts already done for that resource.
    *
    * Returns `undefined` if there's no Cdn left to request the resource.
-   * @param {Array.<Object>}
+   * @param {Array.<Object>} sortedCdns
    * @returns {Object|undefined}
    */
   function getPrioritaryRequestableCdnFromSortedList(

package/src/core/init/directfile_content_initializer.ts

@@ -27,6 +27,7 @@ import {
   IPlayerError,
 } from "../../public_types";
 import assert from "../../utils/assert";
+import isNullOrUndefined from "../../utils/is_null_or_undefined";
 import SharedReference, {
   IReadOnlySharedReference,
 } from "../../utils/reference";
@@ -207,14 +208,14 @@ export default class DirectFileContentInitializer extends ContentInitializer {
       log.debug("Init: Initial time calculated:", initTime);
       return initTime;
     };
-    performInitialSeekAndPlay(
-      mediaElement,
-      playbackObserver,
-      initialTime,
-      autoPlay,
-      (err) => this.trigger("warning", err),
-      cancelSignal
-    ).autoPlayResult
+    performInitialSeekAndPlay({ mediaElement,
+                                playbackObserver,
+                                startTime: initialTime,
+                                mustAutoPlay: autoPlay,
+                                onWarning: (err) => this.trigger("warning", err),
+                                isDirectfile: true },
+                              cancelSignal)
+      .autoPlayResult
       .then(() =>
         getLoadedReference(playbackObserver, mediaElement, true, cancelSignal)
           .onUpdate((isLoaded, stopListening) => {
@@ -241,11 +242,11 @@ function getDirectFileInitialTime(
   mediaElement : HTMLMediaElement,
   startAt? : IInitialTimeOptions
 ) : number {
-  if (startAt == null) {
+  if (isNullOrUndefined(startAt)) {
     return 0;
   }
 
-  if (startAt.position != null) {
+  if (!isNullOrUndefined(startAt.position)) {
     return startAt.position;
   } else if (startAt.wallClockTime != null) {
     return startAt.wallClockTime;
@@ -254,15 +255,30 @@ function getDirectFileInitialTime(
   }
 
   const duration = mediaElement.duration;
-  if (duration == null || !isFinite(duration)) {
-    log.warn("startAt.fromLastPosition set but no known duration, " +
-             "beginning at 0.");
-    return 0;
-  }
 
   if (typeof startAt.fromLastPosition === "number") {
+    if (isNullOrUndefined(duration) || !isFinite(duration)) {
+      log.warn("startAt.fromLastPosition set but no known duration, " +
+               "beginning at 0.");
+      return 0;
+    }
     return Math.max(0, duration + startAt.fromLastPosition);
+  } else if (typeof startAt.fromLivePosition === "number") {
+    const livePosition = mediaElement.seekable.length > 0 ?
+      mediaElement.seekable.end(0) :
+      duration;
+    if (isNullOrUndefined(livePosition)) {
+      log.warn("startAt.fromLivePosition set but no known live position, " +
+               "beginning at 0.");
+      return 0;
+    }
+    return Math.max(0, livePosition + startAt.fromLivePosition);
   } else if (startAt.percentage != null) {
+    if (isNullOrUndefined(duration) || !isFinite(duration)) {
+      log.warn("startAt.percentage set but no known duration, " +
+               "beginning at 0.");
+      return 0;
+    }
     const { percentage } = startAt;
     if (percentage >= 100) {
       return duration;

package/src/core/init/media_source_content_initializer.ts

@@ -416,12 +416,13 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
       segmentBuffersStore.disposeAll();
     });
 
-    const { autoPlayResult, initialPlayPerformed, initialSeekPerformed } =
-      performInitialSeekAndPlay(mediaElement,
-                                playbackObserver,
-                                initialTime,
-                                autoPlay,
-                                (err) => this.trigger("warning", err),
+    const { autoPlayResult, initialPlayPerformed } =
+      performInitialSeekAndPlay({ mediaElement,
+                                  playbackObserver,
+                                  startTime: initialTime,
+                                  mustAutoPlay: autoPlay,
+                                  onWarning: (err) => { this.trigger("warning", err); },
+                                  isDirectfile: false },
                                 cancelSignal);
 
     if (cancelSignal.isCancelled()) {
@@ -451,9 +452,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
                                                         { autoPlay,
                                                           manifest,
                                                           initialPlayPerformed,
-                                                          initialSeekPerformed,
-                                                          speed,
-                                                          startTime: initialTime },
+                                                          speed },
                                                         cancelSignal);
 
     const rebufferingController = this._createRebufferingController(playbackObserver,
@@ -462,11 +461,16 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
                                                                     speed,
                                                                     cancelSignal);
     rebufferingController.addEventListener("needsReload", () => {
+      let position: number;
+      const lastObservation = playbackObserver.getReference().getValue();
+      if (lastObservation.position.isAwaitingFuturePosition()) {
+        position = lastObservation.position.getWanted();
+      } else {
+        position = playbackObserver.getCurrentTime();
+      }
+
       // NOTE couldn't both be always calculated at event destination?
       // Maybe there are exceptions?
-      const position = initialSeekPerformed.getValue() ?
-        playbackObserver.getCurrentTime() :
-        initialTime;
       const autoplay = initialPlayPerformed.getValue() ?
         !playbackObserver.getIsPaused() :
         autoPlay;
@@ -541,11 +545,11 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
             if (
               // Data is buffered around the current position
               obs.currentRange !== null ||
-              // Or, for whatever reason, playback is already advancing
-              obs.position > seekedTime + 0.1
+              // Or, for whatever reason, we have no buffer but we're already advancing
+              obs.position.getPolled() > seekedTime + 0.1
             ) {
               stopListening();
-              playbackObserver.setCurrentTime(obs.position + 0.001);
+              playbackObserver.setCurrentTime(obs.position.getWanted() + 0.001);
             }
           }, { includeLastObservation: false, clearSignal: cancelSignal });
         },
@@ -635,8 +639,9 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
 
         needsMediaSourceReload: (payload) => {
           const lastObservation = streamObserver.getReference().getValue();
-          const currentPosition = lastObservation.position.pending ??
-                                  streamObserver.getCurrentTime();
+          const currentPosition = lastObservation.position.isAwaitingFuturePosition() ?
+            lastObservation.position.getWanted() :
+            streamObserver.getCurrentTime();
           const isPaused = lastObservation.paused.pending ??
                            streamObserver.getIsPaused();
           let position = currentPosition + payload.timeOffset;
@@ -653,15 +658,17 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
           const keySystem = getKeySystemConfiguration(mediaElement);
           if (shouldReloadMediaSourceOnDecipherabilityUpdate(keySystem?.[0])) {
             const lastObservation = streamObserver.getReference().getValue();
-            const position = lastObservation.position.pending ??
-                             streamObserver.getCurrentTime();
+            const position = lastObservation.position.isAwaitingFuturePosition() ?
+              lastObservation.position.getWanted() :
+              streamObserver.getCurrentTime();
             const isPaused = lastObservation.paused.pending ??
                              streamObserver.getIsPaused();
             onReloadOrder({ position, autoPlay: !isPaused });
           } else {
             const lastObservation = streamObserver.getReference().getValue();
-            const position = lastObservation.position.pending ??
-                             streamObserver.getCurrentTime();
+            const position = lastObservation.position.isAwaitingFuturePosition() ?
+              lastObservation.position.getWanted() :
+              streamObserver.getCurrentTime();
             // simple seek close to the current position
             // to flush the buffers
             if (position + 0.001 < lastObservation.duration) {
@@ -728,9 +735,10 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
     contentTimeBoundariesObserver.addEventListener("periodChange", (period) => {
       this.trigger("activePeriodChanged", { period });
     });
-    contentTimeBoundariesObserver.addEventListener("durationUpdate", (newDuration) => {
-      mediaSourceDurationUpdater.updateDuration(newDuration.duration, newDuration.isEnd);
-    });
+    contentTimeBoundariesObserver.addEventListener(
+      "endingPositionChange",
+      (x) => mediaSourceDurationUpdater.updateDuration(x.endingPosition, x.isEnd)
+    );
     contentTimeBoundariesObserver.addEventListener("endOfStream", () => {
       if (endOfStreamCanceller === null) {
         endOfStreamCanceller = new TaskCanceller();
@@ -746,9 +754,8 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
         endOfStreamCanceller = null;
       }
     });
-    const currentDuration = contentTimeBoundariesObserver.getCurrentDuration();
-    mediaSourceDurationUpdater.updateDuration(currentDuration.duration,
-                                              currentDuration.isEnd);
+    const endInfo = contentTimeBoundariesObserver.getCurrentEndingTime();
+    mediaSourceDurationUpdater.updateDuration(endInfo.endingPosition, endInfo.isEnd);
     return contentTimeBoundariesObserver;
   }
 
@@ -835,6 +842,12 @@ export interface IInitializeArguments {
      * `-1` indicates no timeout.
      */
     requestTimeout : number | undefined;
+    /**
+     * Amount of time, in milliseconds, after which a request that hasn't receive
+     * the headers and status code should be aborted and optionnaly retried,
+     * depending on the maxRetry configuration.
+     */
+    connectionTimeout : number | undefined;
     /** Maximum number of time a request on error will be retried. */
     maxRetry : number | undefined;
   };

package/src/core/init/utils/content_time_boundaries_observer.ts

@@ -32,8 +32,8 @@ import { IStreamOrchestratorPlaybackObservation } from "../../stream";
 /**
  * Observes what's being played and take care of media events relating to time
  * boundaries:
- *   - Emits a `durationUpdate` when the duration of the current content is
- *     known and every time it changes.
+ *   - Emits a `endingPositionChange` when the known maximum playable position
+ *     of the current content is known and every time it changes.
  *   - Emits `endOfStream` API once segments have been pushed until the end and
  *     `resumeStream` if downloads starts back.
  *   - Emits a `periodChange` event when the currently-playing Period seemed to
@@ -94,7 +94,7 @@ export default class ContentTimeBoundariesObserver
 
     const cancelSignal = this._canceller.signal;
     playbackObserver.listen(({ position }) => {
-      const wantedPosition = position.pending ?? position.last;
+      const wantedPosition = position.getWanted();
       if (wantedPosition < manifest.getMinimumSafePosition()) {
         const warning = new MediaError("MEDIA_TIME_BEFORE_MANIFEST",
                                        "The current position is behind the " +
@@ -111,7 +111,7 @@ export default class ContentTimeBoundariesObserver
     }, { includeLastObservation: true, clearSignal: cancelSignal });
 
     manifest.addEventListener("manifestUpdate", () => {
-      this.trigger("durationUpdate", this._getManifestDuration());
+      this.trigger("endingPositionChange", this._getManifestEndTime());
       if (cancelSignal.isCancelled()) {
         return;
       }
@@ -120,11 +120,12 @@ export default class ContentTimeBoundariesObserver
   }
 
   /**
-   * Returns an estimate of the current duration of the content.
+   * Returns an estimate of the current last position which may be played in
+   * the content at the moment.
    * @returns {Object}
    */
-  public getCurrentDuration() : IDurationItem  {
-    return this._getManifestDuration();
+  public getCurrentEndingTime() : IEndingPositionInformation  {
+    return this._getManifestEndTime();
   }
 
   /**
@@ -157,12 +158,13 @@ export default class ContentTimeBoundariesObserver
               .updateLastVideoAdaptation(adaptation);
           }
           const endingPosition = this._maximumPositionCalculator.getEndingPosition();
-          const newDuration = endingPosition !== undefined ?
+          const newEndingPosition = endingPosition !== undefined ?
             { isEnd: true,
-              duration: endingPosition } :
+              endingPosition } :
             { isEnd: false,
-              duration: this._maximumPositionCalculator.getMaximumAvailablePosition() };
-          this.trigger("durationUpdate", newDuration);
+              endingPosition: this._maximumPositionCalculator
+                .getMaximumAvailablePosition() };
+          this.trigger("endingPositionChange", newEndingPosition);
         }
       }
     }
@@ -311,13 +313,13 @@ export default class ContentTimeBoundariesObserver
     }
   }
 
-  private _getManifestDuration() : IDurationItem {
+  private _getManifestEndTime() : IEndingPositionInformation {
     const endingPosition = this._maximumPositionCalculator.getEndingPosition();
     return endingPosition !== undefined ?
       { isEnd: true,
-        duration: endingPosition } :
+        endingPosition } :
       { isEnd: false,
-        duration: this._maximumPositionCalculator.getMaximumAvailablePosition() };
+        endingPosition: this._maximumPositionCalculator.getMaximumAvailablePosition() };
   }
 
   private _lazilyCreateActiveStreamInfo(bufferType : IBufferType) : IActiveStreamsInfo {
@@ -348,16 +350,16 @@ export default class ContentTimeBoundariesObserver
   }
 }
 
-export interface IDurationItem {
+export interface IEndingPositionInformation {
   /**
    * The new maximum known position (note that this is the ending position
    * currently known of the current content, it might be superior to the last
    * position at which segments are available and it might also evolve over
    * time), in seconds.
    */
-  duration : number;
+  endingPosition : number;
   /**
-   * If `true`, the communicated `duration` is the actual end of the content.
+   * If `true`, the communicated `endingPosition` is the actual end of the content.
    * It may still be updated due to a track change or to add precision, but it
    * is still a (rough) estimate of the maximum position that content should
    * have.
@@ -365,7 +367,7 @@ export interface IDurationItem {
    * If `false`, this is the currently known maximum position associated to
    * the content, but the content is still evolving (typically, new media
    * segments are still being generated) and as such it can still have a
-   * longer duration in the future.
+   * longer `endingPosition` in the future.
    */
   isEnd : boolean;
 }
@@ -380,10 +382,10 @@ export interface IContentTimeBoundariesObserverEvent {
   /** Triggered when a new `Period` is currently playing. */
   periodChange : Period;
   /**
-   * Triggered when the duration of the currently-playing content became known
-   * or changed.
+   * Triggered when the ending position of the currently-playing content became
+   * known or changed.
    */
-  durationUpdate : IDurationItem;
+  endingPositionChange : IEndingPositionInformation;
   /**
    * Triggered when the last possible chronological segment for all types of
    * buffers has either been pushed or is being pushed to the corresponding
@@ -460,8 +462,7 @@ class MaximumPositionCalculator {
  */
   public getMaximumAvailablePosition() : number {
     if (this._manifest.isDynamic) {
-      return this._manifest.getLivePosition() ??
-             this._manifest.getMaximumSafePosition();
+      return this._manifest.getMaximumSafePosition();
     }
     if (this._lastVideoAdaptation === undefined ||
         this._lastAudioAdaptation === undefined)