rx-player 4.3.0-dev.2024112900 → 4.3.0-dev.2025012900

package/src/main_thread/decrypt/__tests__/find_key_system.test.ts

@@ -0,0 +1,325 @@
+import type { MockInstance } from "vitest";
+import { describe, beforeEach, it, expect, vi } from "vitest";
+import eme from "../../../compat/eme";
+import type { IKeySystemOption } from "../../../public_types";
+import TaskCanceller from "../../../utils/task_canceller";
+import getMediaKeySystemAccess from "../find_key_system";
+import LoadedSessionsStore from "../utils/loaded_sessions_store";
+import mediaKeysAttacher from "../utils/media_keys_attacher";
+
+describe("find_key_systems - ", () => {
+  let requestMediaKeySystemAccessMock: MockInstance;
+
+  beforeEach(() => {
+    vi.resetModules();
+    vi.restoreAllMocks();
+    requestMediaKeySystemAccessMock = vi.spyOn(eme, "requestMediaKeySystemAccess");
+  });
+
+  const baseEmeConfiguration: MediaKeySystemConfiguration = {
+    initDataTypes: ["cenc"],
+    videoCapabilities: [
+      {
+        contentType: 'video/mp4;codecs="avc1.4d401e"',
+        robustness: "HW_SECURE_ALL",
+      },
+      {
+        contentType: 'video/mp4;codecs="avc1.42e01e"',
+        robustness: "HW_SECURE_ALL",
+      },
+      {
+        contentType: 'video/mp4;codecs="hvc1.1.6.L93.B0"',
+        robustness: "HW_SECURE_ALL",
+      },
+      {
+        contentType: 'video/webm;codecs="vp8"',
+        robustness: "HW_SECURE_ALL",
+      },
+      {
+        contentType: 'video/mp4;codecs="avc1.4d401e"',
+        robustness: "HW_SECURE_DECODE",
+      },
+      {
+        contentType: 'video/mp4;codecs="avc1.42e01e"',
+        robustness: "HW_SECURE_DECODE",
+      },
+      {
+        contentType: 'video/mp4;codecs="hvc1.1.6.L93.B0"',
+        robustness: "HW_SECURE_DECODE",
+      },
+      {
+        contentType: 'video/webm;codecs="vp8"',
+        robustness: "HW_SECURE_DECODE",
+      },
+      {
+        contentType: 'video/mp4;codecs="avc1.4d401e"',
+        robustness: "HW_SECURE_CRYPTO",
+      },
+      {
+        contentType: 'video/mp4;codecs="avc1.42e01e"',
+        robustness: "HW_SECURE_CRYPTO",
+      },
+      {
+        contentType: 'video/mp4;codecs="hvc1.1.6.L93.B0"',
+        robustness: "HW_SECURE_CRYPTO",
+      },
+      {
+        contentType: 'video/webm;codecs="vp8"',
+        robustness: "HW_SECURE_CRYPTO",
+      },
+      {
+        contentType: 'video/mp4;codecs="avc1.4d401e"',
+        robustness: "SW_SECURE_DECODE",
+      },
+      {
+        contentType: 'video/mp4;codecs="avc1.42e01e"',
+        robustness: "SW_SECURE_DECODE",
+      },
+      {
+        contentType: 'video/mp4;codecs="hvc1.1.6.L93.B0"',
+        robustness: "SW_SECURE_DECODE",
+      },
+      {
+        contentType: 'video/webm;codecs="vp8"',
+        robustness: "SW_SECURE_DECODE",
+      },
+      {
+        contentType: 'video/mp4;codecs="avc1.4d401e"',
+        robustness: "SW_SECURE_CRYPTO",
+      },
+      {
+        contentType: 'video/mp4;codecs="avc1.42e01e"',
+        robustness: "SW_SECURE_CRYPTO",
+      },
+      {
+        contentType: 'video/mp4;codecs="hvc1.1.6.L93.B0"',
+        robustness: "SW_SECURE_CRYPTO",
+      },
+      {
+        contentType: 'video/webm;codecs="vp8"',
+        robustness: "SW_SECURE_CRYPTO",
+      },
+    ],
+    audioCapabilities: [
+      {
+        contentType: 'audio/mp4;codecs="mp4a.40.2"',
+        robustness: "HW_SECURE_ALL",
+      },
+      {
+        contentType: "audio/webm;codecs=opus",
+        robustness: "HW_SECURE_ALL",
+      },
+      {
+        contentType: 'audio/mp4;codecs="mp4a.40.2"',
+        robustness: "HW_SECURE_DECODE",
+      },
+      {
+        contentType: "audio/webm;codecs=opus",
+        robustness: "HW_SECURE_DECODE",
+      },
+      {
+        contentType: 'audio/mp4;codecs="mp4a.40.2"',
+        robustness: "HW_SECURE_CRYPTO",
+      },
+      {
+        contentType: "audio/webm;codecs=opus",
+        robustness: "HW_SECURE_CRYPTO",
+      },
+      {
+        contentType: 'audio/mp4;codecs="mp4a.40.2"',
+        robustness: "SW_SECURE_DECODE",
+      },
+      {
+        contentType: "audio/webm;codecs=opus",
+        robustness: "SW_SECURE_DECODE",
+      },
+      {
+        contentType: 'audio/mp4;codecs="mp4a.40.2"',
+        robustness: "SW_SECURE_CRYPTO",
+      },
+      {
+        contentType: "audio/webm;codecs=opus",
+        robustness: "SW_SECURE_CRYPTO",
+      },
+    ],
+    distinctiveIdentifier: "optional",
+    persistentState: "optional",
+    sessionTypes: ["temporary"],
+  };
+
+  it("should create a media key the first time and then reuse the previous one if it's the same configuration", async () => {
+    requestMediaKeySystemAccessMock.mockImplementation(() => {
+      return {
+        keySystem: "com.widevine.alpha",
+        createMediaKeys: () => ({
+          createSession: () => ({
+            // eslint-disable-next-line @typescript-eslint/no-empty-function
+            generateRequest: () => {},
+          }),
+        }),
+        getConfiguration: () => {
+          return baseEmeConfiguration;
+        },
+      };
+    });
+    const mediaElement = document.createElement("video");
+    const keySystemOptionsA: IKeySystemOption[] = [
+      {
+        type: "com.widevine.alpha",
+        getLicense: () => null,
+        persistentState: "optional",
+      },
+    ];
+
+    const taskCanceller = new TaskCanceller();
+    const event1 = await getMediaKeySystemAccess(
+      mediaElement,
+      keySystemOptionsA,
+      taskCanceller.signal,
+    );
+    expect(event1.type).toBe("create-media-key-system-access");
+
+    // create the mediaKeys and add it to the cache
+    const mediaKeys = await event1.value.mediaKeySystemAccess.createMediaKeys();
+    await mediaKeysAttacher.attach(mediaElement, {
+      keySystemOptions: keySystemOptionsA[0],
+      emeImplementation: eme,
+      askedConfiguration: baseEmeConfiguration,
+      mediaKeys,
+      mediaKeySystemAccess: event1.value.mediaKeySystemAccess,
+      loadedSessionsStore: new LoadedSessionsStore(mediaKeys),
+    });
+
+    const event2 = await getMediaKeySystemAccess(
+      mediaElement,
+      keySystemOptionsA,
+      taskCanceller.signal,
+    );
+    expect(event2.type).toBe("reuse-media-key-system-access");
+  });
+
+  it("should create a media key the first time and then create another one if the previous is not compatible.", async () => {
+    requestMediaKeySystemAccessMock.mockImplementation(() => {
+      return {
+        keySystem: "com.widevine.alpha",
+        createMediaKeys: () => ({
+          createSession: () => ({
+            // eslint-disable-next-line @typescript-eslint/no-empty-function
+            generateRequest: () => {},
+          }),
+        }),
+        getConfiguration: () => {
+          return baseEmeConfiguration;
+        },
+      };
+    });
+    const mediaElement = document.createElement("video");
+    const keySystemOptionsA: IKeySystemOption[] = [
+      {
+        type: "com.widevine.alpha",
+        getLicense: () => null,
+        persistentState: "optional",
+      },
+    ];
+
+    const taskCanceller = new TaskCanceller();
+    const event1 = await getMediaKeySystemAccess(
+      mediaElement,
+      keySystemOptionsA,
+      taskCanceller.signal,
+    );
+    expect(event1.type).toBe("create-media-key-system-access");
+
+    // create the mediaKeys and add it to the cache
+    const mediaKeys = await event1.value.mediaKeySystemAccess.createMediaKeys();
+    await mediaKeysAttacher.attach(mediaElement, {
+      keySystemOptions: keySystemOptionsA[0],
+      emeImplementation: eme,
+      askedConfiguration: baseEmeConfiguration,
+      mediaKeys,
+      mediaKeySystemAccess: event1.value.mediaKeySystemAccess,
+      loadedSessionsStore: new LoadedSessionsStore(mediaKeys),
+    });
+
+    const keySystemOptionsB: IKeySystemOption[] = [
+      {
+        type: "com.widevine.alpha",
+        getLicense: () => null,
+        persistentState: "required", // persistentState differs from configuration A.
+      },
+    ];
+
+    const event2 = await getMediaKeySystemAccess(
+      mediaElement,
+      keySystemOptionsB,
+      taskCanceller.signal,
+    );
+    expect(event2.type).toBe("create-media-key-system-access");
+  });
+
+  it("should create a media key the first time and then reuse the previous one if it's a different configuration but it's a compatible configuration.", async () => {
+    requestMediaKeySystemAccessMock.mockImplementation(() => {
+      return {
+        keySystem: "com.widevine.alpha",
+        createMediaKeys: () => ({
+          createSession: () => ({
+            // eslint-disable-next-line @typescript-eslint/no-empty-function
+            generateRequest: () => {},
+          }),
+        }),
+        getConfiguration: () => {
+          return baseEmeConfiguration;
+        },
+      };
+    });
+    const mediaElement = document.createElement("video");
+    const keySystemOptionsA: IKeySystemOption[] = [
+      {
+        type: "com.widevine.alpha",
+        getLicense: () => null,
+        videoCapabilitiesConfig: {
+          type: "contentType",
+          value: ['video/mp4;codecs="avc1.4d401e', 'video/mp4;codecs="hvc1.1.6.L93.B0"'],
+        },
+      },
+    ];
+
+    const taskCanceller = new TaskCanceller();
+    const event1 = await getMediaKeySystemAccess(
+      mediaElement,
+      keySystemOptionsA,
+      taskCanceller.signal,
+    );
+    expect(event1.type).toBe("create-media-key-system-access");
+
+    // create the mediaKeys and add it to the cache
+    const mediaKeys = await event1.value.mediaKeySystemAccess.createMediaKeys();
+    await mediaKeysAttacher.attach(mediaElement, {
+      keySystemOptions: keySystemOptionsA[0],
+      emeImplementation: eme,
+      askedConfiguration: baseEmeConfiguration,
+      mediaKeys,
+      mediaKeySystemAccess: event1.value.mediaKeySystemAccess,
+      loadedSessionsStore: new LoadedSessionsStore(mediaKeys),
+    });
+
+    const keySystemOptionsB: IKeySystemOption[] = [
+      {
+        type: "com.widevine.alpha",
+        getLicense: () => null,
+        videoCapabilitiesConfig: {
+          type: "contentType",
+          // configB contains only codec "avc1", it's a subset of configA, it should be compatible.
+          value: ['video/mp4;codecs="avc1.4d401e'],
+        },
+      },
+    ];
+
+    const event2 = await getMediaKeySystemAccess(
+      mediaElement,
+      keySystemOptionsB,
+      taskCanceller.signal,
+    );
+    expect(event2.type).toBe("reuse-media-key-system-access");
+  });
+});

