rx-player 3.33.0 → 3.33.2

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

@@ -1,358 +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 {
-  IPersistentSessionInfo,
-  IPersistentSessionStorage,
-} from "../../../public_types";
-import areArraysOfNumbersEqual from "../../../utils/are_arrays_of_numbers_equal";
-import { assertInterface } from "../../../utils/assert";
-import { bytesToBase64 } from "../../../utils/base64";
-import hashBuffer from "../../../utils/hash_buffer";
-import isNonEmptyString from "../../../utils/is_non_empty_string";
-import isNullOrUndefined from "../../../utils/is_null_or_undefined";
-import { IProcessedProtectionData } from "../types";
-import areInitializationValuesCompatible from "./are_init_values_compatible";
-import { IFormattedInitDataValue } from "./init_data_values_container";
-import SerializableBytes from "./serializable_bytes";
-
-/**
- * Throw if the given storage does not respect the right interface.
- * @param {Object} storage
- */
-function checkStorage(storage : IPersistentSessionStorage) : void {
-  assertInterface(storage,
-                  { save: "function", load: "function" },
-                  "licenseStorage");
-}
-
-/**
- * Set representing persisted licenses. Depends on a simple local-
- * storage implementation with a `save`/`load` synchronous interface
- * to persist information on persisted sessions.
- *
- * This set is used only for a cdm/keysystem with license persistency
- * supported.
- * @class PersistentSessionsStore
- */
-export default class PersistentSessionsStore {
-  private readonly _storage : IPersistentSessionStorage;
-  private _entries : IPersistentSessionInfo[];
-
-  /**
-   * Create a new PersistentSessionsStore.
-   * @param {Object} storage
-   */
-  constructor(storage : IPersistentSessionStorage) {
-    checkStorage(storage);
-    this._entries = [];
-    this._storage = storage;
-    try {
-      let entries = this._storage.load();
-      if (!Array.isArray(entries)) {
-        entries = [];
-      }
-      this._entries = entries;
-    } catch (e) {
-      log.warn("DRM-PSS: Could not get entries from license storage",
-               e instanceof Error ? e : "");
-      this.dispose();
-    }
-  }
-
-  /**
-   * Returns the number of stored values.
-   * @returns {number}
-   */
-  public getLength() : number {
-    return this._entries.length;
-  }
-
-  /**
-   * Returns information about all stored MediaKeySession, in the order in which
-   * the MediaKeySession have been created.
-   * @returns {Array.<Object>}
-   */
-  public getAll() : IPersistentSessionInfo[] {
-    return this._entries;
-  }
-
-  /**
-   * Retrieve an entry based on its initialization data.
-   * @param {Object}  initData
-   * @param {string|undefined} initDataType
-   * @returns {Object|null}
-   */
-  public get(initData : IProcessedProtectionData) : IPersistentSessionInfo | null {
-    const index = this._getIndex(initData);
-    return index === -1 ? null :
-                          this._entries[index];
-  }
-
-  /**
-   * Like `get`, but also move the corresponding value at the end of the store
-   * (as returned by `getAll`) if found.
-   * This can be used for example to tell when a previously-stored value is
-   * re-used to then be able to implement a caching replacement algorithm based
-   * on the least-recently-used values by just evicting the first values
-   * returned by `getAll`.
-   * @param {Uint8Array} initData
-   * @param {string|undefined} initDataType
-   * @returns {*}
-   */
-  public getAndReuse(
-    initData : IProcessedProtectionData
-  ) : IPersistentSessionInfo | null {
-    const index = this._getIndex(initData);
-    if (index === -1) {
-      return null;
-    }
-    const item = this._entries.splice(index, 1)[0];
-    this._entries.push(item);
-    return item;
-  }
-
-  /**
-   * Add a new entry in the PersistentSessionsStore.
-   * @param {Uint8Array}  initData
-   * @param {string|undefined} initDataType
-   * @param {MediaKeySession} session
-   */
-  public add(
-    initData : IProcessedProtectionData,
-    keyIds : Uint8Array[] | undefined,
-    session : MediaKeySession|ICustomMediaKeySession
-  ) : void {
-    if (isNullOrUndefined(session) || !isNonEmptyString(session.sessionId)) {
-      log.warn("DRM-PSS: Invalid Persisten Session given.");
-      return;
-    }
-    const { sessionId } = session;
-    const currentIndex = this._getIndex(initData);
-    if (currentIndex >= 0) {
-      const currVersion = keyIds === undefined ? 3 :
-                                                 4;
-      const currentEntry = this._entries[currentIndex];
-      const entryVersion = currentEntry.version ?? -1;
-      if (entryVersion >= currVersion && sessionId === currentEntry.sessionId) {
-        return;
-      }
-      log.info("DRM-PSS: Updating session info.", sessionId);
-      this._entries.splice(currentIndex, 1);
-    } else {
-      log.info("DRM-PSS: Add new session", sessionId);
-    }
-
-    const storedValues = prepareValuesForStore(initData.values.getFormattedValues());
-    if (keyIds === undefined) {
-      this._entries.push({ version: 3,
-                           sessionId,
-                           values: storedValues,
-                           initDataType: initData.type });
-    } else {
-      this._entries.push({ version: 4,
-                           sessionId,
-                           keyIds: keyIds.map((k) => new SerializableBytes(k)),
-                           values: storedValues,
-                           initDataType: initData.type });
-    }
-    this._save();
-  }
-
-  /**
-   * Delete stored MediaKeySession information based on its session id.
-   * @param {string} sessionId
-   */
-  public delete(sessionId : string) : void {
-    let index = -1;
-    for (let i = 0; i < this._entries.length; i++) {
-      const entry = this._entries[i];
-      if (entry.sessionId === sessionId) {
-        index = i;
-        break;
-      }
-    }
-    if (index === -1) {
-      log.warn("DRM-PSS: initData to delete not found.");
-      return;
-    }
-    const entry = this._entries[index];
-    log.warn("DRM-PSS: Delete session from store", entry.sessionId);
-    this._entries.splice(index, 1);
-    this._save();
-  }
-
-  public deleteOldSessions(sessionsToDelete : number) : void {
-    log.info(`DRM-PSS: Deleting last ${sessionsToDelete} sessions.`);
-    if (sessionsToDelete <= 0) {
-      return;
-    }
-    if (sessionsToDelete <= this._entries.length) {
-      this._entries.splice(0, sessionsToDelete);
-    } else {
-      log.warn("DRM-PSS: Asked to remove more information that it contains",
-               sessionsToDelete,
-               this._entries.length);
-      this._entries = [];
-    }
-    this._save();
-  }
-
-  /**
-   * Delete all saved entries.
-   */
-  public dispose() : void {
-    this._entries = [];
-    this._save();
-  }
-
-  /**
-   * Retrieve index of an entry.
-   * Returns `-1` if not found.
-   * @param {Object} initData
-   * @returns {number}
-   */
-  private _getIndex(initData : IProcessedProtectionData) : number {
-    // Older versions of the format include a concatenation of all
-    // initialization data and its hash.
-    // This is only computed lazily, the first time it is needed.
-    let lazyConcatenatedData : null | { initData : Uint8Array;
-                                        initDataHash : number; } = null;
-    function getConcatenatedInitDataInfo() {
-      if (lazyConcatenatedData === null) {
-        const concatInitData = initData.values.constructRequestData();
-        lazyConcatenatedData = { initData: concatInitData,
-                                 initDataHash: hashBuffer(concatInitData) };
-      }
-      return lazyConcatenatedData;
-    }
-
-    for (let i = 0; i < this._entries.length; i++) {
-      const entry = this._entries[i];
-      if (entry.initDataType === initData.type) {
-        switch (entry.version) {
-          case 4:
-            if (initData.keyIds !== undefined) {
-              const foundCompatible = initData.keyIds.every(keyId => {
-                const keyIdB64 = bytesToBase64(keyId);
-                for (const entryKid of entry.keyIds) {
-                  if (typeof entryKid === "string") {
-                    if (keyIdB64 === entryKid) {
-                      return true;
-                    }
-                  } else if (areArraysOfNumbersEqual(entryKid.initData, keyId)) {
-                    return true;
-                  }
-                }
-                return false;
-              });
-              if (foundCompatible) {
-                return i;
-              }
-            } else {
-              const formatted = initData.values.getFormattedValues();
-              if (areInitializationValuesCompatible(formatted, entry.values)) {
-                return i;
-              }
-            }
-            break;
-
-          case 3:
-            const formatted = initData.values.getFormattedValues();
-            if (areInitializationValuesCompatible(formatted, entry.values)) {
-              return i;
-            }
-            break;
-
-          case 2: {
-            const { initData: concatInitData,
-                    initDataHash: concatHash } = getConcatenatedInitDataInfo();
-            if (entry.initDataHash === concatHash) {
-              try {
-                const decodedInitData : Uint8Array = typeof entry.initData === "string" ?
-                  SerializableBytes.decode(entry.initData) :
-                  entry.initData.initData;
-                if (areArraysOfNumbersEqual(decodedInitData, concatInitData)) {
-                  return i;
-                }
-              } catch (e) {
-                log.warn("DRM-PSS: Could not decode initialization data.",
-                         e instanceof Error ? e : "");
-              }
-            }
-            break;
-          }
-
-          case 1: {
-            const { initData: concatInitData,
-                    initDataHash: concatHash } = getConcatenatedInitDataInfo();
-            if (entry.initDataHash === concatHash) {
-              if (typeof entry.initData.length === "undefined") {
-                // If length is undefined, it has been linearized. We could still
-                // convert it back to an Uint8Array but this would necessitate some
-                // ugly unreadable logic for a very very minor possibility.
-                // Just consider that it is a match based on the hash.
-                return i;
-              } else if (areArraysOfNumbersEqual(entry.initData, concatInitData)) {
-                return i;
-              }
-            }
-            break;
-          }
-
-          default: {
-            const { initDataHash: concatHash } = getConcatenatedInitDataInfo();
-            if (entry.initData === concatHash) {
-              return i;
-            }
-          }
-        }
-      }
-    }
-    return -1;
-  }
-
-  /**
-   * Use the given storage to store the current entries.
-   */
-  private _save() : void {
-    try {
-      this._storage.save(this._entries);
-    } catch (e) {
-      log.warn("DRM-PSS: Could not save licenses in localStorage");
-    }
-  }
-}
-
-/**
- * Format given initializationData's values so they are ready to be stored:
- *   - sort them by systemId, so they are faster to compare
- *   - add hash for each initialization data encountered.
- * @param {Array.<Object>} initialValues
- * @returns {Array.<Object>}
- */
-function prepareValuesForStore(
-  initialValues : IFormattedInitDataValue[]
-) : Array<{ systemId : string | undefined;
-            hash : number;
-            data : SerializableBytes; }> {
-  return initialValues
-    .map(({ systemId, data, hash }) => ({ systemId,
-                                          hash,
-                                          data : new SerializableBytes(data) }));
-}

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

