rx-player 4.2.0-dev.2024100200 → 4.2.0-dev.2024101500

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-dev.2024101500";
     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-dev.2024101500";
 
 /** Every events sent by the RxPlayer's public API. */
 interface IPublicAPIEvent {

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/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/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/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;
       },