rx-player 4.1.0 → 4.2.0-dev.2024080600

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

@@ -12,6 +12,7 @@ import { vi } from "vitest";
 /* eslint-disable @typescript-eslint/explicit-module-boundary-types */
 /* eslint-disable no-restricted-properties */
 
+import type { IMediaElement } from "../../../../compat/browser_compatibility_types";
 import type { IEmeApiImplementation, IEncryptedEventData } from "../../../../compat/eme";
 import { base64ToBytes, bytesToBase64 } from "../../../../utils/base64";
 import EventEmitter from "../../../../utils/event_emitter";
@@ -33,6 +34,7 @@ export const defaultKSConfig = [
     videoCapabilities: [
       { contentType: 'video/mp4;codecs="avc1.4d401e"' },
       { contentType: 'video/mp4;codecs="avc1.42e01e"' },
+      { contentType: 'video/mp4;codecs="hvc1.1.6.L93.B0"' },
       { contentType: 'video/webm;codecs="vp8"' },
     ],
   },
@@ -65,9 +67,11 @@ export const defaultPRRecommendationKSConfig = [
     videoCapabilities: [
       { robustness: "3000", contentType: 'video/mp4;codecs="avc1.4d401e"' },
       { robustness: "3000", contentType: 'video/mp4;codecs="avc1.42e01e"' },
+      { robustness: "3000", contentType: 'video/mp4;codecs="hvc1.1.6.L93.B0"' },
       { 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/mp4;codecs="hvc1.1.6.L93.B0"' },
       { robustness: "2000", contentType: 'video/webm;codecs="vp8"' },
     ],
   },
@@ -94,6 +98,7 @@ export const defaultWidevineConfig = (() => {
     return [
       { contentType: 'video/mp4;codecs="avc1.4d401e"', robustness },
       { contentType: 'video/mp4;codecs="avc1.42e01e"', robustness },
+      { contentType: 'video/mp4;codecs="hvc1.1.6.L93.B0"', robustness },
       { contentType: 'video/webm;codecs="vp8"', robustness },
     ];
   });
@@ -274,12 +279,12 @@ export function requestMediaKeySystemAccessImpl(
 }
 
 class MockedDecryptorEventEmitter extends EventEmitter<{
-  encrypted: { elt: HTMLMediaElement; value: unknown };
+  encrypted: { elt: IMediaElement; value: unknown };
   keymessage: { session: MediaKeySessionImpl; value: unknown };
   keyerror: { session: MediaKeySessionImpl; value: unknown };
   keystatuseschange: { session: MediaKeySessionImpl; value: unknown };
 }> {
-  public triggerEncrypted(elt: HTMLMediaElement, value: unknown) {
+  public triggerEncrypted(elt: IMediaElement, value: unknown) {
     this.trigger("encrypted", { elt, value });
   }
   public triggerKeyError(session: MediaKeySessionImpl, value: unknown) {
@@ -312,7 +317,7 @@ export function mockCompat(
     vi
       .fn()
       .mockImplementation(
-        (elt: HTMLMediaElement, fn: (x: unknown) => void, signal: CancellationSignal) => {
+        (elt: IMediaElement, fn: (x: unknown) => void, signal: CancellationSignal) => {
           elt.addEventListener("encrypted", fn);
           signal.register(() => {
             elt.removeEventListener("encrypted", fn);
@@ -444,7 +449,7 @@ export function mockCompat(
   return {
     mockEvents,
     eventTriggers: {
-      triggerEncrypted(elt: HTMLMediaElement, value: unknown) {
+      triggerEncrypted(elt: IMediaElement, value: unknown) {
         ee.triggerEncrypted(elt, value);
       },
       triggerKeyMessage(session: MediaKeySessionImpl, value: unknown) {
@@ -475,7 +480,7 @@ export function mockCompat(
  */
 export function testContentDecryptorError(
   ContentDecryptor: any,
-  mediaElement: HTMLMediaElement,
+  mediaElement: IMediaElement,
   keySystemsConfigs: unknown[],
 ): Promise<unknown> {
   return new Promise((res, rej) => {

package/src/main_thread/decrypt/attach_media_keys.ts

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+import type { IMediaElement } from "../../compat/browser_compatibility_types";
 import type {
   ICustomMediaKeys,
   ICustomMediaKeySystemAccess,
@@ -34,7 +35,7 @@ import MediaKeysInfosStore from "./utils/media_keys_infos_store";
  * @param {Object} mediaElement
  * @returns {Promise}
  */
-export function disableMediaKeys(mediaElement: HTMLMediaElement): Promise<unknown> {
+export function disableMediaKeys(mediaElement: IMediaElement): Promise<unknown> {
   const previousState = MediaKeysInfosStore.getState(mediaElement);
   MediaKeysInfosStore.setState(mediaElement, null);
   return setMediaKeys(previousState?.emeImplementation ?? eme, mediaElement, null);
@@ -50,7 +51,7 @@ export function disableMediaKeys(mediaElement: HTMLMediaElement): Promise<unknow
  * @returns {Promise}
  */
 export default async function attachMediaKeys(
-  mediaElement: HTMLMediaElement,
+  mediaElement: IMediaElement,
   {
     emeImplementation,
     keySystemOptions,

package/src/main_thread/decrypt/clear_on_stop.ts

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+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";
@@ -25,7 +26,7 @@ import MediaKeysInfosStore from "./utils/media_keys_infos_store";
  * @param {HTMLMediaElement} mediaElement
  * @returns {Promise}
  */
-export default function clearOnStop(mediaElement: HTMLMediaElement): Promise<unknown> {
+export default function clearOnStop(mediaElement: IMediaElement): Promise<unknown> {
   log.info("DRM: Clearing-up DRM session.");
   if (shouldUnsetMediaKeys()) {
     log.info("DRM: disposing current MediaKeys.");

package/src/main_thread/decrypt/content_decryptor.ts

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+import type { IMediaElement } from "../../compat/browser_compatibility_types";
 import type { ICustomMediaKeys, ICustomMediaKeySystemAccess } from "../../compat/eme";
 import eme, { getInitData } from "../../compat/eme";
 import config from "../../config";
@@ -31,6 +32,7 @@ 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";
 import initMediaKeys from "./init_media_keys";
 import type { IKeyUpdateValue } from "./session_events_listener";
@@ -49,6 +51,7 @@ import { DecommissionedSessionError } from "./utils/check_key_statuses";
 import cleanOldStoredPersistentInfo from "./utils/clean_old_stored_persistent_info";
 import getDrmSystemId from "./utils/get_drm_system_id";
 import InitDataValuesContainer from "./utils/init_data_values_container";
+import isCompatibleCodecSupported from "./utils/is_compatible_codec_supported";
 import {
   areAllKeyIdsContainedIn,
   areSomeKeyIdsContainedIn,
@@ -123,6 +126,11 @@ export default class ContentDecryptor extends EventEmitter<IContentDecryptorEven
    */
   private _initDataQueue: IProtectionData[];
 
+  /**
+   * Store the list of supported codecs with the current key system configuration.
+   */
+  private _supportedCodecWhenEncrypted: ICodecSupportList;
+
   /**
    * `true` if the EME API are available on the current platform according to
    * the default EME implementation used.
@@ -147,7 +155,7 @@ export default class ContentDecryptor extends EventEmitter<IContentDecryptorEven
    * configurations. It will choose the appropriate one depending on user
    * settings and browser support.
    */
-  constructor(mediaElement: HTMLMediaElement, ksOptions: IKeySystemOption[]) {
+  constructor(mediaElement: IMediaElement, ksOptions: IKeySystemOption[]) {
     super();
 
     log.debug("DRM: Starting ContentDecryptor logic.");
@@ -162,13 +170,14 @@ export default class ContentDecryptor extends EventEmitter<IContentDecryptorEven
       isInitDataQueueLocked: true,
       data: null,
     };
+    this._supportedCodecWhenEncrypted = [];
     this.error = null;
 
     eme.onEncrypted(
       mediaElement,
       (evt) => {
         log.debug("DRM: Encrypted event received from media element.");
-        const initData = getInitData(evt as MediaEncryptedEvent);
+        const initData = getInitData(evt);
         if (initData !== null) {
           this.onInitializationData(initData);
         }
@@ -179,7 +188,7 @@ export default class ContentDecryptor extends EventEmitter<IContentDecryptorEven
     initMediaKeys(mediaElement, ksOptions, canceller.signal)
       .then((mediaKeysInfo) => {
         const { options, mediaKeySystemAccess } = mediaKeysInfo;
-
+        this._supportedCodecWhenEncrypted = mediaKeysInfo.codecSupport;
         /**
          * String identifying the key system, allowing the rest of the code to
          * only advertise the required initialization data for license requests.
@@ -330,6 +339,33 @@ export default class ContentDecryptor extends EventEmitter<IContentDecryptorEven
     this.trigger("stateChange", this._stateData.state);
   }
 
+  /**
+   * Returns `true` if the given mimeType and codec couple should be supported
+   * by the current key system.
+   * Returns `false` if it isn't.
+   *
+   * Returns `undefined` if we cannot determine if it is supported.
+   *
+   * @param {string} mimeType
+   * @param {string} codec
+   * @returns {boolean}
+   */
+  public isCodecSupported(mimeType: string, codec: string): boolean | undefined {
+    if (this._stateData.state === ContentDecryptorState.Initializing) {
+      log.error(
+        "DRM: Asking for codec support while the ContentDecryptor is still initializing",
+      );
+      return undefined;
+    }
+    if (
+      this._stateData.state === ContentDecryptorState.Error ||
+      this._stateData.state === ContentDecryptorState.Disposed
+    ) {
+      log.error("DRM: Asking for codec support while the ContentDecryptor is disposed");
+    }
+    return isCompatibleCodecSupported(mimeType, codec, this._supportedCodecWhenEncrypted);
+  }
+
   /**
    * Method to call when new protection initialization data is encounted on the
    * content.
@@ -692,6 +728,21 @@ export default class ContentDecryptor extends EventEmitter<IContentDecryptorEven
       return false;
     }
 
+    /**
+     * On Safari using Directfile, the old EME implementation triggers
+     * the "webkitneedkey" event instead of "encrypted". There's an issue in Safari
+     * where "webkitneedkey" fires too early before all tracks are added from an HLS playlist.
+     * Safari incorrectly assumes some keys are missing for these tracks,
+     * leading to repeated "webkitneedkey" events. Because RxPlayer recognizes
+     * it already has a session for these keys and ignores the events,
+     * the content remains frozen. To resolve this, the session is re-created.
+     */
+    const forceSessionRecreation = initializationData.forceSessionRecreation;
+    if (forceSessionRecreation === true) {
+      this.removeSessionForInitData(initializationData, mediaKeysData);
+      return false;
+    }
+
     // Check if the compatible session is blacklisted
     const blacklistedSessionError = compatibleSessionInfo.blacklistedSessionError;
     if (!isNullOrUndefined(blacklistedSessionError)) {
@@ -796,6 +847,48 @@ export default class ContentDecryptor extends EventEmitter<IContentDecryptorEven
     return false;
   }
 
+  /**
+   * Remove the session corresponding to the initData provided, and close it.
+   * It does nothing if no session was found for this initData.
+   * @param {Object} initData : The initialization data corresponding to the session
+   * that need to be removed
+   * @param {Object} mediaKeysData : The media keys data
+   */
+  private removeSessionForInitData(
+    initData: IProcessedProtectionData,
+    mediaKeysData: IAttachedMediaKeysData,
+  ) {
+    const { stores } = mediaKeysData;
+    /** Remove the session and close it from the loadedSessionStore */
+    const entry = stores.loadedSessionsStore.reuse(initData);
+    if (entry !== null) {
+      stores.loadedSessionsStore
+        .closeSession(entry.mediaKeySession)
+        .catch(() =>
+          log.error("DRM: Cannot close the session from the loaded session store"),
+        );
+    }
+
+    /**
+     * If set, a currently-used key session is already compatible to this
+     * initialization data.
+     */
+    const compatibleSessionInfo = arrayFind(this._currentSessions, (x) =>
+      x.record.isCompatibleWith(initData),
+    );
+    if (compatibleSessionInfo === undefined) {
+      return;
+    }
+    /** Remove the session from the currentSessions */
+    const indexOf = this._currentSessions.indexOf(compatibleSessionInfo);
+    if (indexOf !== -1) {
+      log.debug(
+        "DRM: A session from a processed init is removed due to forceSessionRecreation policy.",
+      );
+      this._currentSessions.splice(indexOf, 1);
+    }
+  }
+
   /**
    * Callback that should be called if an error that made the current
    * `ContentDecryptor` instance unusable arised.
@@ -1174,7 +1267,7 @@ type IWaitingForAttachmentStateData = IContentDecryptorStateBase<
   true, // isInitDataQueueLocked
   MediaKeyAttachmentStatus.NotAttached, // isMediaKeysAttached
   // data
-  { mediaKeysInfo: IMediaKeysInfos; mediaElement: HTMLMediaElement }
+  { mediaKeysInfo: IMediaKeysInfos; mediaElement: IMediaElement }
 >;
 
 /**
@@ -1185,7 +1278,7 @@ type IReadyForContentStateDataUnattached = IContentDecryptorStateBase<
   ContentDecryptorState.ReadyForContent,
   true, // isInitDataQueueLocked
   MediaKeyAttachmentStatus.NotAttached | MediaKeyAttachmentStatus.Pending, // isMediaKeysAttached
-  { mediaKeysInfo: IMediaKeysInfos; mediaElement: HTMLMediaElement } // data
+  { mediaKeysInfo: IMediaKeysInfos; mediaElement: IMediaElement } // data
 >;
 
 /**

package/src/main_thread/decrypt/dispose_decryption_resources.ts

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+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";
@@ -24,7 +25,7 @@ import MediaKeysInfosStore from "./utils/media_keys_infos_store";
  * @returns {Promise}
  */
 export default async function disposeDecryptionResources(
-  mediaElement: HTMLMediaElement,
+  mediaElement: IMediaElement,
 ): Promise<unknown> {
   const currentState = MediaKeysInfosStore.getState(mediaElement);
   if (currentState === null) {

package/src/main_thread/decrypt/find_key_system.ts

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+import type { IMediaElement } from "../../compat/browser_compatibility_types";
 import { canRelyOnRequestMediaKeySystemAccess } from "../../compat/can_rely_on_request_media_key_system_access";
 import type { ICustomMediaKeySystemAccess } from "../../compat/eme";
 import eme from "../../compat/eme";
@@ -25,7 +26,12 @@ import shouldRenewMediaKeySystemAccess from "../../compat/should_renew_media_key
 import config from "../../config";
 import { EncryptedMediaError } from "../../errors";
 import log from "../../log";
-import type { IKeySystemOption } from "../../public_types";
+import type {
+  IAudioCapabilitiesConfiguration,
+  IKeySystemOption,
+  IVideoCapabilitiesConfiguration,
+} from "../../public_types";
+import { parseCodec } from "../../utils/are_codecs_compatible";
 import arrayIncludes from "../../utils/array_includes";
 import flatMap from "../../utils/flat_map";
 import isNullOrUndefined from "../../utils/is_null_or_undefined";
@@ -34,9 +40,16 @@ import MediaKeysInfosStore from "./utils/media_keys_infos_store";
 
 type MediaKeysRequirement = "optional" | "required" | "not-allowed";
 
+export type ICodecSupportList = Array<{
+  codec: string;
+  mimeType: string;
+  result: boolean;
+}>;
+
 export interface IMediaKeySystemAccessInfos {
   mediaKeySystemAccess: MediaKeySystemAccess | ICustomMediaKeySystemAccess;
   options: IKeySystemOption;
+  codecSupport: ICodecSupportList;
 }
 
 export interface IReuseMediaKeySystemAccessEvent {
@@ -265,7 +278,67 @@ function buildKeySystemConfigurations(
     } as unknown as MediaKeySystemConfiguration,
   ];
 }
+/**
+ * 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.
+ * @return {Array} The list of supported codec by the CDM.
+ */
+export function extractCodecSupportListFromConfiguration(
+  audioCapabilitiesConfig: IAudioCapabilitiesConfiguration | undefined,
+  videoCapabilitiesConfig: IVideoCapabilitiesConfiguration | undefined,
+  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;
+
+  const testedVideoCodecs =
+    videoCapabilitiesConfig?.type === "contentType"
+      ? videoCapabilitiesConfig.value
+      : EME_DEFAULT_VIDEO_CODECS;
+
+  const testedCodecs = testedAudioCodecs.concat(testedVideoCodecs);
+  const supportedVideoCodecs = mksConfiguration.videoCapabilities?.map(
+    (entry) => entry.contentType,
+  );
+  const supportedAudioCodecs = mksConfiguration.audioCapabilities?.map(
+    (entry) => entry.contentType,
+  );
+
+  const supportedCodecs = [
+    ...(supportedVideoCodecs ?? []),
+    ...(supportedAudioCodecs ?? []),
+  ].filter((contentType): contentType is string => contentType !== undefined);
 
+  if (supportedCodecs.length === 0) {
+    // Some legacy implementations have issues with `audioCapabilities` and
+    // `videoCapabilities` in requestMediaKeySystemAccess so the codecs are not provided.
+    // In this case, we can't tell which codec is supported or not.
+    // Let's instead provide an empty list.
+
+    // Note: on a correct EME implementation, if a list of codec is provided
+    // with `audioCapabilities` or `videoCapabilities`, but none of them is supported,
+    // requestMediaKeySystemAccess should yield an error "NotSupported" and we should
+    // never reach this code.
+    return [];
+  }
+
+  const codecSupportList: ICodecSupportList = testedCodecs.map((codec) => {
+    const { codecs, mimeType } = parseCodec(codec);
+    const isSupported = arrayIncludes(supportedCodecs, codec);
+    return {
+      codec: codecs,
+      mimeType,
+      result: isSupported,
+    };
+  });
+  return codecSupportList;
+}
 /**
  * Try to find a compatible key system from the keySystems array given.
  *
@@ -283,7 +356,7 @@ function buildKeySystemConfigurations(
  * @returns {Promise.<Object>}
  */
 export default function getMediaKeySystemAccess(
-  mediaElement: HTMLMediaElement,
+  mediaElement: IMediaElement,
   keySystemsConfigs: IKeySystemOption[],
   cancelSignal: CancellationSignal,
 ): Promise<IFoundMediaKeySystemAccessEvent> {
@@ -305,6 +378,11 @@ export default function getMediaKeySystemAccess(
           value: {
             mediaKeySystemAccess: cachedKeySystemAccess.keySystemAccess,
             options: cachedKeySystemAccess.keySystemOptions,
+            codecSupport: extractCodecSupportListFromConfiguration(
+              cachedKeySystemAccess.keySystemOptions.audioCapabilitiesConfig,
+              cachedKeySystemAccess.keySystemOptions.videoCapabilitiesConfig,
+              cachedKeySystemAccess.keySystemAccess.getConfiguration(),
+            ),
           },
         });
       }
@@ -388,6 +466,11 @@ export default function getMediaKeySystemAccess(
         value: {
           options: keySystemOptions,
           mediaKeySystemAccess: keySystemAccess,
+          codecSupport: extractCodecSupportListFromConfiguration(
+            keySystemOptions.audioCapabilitiesConfig,
+            keySystemOptions.videoCapabilitiesConfig,
+            keySystemAccess.getConfiguration(),
+          ),
         },
       };
     } catch (_) {

package/src/main_thread/decrypt/get_key_system_configuration.ts

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+import type { IMediaElement } from "../../compat/browser_compatibility_types";
 import MediaKeysInfosStore from "./utils/media_keys_infos_store";
 
 /**
@@ -23,7 +24,7 @@ import MediaKeysInfosStore from "./utils/media_keys_infos_store";
  * @returns {Array|null}
  */
 export default function getKeySystemConfiguration(
-  mediaElement: HTMLMediaElement,
+  mediaElement: IMediaElement,
 ): [string, MediaKeySystemConfiguration] | null {
   const currentState = MediaKeysInfosStore.getState(mediaElement);
   if (currentState === null) {

package/src/main_thread/decrypt/get_media_keys.ts

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+import type { IMediaElement } from "../../compat/browser_compatibility_types";
 import canReuseMediaKeys from "../../compat/can_reuse_media_keys";
 import type { ICustomMediaKeys, ICustomMediaKeySystemAccess } from "../../compat/eme";
 import { EncryptedMediaError } from "../../errors";
@@ -22,6 +23,7 @@ import type { IKeySystemOption } from "../../public_types";
 import isNullOrUndefined from "../../utils/is_null_or_undefined";
 import type { CancellationSignal } from "../../utils/task_canceller";
 import getMediaKeySystemAccess from "./find_key_system";
+import type { ICodecSupportList } from "./find_key_system";
 import type { IMediaKeySessionStores } from "./types";
 import LoadedSessionsStore from "./utils/loaded_sessions_store";
 import MediaKeysInfosStore from "./utils/media_keys_infos_store";
@@ -55,6 +57,8 @@ export interface IMediaKeysInfos {
   stores: IMediaKeySessionStores;
   /** IKeySystemOption compatible to the created MediaKeys instance. */
   options: IKeySystemOption;
+  /** The codecs support */
+  codecSupport: ICodecSupportList;
 }
 
 /**
@@ -71,7 +75,7 @@ export interface IMediaKeysInfos {
  * @returns {Promise.<Object>}
  */
 export default async function getMediaKeysInfos(
-  mediaElement: HTMLMediaElement,
+  mediaElement: IMediaElement,
   keySystemsConfigs: IKeySystemOption[],
   cancelSignal: CancellationSignal,
 ): Promise<IMediaKeysInfos> {
@@ -84,7 +88,7 @@ export default async function getMediaKeysInfos(
     throw cancelSignal.cancellationError;
   }
 
-  const { options, mediaKeySystemAccess } = evt.value;
+  const { options, mediaKeySystemAccess, codecSupport } = evt.value;
   const currentState = MediaKeysInfosStore.getState(mediaElement);
   const persistentSessionsStore = createPersistentSessionsStorage(options);
 
@@ -108,6 +112,7 @@ export default async function getMediaKeysInfos(
         mediaKeySystemAccess,
         stores: { loadedSessionsStore, persistentSessionsStore },
         options,
+        codecSupport,
       };
     }
   }
@@ -120,6 +125,7 @@ export default async function getMediaKeysInfos(
     mediaKeySystemAccess,
     stores: { loadedSessionsStore, persistentSessionsStore },
     options,
+    codecSupport,
   };
 }
 

package/src/main_thread/decrypt/init_media_keys.ts

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+import type { IMediaElement } from "../../compat/browser_compatibility_types";
 import log from "../../log";
 import type { IKeySystemOption } from "../../public_types";
 import type { CancellationSignal } from "../../utils/task_canceller";
@@ -29,7 +30,7 @@ import getMediaKeysInfos from "./get_media_keys";
  * @returns {Promise.<Object>}
  */
 export default async function initMediaKeys(
-  mediaElement: HTMLMediaElement,
+  mediaElement: IMediaElement,
   keySystemsConfigs: IKeySystemOption[],
   cancelSignal: CancellationSignal,
 ): Promise<IMediaKeysInfos> {

package/src/main_thread/decrypt/types.ts

@@ -122,6 +122,8 @@ export interface IProtectionData {
   content?: IContent;
   /** Every initialization data for that type. */
   values: IInitDataValue[];
+
+  forceSessionRecreation?: boolean | undefined;
 }
 
 /** Protection initialization data actually processed by the `ContentDecryptor`. */

package/src/main_thread/decrypt/utils/__tests__/is_compatible_codec_supported.test.ts

@@ -0,0 +1,38 @@
+import { describe, it, expect } from "vitest";
+import isCompatibleCodecSupported from "../is_compatible_codec_supported";
+
+describe("isCodecInCompatibleCodecList", () => {
+  it("should return true if the compatible codec is supported", () => {
+    const supportedCodecs = [
+      { mimeType: "video/mp4", codec: "avc1.4eed1", result: true },
+    ];
+    const isCompatible = isCompatibleCodecSupported(
+      "video/mp4",
+      "avc1.4df1",
+      supportedCodecs,
+    );
+    expect(isCompatible).toBe(true);
+  });
+
+  it("should return false if the compatible codec is explicitly not supported", () => {
+    const supportedCodecs = [
+      { mimeType: "video/mp4", codec: "avc1.4df1", result: true },
+      { mimeType: "video/mp4", codec: "hvc1.1.6.L93.B0", result: false },
+    ];
+    const isCompatible = isCompatibleCodecSupported(
+      "video/mp4",
+      "hvc1.1.6.L153",
+      supportedCodecs,
+    );
+    expect(isCompatible).toBe(false);
+  });
+
+  it("should return undefined if there is no compatible codec", () => {
+    const supportedCodecs = [
+      { mimeType: "video/mp4", codec: "avc1.4df1", result: true },
+      { mimeType: "video/mp4", codec: "hvc1.1.6.L93.B0", result: false },
+    ];
+    const isCompatible = isCompatibleCodecSupported("video/mp4", "vp9", supportedCodecs);
+    expect(isCompatible).toBe(undefined);
+  });
+});

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

@@ -0,0 +1,39 @@
+import areCodecsCompatible from "../../../utils/are_codecs_compatible";
+import type { ICodecSupportList } from "../find_key_system";
+
+/**
+ * Find the first codec in the provided codec list that is compatible with the given mimeType and codec.
+ * This first codec is called the "compatible codec". Return true if the "compatible codec"
+ * is supported or false if it's not supported. If no "compatible codec" has been found, return undefined.
+ *
+ * @param {string} mimeType - The MIME type to check.
+ * @param {string} codec - The codec to check.
+ * @param {Array} codecList - The list of codecs to check against.
+ * @returns {boolean|undefined} - True if the "compatible codec" is supported, false if not,
+ * or undefined if no "compatible codec" is found.
+ */
+export default function isCompatibleCodecSupported(
+  mimeType: string,
+  codec: string,
+  codecList: ICodecSupportList,
+): boolean | undefined {
+  const inputCodec = `${mimeType};codecs="${codec}"`;
+  const sameMimeTypeCodec = codecList.filter((c) => c.mimeType === mimeType);
+  if (sameMimeTypeCodec.length === 0) {
+    // No codec with the same MIME type was found.
+    return undefined;
+  }
+
+  for (const {
+    codec: currentCodec,
+    mimeType: currentMimeType,
+    result,
+  } of sameMimeTypeCodec) {
+    const existingCodec = `${currentMimeType};codecs="${currentCodec}"`;
+    if (areCodecsCompatible(inputCodec, existingCodec)) {
+      return result;
+    }
+  }
+  // No compatible codec was found.
+  return undefined;
+}