@@ -1,59 +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 {
-  base64ToBytes,
-  bytesToBase64,
-} from "../../../utils/base64";
-
-/** Wrap byte-based data and allow serialization of it into base64. */
-export default class SerializableBytes {
-  /**
-   * The data itself. Named `initData` for legacy reasons (cannot be changed
-   * because it has an impact on saved persistent session information.
-   */
-  public initData : Uint8Array;
-
-  /**
-   * Create a new `SerializableBytes`, wrapping the initialization data
-   * given and allowing serialization into base64.
-   * @param {Uint8Array}
-   */
-  constructor(initData : Uint8Array) {
-    this.initData = initData;
-  }
-
-  /**
-   * Convert it to base64.
-   * `toJSON` is specially interpreted by JavaScript engines to be able to rely
-   * on it when calling `JSON.stringify` on it or any of its parent objects:
-   * https://tc39.es/ecma262/#sec-serializejsonproperty
-   * @returns {string}
-   */
-  toJSON() : string {
-    return bytesToBase64(this.initData);
-  }
-
-  /**
-   * Decode a base64 sequence representing an initialization data back to an
-   * Uint8Array.
-   * @param {string}
-   * @returns {Uint8Array}
-   */
-  static decode(base64 : string) : Uint8Array {
-    return base64ToBytes(base64);
-  }
-}

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

