rx-player 3.26.2 → 3.27.0-dev.20220317

package/src/core/{eme → decrypt/utils}/__tests__/clean_old_stored_persistent_info.test.ts

@@ -48,8 +48,8 @@ const emptyPersistentSessionsStore = {
 function checkNothingHappen(persistentSessionsStore : any, limit : number) {
   const deleteLastSpy = jest.spyOn(persistentSessionsStore, "deleteOldSessions");
   const logInfoSpy = jest.fn();
-  jest.mock("../../../log", () => ({ __esModule: true as const,
-                                     default: { info: logInfoSpy } }));
+  jest.mock("../../../../log", () => ({ __esModule: true as const,
+                                        default: { info: logInfoSpy } }));
   const cleanOldStoredPersistentInfo = require("../clean_old_stored_persistent_info")
     .default;
   cleanOldStoredPersistentInfo(persistentSessionsStore, limit);
@@ -73,22 +73,22 @@ function checkRemoved(
 ) {
   const deleteLastSpy = jest.spyOn(persistentSessionsStore, "deleteOldSessions");
   const logInfoSpy = jest.fn();
-  jest.mock("../../../log", () => ({ __esModule: true as const,
-                                     default: { info: logInfoSpy } }));
+  jest.mock("../../../../log", () => ({ __esModule: true as const,
+                                        default: { info: logInfoSpy } }));
   const cleanOldStoredPersistentInfo = require("../clean_old_stored_persistent_info")
     .default;
   cleanOldStoredPersistentInfo(persistentSessionsStore, limit);
   expect(deleteLastSpy).toHaveBeenCalledTimes(1);
   expect(deleteLastSpy).toHaveBeenCalledWith(numberToRemove);
   expect(logInfoSpy).toHaveBeenCalledTimes(1);
-  expect(logInfoSpy).toHaveBeenCalledWith("EME: Too many stored persistent sessions," +
+  expect(logInfoSpy).toHaveBeenCalledWith("DRM: Too many stored persistent sessions," +
                                             " removing some.",
                                           persistentSessionsStore.getLength(),
                                           numberToRemove);
   jest.resetModules();
 }
 
-describe("core - eme - cleanOldStoredPersistentInfo", () => {
+describe("core - decrypt - cleanOldStoredPersistentInfo", () => {
   it("should do nothing with a negative limit", () => {
     checkNothingHappen(createPersistentSessionsStore(), -1);
     checkNothingHappen(createPersistentSessionsStore(), -20);

package/src/core/{eme → decrypt}/utils/are_init_values_compatible.ts

@@ -15,7 +15,7 @@
  */
 
 import areArraysOfNumbersEqual from "../../../utils/are_arrays_of_numbers_equal";
-import InitDataContainer from "./init_data_container";
+import SerializableBytes from "./serializable_bytes";
 
 /**
  * Returns `true` if both values are compatible initialization data, which
@@ -29,10 +29,10 @@ import InitDataContainer from "./init_data_container";
 export default function areInitializationValuesCompatible(
   stored : Array<{ systemId : string | undefined;
                    hash : number;
-                   data : Uint8Array | InitDataContainer; }>,
+                   data : Uint8Array | SerializableBytes | string; }>,
   newElts : Array<{ systemId : string | undefined;
                     hash : number;
-                    data : Uint8Array | InitDataContainer; }>
+                    data : Uint8Array | SerializableBytes | string; }>
 ) : boolean {
   return _isAInB(stored, newElts) ??
          _isAInB(newElts, stored) ??
@@ -62,10 +62,10 @@ export default function areInitializationValuesCompatible(
 function _isAInB(
   a : Array<{ systemId : string | undefined;
               hash : number;
-              data : Uint8Array | InitDataContainer; }>,
+              data : Uint8Array | SerializableBytes | string; }>,
   b : Array<{ systemId : string | undefined;
               hash : number;
-              data : Uint8Array | InitDataContainer; }>
+              data : Uint8Array | SerializableBytes | string; }>
 ) : boolean | null {
   if (a.length === 0) {
     return false;
@@ -89,11 +89,11 @@ function _isAInB(
 
     const aData : Uint8Array =
       firstAElt.data instanceof Uint8Array ? firstAElt.data :
-      typeof firstAElt.data === "string"   ? InitDataContainer.decode(firstAElt.data) :
+      typeof firstAElt.data === "string"   ? SerializableBytes.decode(firstAElt.data) :
                                              firstAElt.data.initData;
     const bData : Uint8Array =
       bElt.data instanceof Uint8Array ? bElt.data :
-      typeof bElt.data === "string"   ? InitDataContainer.decode(bElt.data) :
+      typeof bElt.data === "string"   ? SerializableBytes.decode(bElt.data) :
                                              bElt.data.initData;
     if (!areArraysOfNumbersEqual(aData, bData)) {
       return false;
@@ -117,11 +117,11 @@ function _isAInB(
         }
         const aNewData : Uint8Array =
           aElt.data instanceof Uint8Array ? aElt.data :
-          typeof aElt.data === "string"   ? InitDataContainer.decode(aElt.data) :
+          typeof aElt.data === "string"   ? SerializableBytes.decode(aElt.data) :
                                                  aElt.data.initData;
         const bNewData : Uint8Array =
           bNewElt.data instanceof Uint8Array ? bNewElt.data :
-          typeof bNewElt.data === "string"   ? InitDataContainer.decode(bNewElt.data) :
+          typeof bNewElt.data === "string"   ? SerializableBytes.decode(bNewElt.data) :
                                                bNewElt.data.initData;
         if (!areArraysOfNumbersEqual(aNewData, bNewData)) {
           return false;

package/src/core/{eme → decrypt/utils}/check_key_statuses.ts

@@ -14,11 +14,12 @@
  * limitations under the License.
  */
 
-import { ICustomMediaKeySession } from "../../compat";
-import getUUIDKidFromKeyStatusKID from "../../compat/eme/get_uuid_kid_from_keystatus_kid";
-import { EncryptedMediaError } from "../../errors";
-import { bytesToHex } from "../../utils/string_parsing";
-import { IEMEWarningEvent } from "./types";
+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 { bytesToHex } from "../../../utils/string_parsing";
+import { IEMEWarningEvent } from "../types";
 
 const KEY_STATUSES = { EXPIRED: "expired",
                        INTERNAL_ERROR: "internal-error",

package/{dist/_esm5.processed/core/eme/clean_old_loaded_sessions.js → src/core/decrypt/utils/clean_old_loaded_sessions.ts}

@@ -13,7 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { EMPTY, mapTo, merge as observableMerge, startWith, } from "rxjs";
+
+import PPromise from "../../../utils/promise";
+import LoadedSessionsStore from "./loaded_sessions_store";
+
 /**
  * Close sessions from the loadedSessionsStore to allow at maximum `limit`
  * stored MediaKeySessions in it.
@@ -23,23 +26,20 @@ import { EMPTY, mapTo, merge as observableMerge, startWith, } from "rxjs";
  * @param {Object} loadedSessionsStore
  * @returns {Observable}
  */
-export default function cleanOldLoadedSessions(loadedSessionsStore, limit) {
-    if (limit < 0 || limit >= loadedSessionsStore.getLength()) {
-        return EMPTY;
-    }
-    var cleaningOldSessions$ = [];
-    var entries = loadedSessionsStore
-        .getAll()
-        .slice(); // clone
-    var toDelete = entries.length - limit;
-    for (var i = 0; i < toDelete; i++) {
-        var entry = entries[i];
-        var cleaning$ = loadedSessionsStore
-            .closeSession(entry.initializationData)
-            .pipe(mapTo({ type: "cleaned-old-session",
-            value: entry }), startWith({ type: "cleaning-old-session",
-            value: entry }));
-        cleaningOldSessions$.push(cleaning$);
-    }
-    return observableMerge.apply(void 0, cleaningOldSessions$);
+export default async function cleanOldLoadedSessions(
+  loadedSessionsStore : LoadedSessionsStore,
+  limit : number
+) : Promise<void> {
+  if (limit < 0 || limit >= loadedSessionsStore.getLength()) {
+    return ;
+  }
+
+  const proms : Array<Promise<unknown>> = [];
+  const entries = loadedSessionsStore.getAll().slice(); // clone
+  const toDelete = entries.length - limit;
+  for (let i = 0; i < toDelete; i++) {
+    const entry = entries[i];
+    proms.push(loadedSessionsStore.closeSession(entry.mediaKeySession));
+  }
+  await PPromise.all(proms);
 }

package/src/core/{eme → decrypt/utils}/clean_old_stored_persistent_info.ts

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-import log from "../../log";
-import PersistentSessionsStore from "./utils/persistent_sessions_store";
+import log from "../../../log";
+import PersistentSessionsStore from "./persistent_sessions_store";
 
 /**
  * Remove old information from a PersistentSessionsStore so that it respects the
@@ -41,7 +41,7 @@ export default function cleanOldStoredPersistentInfo(
   }
   const numberOfPersistentSessions = persistentSessionsStore.getLength();
   const toDelete = numberOfPersistentSessions - limit;
-  log.info("EME: Too many stored persistent sessions, removing some.",
+  log.info("DRM: Too many stored persistent sessions, removing some.",
            numberOfPersistentSessions,
            toDelete);
   persistentSessionsStore.deleteOldSessions(toDelete);

package/src/core/{eme → decrypt/utils}/get_drm_system_id.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import startsWith from "../../utils/starts_with";
+import startsWith from "../../../utils/starts_with";
 
 /**
  * @param {string} keySystem

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

@@ -0,0 +1,119 @@
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { concat } from "../../../utils/byte_parsing";
+import hashBuffer from "../../../utils/hash_buffer";
+import { IInitDataValue } from "../types";
+import areInitializationValuesCompatible from "./are_init_values_compatible";
+
+/**
+ * Wrap initialization data values and reformat it so it becomes easier to check
+ * compatibility with other `InitDataValuesContainer`.
+ * @class InitDataValuesContainer
+ */
+export default class InitDataValuesContainer {
+  private readonly _innerValues : IInitDataValue[];
+  private _lazyFormattedValues : IFormattedInitDataValue[] | null;
+
+  /**
+   * Construct a new `InitDataValuesContainer`.
+   * Note that the data is not formatted right away.
+   * It is only really formatted lazily the first time we need it.
+   *
+   * @param {Array.<Object>} initDataValues
+   */
+  constructor(initDataValues : IInitDataValue[]) {
+    this._innerValues = initDataValues;
+    this._lazyFormattedValues = null;
+  }
+
+  /**
+   * Construct data that should be given to the `generateRequest` EME API.
+   * @returns {Uint8Array}
+   */
+  public constructRequestData() : Uint8Array {
+    // `generateKeyRequest` awaits a single Uint8Array containing all
+    // initialization data.
+    return concat(...this._innerValues.map(i => i.data));
+  }
+
+  /**
+   * Returns `true` if the given `InitDataValuesContainer` seems to be
+   * "compatible" with the one stored in this instance.
+   * Returns `false` if not.
+   *
+   * By "compatible" we mean that it will generate the same key request.
+   * @param {InitDataValuesContainer | Object} initDataValues
+   * @returns {boolean}
+   */
+  public isCompatibleWith(
+    initDataValues : InitDataValuesContainer | IFormattedInitDataValue[]
+  ) : boolean {
+    const formatted = initDataValues instanceof InitDataValuesContainer ?
+      initDataValues.getFormattedValues() :
+      initDataValues;
+    return areInitializationValuesCompatible(this.getFormattedValues(), formatted);
+  }
+
+  /**
+   * Return the stored initialization data values, with added niceties:
+   *   - they are sorted always the same way for similar
+   *     `InitDataValuesContainer`
+   *   - each value is associated to its hash, which is always done with  the
+   *     same hashing function than for all other InitDataValuesContainer).
+   *
+   * The main point being to be able to compare much faster multiple
+   * `InitDataValuesContainer`, though that data can also be used in any
+   * other way.
+   * @returns {Array.<Object>}
+   */
+  public getFormattedValues() : IFormattedInitDataValue[] {
+    if (this._lazyFormattedValues === null) {
+      this._lazyFormattedValues = formatInitDataValues(this._innerValues);
+    }
+    return this._lazyFormattedValues;
+  }
+}
+
+/**
+ * Format given initializationData's values so they are faster to compare:
+ *   - sort them by systemId
+ *   - add hash for each initialization data encountered.
+ * @param {Array.<Object>} initialValues
+ * @returns {Array.<Object>}
+ */
+function formatInitDataValues(
+  initialValues : IInitDataValue[]
+) : IFormattedInitDataValue[] {
+  return initialValues.slice()
+    .sort((a, b) => a.systemId === b.systemId ? 0 :
+                    a.systemId === undefined  ? 1 :
+                    b.systemId === undefined  ? -1 :
+                    a.systemId < b.systemId   ? -1 :
+                    1)
+    .map(({ systemId, data }) => ({ systemId,
+                                    data,
+                                    hash: hashBuffer(data) }));
+}
+
+/**
+ * Formatted initialization data value, so it is faster to compare to others.
+ */
+export interface IFormattedInitDataValue {
+  systemId : string | undefined;
+  hash : number;
+  data : Uint8Array;
+}

package/src/core/{eme → decrypt}/utils/is_session_usable.ts

@@ -22,7 +22,6 @@ import arrayIncludes from "../../../utils/array_includes";
  * If all key statuses attached to session are valid (either not
  * "expired" or "internal-error"), return true.
  * If not, return false.
- * @param {Uint8Array} initData
  * @param {MediaKeySession} loadedSession
  * @returns {MediaKeySession}
  */
@@ -40,24 +39,24 @@ export default function isSessionUsable(
   });
 
   if (keyStatuses.length <= 0) {
-    log.debug("EME: isSessionUsable: MediaKeySession given has an empty keyStatuses",
+    log.debug("DRM: isSessionUsable: MediaKeySession given has an empty keyStatuses",
               loadedSession.sessionId);
     return false;
   }
 
   if (arrayIncludes(keyStatuses, "expired")) {
-    log.debug("EME: isSessionUsable: MediaKeySession given has an expired key",
+    log.debug("DRM: isSessionUsable: MediaKeySession given has an expired key",
               loadedSession.sessionId);
     return false;
   }
 
   if (arrayIncludes(keyStatuses, "internal-error")) {
-    log.debug("EME: isSessionUsable: MediaKeySession given has a key with an " +
+    log.debug("DRM: isSessionUsable: MediaKeySession given has a key with an " +
               "internal-error",
               loadedSession.sessionId);
     return false;
   }
 
-  log.debug("EME: isSessionUsable: MediaKeySession is usable", loadedSession.sessionId);
+  log.debug("DRM: isSessionUsable: MediaKeySession is usable", loadedSession.sessionId);
   return true;
 }

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

@@ -0,0 +1,82 @@
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import areArraysOfNumbersEqual from "../../../utils/are_arrays_of_numbers_equal";
+
+/**
+ * Returns `true` if both given key id appear to be equal.
+ * @param {Uint8Array} keyId1
+ * @param {Uint8Array} keyId2
+ * @returns {boolean}
+ */
+export function areKeyIdsEqual(
+  keyId1 : Uint8Array,
+  keyId2 : Uint8Array
+) : boolean {
+  return keyId1 === keyId2 || areArraysOfNumbersEqual(keyId1, keyId2);
+}
+
+/**
+ * @param {Uint8Array} wantedKeyId
+ * @param {Array.<Uint8Array>} keyIdsArr
+ * @returns {boolean}
+ */
+export function isKeyIdContainedIn(
+  wantedKeyId : Uint8Array,
+  keyIdsArr : Uint8Array[]
+) : boolean {
+  return keyIdsArr.some(k => areKeyIdsEqual(k, wantedKeyId));
+}
+
+/**
+ * Returns `true` if all key ids in `wantedKeyIds` are present in the
+ * `keyIdsArr` array.
+ * @param {Array.<Uint8Array>} wantedKeyIds
+ * @param {Array.<Uint8Array>} keyIdsArr
+ * @returns {boolean}
+ */
+export function areAllKeyIdsContainedIn(
+  wantedKeyIds : Uint8Array[],
+  keyIdsArr : Uint8Array[]
+) : boolean {
+  for (const keyId of wantedKeyIds) {
+    const found = keyIdsArr.some(k => areKeyIdsEqual(k, keyId));
+    if (!found) {
+      return false;
+    }
+  }
+  return true;
+}
+
+/**
+ * Returns `true` if at least one key id in `wantedKeyIds` is present in the
+ * `keyIdsArr` array.
+ * @param {Array.<Uint8Array>} wantedKeyIds
+ * @param {Array.<Uint8Array>} keyIdsArr
+ * @returns {boolean}
+ */
+export function areSomeKeyIdsContainedIn(
+  wantedKeyIds : Uint8Array[],
+  keyIdsArr : Uint8Array[]
+) : boolean {
+  for (const keyId of wantedKeyIds) {
+    const found = keyIdsArr.some(k => areKeyIdsEqual(k, keyId));
+    if (found) {
+      return true;
+    }
+  }
+  return false;
+}

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

@@ -0,0 +1,175 @@
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { IProcessedProtectionData } from "../types";
+import {
+  areKeyIdsEqual,
+  areAllKeyIdsContainedIn,
+} from "./key_id_comparison";
+
+/**
+ * Class storing key-related information linked to a created `MediaKeySession`.
+ *
+ * This class allows to regroup one or multiple key ids and can be linked to a
+ * single MediaKeySession so you can know which key that MediaKeySession
+ * handles.
+ *
+ * The main use case behind the complexities of this `KeySessionRecord` is to
+ * better handle the `singleLicensePer` RxPlayer option, which allows the
+ * recuperation of a license containing multiple keys, even if only one of
+ * those keys was asked for (which in turn allows to reduce the number of
+ * requests and to improve performance).
+ * Here, the `KeySessionRecord` will regroup all those key's id and can be
+ * linked to the corresponding MediaKeySession.
+ * That way, you can later check if another encrypted content is compatible with
+ * that session through the `KeySessionRecord`'s `isCompatibleWith` method.
+ *
+ * @example
+ * ```js
+ * const record = new KeySessionRecord(initData);
+ *
+ * // Create a MediaKeySession linked to that initialization data and fetch the
+ * // license
+ * // ...
+ *
+ * // Once the license has been loaded to the MediaKeySession linked to that
+ - // initialization data, associate the license's key Ids with the latter.
+ * record.associateKeyIds(someKeyIds);
+ *
+ * // Function called when new initialization data is encountered
+ * function onNewInitializationData(newInitializationData) {
+ *   if (record.isCompatibleWith(newInitializationData)) {
+ *     console.log("This initialization data should already be handled, ignored.");
+ *   } else {
+ *     console.log("This initialization data is not handled yet.";
+ *   }
+ * }
+ * ```
+ * @class KeySessionRecord
+ */
+export default class KeySessionRecord {
+  private readonly _initializationData : IProcessedProtectionData;
+  private _keyIds : Uint8Array[] | null;
+
+  /**
+   * Create a new `KeySessionRecord`, linked to its corresponding initialization
+   * data,
+   * @param {Object} initializationData
+   */
+  constructor(initializationData : IProcessedProtectionData) {
+    this._initializationData = initializationData;
+    this._keyIds = null;
+  }
+
+  /**
+   * Associate supplementary key ids to this `KeySessionRecord` so it becomes
+   * "compatible" to them.
+   *
+   * After this call, new initialization data linked to subsets of those key
+   * ids will be considered compatible  to this `KeySessionRecord` (calls to
+   * `isCompatibleWith` with the corresponding initialization data will return
+   * `true`).
+   * @param {Array.<Uint8Array>} keyIds
+   */
+  public associateKeyIds(
+    keyIds : Uint8Array[] | IterableIterator<Uint8Array>
+  ) : void {
+    if (this._keyIds === null) {
+      this._keyIds = [];
+    }
+    const keyIdsArr = Array.from(keyIds);
+    for (const keyId of keyIdsArr) {
+      if (!this.isAssociatedWithKeyId(keyId)) {
+        this._keyIds.push(keyId);
+      }
+    }
+  }
+
+  /**
+   * @param {Uint8Array} keyId
+   * @returns {boolean}
+   */
+  public isAssociatedWithKeyId(keyId : Uint8Array) : boolean {
+    if (this._keyIds === null) {
+      return false;
+    }
+    for (const storedKeyId of this._keyIds) {
+      if (areKeyIdsEqual(storedKeyId, keyId)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * @returns {Array.<Uint8Array>}
+   */
+  public getAssociatedKeyIds() : Uint8Array[] {
+    if (this._keyIds === null) {
+      return [];
+    }
+    return this._keyIds;
+  }
+
+  /**
+   * Check if that `KeySessionRecord` is compatible to the initialization data
+   * given.
+   *
+   * If it returns `true`, it means that this `KeySessionRecord` is already
+   * linked to that initialization data's key. As such, if that
+   * `KeySessionRecord` is already associated to an active MediaKeySession for
+   * example, the content linked to that initialization data should already be
+   * handled.
+   *
+   * If it returns `false`, it means that this `KeySessionRecord` has no
+   * relation with the given initialization data.
+   *
+   * @param {Object} initializationData
+   * @returns {boolean}
+   */
+  public isCompatibleWith(
+    initializationData : IProcessedProtectionData
+  ) : boolean {
+    const { keyIds } = initializationData;
+    if (keyIds !== undefined) {
+      if (this._keyIds !== null && areAllKeyIdsContainedIn(keyIds, this._keyIds)) {
+        return true;
+      }
+      if (this._initializationData.keyIds !== undefined) {
+        return areAllKeyIdsContainedIn(keyIds, this._initializationData.keyIds);
+      }
+    }
+    return this._checkInitializationDataCompatibility(initializationData);
+  }
+
+  private _checkInitializationDataCompatibility(
+    initializationData : IProcessedProtectionData
+  ) : boolean {
+    if (initializationData.keyIds !== undefined &&
+        this._initializationData.keyIds !== undefined)
+    {
+      return areAllKeyIdsContainedIn(initializationData.keyIds,
+                                     this._initializationData.keyIds);
+    }
+
+    if (this._initializationData.type !== initializationData.type) {
+      return false;
+    }
+
+    return this._initializationData.values
+      .isCompatibleWith(initializationData.values);
+  }
+}