rx-player 3.30.0-dev.2023020100 → 3.30.0-dev.2023030200

package/src/core/api/playback_observer.ts

@@ -217,7 +217,7 @@ export default class PlaybackObserver {
     options? : { includeLastObservation? : boolean | undefined;
                  clearSignal? : CancellationSignal | undefined; }
   ) {
-    if (this._canceller.isUsed || options?.clearSignal?.isCancelled === true) {
+    if (this._canceller.isUsed() || options?.clearSignal?.isCancelled() === true) {
       return noop;
     }
     this._observationRef.onUpdate(cb, {
@@ -971,7 +971,9 @@ function generateReadOnlyObserver<TSource, TDest>(
       options? : { includeLastObservation? : boolean | undefined;
                    clearSignal? : CancellationSignal | undefined; }
     ) : void {
-      if (cancellationSignal.isCancelled || options?.clearSignal?.isCancelled === true) {
+      if (cancellationSignal.isCancelled() ||
+          options?.clearSignal?.isCancelled() === true)
+      {
         return ;
       }
       mappedRef.onUpdate(cb, {

package/src/core/api/public_api.ts

@@ -364,7 +364,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     // See: https://bugzilla.mozilla.org/show_bug.cgi?id=1194624
     videoElement.preload = "auto";
 
-    this.version = /* PLAYER_VERSION */"3.30.0-dev.2023020100";
+    this.version = /* PLAYER_VERSION */"3.30.0-dev.2023030200";
     this.log = log;
     this.state = "STOPPED";
     this.videoElement = videoElement;
@@ -602,6 +602,21 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     this._priv_initializeContentPlayback(newOptions);
   }
 
+  public createDebugElement(element : HTMLElement) : {
+    dispose() : void;
+  } {
+    if (features.createDebugElement === null) {
+      throw new Error("Feature `DEBUG_ELEMENT` not added to the RxPlayer");
+    }
+    const canceller = new TaskCanceller() ;
+    features.createDebugElement(element, this, canceller.signal);
+    return {
+      dispose() {
+        canceller.cancel();
+      },
+    };
+  }
+
   /**
    * From given options, initialize content playback.
    * @param {Object} options
@@ -764,7 +779,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
           defaultTextTrack,
           currentContentCanceller.signal
         );
-      if (currentContentCanceller.isUsed) {
+      if (currentContentCanceller.isUsed()) {
         return;
       }
       initializer = new features.directfile.initDirectFile({ autoPlay,
@@ -943,7 +958,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
       updateReloadingMetadata(newState);
       this._priv_setPlayerState(newState);
 
-      if (currentContentCanceller.isUsed) {
+      if (currentContentCanceller.isUsed()) {
         return;
       }
 
@@ -953,9 +968,8 @@ class Player extends EventEmitter<IPublicAPIEvent> {
           seekEventsCanceller = null;
         }
       } else if (isLoadedState(this.state)) {
-        seekEventsCanceller = new TaskCanceller({
-          cancelOn: currentContentCanceller.signal,
-        });
+        seekEventsCanceller = new TaskCanceller();
+        seekEventsCanceller.linkToSignal(currentContentCanceller.signal);
         emitSeekEvents(videoElement,
                        playbackObserver,
                        () => this.trigger("seeking", null),
@@ -966,7 +980,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
       // Previous call could have performed all kind of side-effects, thus,
       // we re-check the current state associated to the RxPlayer
       if (this.state === PLAYER_STATES.ENDED && this._priv_stopAtEnd) {
-        currentContentCanceller.cancel();
+        this.stop();
       }
     }, { emitCurrentValue: true, clearSignal: currentContentCanceller.signal });
 
@@ -2468,20 +2482,20 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     this._priv_triggerAvailableBitratesChangeEvent("availableAudioBitratesChange",
                                                    this.getAvailableAudioBitrates(),
                                                    cancelSignal);
-    if (contentInfos.currentContentCanceller.isUsed) {
+    if (contentInfos.currentContentCanceller.isUsed()) {
       return;
     }
     this._priv_triggerAvailableBitratesChangeEvent("availableVideoBitratesChange",
                                                    this.getAvailableVideoBitrates(),
                                                    cancelSignal);
-    if (contentInfos.currentContentCanceller.isUsed) {
+    if (contentInfos.currentContentCanceller.isUsed()) {
       return;
     }
     const audioBitrate = this._priv_getCurrentRepresentations()?.audio?.bitrate ?? -1;
     this._priv_triggerCurrentBitrateChangeEvent("audioBitrateChange",
                                                 audioBitrate,
                                                 cancelSignal);
-    if (contentInfos.currentContentCanceller.isUsed) {
+    if (contentInfos.currentContentCanceller.isUsed()) {
       return;
     }
 
@@ -2833,7 +2847,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     currentContentCancelSignal  : CancellationSignal
   ) : void {
     const prevVal = this._priv_contentEventsMemory[event];
-    if (!currentContentCancelSignal.isCancelled &&
+    if (!currentContentCancelSignal.isCancelled() &&
         (prevVal === undefined || !areArraysOfNumbersEqual(newVal, prevVal)))
     {
       this._priv_contentEventsMemory[event] = newVal;
@@ -2853,7 +2867,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     newVal : number,
     currentContentCancelSignal  : CancellationSignal
   ) : void {
-    if (!currentContentCancelSignal.isCancelled &&
+    if (!currentContentCancelSignal.isCancelled() &&
         newVal !== this._priv_contentEventsMemory[event])
     {
       this._priv_contentEventsMemory[event] = newVal;
@@ -2886,7 +2900,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     arg : IEventPayload<IPublicAPIEvent, TEventName>,
     currentContentCancelSignal  : CancellationSignal
   ) {
-    if (!currentContentCancelSignal.isCancelled) {
+    if (!currentContentCancelSignal.isCancelled()) {
       this.trigger(evt, arg);
     }
   }
@@ -2971,7 +2985,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     return mediaElementTrackChoiceManager;
   }
 }
-Player.version = /* PLAYER_VERSION */"3.30.0-dev.2023020100";
+Player.version = /* PLAYER_VERSION */"3.30.0-dev.2023030200";
 
 /** Every events sent by the RxPlayer's public API. */
 interface IPublicAPIEvent {

package/src/core/api/utils.ts

@@ -48,14 +48,14 @@ export function emitSeekEvents(
   onSeeked: () => void,
   cancelSignal : CancellationSignal
 ) : void {
-  if (cancelSignal.isCancelled || mediaElement === null) {
+  if (cancelSignal.isCancelled() || mediaElement === null) {
     return ;
   }
 
   let wasSeeking = playbackObserver.getReference().getValue().seeking;
   if (wasSeeking) {
     onSeeking();
-    if (cancelSignal.isCancelled) {
+    if (cancelSignal.isCancelled()) {
       return;
     }
   }
@@ -94,7 +94,7 @@ export function constructPlayerStateReference(
   initializer.addEventListener("loaded", () => {
     if (playerStateRef.getValue() === PLAYER_STATES.LOADING) {
       playerStateRef.setValue(PLAYER_STATES.LOADED);
-      if (!cancelSignal.isCancelled) {
+      if (!cancelSignal.isCancelled()) {
         const newState = getLoadedContentState(mediaElement, null);
         if (newState !== PLAYER_STATES.PAUSED) {
           playerStateRef.setValue(newState);

package/src/core/decrypt/__tests__/__global__/utils.ts

@@ -40,48 +40,68 @@ import {
 import { CancellationSignal } from "../../../../utils/task_canceller";
 
 /** Default MediaKeySystemAccess configuration used by the RxPlayer. */
-export const defaultKSConfig = [{
-  audioCapabilities: [ { contentType: "audio/mp4;codecs=\"mp4a.40.2\"" },
-                       { contentType: "audio/webm;codecs=opus" } ],
-  distinctiveIdentifier: "optional" as const,
-  initDataTypes: ["cenc"] as const,
-  persistentState: "optional" as const,
-  sessionTypes: ["temporary"] as const,
-  videoCapabilities: [ { contentType: "video/mp4;codecs=\"avc1.4d401e\"" },
-                       { contentType: "video/mp4;codecs=\"avc1.42e01e\"" },
-                       { contentType: "video/webm;codecs=\"vp8\"" } ],
-}];
+export const defaultKSConfig = [
+  {
+    audioCapabilities: [ { contentType: "audio/mp4;codecs=\"mp4a.40.2\"" },
+                         { contentType: "audio/webm;codecs=opus" } ],
+    distinctiveIdentifier: "optional" as const,
+    initDataTypes: ["cenc"] as const,
+    persistentState: "optional" as const,
+    sessionTypes: ["temporary"] as const,
+    videoCapabilities: [ { contentType: "video/mp4;codecs=\"avc1.4d401e\"" },
+                         { contentType: "video/mp4;codecs=\"avc1.42e01e\"" },
+                         { contentType: "video/webm;codecs=\"vp8\"" } ],
+  },
+  {
+    audioCapabilities: undefined,
+    distinctiveIdentifier: "optional" as const,
+    initDataTypes: ["cenc"] as const,
+    persistentState: "optional" as const,
+    sessionTypes: ["temporary"] as const,
+    videoCapabilities: undefined,
+  },
+];
 
 /**
  * Default "com.microsoft.playready.recommendation" MediaKeySystemAccess
  * configuration used by the RxPlayer.
  */
-export const defaultPRRecommendationKSConfig = [{
-  audioCapabilities: [ { robustness: "3000",
-                         contentType: "audio/mp4;codecs=\"mp4a.40.2\"" },
-                       { robustness: "3000",
-                         contentType: "audio/webm;codecs=opus" },
-                       { robustness: "2000",
-                         contentType: "audio/mp4;codecs=\"mp4a.40.2\"" },
-                       { robustness: "2000",
-                         contentType: "audio/webm;codecs=opus" } ],
-  distinctiveIdentifier: "optional" as const,
-  initDataTypes: ["cenc"] as const,
-  persistentState: "optional" as const,
-  sessionTypes: ["temporary"] as const,
-  videoCapabilities: [ { robustness: "3000",
-                         contentType: "video/mp4;codecs=\"avc1.4d401e\"" },
-                       { robustness: "3000",
-                         contentType: "video/mp4;codecs=\"avc1.42e01e\"" },
-                       { robustness: "3000",
-                         contentType: "video/webm;codecs=\"vp8\"" },
-                       { robustness: "2000",
-                         contentType: "video/mp4;codecs=\"avc1.4d401e\"" },
-                       { robustness: "2000",
-                         contentType: "video/mp4;codecs=\"avc1.42e01e\"" },
-                       { robustness: "2000",
-                         contentType: "video/webm;codecs=\"vp8\"" } ],
-}];
+export const defaultPRRecommendationKSConfig = [
+  {
+    audioCapabilities: [ { robustness: "3000",
+                           contentType: "audio/mp4;codecs=\"mp4a.40.2\"" },
+                         { robustness: "3000",
+                           contentType: "audio/webm;codecs=opus" },
+                         { robustness: "2000",
+                           contentType: "audio/mp4;codecs=\"mp4a.40.2\"" },
+                         { robustness: "2000",
+                           contentType: "audio/webm;codecs=opus" } ],
+    distinctiveIdentifier: "optional" as const,
+    initDataTypes: ["cenc"] as const,
+    persistentState: "optional" as const,
+    sessionTypes: ["temporary"] as const,
+    videoCapabilities: [ { robustness: "3000",
+                           contentType: "video/mp4;codecs=\"avc1.4d401e\"" },
+                         { robustness: "3000",
+                           contentType: "video/mp4;codecs=\"avc1.42e01e\"" },
+                         { robustness: "3000",
+                           contentType: "video/webm;codecs=\"vp8\"" },
+                         { robustness: "2000",
+                           contentType: "video/mp4;codecs=\"avc1.4d401e\"" },
+                         { robustness: "2000",
+                           contentType: "video/mp4;codecs=\"avc1.42e01e\"" },
+                         { robustness: "2000",
+                           contentType: "video/webm;codecs=\"vp8\"" } ],
+  },
+  {
+    audioCapabilities: undefined,
+    distinctiveIdentifier: "optional" as const,
+    initDataTypes: ["cenc"] as const,
+    persistentState: "optional" as const,
+    sessionTypes: ["temporary"] as const,
+    videoCapabilities: undefined,
+  },
+];
 
 /** Default Widevine MediaKeySystemAccess configuration used by the RxPlayer. */
 export const defaultWidevineConfig = (() => {
@@ -104,9 +124,10 @@ export const defaultWidevineConfig = (() => {
             { contentType: "audio/webm;codecs=opus",
               robustness } ];
   });
-  return defaultKSConfig.map(conf => {
-    return { ...conf,  audioCapabilities, videoCapabilities };
-  });
+  return [
+    { ...defaultKSConfig[0],  audioCapabilities, videoCapabilities },
+    defaultKSConfig[1],
+  ];
 })();
 
 /**

package/src/core/decrypt/attach_media_keys.ts

@@ -62,7 +62,7 @@ export default async function attachMediaKeys(
 
   // If this task has been cancelled while we were closing previous sessions,
   // stop now (and thus avoid setting the new media keys);
-  if (cancelSignal.isCancelled) {
+  if (cancelSignal.isCancelled()) {
     throw cancelSignal.cancellationError;
   }
 

package/src/core/decrypt/content_decryptor.ts

@@ -727,7 +727,7 @@ export default class ContentDecryptor extends EventEmitter<IContentDecryptorEven
    * formatted and sent in an "error" event.
    */
   private _onFatalError(err : unknown) : void {
-    if (this._canceller.isUsed) {
+    if (this._canceller.isUsed()) {
       return;
     }
     const formattedErr = err instanceof Error ?

package/src/core/decrypt/find_key_system.ts

@@ -155,7 +155,9 @@ function buildKeySystemConfigurations(
   if (keySystem.distinctiveIdentifierRequired === true) {
     distinctiveIdentifier = "required";
   }
-  const { EME_DEFAULT_WIDEVINE_ROBUSTNESSES,
+  const { EME_DEFAULT_AUDIO_CODECS,
+          EME_DEFAULT_VIDEO_CODECS,
+          EME_DEFAULT_WIDEVINE_ROBUSTNESSES,
           EME_DEFAULT_PLAYREADY_ROBUSTNESSES } = config.getCurrent();
 
   // Set robustness, in order of consideration:
@@ -206,42 +208,41 @@ function buildKeySystemConfigurations(
   // https://www.w3.org/TR/encrypted-media/#get-supported-configuration-and-consent
 
   const videoCapabilities: IMediaCapability[] =
-    flatMap(videoRobustnesses, (robustness) =>
-      ["video/mp4;codecs=\"avc1.4d401e\"",
-       "video/mp4;codecs=\"avc1.42e01e\"",
-       "video/webm;codecs=\"vp8\""].map(contentType => {
-        return robustness !== undefined ? { contentType, robustness } :
-                                          { contentType };
-      }));
+    flatMap(videoRobustnesses, (robustness) => {
+      return EME_DEFAULT_VIDEO_CODECS.map(contentType => {
+        return robustness === undefined ? { contentType } :
+                                          { contentType, robustness };
+      });
+    });
 
   const audioCapabilities: IMediaCapability[] =
-    flatMap(audioRobustnesses, (robustness) =>
-      ["audio/mp4;codecs=\"mp4a.40.2\"",
-       "audio/webm;codecs=opus"].map(contentType => {
-        return robustness !== undefined ? { contentType, robustness } :
-                                          { contentType };
-      }));
-
-  // TODO Re-test with a set contentType but an undefined robustness on the
-  // STBs on which this problem was found.
-  //
-  // add another with no {audio,video}Capabilities for some legacy browsers.
-  // As of today's spec, this should return NotSupported but the first
-  // candidate configuration should be good, so we should have no downside
-  // doing that.
-  // initDataTypes: ["cenc"],
-  // videoCapabilities: undefined,
-  // audioCapabilities: undefined,
-  // distinctiveIdentifier,
-  // persistentState,
-  // sessionTypes,
-
-  return [{ initDataTypes: ["cenc"],
-            videoCapabilities,
-            audioCapabilities,
-            distinctiveIdentifier,
-            persistentState,
-            sessionTypes }];
+    flatMap(audioRobustnesses, (robustness) => {
+      return EME_DEFAULT_AUDIO_CODECS.map(contentType => {
+        return robustness === undefined ? { contentType } :
+                                          { contentType, robustness };
+      });
+    });
+
+  const wantedMediaKeySystemConfiguration : MediaKeySystemConfiguration = {
+    initDataTypes: ["cenc"],
+    videoCapabilities,
+    audioCapabilities,
+    distinctiveIdentifier,
+    persistentState,
+    sessionTypes,
+  };
+
+  return [
+    wantedMediaKeySystemConfiguration,
+
+    // Some legacy implementations have issues with `audioCapabilities` and
+    // `videoCapabilities`, so we're including a supplementary
+    // `MediaKeySystemConfiguration` without those properties.
+    { ...wantedMediaKeySystemConfiguration,
+      audioCapabilities: undefined ,
+      videoCapabilities: undefined,
+    } as unknown as MediaKeySystemConfiguration,
+  ];
 }
 
 /**

package/src/core/decrypt/session_events_listener.ts

@@ -58,13 +58,14 @@ export default function SessionEventsListener(
   const { getLicenseConfig = {} } = keySystemOptions;
 
   /** Allows to manually cancel everything the `SessionEventsListener` is doing. */
-  const manualCanceller = new TaskCanceller({ cancelOn: cancelSignal });
+  const manualCanceller = new TaskCanceller();
+  manualCanceller.linkToSignal(cancelSignal);
 
   if (!isNullOrUndefined(session.closed)) {
     session.closed
       .then(() => manualCanceller.cancel())
       .catch((err) => { // Should never happen
-        if (cancelSignal.isCancelled) {
+        if (cancelSignal.isCancelled()) {
           return;
         }
         manualCanceller.cancel();
@@ -79,8 +80,8 @@ export default function SessionEventsListener(
 
   onKeyStatusesChange(session, (keyStatusesEvent) => {
     handleKeyStatusesChangeEvent(keyStatusesEvent as Event).catch(error => {
-      if (cancelSignal.isCancelled ||
-          (manualCanceller.isUsed && error instanceof CancellationSignal))
+      if (cancelSignal.isCancelled() ||
+          (manualCanceller.isUsed() && error instanceof CancellationSignal))
       {
         return;
       }
@@ -104,7 +105,7 @@ export default function SessionEventsListener(
                             backoffOptions,
                             manualCanceller.signal)
       .then((licenseObject) => {
-        if (manualCanceller.isUsed) {
+        if (manualCanceller.isUsed()) {
           return Promise.resolve();
         }
         if (isNullOrUndefined(licenseObject)) {
@@ -114,7 +115,7 @@ export default function SessionEventsListener(
         }
       })
       .catch((err : unknown) => {
-        if (manualCanceller.isUsed) {
+        if (manualCanceller.isUsed()) {
           return;
         }
         manualCanceller.cancel();
@@ -133,6 +134,8 @@ export default function SessionEventsListener(
       });
   }, manualCanceller.signal);
 
+  checkAndHandleCurrentKeyStatuses();
+  return;
   /**
    * @param {Event} keyStatusesEvent
    * @returns {Promise}
@@ -144,22 +147,22 @@ export default function SessionEventsListener(
 
     await Promise.all([
       runOnKeyStatusesChangeCallback(),
-      Promise.resolve(handleKeyStatusEvent()),
+      Promise.resolve(checkAndHandleCurrentKeyStatuses()),
     ]);
 
     async function runOnKeyStatusesChangeCallback() {
-      if (manualCanceller.isUsed) {
+      if (manualCanceller.isUsed()) {
         return;
       }
       if (typeof keySystemOptions.onKeyStatusesChange === "function") {
         let ret;
         try {
           ret = await keySystemOptions.onKeyStatusesChange(keyStatusesEvent, session);
-          if (manualCanceller.isUsed) {
+          if (manualCanceller.isUsed()) {
             return;
           }
         } catch (error) {
-          if (cancelSignal.isCancelled) {
+          if (cancelSignal.isCancelled()) {
             return;
           }
           const err = new EncryptedMediaError("KEY_STATUS_CHANGE_ERROR",
@@ -178,67 +181,65 @@ export default function SessionEventsListener(
         }
       }
     }
+  }
 
-    /**
-     * Check current MediaKeyStatus for each key in the given MediaKeySession and:
-     *   - throw if at least one status is a non-recoverable error
-     *   - call warning callback for recoverable errors
-     *   - call onKeyUpdate callback when the MediaKeyStatus of any key is updated
-     */
-    function handleKeyStatusEvent() : void {
-      if (manualCanceller.isUsed || session.keyStatuses.size === 0) {
-        return ;
-      }
-      const { warning, blacklistedKeyIds, whitelistedKeyIds } =
-        checkKeyStatuses(session, keySystemOptions, keySystem);
-      if (warning !== undefined) {
-        callbacks.onWarning(warning);
-        if (manualCanceller.isUsed) {
-          return;
-        }
+  /**
+   * Check current MediaKeyStatus for each key in the given MediaKeySession and:
+   *   - throw if at least one status is a non-recoverable error
+   *   - call warning callback for recoverable errors
+   *   - call onKeyUpdate callback when the MediaKeyStatus of any key is updated
+   */
+  function checkAndHandleCurrentKeyStatuses() : void {
+    if (manualCanceller.isUsed() || session.keyStatuses.size === 0) {
+      return ;
+    }
+    const { warning, blacklistedKeyIds, whitelistedKeyIds } =
+      checkKeyStatuses(session, keySystemOptions, keySystem);
+    if (warning !== undefined) {
+      callbacks.onWarning(warning);
+      if (manualCanceller.isUsed()) {
+        return;
       }
-      callbacks.onKeyUpdate({ whitelistedKeyIds, blacklistedKeyIds });
     }
+    callbacks.onKeyUpdate({ whitelistedKeyIds, blacklistedKeyIds });
   }
 
   function runGetLicense(
     message : Uint8Array,
     messageType : MediaKeyMessageType
   ) : Promise<BufferSource | null> {
-    return new Promise((res, rej) => {
-      log.debug("DRM: Calling `getLicense`", messageType);
-      const getLicense = keySystemOptions.getLicense(message, messageType);
-      const getLicenseTimeout = isNullOrUndefined(getLicenseConfig.timeout) ?
-        10 * 1000 :
-        getLicenseConfig.timeout;
-
-      let timeoutId : number | undefined;
-      if (getLicenseTimeout >= 0) {
-        timeoutId = setTimeout(() => {
-          rej(new GetLicenseTimeoutError(
-            `"getLicense" timeout exceeded (${getLicenseTimeout} ms)`
-          ));
-        }, getLicenseTimeout) as unknown as number;
-      }
-
+    let timeoutId : number | undefined;
+    return new Promise<BufferSource | null>((res, rej) => {
       try {
-        Promise.resolve(getLicense).then(
-          (val) => {
-            clearTimeoutIfOne();
-            res(val);
-          },
-          (err) => {
-            clearTimeoutIfOne();
-            rej(err);
-          });
+        log.debug("DRM: Calling `getLicense`", messageType);
+        const getLicense = keySystemOptions.getLicense(message, messageType);
+        const getLicenseTimeout = isNullOrUndefined(getLicenseConfig.timeout) ?
+          10 * 1000 :
+          getLicenseConfig.timeout;
+
+        if (getLicenseTimeout >= 0) {
+          timeoutId = setTimeout(() => {
+            rej(new GetLicenseTimeoutError(
+              `"getLicense" timeout exceeded (${getLicenseTimeout} ms)`
+            ));
+          }, getLicenseTimeout) as unknown as number;
+        }
+        Promise.resolve(getLicense)
+          .then(clearTimeoutAndResolve, clearTimeoutAndReject);
       } catch (err) {
-        clearTimeoutIfOne();
-        rej(err);
+        clearTimeoutAndReject(err);
       }
-      function clearTimeoutIfOne() {
+      function clearTimeoutAndResolve(data : BufferSource | null) {
         if (timeoutId !== undefined) {
           clearTimeout(timeoutId);
         }
+        res(data);
+      }
+      function clearTimeoutAndReject(err : unknown) {
+        if (timeoutId !== undefined) {
+          clearTimeout(timeoutId);
+        }
+        rej(err);
       }
     });
   }

package/src/core/decrypt/utils/check_key_statuses.ts

@@ -18,6 +18,7 @@ import { ICustomMediaKeySession } from "../../../compat";
 /* eslint-disable-next-line max-len */
 import getUUIDKidFromKeyStatusKID from "../../../compat/eme/get_uuid_kid_from_keystatus_kid";
 import { EncryptedMediaError } from "../../../errors";
+import log from "../../../log";
 import {
   IEncryptedMediaErrorKeyStatusObject,
   IKeySystemOption,
@@ -109,6 +110,11 @@ export default function checkKeyStatuses(
                                              new Uint8Array(keyStatusKeyId));
 
     const keyStatusObj = { keyId: keyId.buffer, keyStatus };
+
+    if (log.hasLevel("DEBUG")) {
+      log.debug(`DRM: key status update (${bytesToHex(keyId)}): ${keyStatus}`);
+    }
+
     switch (keyStatus) {
       case KEY_STATUSES.EXPIRED: {
         const error = new EncryptedMediaError(