rx-player 4.2.0-dev.2024081400 → 4.2.0-dev.2024090300

package/src/main_thread/decrypt/content_decryptor.ts

@@ -177,7 +177,7 @@ export default class ContentDecryptor extends EventEmitter<IContentDecryptorEven
       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);
         }
@@ -730,6 +730,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)) {
@@ -834,6 +849,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.
@@ -1147,8 +1204,8 @@ function addKeyIdsFromPeriod(set: Set<Uint8Array>, period: IPeriodMetadata) {
         representation.contentProtections !== undefined &&
         representation.contentProtections.keyIds !== undefined
       ) {
-        for (const kidInf of representation.contentProtections.keyIds) {
-          set.add(kidInf.keyId);
+        for (const kid of representation.contentProtections.keyIds) {
+          set.add(kid);
         }
       }
     }

package/src/main_thread/decrypt/types.ts

@@ -127,6 +127,11 @@ export interface IProtectionData {
 /** Protection initialization data actually processed by the `ContentDecryptor`. */
 export interface IProcessedProtectionData extends Omit<IProtectionData, "values"> {
   values: InitDataValuesContainer;
+  /**
+   * Enforce to recreate the media key session if there is already a session created
+   * with this init data
+   */
+  forceSessionRecreation?: boolean | undefined;
 }
 
 /**

package/src/main_thread/init/media_source_content_initializer.ts

@@ -1267,17 +1267,17 @@ function updateKeyIdsDecipherabilityOnManifest(
     if (contentKIDs !== undefined) {
       for (const elt of contentKIDs) {
         for (const blacklistedKeyId of blacklistedKeyIds) {
-          if (areArraysOfNumbersEqual(blacklistedKeyId, elt.keyId)) {
+          if (areArraysOfNumbersEqual(blacklistedKeyId, elt)) {
             return false;
           }
         }
         for (const whitelistedKeyId of whitelistedKeyIds) {
-          if (areArraysOfNumbersEqual(whitelistedKeyId, elt.keyId)) {
+          if (areArraysOfNumbersEqual(whitelistedKeyId, elt)) {
             return true;
           }
         }
         for (const delistedKeyId of delistedKeyIds) {
-          if (areArraysOfNumbersEqual(delistedKeyId, elt.keyId)) {
+          if (areArraysOfNumbersEqual(delistedKeyId, elt)) {
             return undefined;
           }
         }

package/src/main_thread/tracks_store/tracks_store.ts

@@ -910,10 +910,16 @@ export default class TracksStore extends EventEmitter<ITracksStoreEvents> {
    * `null` if audio tracks were disabled and `undefined` if the Period is not
    * known.
    */
-  public getChosenAudioTrack(periodObj: ITSPeriodObject): IAudioTrack | null {
+  public getChosenAudioTrack(
+    periodObj: ITSPeriodObject,
+    filterPlayableRepresentations: boolean,
+  ): IAudioTrack | null {
     return isNullOrUndefined(periodObj.audio.storedSettings)
       ? null
-      : toAudioTrack(periodObj.audio.storedSettings.adaptation, true);
+      : toAudioTrack(
+          periodObj.audio.storedSettings.adaptation,
+          filterPlayableRepresentations,
+        );
   }
 
   /**
@@ -942,12 +948,18 @@ export default class TracksStore extends EventEmitter<ITracksStoreEvents> {
    * @param {Object} periodObj - The concerned Period's object
    * @returns {Object|null} - The video track chosen for this Period
    */
-  public getChosenVideoTrack(periodObj: ITSPeriodObject): IVideoTrack | null {
+  public getChosenVideoTrack(
+    periodObj: ITSPeriodObject,
+    filterPlayableRepresentations: boolean,
+  ): IVideoTrack | null {
     if (isNullOrUndefined(periodObj.video.storedSettings)) {
       return null;
     }
 
-    return toVideoTrack(periodObj.video.storedSettings.adaptation, true);
+    return toVideoTrack(
+      periodObj.video.storedSettings.adaptation,
+      filterPlayableRepresentations,
+    );
   }
 
   /**
@@ -957,10 +969,15 @@ export default class TracksStore extends EventEmitter<ITracksStoreEvents> {
    * Returns `undefined` if the given Period's id is not known.
    *
    * @param {Object} periodObj - The concerned Period's object
+   * @param {boolean} filterPlayableRepresentations - If `true`, only
+   * representations considered to be "playable" will be included in the
+   * returned response.
+   * If `false`, the response should contain all linked representations.
    * @returns {Array.<Object>}
    */
   public getAvailableAudioTracks(
     periodObj: ITSPeriodObject,
+    filterPlayableRepresentations: boolean,
   ): IAvailableAudioTrack[] | undefined {
     const storedSettings = periodObj.audio.storedSettings;
     const currentId = !isNullOrUndefined(storedSettings)
@@ -969,7 +986,9 @@ export default class TracksStore extends EventEmitter<ITracksStoreEvents> {
     const adaptations = getSupportedAdaptations(periodObj.period, "audio");
     return adaptations.map((adaptation: IAdaptationMetadata) => {
       const active = currentId === null ? false : currentId === adaptation.id;
-      return objectAssign(toAudioTrack(adaptation, true), { active });
+      return objectAssign(toAudioTrack(adaptation, filterPlayableRepresentations), {
+        active,
+      });
     });
   }
 
@@ -1004,10 +1023,15 @@ export default class TracksStore extends EventEmitter<ITracksStoreEvents> {
    * Returns `undefined` if the given Period's id is not known.
    *
    * @param {Object} periodObj - The concerned Period's object
+   * @param {boolean} filterPlayableRepresentations - If `true`, only
+   * representations considered to be "playable" will be included in the
+   * returned response.
+   * If `false`, the response should contain all linked representations.
    * @returns {Array.<Object>}
    */
   public getAvailableVideoTracks(
     periodObj: ITSPeriodObject,
+    filterPlayableRepresentations: boolean,
   ): IAvailableVideoTrack[] | undefined {
     const storedSettings = periodObj.video.storedSettings;
     const currentId = isNullOrUndefined(storedSettings)
@@ -1017,7 +1041,7 @@ export default class TracksStore extends EventEmitter<ITracksStoreEvents> {
     const adaptations = getSupportedAdaptations(periodObj.period, "video");
     return adaptations.map((adaptation) => {
       const active = currentId === null ? false : currentId === adaptation.id;
-      const track = toVideoTrack(adaptation, true);
+      const track = toVideoTrack(adaptation, filterPlayableRepresentations);
       const trickModeTracks =
         track.trickModeTracks !== undefined
           ? track.trickModeTracks.map((trickModeAdaptation) => {

package/src/manifest/classes/adaptation.ts

@@ -49,55 +49,55 @@ export default class Adaptation implements IAdaptationMetadata {
    */
   public manuallyAdded?: boolean;
   /**
-   * @see IRepresentationMetadata
+   * @see IAdaptationMetadata.representations
    */
   public readonly representations: Representation[];
   /**
-   * @see IRepresentationMetadata
+   * @see ITrackType
    */
   public readonly type: ITrackType;
   /**
-   * @see IRepresentationMetadata
+   * @see IAdaptationMetadata.isAudioDescription
    */
   public isAudioDescription?: boolean;
   /**
-   * @see IRepresentationMetadata
+   * @see IAdaptationMetadata.isClosedCaption
    */
   public isClosedCaption?: boolean;
   /**
-   * @see IRepresentationMetadata
+   * @see IAdaptationMetadata.isForcedSubtitles
    */
   public isForcedSubtitles?: boolean;
   /**
-   * @see IRepresentationMetadata
+   * @see IAdaptationMetadata.isSignInterpreted
    */
   public isSignInterpreted?: boolean;
   /**
-   * @see IRepresentationMetadata
+   * @see IAdaptationMetadata.isDub
    */
   public isDub?: boolean;
   /**
-   * @see IRepresentationMetadata
+   * @see IAdaptationMetadata.language
    */
   public language?: string;
   /**
-   * @see IRepresentationMetadata
+   * @see IAdaptationMetadata.normalizedLanguage
    */
   public normalizedLanguage?: string;
   /**
-   * @see IRepresentationMetadata
+   * @see IAdaptationSupportStatus
    */
   public supportStatus: IAdaptationSupportStatus;
   /**
-   * @see IRepresentationMetadata
+   * @see IAdaptationMetadata.isTrickModeTrack
    */
   public isTrickModeTrack?: boolean;
   /**
-   * @see IRepresentationMetadata
+   * @see IAdaptationMetadata.label
    */
   public label?: string;
   /**
-   * @see IRepresentationMetadata
+   * @see IAdaptationMetadata.trickModeTracks
    */
   public readonly trickModeTracks?: Adaptation[];
 
@@ -180,9 +180,7 @@ export default class Adaptation implements IAdaptationMetadata {
         if (representation.contentProtections !== undefined) {
           reprObject.contentProtections = {};
           if (representation.contentProtections.keyIds !== undefined) {
-            const keyIds = representation.contentProtections.keyIds.map(
-              ({ keyId }) => keyId,
-            );
+            const keyIds = representation.contentProtections.keyIds;
             reprObject.contentProtections.keyIds = keyIds;
           }
         }

package/src/manifest/classes/representation.ts

@@ -37,15 +37,15 @@ class Representation implements IRepresentationMetadata {
   /** ID uniquely identifying the Representation in its parent Adaptation. */
   public readonly id: string;
   /**
-   * @see IRepresentationMetadata
+   * @see IRepresentationMetadata.uniqueId
    */
   public readonly uniqueId: string;
   /**
-   * @see IRepresentationMetadata
+   * @see IRepresentationMetadata.bitrate
    */
   public bitrate: number;
   /**
-   * @see IRepresentationMetadata
+   * @see IRepresentationMetadata.frameRate
    */
   public frameRate?: number;
   /**
@@ -65,39 +65,47 @@ class Representation implements IRepresentationMetadata {
    */
   public cdnMetadata: ICdnMetadata[] | null;
   /**
-   * @see IRepresentationMetadata
+   * @see IRepresentationMetadata.isSpatialAudio
    */
   public isSpatialAudio?: boolean | undefined;
   /**
-   * @see IRepresentationMetadata
+   * @see IRepresentationMetadata.codecs
    */
   public codecs: string[];
   /**
-   * @see IRepresentationMetadata
+   * @see IRepresentationMetadata.mimeType
    */
   public mimeType?: string;
   /**
-   * @see IRepresentationMetadata
+   * @see IRepresentationMetadata.width
    */
   public width?: number;
   /**
-   * @see IRepresentationMetadata
+   * @see IRepresentationMetadata.height
    */
   public height?: number;
   /**
-   * @see IRepresentationMetadata
+   * @see IRepresentationMetadata.contentProtections
    */
   public contentProtections?: IContentProtections;
   /**
-   * @see IRepresentationMetadata
+   * @see IRepresentationMetadata.hdrInfo
    */
   public hdrInfo?: IHDRInformation;
   /**
-   * @see IRepresentationMetadata
+   * @see IRepresentationMetadata.decipherable
+   *
+   * Note that this property should __NEVER__ be updated directly on an
+   * instanciated `Representation`, you are supposed to rely on
+   * `Manifest` methods for this.
    */
   public decipherable?: boolean | undefined;
   /**
-   * @see IRepresentationMetadata
+   * @see IRepresentationMetadata.isSupported
+   *
+   * Note that this property should __NEVER__ be updated directly on an
+   * instanciated `Representation`, you are supposed to rely on
+   * `Manifest` methods for this.
    */
   public isSupported: boolean | undefined;
   /**
@@ -281,7 +289,7 @@ class Representation implements IRepresentationMetadata {
       for (let j = 0; j < initData.values.length; j++) {
         if (initData.values[j].systemId.toLowerCase() === drmSystemId.toLowerCase()) {
           if (!createdObjForType) {
-            const keyIds = this.contentProtections?.keyIds?.map((val) => val.keyId);
+            const keyIds = this.contentProtections?.keyIds;
             filtered.push({
               type: initData.type,
               keyIds,
@@ -330,7 +338,7 @@ class Representation implements IRepresentationMetadata {
     ) {
       return [];
     }
-    const keyIds = this.contentProtections?.keyIds?.map((val) => val.keyId);
+    const keyIds = this.contentProtections?.keyIds;
     return this.contentProtections.initData.map((x) => {
       return { type: x.type, keyIds, values: x.values };
     });
@@ -363,7 +371,7 @@ class Representation implements IRepresentationMetadata {
     let hasUpdatedProtectionData = false;
     if (this.contentProtections === undefined) {
       this.contentProtections = {
-        keyIds: keyId !== undefined ? [{ keyId }] : [],
+        keyIds: keyId !== undefined ? [keyId] : [],
         initData: [{ type: initDataType, values: data }],
       };
       return true;
@@ -372,17 +380,17 @@ class Representation implements IRepresentationMetadata {
     if (keyId !== undefined) {
       const keyIds = this.contentProtections.keyIds;
       if (keyIds === undefined) {
-        this.contentProtections.keyIds = [{ keyId }];
+        this.contentProtections.keyIds = [keyId];
       } else {
         let foundKeyId = false;
         for (const knownKeyId of keyIds) {
-          if (areArraysOfNumbersEqual(knownKeyId.keyId, keyId)) {
+          if (areArraysOfNumbersEqual(knownKeyId, keyId)) {
             foundKeyId = true;
           }
         }
         if (!foundKeyId) {
           log.warn("Manifest: found unanounced key id.");
-          keyIds.push({ keyId });
+          keyIds.push(keyId);
         }
       }
     }

package/src/manifest/utils.ts

@@ -358,6 +358,7 @@ function toVideoRepresentation(
     hdrInfo,
     isSupported,
     decipherable,
+    contentProtections,
   } = representation;
   return {
     id,
@@ -369,6 +370,12 @@ function toVideoRepresentation(
     hdrInfo,
     isCodecSupported: isSupported,
     decipherable,
+    contentProtections:
+      contentProtections !== undefined
+        ? {
+            keyIds: contentProtections.keyIds,
+          }
+        : undefined,
   };
 }
 
@@ -407,9 +414,10 @@ export interface IDecipherabilityStatusChangedElement {
  *     decipherability updated to `undefined`.
  *
  * @param {Object} manifest
- * @param {Array.<Uint8Array>} whitelistedKeyIds
- * @param {Array.<Uint8Array>} blacklistedKeyIds
- * @param {Array.<Uint8Array>} delistedKeyIds
+ * @param {Object} updates
+ * @param {Array.<Uint8Array>} updates.whitelistedKeyIds
+ * @param {Array.<Uint8Array>} updates.blacklistedKeyIds
+ * @param {Array.<Uint8Array>} updates.delistedKeyIds
  */
 export function updateDecipherabilityFromKeyIds(
   manifest: IManifestMetadata,
@@ -428,17 +436,17 @@ export function updateDecipherabilityFromKeyIds(
     if (contentKIDs !== undefined) {
       for (const elt of contentKIDs) {
         for (const blacklistedKeyId of blacklistedKeyIds) {
-          if (areArraysOfNumbersEqual(blacklistedKeyId, elt.keyId)) {
+          if (areArraysOfNumbersEqual(blacklistedKeyId, elt)) {
             return false;
           }
         }
         for (const whitelistedKeyId of whitelistedKeyIds) {
-          if (areArraysOfNumbersEqual(whitelistedKeyId, elt.keyId)) {
+          if (areArraysOfNumbersEqual(whitelistedKeyId, elt)) {
             return true;
           }
         }
         for (const delistedKeyId of delistedKeyIds) {
-          if (areArraysOfNumbersEqual(delistedKeyId, elt.keyId)) {
+          if (areArraysOfNumbersEqual(delistedKeyId, elt)) {
             return undefined;
           }
         }

package/src/parsers/manifest/dash/common/content_protection_parser.ts

@@ -214,13 +214,13 @@ function parseContentProtection(
     contentProtectionIr.attributes.keyId !== undefined &&
     contentProtectionIr.attributes.keyId.length > 0
   ) {
-    const kidObj = { keyId: contentProtectionIr.attributes.keyId, systemId };
+    const kid = contentProtectionIr.attributes.keyId;
     if (representation.contentProtections === undefined) {
-      representation.contentProtections = { keyIds: [kidObj], initData: [] };
+      representation.contentProtections = { keyIds: [kid], initData: [] };
     } else if (representation.contentProtections.keyIds === undefined) {
-      representation.contentProtections.keyIds = [kidObj];
+      representation.contentProtections.keyIds = [kid];
     } else {
-      representation.contentProtections.keyIds.push(kidObj);
+      representation.contentProtections.keyIds.push(kid);
     }
   }
 

package/src/parsers/manifest/local/parse_local_manifest.ts

@@ -169,7 +169,7 @@ function parseRepresentation(
 function formatContentProtections(
   localContentProtections: ILocalContentProtections,
 ): IContentProtections {
-  const keyIds = localContentProtections.keyIds;
+  const keyIds = localContentProtections.keyIds.map((k) => k.keyId);
   const initData: IContentProtectionInitData[] = Object.keys(
     localContentProtections.initData,
   ).map((currType) => {

package/src/parsers/manifest/smooth/create_parser.ts

@@ -27,7 +27,6 @@ import { getFilenameIndexInUrl } from "../../../utils/resolve_url";
 import { hexToBytes } from "../../../utils/string_parsing";
 import { createBox } from "../../containers/isobmff";
 import type {
-  IContentProtectionKID,
   IParsedAdaptation,
   IParsedAdaptations,
   IParsedManifest,
@@ -371,15 +370,12 @@ function createSmoothStreamingParser(
         (!isNullOrUndefined(codecs) ? codecs + "-" : "") +
         String(qualityLevel.bitrate);
 
-      const keyIDs: IContentProtectionKID[] = [];
+      const keyIDs: Uint8Array[] = [];
       let firstProtection: IContentProtectionSmooth | undefined;
       if (protections.length > 0) {
         firstProtection = protections[0];
         protections.forEach((protection) => {
-          const keyId = protection.keyId;
-          protection.keySystems.forEach((keySystem) => {
-            keyIDs.push({ keyId, systemId: keySystem.systemId });
-          });
+          keyIDs.push(protection.keyId);
         });
       }
 

package/src/parsers/manifest/types.ts

@@ -39,12 +39,6 @@ export interface IParsedStreamEventData {
   };
 }
 
-/** Describes information about an encryption Key ID of a given media. */
-export interface IContentProtectionKID {
-  keyId: Uint8Array;
-  systemId?: string | undefined;
-}
-
 /**
  * Encryption initialization data.
  * This is the data used to initialize a license request.
@@ -85,7 +79,7 @@ export interface IContentProtections {
    * `undefined` if the key id(s) associated with that content may exist but are
    * not known.
    */
-  keyIds: IContentProtectionKID[] | undefined;
+  keyIds: Uint8Array[] | undefined;
   /** The different encryption initialization data associated with that content. */
   initData: IContentProtectionInitData[];
 }

package/src/public_types.ts

@@ -803,12 +803,50 @@ export interface IRepresentationContext {
  * RxPlayer.
  */
 export interface IAudioRepresentation {
+  /**
+   * Identifier for that Representation.
+   * Might e.g. be used with the `lockVideoRepresentation` API.
+   */
   id: string | number;
+  /** Optional maximum bitrate, in bits per seconds, for this Representation. */
   bitrate?: number | undefined;
+  /** Codec(s) relied on by the media segments of that Representation. */
   codec?: string | undefined;
+  /**
+   * If `true`, this Representation is linked to "spatial audio" technology, such as
+   * Dolby Atmos.
+   * If `false`, it is not linked to such technology.
+   *
+   * If `undefined`, we don't if it is linked to a spatial audio technology or not.
+   */
   isSpatialAudio?: boolean | undefined;
+  /**
+   * If `true`, the codec is known to be supported on the current device.
+   * If `false`, it is known to be unsupported.
+   *
+   * If `undefined`, we don't know yet if it is supported or not.
+   */
   isCodecSupported?: boolean | undefined;
+  /**
+   * If `true`, this Representation is known to be decipherable.
+   * If `false`, it is known to be encrypted and not decipherable.
+   *
+   * If `undefined`, we don't know yet if it is decipherable or not (or if it is
+   * encrypted or not in some cases).
+   */
   decipherable?: boolean | undefined;
+  /**
+   * Encryption information linked to this content.
+   * If set to an Object, the Representation is known to be encrypted.
+   * If unset or set to `undefined` the Representation is either unencrypted or
+   * we don't know if it is.
+   */
+  contentProtections?:
+    | {
+        /** Known key ids linked to that Representation. */
+        keyIds?: Uint8Array[] | undefined;
+      }
+    | undefined;
 }
 
 /** Audio track returned by the RxPlayer. */
@@ -847,15 +885,50 @@ export interface ITextTrack {
  * RxPlayer.
  */
 export interface IVideoRepresentation {
+  /**
+   * Identifier for that Representation.
+   * Might e.g. be used with the `lockVideoRepresentation` API.
+   */
   id: string;
+  /** Optional maximum bitrate, in bits per seconds, for this Representation. */
   bitrate?: number | undefined;
+  /** Defines the width of the Representation in pixels. */
   width?: number | undefined;
+  /** Defines the height of the Representation in pixels. */
   height?: number | undefined;
+  /** Codec(s) relied on by the media segments of that Representation. */
   codec?: string | undefined;
+  /** The frame rate for this Representation, in frame per seconds. */
   frameRate?: number | undefined;
+  /** If the track is HDR, gives the HDR characteristics of the content */
   hdrInfo?: IHDRInformation | undefined;
+  /**
+   * If `true`, the codec is known to be supported on the current device.
+   * If `false`, it is known to be unsupported.
+   *
+   * If `undefined`, we don't know yet if it is supported or not.
+   */
   isCodecSupported?: boolean | undefined;
+  /**
+   * If `true`, this Representation is known to be decipherable.
+   * If `false`, it is known to be encrypted and not decipherable.
+   *
+   * If `undefined`, we don't know yet if it is decipherable or not (or if it is
+   * encrypted or not in some cases).
+   */
   decipherable?: boolean | undefined;
+  /**
+   * Encryption information linked to this content.
+   * If set to an Object, the Representation is known to be encrypted.
+   * If unset or set to `undefined` the Representation is either unencrypted or
+   * we don't know if it is.
+   */
+  contentProtections?:
+    | {
+        /** Known key ids linked to that Representation. */
+        keyIds?: Uint8Array[] | undefined;
+      }
+    | undefined;
 }
 
 /** Video track returned by the RxPlayer. */

package/vitest.config.mjs

@@ -91,6 +91,7 @@ export default defineConfig({
     globals: false,
     reporters: "dot",
     include: ["tests/**/*.[jt]s?(x)"],
+    exclude: ["tests/performance/**/*.[jt]s?(x)"],
     globalSetup: "tests/contents/server.mjs",
     browser: getBrowserConfig(process.env.BROWSER_CONFIG),
   },