@@ -1,133 +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 { ICustomMediaKeys } from "../../../compat/eme";
-import hashBuffer from "../../../utils/hash_buffer";
-
-/**
- * Keep track of server certificate which have been set for a MediaKeys.
- * As it is impossible for a MediaKeys to have his server certificate reset
- * or updated, we consider that once it has been set, it will remain set until
- * the MediaKeys instance is killed.
- *
- * So, a WeakMap helps keeping a trace of which server certificate (identified
- * with a unique hash) is set on a MediaKeys.
- * `null` indicate that we don't know (and not `undefined`, because this is the
- * default value for when a WeakMap has no value for a key) which server
- * certificate is attached to a MediaKeys instance (most likely because related
- * EME APIs failed or had an unexpected behavior).
- */
-const serverCertificateHashesMap =
-  new WeakMap<MediaKeys | ICustomMediaKeys,
-              { hash: number; serverCertificate: Uint8Array } | null>();
-
-/** ServerCertificateStore */
-export default {
-  /**
-   * Tells the ServerCertificateStore that you begin to call the APIs to set a
-   * ServerCertificate on `mediaKeys`.
-   *
-   * Calling this function is necessary due to how server certificate work
-   * currently in EME APIs:
-   * Because right now, it is impossible to tell if a MediaKeys instance has an
-   * attached ServerCertificate or not when the corresponding API fails or if it
-   * never answers, we prefer to announce through this function that the current
-   * server certificate attached to this MediaKeys is for now invalid.
-   * @param {MediaKeys | Object} mediaKeys
-   */
-  prepare(mediaKeys : MediaKeys | ICustomMediaKeys) : void {
-    serverCertificateHashesMap.set(mediaKeys, null);
-  },
-
-  /**
-   * Attach a new server certificate to a MediaKeys in the
-   * ServerCertificateStore.
-   *
-   * Only one server certificate should ever be attached to a MediaKeys
-   * instance and the `prepare` function should have been called before any
-   * action to update the server certificate took place (this function does not
-   * enforce either of those behaviors).
-   * @param {MediaKeys | Object} mediaKeys
-   * @param {ArrayBufferView | BufferSource} serverCertificate
-   */
-  set(
-    mediaKeys: MediaKeys | ICustomMediaKeys,
-    serverCertificate: ArrayBufferView | BufferSource
-  ) : void {
-    const formattedServerCertificate: Uint8Array =
-    serverCertificate instanceof Uint8Array ?
-      serverCertificate :
-      new Uint8Array(
-        serverCertificate instanceof ArrayBuffer ? serverCertificate :
-                                                   serverCertificate.buffer);
-    const hash = hashBuffer(formattedServerCertificate);
-    serverCertificateHashesMap.set(
-      mediaKeys, { hash, serverCertificate: formattedServerCertificate });
-  },
-
-  /**
-   * Returns `true` if the MediaKeys instance has an attached ServerCertificate.
-   * Returns `false` if it doesn't.
-   *
-   * Returns `undefined` if we cannot know, most likely because related EME APIs
-   * failed or had an unexpected behavior.
-   * @param {MediaKeys} mediaKeys
-   * @returns {Boolean|undefined}
-   */
-  hasOne(mediaKeys : MediaKeys | ICustomMediaKeys) : boolean | undefined {
-    const currentServerCertificate = serverCertificateHashesMap.get(mediaKeys);
-    return currentServerCertificate === undefined ? false :
-           currentServerCertificate === null ? undefined :
-                                               true;
-  },
-
-  /**
-   * Returns `true` if the given `mediaKeys` has `serverCertificate` attached to
-   * it.
-   * Returns `false` either if it doesn't of if we doesn't know if it does.
-   * @param {MediaKeys | Object} mediaKeys
-   * @param {ArrayBufferView | BufferSource} serverCertificate
-   * @returns {boolean}
-   */
-  has(
-    mediaKeys: MediaKeys | ICustomMediaKeys,
-    serverCertificate: ArrayBufferView | BufferSource
-  ): boolean {
-    const serverCertificateHash = serverCertificateHashesMap.get(mediaKeys);
-    if (serverCertificateHash === undefined || serverCertificateHash === null) {
-      return false;
-    }
-    const { hash: oldHash, serverCertificate: oldServerCertificate } =
-      serverCertificateHash;
-    const newServerCertificate: Uint8Array =
-      serverCertificate instanceof Uint8Array ?
-        serverCertificate :
-        new Uint8Array(
-          serverCertificate instanceof ArrayBuffer ? serverCertificate :
-                                                     serverCertificate.buffer);
-    const newHash = hashBuffer(newServerCertificate);
-    if (newHash !== oldHash ||
-        oldServerCertificate.length !== newServerCertificate.length) {
-      return false;
-    }
-    for (let i = 0; i < oldServerCertificate.length; i++) {
-      if (oldServerCertificate[i] !== newServerCertificate[i]) {
-        return false;
-      }
-    }
-    return true;
-  },
-};

