rx-player 3.33.0 → 3.33.2

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

@@ -1,48 +0,0 @@
-/**
- * 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 log from "../../../log";
-import PersistentSessionsStore from "./persistent_sessions_store";
-
-/**
- * Remove old information from a PersistentSessionsStore so that it respects the
- * given `limit` as a maximum size. This can be used to prevent its size from
- * growing indefinitely.
- *
- * This is needed because our persistent session information storage is
- * un-bounded in size, adding more data will just add more data without removing
- * the old one - which can be valid or invalid.
- *
- * This is problematic for at least two reasons:
- *   - This data is loaded into JS memory which is finite (and which maximum
- *     bounds depends on the user environment).
- *   - The final storage used (as chosen by the application using the RxPlayer)
- *     will in most cases have a maximum storage size.
- */
-export default function cleanOldStoredPersistentInfo(
-  persistentSessionsStore : PersistentSessionsStore,
-  limit : number
-) : void {
-  if (isNaN(limit) || limit < 0 || limit >= persistentSessionsStore.getLength()) {
-    return;
-  }
-  const numberOfPersistentSessions = persistentSessionsStore.getLength();
-  const toDelete = numberOfPersistentSessions - limit;
-  log.info("DRM: Too many stored persistent sessions, removing some.",
-           numberOfPersistentSessions,
-           toDelete);
-  persistentSessionsStore.deleteOldSessions(toDelete);
-}

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

@@ -1,42 +0,0 @@
-/**
- * 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 startsWith from "../../../utils/starts_with";
-
-/**
- * @param {string} keySystem
- * @returns {string|undefined}
- */
-export default function getDrmSystemId(
-  keySystem : string
-) : string | undefined {
-  if (startsWith(keySystem, "com.microsoft.playready") ||
-      keySystem === "com.chromecast.playready" ||
-      keySystem === "com.youtube.playready")
-  {
-    return "9a04f07998404286ab92e65be0885f95";
-  }
-  if (keySystem === "com.widevine.alpha") {
-    return "edef8ba979d64acea3c827dcd51d21ed";
-  }
-  if (startsWith(keySystem, "com.apple.fps")) {
-    return "94ce86fb07ff4f43adb893d2fa968ca2";
-  }
-  if (startsWith(keySystem, "com.nagra.")) {
-    return "adb41c242dbf4a6d958b4457c0d27b95";
-  }
-  return undefined;
-}

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

@@ -1,119 +0,0 @@
-/**
- * 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/decrypt/utils/is_session_usable.ts

@@ -1,62 +0,0 @@
-/**
- * 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 { ICustomMediaKeySession } from "../../../compat/eme";
-import log from "../../../log";
-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 {MediaKeySession} loadedSession
- * @returns {MediaKeySession}
- */
-export default function isSessionUsable(
-  loadedSession : MediaKeySession | ICustomMediaKeySession
-) : boolean {
-  if (loadedSession.sessionId === "") {
-    return false;
-  }
-
-  const keyStatusesMap = loadedSession.keyStatuses;
-  const keyStatuses: string[] = [];
-  keyStatusesMap.forEach((keyStatus) => {
-    keyStatuses.push(keyStatus);
-  });
-
-  if (keyStatuses.length <= 0) {
-    log.debug("DRM: isSessionUsable: MediaKeySession given has an empty keyStatuses",
-              loadedSession.sessionId);
-    return false;
-  }
-
-  if (arrayIncludes(keyStatuses, "expired")) {
-    log.debug("DRM: isSessionUsable: MediaKeySession given has an expired key",
-              loadedSession.sessionId);
-    return false;
-  }
-
-  if (arrayIncludes(keyStatuses, "internal-error")) {
-    log.debug("DRM: isSessionUsable: MediaKeySession given has a key with an " +
-              "internal-error",
-              loadedSession.sessionId);
-    return false;
-  }
-
-  log.debug("DRM: isSessionUsable: MediaKeySession is usable", loadedSession.sessionId);
-  return true;
-}

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

@@ -1,57 +0,0 @@
-/**
- * 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 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 => areArraysOfNumbersEqual(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 => areArraysOfNumbersEqual(k, keyId));
-    if (found) {
-      return true;
-    }
-  }
-  return false;
-}

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

@@ -1,174 +0,0 @@
-/**
- * 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";
-import { IProcessedProtectionData } from "../types";
-import { 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 (areArraysOfNumbersEqual(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 && keyIds.length > 0) {
-      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 &&
-        initializationData.keyIds.length > 0 &&
-        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);
-  }
-}