rx-player 4.2.0-dev.2024080600 → 4.2.0-dev.2024080900

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

@@ -21,7 +21,7 @@ import { strToUtf8, utf8ToStr } from "../../../../utils/string_parsing";
 import type { CancellationSignal } from "../../../../utils/task_canceller";
 
 /** Default MediaKeySystemAccess configuration used by the RxPlayer. */
-export const defaultKSConfig = [
+export const defaultKSConfig: MediaKeySystemConfiguration[] = [
   {
     audioCapabilities: [
       { contentType: 'audio/mp4;codecs="mp4a.40.2"' },
@@ -38,21 +38,13 @@ export const defaultKSConfig = [
       { 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 = [
+export const defaultPRRecommendationKSConfig: MediaKeySystemConfiguration[] = [
   {
     audioCapabilities: [
       { robustness: "3000", contentType: 'audio/mp4;codecs="mp4a.40.2"' },
@@ -75,18 +67,10 @@ export const defaultPRRecommendationKSConfig = [
       { 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 = (() => {
+export const defaultWidevineConfig: MediaKeySystemConfiguration[] = (() => {
   const ROBUSTNESSES = [
     "HW_SECURE_ALL",
     "HW_SECURE_DECODE",
@@ -108,10 +92,7 @@ export const defaultWidevineConfig = (() => {
       { contentType: "audio/webm;codecs=opus", robustness },
     ];
   });
-  return [
-    { ...defaultKSConfig[0], audioCapabilities, videoCapabilities },
-    defaultKSConfig[1],
-  ];
+  return [{ ...defaultKSConfig[0], audioCapabilities, videoCapabilities }];
 })();
 
 /**

package/src/main_thread/decrypt/attach_media_keys.ts

@@ -55,6 +55,7 @@ export default async function attachMediaKeys(
   {
     emeImplementation,
     keySystemOptions,
+    askedConfiguration,
     loadedSessionsStore,
     mediaKeySystemAccess,
     mediaKeys,
@@ -81,6 +82,7 @@ export default async function attachMediaKeys(
     mediaKeySystemAccess,
     mediaKeys,
     loadedSessionsStore,
+    askedConfiguration,
   });
   if (mediaElement.mediaKeys === mediaKeys) {
     return;
@@ -109,6 +111,11 @@ export interface IMediaKeysState {
   mediaKeySystemAccess: MediaKeySystemAccess | ICustomMediaKeySystemAccess;
   /** The MediaKeys instance to attach to the media element. */
   mediaKeys: MediaKeys | ICustomMediaKeys;
+  /**
+   * The MediaKeySystemConfiguration that has been provided to the
+   * `requestMediaKeySystemAccess` API.
+   */
+  askedConfiguration: MediaKeySystemConfiguration;
   /**
    * The chosen EME implementation abstraction linked to `mediaKeys`.
    * Different EME implementation might for example be used while debugging or

package/src/main_thread/decrypt/content_decryptor.ts

@@ -255,7 +255,8 @@ export default class ContentDecryptor extends EventEmitter<IContentDecryptorEven
     }
 
     const { mediaElement, mediaKeysInfo } = this._stateData.data;
-    const { options, mediaKeys, mediaKeySystemAccess, stores } = mediaKeysInfo;
+    const { options, mediaKeys, mediaKeySystemAccess, stores, askedConfiguration } =
+      mediaKeysInfo;
     const shouldDisableLock = options.disableMediaKeysAttachmentLock === true;
 
     if (shouldDisableLock) {
@@ -279,6 +280,7 @@ export default class ContentDecryptor extends EventEmitter<IContentDecryptorEven
       loadedSessionsStore: stores.loadedSessionsStore,
       mediaKeySystemAccess,
       mediaKeys,
+      askedConfiguration,
       keySystemOptions: options,
     };
 

package/src/main_thread/decrypt/find_key_system.ts

@@ -26,11 +26,7 @@ import shouldRenewMediaKeySystemAccess from "../../compat/should_renew_media_key
 import config from "../../config";
 import { EncryptedMediaError } from "../../errors";
 import log from "../../log";
-import type {
-  IAudioCapabilitiesConfiguration,
-  IKeySystemOption,
-  IVideoCapabilitiesConfiguration,
-} from "../../public_types";
+import type { IKeySystemOption } from "../../public_types";
 import { parseCodec } from "../../utils/are_codecs_compatible";
 import arrayIncludes from "../../utils/array_includes";
 import flatMap from "../../utils/flat_map";
@@ -47,8 +43,19 @@ export type ICodecSupportList = Array<{
 }>;
 
 export interface IMediaKeySystemAccessInfos {
+  /** `MediaKeySystemAccess` to use to create `MediaKeys` instances. */
   mediaKeySystemAccess: MediaKeySystemAccess | ICustomMediaKeySystemAccess;
+  /**
+   * The MediaKeySystemConfiguration that has been provided to the
+   * `requestMediaKeySystemAccess` API.
+   */
+  askedConfiguration: MediaKeySystemConfiguration;
+  /**
+   * Corresponding `keySystems` element that has led to the creation of the
+   * `MediaKeySystemAccess`.
+   */
   options: IKeySystemOption;
+  /** Information on supported or unsupported codec on that `MediaKeySystemAccess`. */
   codecSupport: ICodecSupportList;
 }
 
@@ -88,10 +95,12 @@ interface IKeySystemType {
  */
 function checkCachedMediaKeySystemAccess(
   keySystems: IKeySystemOption[],
+  askedConfiguration: MediaKeySystemConfiguration,
   currentKeySystemAccess: MediaKeySystemAccess | ICustomMediaKeySystemAccess,
   currentKeySystemOptions: IKeySystemOption,
 ): null | {
   keySystemOptions: IKeySystemOption;
+  askedConfiguration: MediaKeySystemConfiguration;
   keySystemAccess: MediaKeySystemAccess | ICustomMediaKeySystemAccess;
 } {
   const mksConfiguration = currentKeySystemAccess.getConfiguration();
@@ -127,6 +136,7 @@ function checkCachedMediaKeySystemAccess(
     return {
       keySystemOptions: firstCompatibleOption,
       keySystemAccess: currentKeySystemAccess,
+      askedConfiguration,
     };
   }
   return null;
@@ -280,29 +290,23 @@ function buildKeySystemConfigurations(
 }
 /**
  * Extract from the current mediaKeys the supported Codecs.
- * @param {Object | undefined} audioCapabilitiesConfig - The audio capabilities provided to the KeySystem.
- * @param {Object | undefined} videoCapabilitiesConfig - The video capabilities provided to the KeySystem.
- * @param {Object | undefined} mksConfiguration - The result of getConfiguration() of the media keys.
+ * @param {Object} initialConfiguration - The MediaKeySystemConfiguration given
+ * to the `navigator.requestMediaKeySystemAccess` API.
+ * @param {Object | undefined} mksConfiguration - The result of
+ * getConfiguration() of the media keys.
  * @return {Array} The list of supported codec by the CDM.
  */
 export function extractCodecSupportListFromConfiguration(
-  audioCapabilitiesConfig: IAudioCapabilitiesConfiguration | undefined,
-  videoCapabilitiesConfig: IVideoCapabilitiesConfiguration | undefined,
+  initialConfiguration: MediaKeySystemConfiguration,
   mksConfiguration: MediaKeySystemConfiguration,
 ): ICodecSupportList {
-  const { EME_DEFAULT_AUDIO_CODECS, EME_DEFAULT_VIDEO_CODECS } = config.getCurrent();
-
   const testedAudioCodecs =
-    audioCapabilitiesConfig?.type === "contentType"
-      ? audioCapabilitiesConfig?.value
-      : EME_DEFAULT_AUDIO_CODECS;
-
+    initialConfiguration.audioCapabilities?.map((v) => v.contentType) ?? [];
   const testedVideoCodecs =
-    videoCapabilitiesConfig?.type === "contentType"
-      ? videoCapabilitiesConfig.value
-      : EME_DEFAULT_VIDEO_CODECS;
-
-  const testedCodecs = testedAudioCodecs.concat(testedVideoCodecs);
+    initialConfiguration.videoCapabilities?.map((v) => v.contentType) ?? [];
+  const testedCodecs: string[] = testedAudioCodecs
+    .concat(testedVideoCodecs)
+    .filter((c): c is string => c !== undefined);
   const supportedVideoCodecs = mksConfiguration.videoCapabilities?.map(
     (entry) => entry.contentType,
   );
@@ -368,6 +372,7 @@ export default function getMediaKeySystemAccess(
       // one as exactly the same compatibility options.
       const cachedKeySystemAccess = checkCachedMediaKeySystemAccess(
         keySystemsConfigs,
+        currentState.askedConfiguration,
         currentState.mediaKeySystemAccess,
         currentState.keySystemOptions,
       );
@@ -377,10 +382,10 @@ export default function getMediaKeySystemAccess(
           type: "reuse-media-key-system-access" as const,
           value: {
             mediaKeySystemAccess: cachedKeySystemAccess.keySystemAccess,
+            askedConfiguration: cachedKeySystemAccess.askedConfiguration,
             options: cachedKeySystemAccess.keySystemOptions,
             codecSupport: extractCodecSupportListFromConfiguration(
-              cachedKeySystemAccess.keySystemOptions.audioCapabilitiesConfig,
-              cachedKeySystemAccess.keySystemOptions.videoCapabilitiesConfig,
+              cachedKeySystemAccess.askedConfiguration,
               cachedKeySystemAccess.keySystemAccess.getConfiguration(),
             ),
           },
@@ -458,30 +463,35 @@ export default function getMediaKeySystemAccess(
         `${index + 1} of ${keySystemsType.length}`,
     );
 
-    try {
-      const keySystemAccess = await testKeySystem(keyType, keySystemConfigurations);
-      log.info("DRM: Found compatible keysystem", keyType, index + 1);
-      return {
-        type: "create-media-key-system-access" as const,
-        value: {
-          options: keySystemOptions,
-          mediaKeySystemAccess: keySystemAccess,
-          codecSupport: extractCodecSupportListFromConfiguration(
-            keySystemOptions.audioCapabilitiesConfig,
-            keySystemOptions.videoCapabilitiesConfig,
-            keySystemAccess.getConfiguration(),
-          ),
-        },
-      };
-    } catch (_) {
-      log.debug("DRM: Rejected access to keysystem", keyType, index + 1);
-      if (cancelSignal.cancellationError !== null) {
-        throw cancelSignal.cancellationError;
+    let keySystemAccess;
+    for (let configIdx = 0; configIdx < keySystemConfigurations.length; configIdx++) {
+      const keySystemConfiguration = keySystemConfigurations[configIdx];
+      try {
+        keySystemAccess = await testKeySystem(keyType, [keySystemConfiguration]);
+        log.info("DRM: Found compatible keysystem", keyType, index + 1);
+        return {
+          type: "create-media-key-system-access" as const,
+          value: {
+            options: keySystemOptions,
+            mediaKeySystemAccess: keySystemAccess,
+            askedConfiguration: keySystemConfiguration,
+            codecSupport: extractCodecSupportListFromConfiguration(
+              keySystemConfiguration,
+              keySystemAccess.getConfiguration(),
+            ),
+          },
+        };
+      } catch (_) {
+        log.debug("DRM: Rejected access to keysystem", keyType, index + 1, configIdx);
+        if (cancelSignal.cancellationError !== null) {
+          throw cancelSignal.cancellationError;
+        }
       }
-      return recursivelyTestKeySystems(index + 1);
     }
+    return recursivelyTestKeySystems(index + 1);
   }
 }
+
 /**
  * Test a key system configuration, resolves with the MediaKeySystemAccess
  * or reject if the key system is unsupported.

package/src/main_thread/decrypt/get_media_keys.ts

@@ -51,6 +51,11 @@ function createPersistentSessionsStorage(
 export interface IMediaKeysInfos {
   /** The MediaKeySystemAccess which allowed to create the MediaKeys instance. */
   mediaKeySystemAccess: MediaKeySystemAccess | ICustomMediaKeySystemAccess;
+  /**
+   * The MediaKeySystemConfiguration that has been provided to the
+   * `requestMediaKeySystemAccess` API.
+   */
+  askedConfiguration: MediaKeySystemConfiguration;
   /** The MediaKeys instance. */
   mediaKeys: MediaKeys | ICustomMediaKeys;
   /** Stores allowing to create and retrieve MediaKeySessions. */
@@ -88,7 +93,7 @@ export default async function getMediaKeysInfos(
     throw cancelSignal.cancellationError;
   }
 
-  const { options, mediaKeySystemAccess, codecSupport } = evt.value;
+  const { options, mediaKeySystemAccess, askedConfiguration, codecSupport } = evt.value;
   const currentState = MediaKeysInfosStore.getState(mediaElement);
   const persistentSessionsStore = createPersistentSessionsStorage(options);
 
@@ -110,6 +115,7 @@ export default async function getMediaKeysInfos(
       return {
         mediaKeys,
         mediaKeySystemAccess,
+        askedConfiguration,
         stores: { loadedSessionsStore, persistentSessionsStore },
         options,
         codecSupport,
@@ -123,6 +129,7 @@ export default async function getMediaKeysInfos(
   return {
     mediaKeys,
     mediaKeySystemAccess,
+    askedConfiguration,
     stores: { loadedSessionsStore, persistentSessionsStore },
     options,
     codecSupport,

package/src/main_thread/decrypt/utils/media_keys_infos_store.ts

@@ -30,6 +30,12 @@ export interface IMediaElementMediaKeysInfos {
   /** Last keySystemOptions used with that HTMLMediaElement. */
   keySystemOptions: IKeySystemOption;
 
+  /**
+   * The actual MediaKeySystemConfiguration asked to the
+   * `requestMediaKeySystemAccess` API.
+   */
+  askedConfiguration: MediaKeySystemConfiguration;
+
   /**
    * Last MediaKeySystemAccess used to create a MediaKeys bound to that
    * HTMLMediaElement.