package/src/main_thread/decrypt/clear_on_stop.ts

@@ -18,7 +18,7 @@ import type { IMediaElement } from "../../compat/browser_compatibility_types";
 import shouldUnsetMediaKeys from "../../compat/should_unset_media_keys";
 import log from "../../log";
 import disposeDecryptionResources from "./dispose_decryption_resources";
-import MediaKeysInfosStore from "./utils/media_keys_infos_store";
+import MediaKeysAttacher from "./utils/media_keys_attacher";
 
 /**
  * Clear DRM-related resources that should be cleared when the current content
@@ -26,14 +26,14 @@ import MediaKeysInfosStore from "./utils/media_keys_infos_store";
  * @param {HTMLMediaElement} mediaElement
  * @returns {Promise}
  */
-export default function clearOnStop(mediaElement: IMediaElement): Promise<unknown> {
+export default async function clearOnStop(mediaElement: IMediaElement): Promise<unknown> {
   log.info("DRM: Clearing-up DRM session.");
   if (shouldUnsetMediaKeys()) {
     log.info("DRM: disposing current MediaKeys.");
     return disposeDecryptionResources(mediaElement);
   }
 
-  const currentState = MediaKeysInfosStore.getState(mediaElement);
+  const currentState = await MediaKeysAttacher.getAttachedMediaKeysState(mediaElement);
   if (
     currentState !== null &&
     currentState.keySystemOptions.closeSessionsOnStop === true

package/src/main_thread/decrypt/content_decryptor.ts

@@ -30,7 +30,6 @@ import isNullOrUndefined from "../../utils/is_null_or_undefined";
 import { objectValues } from "../../utils/object_values";
 import { bytesToHex } from "../../utils/string_parsing";
 import TaskCanceller from "../../utils/task_canceller";
-import attachMediaKeys from "./attach_media_keys";
 import createOrLoadSession from "./create_or_load_session";
 import type { ICodecSupportList } from "./find_key_system";
 import type { IMediaKeysInfos } from "./get_media_keys";
@@ -57,6 +56,7 @@ import {
   areSomeKeyIdsContainedIn,
 } from "./utils/key_id_comparison";
 import type KeySessionRecord from "./utils/key_session_record";
+import MediaKeysAttacher from "./utils/media_keys_attacher";
 
 /**
  * Module communicating with the Content Decryption Module (or CDM) to be able
@@ -287,8 +287,12 @@ export default class ContentDecryptor extends EventEmitter<IContentDecryptorEven
     };
 
     log.debug("DRM: Attaching current MediaKeys");
-    attachMediaKeys(mediaElement, stateToAttach, this._canceller.signal)
+    MediaKeysAttacher.attach(mediaElement, stateToAttach)
       .then(async () => {
+        if (this._isStopped()) {
+          // We might be stopped since then
+          return;
+        }
         this._stateData.isMediaKeysAttached = MediaKeyAttachmentStatus.Attached;
 
         const { serverCertificate } = options;
@@ -526,13 +530,14 @@ export default class ContentDecryptor extends EventEmitter<IContentDecryptorEven
     this._lockInitDataQueue();
 
     let wantedSessionType: MediaKeySessionType;
-    if (isNullOrUndefined(options.persistentLicenseConfig)) {
-      wantedSessionType = "temporary";
-    } else if (!canCreatePersistentSession(mediaKeySystemAccess)) {
-      log.warn('DRM: Cannot create "persistent-license" session: not supported');
-      wantedSessionType = "temporary";
-    } else {
+    if (
+      canCreatePersistentSession(mediaKeySystemAccess) &&
+      (!isNullOrUndefined(options.persistentLicenseConfig) ||
+        !canCreateTemporarySession(mediaKeySystemAccess))
+    ) {
       wantedSessionType = "persistent-license";
+    } else {
+      wantedSessionType = "temporary";
     }
 
     const {
@@ -993,6 +998,19 @@ function canCreatePersistentSession(
   return sessionTypes !== undefined && arrayIncludes(sessionTypes, "persistent-license");
 }
 
+/**
+ * Returns `true` if the given MediaKeySystemAccess can create
+ * "temporary" MediaKeySessions.
+ * @param {MediaKeySystemAccess} mediaKeySystemAccess
+ * @returns {Boolean}
+ */
+function canCreateTemporarySession(
+  mediaKeySystemAccess: MediaKeySystemAccess | ICustomMediaKeySystemAccess,
+): boolean {
+  const { sessionTypes } = mediaKeySystemAccess.getConfiguration();
+  return sessionTypes !== undefined && arrayIncludes(sessionTypes, "temporary");
+}
+
 /**
  * Return the list of key IDs present in the `expectedKeyIds` array
  * but that are not present in `actualKeyIds`.

package/src/main_thread/decrypt/dispose_decryption_resources.ts

@@ -15,9 +15,7 @@
  */
 
 import type { IMediaElement } from "../../compat/browser_compatibility_types";
-import { setMediaKeys } from "../../compat/eme/set_media_keys";
-import log from "../../log";
-import MediaKeysInfosStore from "./utils/media_keys_infos_store";
+import MediaKeysAttacher from "./utils/media_keys_attacher";
 
 /**
  * Free up all ressources taken by the content decryption logic.
@@ -27,14 +25,5 @@ import MediaKeysInfosStore from "./utils/media_keys_infos_store";
 export default async function disposeDecryptionResources(
   mediaElement: IMediaElement,
 ): Promise<unknown> {
-  const currentState = MediaKeysInfosStore.getState(mediaElement);
-  if (currentState === null) {
-    return undefined;
-  }
-
-  log.info("DRM: Disposing of the current MediaKeys");
-  const { loadedSessionsStore } = currentState;
-  MediaKeysInfosStore.clearState(mediaElement);
-  await loadedSessionsStore.closeAllSessions();
-  return setMediaKeys(currentState.emeImplementation, mediaElement, null);
+  return MediaKeysAttacher.clearMediaKeys(mediaElement);
 }