rx-player 4.2.0-dev.2024100200 → 4.2.0

package/src/core/segment_sinks/segment_buffers_store.ts

@@ -103,7 +103,11 @@ export default class SegmentSinksStore {
    * disabled. This means that the corresponding type (e.g. audio, video etc.)
    * won't be needed when playing the current content.
    */
-  private _initializedSegmentSinks: Partial<Record<IBufferType, SegmentSink | null>>;
+  private _initializedSegmentSinks: {
+    audio?: AudioVideoSegmentSink | undefined | null;
+    video?: AudioVideoSegmentSink | undefined | null;
+    text?: TextSegmentSink | null;
+  };
 
   /**
    * Callbacks called after a SourceBuffer is either created or disabled.
@@ -308,7 +312,7 @@ export default class SegmentSinksStore {
       return memorizedSegmentSink;
     }
 
-    let segmentSink: SegmentSink;
+    let segmentSink: TextSegmentSink;
     if (bufferType === "text") {
       log.info("SB: Creating a new text SegmentSink");
       if (this._textInterface === null) {

package/src/experimental/tools/mediaCapabilitiesProber/probers/DRMInfos.ts

@@ -14,7 +14,12 @@
  * limitations under the License.
  */
 
+import { canRelyOnRequestMediaKeySystemAccess } from "../../../../compat/can_rely_on_request_media_key_system_access";
 import eme from "../../../../compat/eme";
+import {
+  DUMMY_PLAY_READY_HEADER,
+  generatePlayReadyInitData,
+} from "../../../../compat/generate_init_data";
 import isNullOrUndefined from "../../../../utils/is_null_or_undefined";
 import log from "../log";
 import type { ICompatibleKeySystem, IMediaConfiguration } from "../types";
@@ -57,13 +62,40 @@ export default function probeDRMInfos(
 
   return eme
     .requestMediaKeySystemAccess(type, [configuration])
-    .then((keySystemAccess) => {
-      result.compatibleConfiguration = keySystemAccess.getConfiguration();
-      const status: [ProberStatus, ICompatibleKeySystem?] = [
-        ProberStatus.Supported,
-        result,
-      ];
-      return status;
+    .then(async (keySystemAccess) => {
+      if (!canRelyOnRequestMediaKeySystemAccess(type)) {
+        try {
+          const mediaKeys = await keySystemAccess.createMediaKeys();
+          const session = mediaKeys.createSession();
+          const initData = generatePlayReadyInitData(DUMMY_PLAY_READY_HEADER);
+          await session.generateRequest("cenc", initData);
+          session.close().catch(() => {
+            log.warn("DRM: Failed to close the dummy session");
+          });
+          result.compatibleConfiguration = keySystemAccess.getConfiguration();
+          const status: [ProberStatus, ICompatibleKeySystem?] = [
+            ProberStatus.Supported,
+            result,
+          ];
+          return status;
+        } catch (err) {
+          log.debug("DRM: KeySystemAccess was granted but it is not usable");
+
+          const statusError: [ProberStatus, ICompatibleKeySystem] = [
+            ProberStatus.NotSupported,
+            result,
+          ];
+          return statusError;
+        }
+      } else {
+        result.compatibleConfiguration = keySystemAccess.getConfiguration();
+
+        const status: [ProberStatus, ICompatibleKeySystem?] = [
+          ProberStatus.Supported,
+          result,
+        ];
+        return status;
+      }
     })
     .catch(() => {
       return [ProberStatus.NotSupported, result];

package/src/main_thread/api/debug/modules/general_info.ts

@@ -65,7 +65,7 @@ export default function constructDebugGeneralInfo(
         valuesLine1.push(["wo", "0"]);
       }
 
-      const valuesLine2: Array<[string, string]> = [];
+      const valuesLine2: Array<[string, string]> = [["v", instance.version]];
       const ks = instance.getKeySystemConfiguration();
       if (ks !== null) {
         valuesLine2.push(["ks", ks.keySystem]);

package/src/main_thread/api/public_api.ts

@@ -411,7 +411,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     // See: https://bugzilla.mozilla.org/show_bug.cgi?id=1194624
     videoElement.preload = "auto";
 
-    this.version = /* PLAYER_VERSION */ "4.2.0-dev.2024100200";
+    this.version = /* PLAYER_VERSION */ "4.2.0";
     this.log = log;
     this.state = "STOPPED";
     this.videoElement = videoElement;
@@ -3330,7 +3330,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     }
   }
 }
-Player.version = /* PLAYER_VERSION */ "4.2.0-dev.2024100200";
+Player.version = /* PLAYER_VERSION */ "4.2.0";
 
 /** Every events sent by the RxPlayer's public API. */
 interface IPublicAPIEvent {

package/src/main_thread/decrypt/create_or_load_session.ts

@@ -82,7 +82,12 @@ export default async function createOrLoadSession(
     }
   }
 
-  await cleanOldLoadedSessions(loadedSessionsStore, maxSessionCacheSize);
+  await cleanOldLoadedSessions(
+    loadedSessionsStore,
+    // Account for the next session we will be creating
+    // Note that `maxSessionCacheSize < 0 has special semantic (no limit)`
+    maxSessionCacheSize <= 0 ? maxSessionCacheSize : maxSessionCacheSize - 1,
+  );
   if (cancelSignal.cancellationError !== null) {
     throw cancelSignal.cancellationError; // stop here if cancelled since
   }

package/src/main_thread/decrypt/find_key_system.ts

@@ -539,6 +539,9 @@ export async function testKeySystem(
       const session = mediaKeys.createSession();
       const initData = generatePlayReadyInitData(DUMMY_PLAY_READY_HEADER);
       await session.generateRequest("cenc", initData);
+      session.close().catch(() => {
+        log.warn("DRM: Failed to close the dummy session");
+      });
     } catch (err) {
       log.debug("DRM: KeySystemAccess was granted but it is not usable");
       throw err;

package/src/main_thread/decrypt/get_media_keys.ts

@@ -98,6 +98,7 @@ export default async function getMediaKeysInfos(
   const persistentSessionsStore = createPersistentSessionsStorage(options);
 
   if (
+    evt.value.options.reuseMediaKeys !== false &&
     canReuseMediaKeys() &&
     currentState !== null &&
     evt.type === "reuse-media-key-system-access"

package/src/main_thread/init/media_source_content_initializer.ts

@@ -92,7 +92,7 @@ import listenToMediaError from "./utils/throw_on_media_error";
  */
 export default class MediaSourceContentInitializer extends ContentInitializer {
   /** Constructor settings associated to this `MediaSourceContentInitializer`. */
-  private _settings: IInitializeArguments;
+  private _initSettings: IInitializeArguments;
   /**
    * `TaskCanceller` allowing to abort everything that the
    * `MediaSourceContentInitializer` is doing.
@@ -145,7 +145,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
    */
   constructor(settings: IInitializeArguments) {
     super();
-    this._settings = settings;
+    this._initSettings = settings;
     this._initCanceller = new TaskCanceller();
     this._manifest = null;
     this._decryptionCapabilities = { status: "uninitialized", value: null };
@@ -234,6 +234,10 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
     this._initCanceller.cancel();
   }
 
+  /**
+   * Callback called when an error interrupting playback arised.
+   * @param {*} err
+   */
   private _onFatalError(err: unknown) {
     if (this._initCanceller.isUsed()) {
       return;
@@ -242,6 +246,12 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
     this.trigger("error", err);
   }
 
+  /**
+   * Initialize decryption mechanisms if needed and begin creating and relying
+   * on the initial `MediaSourceInterface` for this content.
+   * @param {HTMLMediaElement|null} mediaElement
+   * @returns {Promise.<Object>}
+   */
   private _initializeMediaSourceAndDecryption(mediaElement: IMediaElement): Promise<{
     mediaSource: MainMediaSourceInterface;
     drmSystemId: string | undefined;
@@ -249,7 +259,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
   }> {
     const initCanceller = this._initCanceller;
     return createCancellablePromise(initCanceller.signal, (resolve) => {
-      const { keySystems } = this._settings;
+      const { keySystems } = this._initSettings;
 
       /** Initialize decryption capabilities. */
       const { statusRef: drmInitRef, contentDecryptor } = initializeContentDecryption(
@@ -383,7 +393,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
       startAt,
       textTrackOptions,
       transport,
-    } = this._settings;
+    } = this._initSettings;
     const initCanceller = this._initCanceller;
     assert(this._manifest !== null);
     let manifest: IManifest;
@@ -526,7 +536,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
    */
   private _startBufferingOnMediaSource(
     args: IBufferingMediaSettings,
-    onReloadOrder: (reloadOrder: { position: number; autoPlay: boolean }) => void,
+    onReloadOrder: IReloadMediaSourceCallback,
     cancelSignal: CancellationSignal,
   ): void {
     const {
@@ -553,18 +563,10 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
     }
 
     let textDisplayerInterface: ITextDisplayerInterface | null = null;
-    let textDisplayer: ITextDisplayer | null = null;
-    if (
-      this._settings.textTrackOptions.textTrackMode === "html" &&
-      features.htmlTextDisplayer !== null
-    ) {
-      textDisplayer = new features.htmlTextDisplayer(
-        mediaElement,
-        this._settings.textTrackOptions.textTrackElement,
-      );
-    } else if (features.nativeTextDisplayer !== null) {
-      textDisplayer = new features.nativeTextDisplayer(mediaElement);
-    }
+    const textDisplayer = createTextDisplayer(
+      mediaElement,
+      this._initSettings.textTrackOptions,
+    );
     if (textDisplayer !== null) {
       const sender = new MainThreadTextDisplayerInterface(textDisplayer);
       textDisplayerInterface = sender;
@@ -1123,6 +1125,21 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
   }
 }
 
+function createTextDisplayer(
+  mediaElement: IMediaElement,
+  textTrackOptions: ITextDisplayerOptions,
+): ITextDisplayer | null {
+  if (textTrackOptions.textTrackMode === "html" && features.htmlTextDisplayer !== null) {
+    return new features.htmlTextDisplayer(
+      mediaElement,
+      textTrackOptions.textTrackElement,
+    );
+  } else if (features.nativeTextDisplayer !== null) {
+    return new features.nativeTextDisplayer(mediaElement);
+  }
+  return null;
+}
+
 /** Arguments to give to the `InitializeOnMediaSource` function. */
 export interface IInitializeArguments {
   /** Options concerning the ABR logic. */
@@ -1324,3 +1341,19 @@ function blackListProtectionDataOnManifest(
     return rep.decipherable;
   });
 }
+
+/**
+ * Function to call when you want to "reload" the MediaSource: basically
+ * restarting playback on a new MediaSource for the same content (it may
+ * be for varied reasons, such as ensuring data buffers are empty, or
+ * restarting after some kind of fatal error).
+ * @param {Object} reloadOrder
+ * @param {number} reloadOrder.position - Position in seconds at which we
+ * should restart from when playback restarts.
+ * @param {boolean} reloadOrder.autoPlay - If `true` we will directly play
+ * once enough data is re-loaded.
+ */
+type IReloadMediaSourceCallback = (reloadOrder: {
+  position: number;
+  autoPlay: boolean;
+}) => void;

package/src/main_thread/init/multi_thread_content_initializer.ts

@@ -113,12 +113,13 @@ export default class MultiThreadContentInitializer extends ContentInitializer {
   private _currentMediaSourceCanceller: TaskCanceller;
 
   /**
-   * Stores the resolvers and the current messageId that is sent to the web worker to receive segment sink metrics.
+   * Stores the resolvers and the current messageId that is sent to the web worker to
+   * receive segment sink metrics.
    * The purpose of collecting metrics is for monitoring and debugging.
    */
   private _segmentMetrics: {
     lastMessageId: number;
-    resolvers: Record<number, (value: ISegmentSinkMetrics | undefined) => void>;
+    resolvers: Map<number, (value: ISegmentSinkMetrics | undefined) => void>;
   };
 
   /**
@@ -135,7 +136,7 @@ export default class MultiThreadContentInitializer extends ContentInitializer {
     this._currentContentInfo = null;
     this._segmentMetrics = {
       lastMessageId: 0,
-      resolvers: {},
+      resolvers: new Map(),
     };
     this._queuedWorkerMessages = null;
   }
@@ -1121,10 +1122,9 @@ export default class MultiThreadContentInitializer extends ContentInitializer {
           if (this._currentContentInfo?.contentId !== msgData.contentId) {
             return;
           }
-          const resolveFn = this._segmentMetrics.resolvers[msgData.value.messageId];
+          const resolveFn = this._segmentMetrics.resolvers.get(msgData.value.messageId);
           if (resolveFn !== undefined) {
             resolveFn(msgData.value.segmentSinkMetrics);
-            delete this._segmentMetrics.resolvers[msgData.value.messageId];
           } else {
             log.error("MTCI: Failed to send segment sink store update");
           }
@@ -1589,11 +1589,19 @@ export default class MultiThreadContentInitializer extends ContentInitializer {
         value: { messageId },
       });
       return new Promise((resolve, reject) => {
-        this._segmentMetrics.resolvers[messageId] = resolve;
         const rejectFn = (err: CancellationError) => {
-          delete this._segmentMetrics.resolvers[messageId];
+          cancelSignal.deregister(rejectFn);
+          this._segmentMetrics.resolvers.delete(messageId);
           return reject(err);
         };
+        this._segmentMetrics.resolvers.set(
+          messageId,
+          (value: ISegmentSinkMetrics | undefined) => {
+            cancelSignal.deregister(rejectFn);
+            this._segmentMetrics.resolvers.delete(messageId);
+            resolve(value);
+          },
+        );
         cancelSignal.register(rejectFn);
       });
     };

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

@@ -121,13 +121,9 @@ export default function performInitialSeekAndPlay(
               obs.readyState < HTMLMediaElement.HAVE_CURRENT_DATA
             ) {
               /**
-               * On browser, such as Safari, the HTMLMediaElement.duration
-               * and HTMLMediaElement.buffered may not be initialized at readyState 1, leading
-               * to cases where it can be equal to `Infinity`.
-               * If so, the range in which it is possible to seek is not yet known.
-               * To solve this, the seek should be done after readyState HAVE_CURRENT_DATA (2),
-               * at that time the previously mentioned attributes are correctly initialized and
-               * the range in which it is possible to seek is correctly known.
+               * The starting position may not be known yet.
+               * Postpone the seek to a moment where the starting position should be known,
+               * assumely it's when readyState is greater or equal to HAVE_CURRENT_DATA (2).
                * If the initiallySeekedTime is still `undefined` when the readyState is >= 2,
                * let assume that the initiallySeekedTime will never be known and continue
                * the logic without seeking.

package/src/main_thread/text_displayer/native/native_text_displayer.ts

@@ -158,24 +158,7 @@ export default class NativeTextDisplayer implements ITextDisplayer {
   public reset(): void {
     log.debug("NTD: Aborting NativeTextDisplayer");
     this._removeData(0, Infinity);
-    const { _trackElement, _videoElement } = this;
-
-    if (_trackElement !== undefined && _videoElement.hasChildNodes()) {
-      try {
-        _videoElement.removeChild(_trackElement);
-      } catch (_e) {
-        log.warn("NTD: Can't remove track element from the video");
-      }
-    }
-
-    // Ugly trick to work-around browser bugs by refreshing its mode
-    const oldMode = this._track.mode;
-    this._track.mode = "disabled";
-    this._track.mode = oldMode;
-
-    if (this._trackElement !== undefined) {
-      this._trackElement.innerHTML = "";
-    }
+    this._clearTrackElement();
   }
 
   public stop(): void {
@@ -213,6 +196,27 @@ export default class NativeTextDisplayer implements ITextDisplayer {
     }
     this._buffered.remove(start, end);
   }
+
+  private _clearTrackElement(): void {
+    const { _trackElement, _videoElement } = this;
+
+    if (_trackElement !== undefined && _videoElement.hasChildNodes()) {
+      try {
+        _videoElement.removeChild(_trackElement);
+      } catch (_e) {
+        log.warn("NTD: Can't remove track element from the video");
+      }
+    }
+
+    // Ugly trick to work-around browser bugs by refreshing its mode
+    const oldMode = this._track.mode;
+    this._track.mode = "disabled";
+    this._track.mode = oldMode;
+
+    if (this._trackElement !== undefined) {
+      this._trackElement.innerHTML = "";
+    }
+  }
 }
 
 /** Data of chunks that should be pushed to the NativeTextDisplayer. */

package/src/public_types.ts

@@ -559,11 +559,62 @@ export interface IKeySystemOption {
    */
   distinctiveIdentifier?: MediaKeysRequirement | undefined;
   /**
-   * If true, all open MediaKeySession (used to decrypt the content) will be
-   * closed when the current playback stops.
+   * If true, all open `MediaKeySession` (JavaScript Objects linked to the keys
+   * used to decrypt the content) will be closed when the current playback
+   * stops.
+   *
+   * By default, we keep `MediaKeySession` from previous contents (up to
+   * `maxSessionCacheSize` `MediaKeySession`) to speed-up playback and avoid
+   * round-trips to the license server if the user ever decide to go back to
+   * those contents or to other contents relying to the same keys.
+   *
+   * However we found that some devices poorly handle that optimization.
+   *
+   * Note that if setting that property to `true` fixes your issue, it may be
+   * that it's just the `maxSessionCacheSize` which is for now too high.
+   *
+   * However if your problem doesn't disappear after setting
+   * `closeSessionsOnStop` to `true`, you may try `reuseMediaKeys` next.
    */
   closeSessionsOnStop?: boolean;
-
+  /**
+   * If set to `true` or if not set, we might rely on the previous `MediaKeys`
+   * if a compatible one is already set on the media element, allowing to
+   * potentially speed-up content playback.
+   *
+   * If set to `false`, we will create a new `MediaKeys` instance (a
+   * JavaScript object needed to decrypt contents) if needed for that content.
+   *
+   * We noticed that reusing a previous MediaKeys had led to errors on a few
+   * devices. For example some smart TVs had shown errors after playing several
+   * encrypted contents, errors which disappeared if we renewed the
+   * `MediaKeys` for each content.
+   *
+   * We should already be able to detect most of those cases in the RxPlayer
+   * logic. However, it is still possible that we don't know yet of a device
+   * which also has problem with that optimization.
+   *
+   * If you have issues appearing only after playing multiple encrypted
+   * contents:
+   *
+   *   - First, try setting the `closeSessionsOnStop` option which is less
+   *     destructive.
+   *
+   *     If it fixes your issue, it may be that it's just the number of
+   *     `MediaKeySession` cached by the RxPlayer that is here too high.
+   *
+   *     In that case you can instead update the `maxSessionCacheSize` option
+   *     to still profit from a `MediaKeySession` cache (which avoid making
+   *     license requests for already-played contents).
+   *
+   *     If that second option doesn't seem to have an effect, you can just set
+   *     `closeSessionsOnStop`.
+   *
+   *   - If none of the precedent work-arounds work however, you can try setting
+   *     `reuseMediaKeys` to `false`. If it fixes your problem, please open an
+   *     RxPlayer issue so we can add your device to our list.
+   */
+  reuseMediaKeys?: boolean | undefined;
   singleLicensePer?: "content" | "periods" | "init-data";
   /**
    * Maximum number of `MediaKeySession` that should be created on the same

package/src/utils/sync_or_async.ts

@@ -78,12 +78,14 @@ const SyncOrAsync = {
    * @returns {Object}
    */
   createAsync<T>(val: Promise<T>): ISyncOrAsyncValue<T> {
-    let ret = null;
-    val.then((resolved) => {
+    let ret: T | null = null;
+    val.then((resolved: T) => {
       ret = resolved;
     }, noop);
     return {
-      syncValue: ret,
+      get syncValue(): T | null {
+        return ret;
+      },
       getValueAsAsync() {
         return val;
       },