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

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/init/directfile_content_initializer.ts

@@ -208,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) => {

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;
@@ -542,10 +546,10 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
               // Data is buffered around the current position
               obs.currentRange !== null ||
               // Or, for whatever reason, we have no buffer but we're already advancing
-              obs.position > seekedTime + 0.1
+              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) {

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

@@ -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 " +

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

@@ -36,12 +36,8 @@ export interface IStreamPlaybackObserverArguments {
   manifest : Manifest;
   /** Becomes `true` after the initial play has been taken care of. */
   initialPlayPerformed : IReadOnlySharedReference<boolean>;
-  /** Becomes `true` after the initial seek has been taken care of. */
-  initialSeekPerformed : IReadOnlySharedReference<boolean>;
   /** The last speed requested by the user. */
   speed : IReadOnlySharedReference<number>;
-  /** The time the player will seek when `initialSeekPerformed` becomes `true`. */
-  startTime : number;
 }
 
 /**
@@ -57,10 +53,8 @@ export default function createStreamPlaybackObserver(
   srcPlaybackObserver : PlaybackObserver,
   { autoPlay,
     initialPlayPerformed,
-    initialSeekPerformed,
     manifest,
-    speed,
-    startTime } : IStreamPlaybackObserverArguments,
+    speed } : IStreamPlaybackObserverArguments,
   fnCancelSignal : CancellationSignal
 ) : IReadOnlyPlaybackObserver<IStreamOrchestratorPlaybackObservation> {
   return srcPlaybackObserver.deriveReadOnlyObserver(function transform(
@@ -87,10 +81,8 @@ export default function createStreamPlaybackObserver(
     function constructStreamPlaybackObservation() {
       const observation = observationRef.getValue();
       const lastSpeed = speed.getValue();
-      let pendingPosition : number | undefined;
-      if (!initialSeekPerformed.getValue()) {
-        pendingPosition = startTime;
-      } else if (!manifest.isDynamic || manifest.isLastPeriodKnown) {
+
+      if (!manifest.isDynamic || manifest.isLastPeriodKnown) {
         // HACK: When the position is actually further than the maximum
         // position for a finished content, we actually want to be loading
         // the last segment before ending.
@@ -98,21 +90,28 @@ export default function createStreamPlaybackObserver(
         // want to seek one second before the period's end (despite never
         // doing it).
         const lastPeriod = manifest.periods[manifest.periods.length - 1];
-        if (lastPeriod !== undefined &&
-            lastPeriod.end !== undefined &&
-            observation.position > lastPeriod.end)
-        {
-          pendingPosition = lastPeriod.end - 1;
+        if (lastPeriod !== undefined && lastPeriod.end !== undefined) {
+          const wantedPosition = observation.position.getWanted();
+          if (wantedPosition >= lastPeriod.start &&
+              wantedPosition >= lastPeriod.end - 1)
+          {
+            // We're after the end of the last Period, check if `buffered`
+            // indicates that the last segment is probably not loaded, in which
+            // case act as if we want to load one second before the end.
+            const buffered = observation.buffered;
+            if (buffered.length === 0 ||
+                buffered.end(buffered.length - 1) < observation.duration - 1)
+            {
+              observation.position.forceWantedPosition(lastPeriod.end - 1);
+            }
+          }
         }
       }
 
       return {
         // TODO more exact according to the current Adaptation chosen?
         maximumPosition: manifest.getMaximumSafePosition(),
-        position: {
-          last: observation.position,
-          pending: pendingPosition,
-        },
+        position: observation.position,
         duration: observation.duration,
         paused: {
           last: observation.paused,

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

@@ -15,7 +15,6 @@
  */
 
 import { shouldValidateMetadata } from "../../../compat";
-import { READY_STATES } from "../../../compat/browser_compatibility_types";
 import { MediaError } from "../../../errors";
 import log from "../../../log";
 import { IPlayerError } from "../../../public_types";
@@ -24,6 +23,7 @@ import SharedReference, {
 } from "../../../utils/reference";
 import { CancellationError, CancellationSignal } from "../../../utils/task_canceller";
 import { PlaybackObserver } from "../../api";
+import { SeekingState } from "../../api/playback_observer";
 
 /** Event emitted when trying to perform the initial `play`. */
 export type IInitialPlayEvent =
@@ -42,12 +42,6 @@ export interface IInitialSeekAndPlayObject {
   /** Emit the result of the auto-play operation, once performed. */
   autoPlayResult : Promise<IInitialPlayEvent>;
 
-  /**
-   * Shared reference whose value becomes `true` once the initial seek has
-   * been considered / has been done by `performInitialSeekAndPlay`.
-   */
-  initialSeekPerformed : IReadOnlySharedReference<boolean>;
-
   /**
    * Shared reference whose value becomes `true` once the initial play has
    * been considered / has been done by `performInitialSeekAndPlay`.
@@ -58,126 +52,164 @@ export interface IInitialSeekAndPlayObject {
 /**
  * Seek as soon as possible at the initially wanted position and play if
  * autoPlay is wanted.
- * @param {HTMLMediaElement} mediaElement
- * @param {Object} playbackObserver
- * @param {number|Function} startTime
- * @param {boolean} mustAutoPlay
- * @param {Function} onWarning
+ * @param {Object} args
  * @param {Object} cancelSignal
  * @returns {Object}
  */
 export default function performInitialSeekAndPlay(
-  mediaElement : HTMLMediaElement,
-  playbackObserver : PlaybackObserver,
-  startTime : number|(() => number),
-  mustAutoPlay : boolean,
-  onWarning : (err : IPlayerError) => void,
+  { mediaElement,
+    playbackObserver,
+    startTime,
+    mustAutoPlay,
+    isDirectfile,
+    onWarning }: { mediaElement : HTMLMediaElement;
+                   playbackObserver : PlaybackObserver;
+                   startTime : number|(() => number);
+                   mustAutoPlay : boolean;
+                   isDirectfile: boolean;
+                   onWarning : (err : IPlayerError) => void; },
   cancelSignal : CancellationSignal
 ) : IInitialSeekAndPlayObject {
-  let resolveAutoPlay : (x : IInitialPlayEvent) => void;
-  let rejectAutoPlay : (x : unknown) => void;
-  const autoPlayResult = new Promise<IInitialPlayEvent>((res, rej) => {
-    resolveAutoPlay = res;
-    rejectAutoPlay = rej;
-  });
-
-  const initialSeekPerformed = new SharedReference(false, cancelSignal);
   const initialPlayPerformed = new SharedReference(false, cancelSignal);
-
-  mediaElement.addEventListener("loadedmetadata", onLoadedMetadata);
-
-  const deregisterCancellation = cancelSignal.register((err : CancellationError) => {
-    mediaElement.removeEventListener("loadedmetadata", onLoadedMetadata);
-    rejectAutoPlay(err);
-  });
-
-  if (mediaElement.readyState >= READY_STATES.HAVE_METADATA) {
-    onLoadedMetadata();
-  }
-
-  return { autoPlayResult, initialPlayPerformed, initialSeekPerformed };
-
-  function onLoadedMetadata() {
-    mediaElement.removeEventListener("loadedmetadata", onLoadedMetadata);
-    const initialTime = typeof startTime === "function" ? startTime() :
-                                                          startTime;
-    log.info("Init: Set initial time", initialTime);
-    playbackObserver.setCurrentTime(initialTime);
-    initialSeekPerformed.setValue(true);
-    initialSeekPerformed.finish();
-
-    if (shouldValidateMetadata() && mediaElement.duration === 0) {
-      const error = new MediaError("MEDIA_ERR_NOT_LOADED_METADATA",
-                                   "Cannot load automatically: your browser " +
-                                   "falsely announced having loaded the content.");
-      onWarning(error);
-    }
-    if (cancelSignal.isCancelled()) {
-      return ;
+  const autoPlayResult = new Promise<IInitialPlayEvent>((
+    resolveAutoPlay,
+    rejectAutoPlay
+  ) => {
+    // `startTime` defined as a function might depend on metadata to make its
+    // choice, such as the content duration, minimum and/or maximum position.
+    //
+    // The RxPlayer might already know those through the Manifest file for
+    // non-Directfile contents, yet only through the `HTMLMediaElement` once a
+    // a sufficient `readyState` has been reached for directfile contents.
+    // So let's divide the two possibilities here.
+    if (!isDirectfile || typeof startTime === "number") {
+      playbackObserver.setCurrentTime(
+        typeof startTime === "number" ? startTime : startTime()
+      );
+      waitForSeekable();
+    } else {
+      playbackObserver.listen((obs, stopListening) => {
+        if (obs.readyState >= 1) {
+          stopListening();
+          playbackObserver.setCurrentTime(
+            typeof startTime === "number" ? startTime : startTime()
+          );
+          waitForSeekable();
+        }
+      }, { includeLastObservation: true, clearSignal: cancelSignal });
     }
 
-    playbackObserver.listen((observation, stopListening) => {
-      if (!observation.seeking &&
-          observation.rebuffering === null &&
-          observation.readyState >= 1)
-      {
+    const deregisterCancellation = cancelSignal.register((err : CancellationError) => {
+      rejectAutoPlay(err);
+    });
+
+    /**
+     * Logic that should be run once the initial seek has been asked to the
+     * PlaybackObserver.
+     *
+     * Actually wait until the seek has been performed, wait for the right moment
+     * to perform autoplay, resolve the promise once everything has been done and
+     * potentially send warning if a minor issue is detected.
+     */
+    function waitForSeekable() {
+      playbackObserver.listen((obs, stopListening) => {
+        if (obs.seeking === SeekingState.None || obs.readyState === 0) {
+          return;
+        }
         stopListening();
-        onPlayable();
-      }
-    }, { includeLastObservation: true, clearSignal: cancelSignal });
-  }
-
-  function onPlayable() {
-    log.info("Init: Can begin to play content");
-    if (!mustAutoPlay) {
-      if (mediaElement.autoplay) {
-        log.warn("Init: autoplay is enabled on HTML media element. " +
-                 "Media will play as soon as possible.");
-      }
-      initialPlayPerformed.setValue(true);
-      initialPlayPerformed.finish();
-      deregisterCancellation();
-      return resolveAutoPlay({ type: "skipped" as const });
+        if (shouldValidateMetadata() && mediaElement.duration === 0) {
+          const error = new MediaError("MEDIA_ERR_NOT_LOADED_METADATA",
+                                       "Cannot load automatically: your browser " +
+                                       "falsely announced having loaded the content.");
+          onWarning(error);
+        }
+        if (cancelSignal.isCancelled()) {
+          return ;
+        }
+        waitForPlayable();
+      }, { includeLastObservation: true, clearSignal: cancelSignal });
     }
 
-    let playResult : Promise<unknown>;
-    try {
-      playResult = mediaElement.play() ?? Promise.resolve();
-    } catch (playError) {
-      deregisterCancellation();
-      return rejectAutoPlay(playError);
+    /**
+     * Logic that should be run once the initial seek has been properly performed.
+     *
+     * Wait for the media being playable before performing the autoplay operation
+     * if asked. Potentially send warning if a minor issue has been detected while
+     * doing so.
+     */
+    function waitForPlayable() {
+      playbackObserver.listen((observation, stopListening) => {
+        if (observation.seeking === SeekingState.None &&
+            observation.rebuffering === null &&
+            observation.readyState >= 1)
+        {
+          stopListening();
+          onPlayable();
+        }
+      }, { includeLastObservation: true, clearSignal: cancelSignal });
     }
-    playResult
-      .then(() => {
-        if (cancelSignal.isCancelled()) {
-          return;
+
+    /**
+     * Callback called once the content is considered "playable".
+     *
+     * Perform the autoplay if needed, handling potential issues and resolve the
+     * Promise when done.
+     * Might also send warnings if minor issues arise.
+     */
+    function onPlayable() {
+      log.info("Init: Can begin to play content");
+      if (!mustAutoPlay) {
+        if (mediaElement.autoplay) {
+          log.warn("Init: autoplay is enabled on HTML media element. " +
+                   "Media will play as soon as possible.");
         }
         initialPlayPerformed.setValue(true);
         initialPlayPerformed.finish();
         deregisterCancellation();
-        return resolveAutoPlay({ type: "autoplay" as const });
-      })
-      .catch((playError : unknown) => {
-        deregisterCancellation();
-        if (cancelSignal.isCancelled()) {
-          return;
-        }
-        if (playError instanceof Error && playError.name === "NotAllowedError") {
-          // auto-play was probably prevented.
-          log.warn("Init: Media element can't play." +
-                   " It may be due to browser auto-play policies.");
+        return resolveAutoPlay({ type: "skipped" as const });
+      }
 
-          const error = new MediaError("MEDIA_ERR_BLOCKED_AUTOPLAY",
-                                       "Cannot trigger auto-play automatically: " +
-                                       "your browser does not allow it.");
-          onWarning(error);
+      let playResult : Promise<unknown>;
+      try {
+        playResult = mediaElement.play() ?? Promise.resolve();
+      } catch (playError) {
+        deregisterCancellation();
+        return rejectAutoPlay(playError);
+      }
+      playResult
+        .then(() => {
           if (cancelSignal.isCancelled()) {
             return;
           }
-          return resolveAutoPlay({ type: "autoplay-blocked" as const });
-        } else {
-          rejectAutoPlay(playError);
-        }
-      });
-  }
+          initialPlayPerformed.setValue(true);
+          initialPlayPerformed.finish();
+          deregisterCancellation();
+          return resolveAutoPlay({ type: "autoplay" as const });
+        })
+        .catch((playError : unknown) => {
+          deregisterCancellation();
+          if (cancelSignal.isCancelled()) {
+            return;
+          }
+          if (playError instanceof Error && playError.name === "NotAllowedError") {
+            // auto-play was probably prevented.
+            log.warn("Init: Media element can't play." +
+                     " It may be due to browser auto-play policies.");
+
+            const error = new MediaError("MEDIA_ERR_BLOCKED_AUTOPLAY",
+                                         "Cannot trigger auto-play automatically: " +
+                                         "your browser does not allow it.");
+            onWarning(error);
+            if (cancelSignal.isCancelled()) {
+              return;
+            }
+            return resolveAutoPlay({ type: "autoplay-blocked" as const });
+          } else {
+            rejectAutoPlay(playError);
+          }
+        });
+    }
+  });
+
+  return { autoPlayResult, initialPlayPerformed };
 }