package/src/core/fetchers/README.md

@@ -1,84 +0,0 @@
-# The `fetchers` ###############################################################
-
-The fetchers is the part of the code interacting with `transports` files, which
-allows, to download and parse the Manifest and the media segments.
-
-This directory actually exports two completely isolated type of fetchers:
-
-  - The __Manifest fetcher__ is used to download and parse the manifest file.
-
-  - The __SegmentFetcherCreator__ is used to create Segment fetchers,
-    allowing to download and parse media segments.
-
-
-
-## The Manifest fetcher ########################################################
-
-The Manifest fetcher allows to download and parse the Manifest/Playlist of the
-current transport protocol to then return a `Manifest` object, which is
-protocol-agnostic.
-
-This is the part of the code that interacts with `transports` to perform the
-request and parsing of the Manifest file.
-
-It also regularly refreshes the Manifest, based on its attributes and other
-criteria, like performances when doing that.
-
-
-
-## The SegmentFetcherCreator ###################################################
-
-The SegmentFetcherCreator allows to easily perform segment downloads for the
-rest of the code.
-This is the part of the code that interacts with the transport protocols -
-defined in `stc/transports` - to load and parse media segments.
-
-To do so, the SegmentFetcherCreator creates "segment fetchers" of different
-types (example: a video or audio segment fetcher) when you ask for it.
-Through those fetchers, you can then schedule various segment requests with a
-given priority.
-
-The priority of this request is then corroborated with the priority of all
-requests currently pending in the SegmentFetcherCreator (and not only with
-those on the current segment fetcher) to know when the request should
-effectively be done - more prioritary requests will be done first.
-
-During the lifecycle of the request, the segment fetcher will communicate about
-data and metrics through several means - documented in the code.
-
-
-### Priorization ###############################################################
-
-Each Segment request can be linked to a priorization number.
-Such number will indicate which segment is needed more immediately than other
-(the lower it is, the higher the priority of the segment is).
-
-This is for example used to indicate that a very close video segment has a
-higher priority than some distant audio segment (both might be scheduled at the
-same time depending on the situation).
-
-If the request has no priorization number, the lowest priorization number
-(the highest priority) will be set on it: ``0``
-
-Basically, any new request will have their priorization number compared to the
-one of the current request(s) done by the SegmentFetcherCreator:
-
-  - if no request is already pending, we perform the request immediately
-
-  - if (and only if) this priorization number is higher (so lower priority) than
-    all current requests, this new request will be postponed to let the
-    higher-priority ones finish.
-
-  - If a new request has a priorization number lower or equal than all current
-    downloads, we perform the request immediately without interrupting the
-    current, lower-priority ones.
-
-  - If a new request has a very low priorization number (so a very high
-    priority, the number is defined in `src/config.ts`), all current downloads
-    with a very high priorization number (also defined in the config) will be
-    interrupted.
-
-The priority of a download can be updated at any time, until this request either
-has finished, was canceled or failed. The same rules apply when the priorization
-number is updated (if this request is already pending, we keep it going in any
-case).