rx-player 3.26.3-dev.2022021400 → 3.27.0-dev.2022032100

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

@@ -18,20 +18,19 @@ import { ICustomMediaKeySession } from "../../../compat";
 import log from "../../../log";
 import areArraysOfNumbersEqual from "../../../utils/are_arrays_of_numbers_equal";
 import { assertInterface } from "../../../utils/assert";
-import {
-  base64ToBytes,
-  bytesToBase64,
-} from "../../../utils/base64";
-import { concat } from "../../../utils/byte_parsing";
+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 {
-  IInitializationDataInfo,
+  IProcessedProtectionData,
   IPersistentSessionInfo,
   IPersistentSessionStorage,
 } from "../types";
 import areInitializationValuesCompatible from "./are_init_values_compatible";
+import { IFormattedInitDataValue } from "./init_data_values_container";
+import { areKeyIdsEqual } from "./key_id_comparison";
+import SerializableBytes from "./serializable_bytes";
 
 /**
  * Throw if the given storage does not respect the right interface.
@@ -43,42 +42,6 @@ function checkStorage(storage : IPersistentSessionStorage) : void {
                   "licenseStorage");
 }
 
-/** Wrap initialization data and allow serialization of it into base64. */
-class InitDataContainer {
-  /** The initData itself. */
-  public initData : Uint8Array;
-
-  /**
-   * Create a new container, wrapping the initialization data given and allowing
-   * linearization 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);
-  }
-}
-
 /**
  * Set representing persisted licenses. Depends on a simple local-
  * storage implementation with a `save`/`load` synchronous interface
@@ -101,12 +64,13 @@ export default class PersistentSessionsStore {
     this._entries = [];
     this._storage = storage;
     try {
-      this._entries = this._storage.load();
-      if (!Array.isArray(this._entries)) {
-        this._entries = [];
+      let entries = this._storage.load();
+      if (!Array.isArray(entries)) {
+        entries = [];
       }
+      this._entries = entries;
     } catch (e) {
-      log.warn("EME-PSS: Could not get entries from license storage", e);
+      log.warn("DRM-PSS: Could not get entries from license storage", e);
       this.dispose();
     }
   }
@@ -130,11 +94,11 @@ export default class PersistentSessionsStore {
 
   /**
    * Retrieve an entry based on its initialization data.
-   * @param {Uint8Array}  initData
+   * @param {Object}  initData
    * @param {string|undefined} initDataType
    * @returns {Object|null}
    */
-  public get(initData : IInitializationDataInfo) : IPersistentSessionInfo | null {
+  public get(initData : IProcessedProtectionData) : IPersistentSessionInfo | null {
     const index = this._getIndex(initData);
     return index === -1 ? null :
                           this._entries[index];
@@ -151,7 +115,9 @@ export default class PersistentSessionsStore {
    * @param {string|undefined} initDataType
    * @returns {*}
    */
-  public getAndReuse(initData : IInitializationDataInfo) : IPersistentSessionInfo | null {
+  public getAndReuse(
+    initData : IProcessedProtectionData
+  ) : IPersistentSessionInfo | null {
     const index = this._getIndex(initData);
     if (index === -1) {
       return null;
@@ -168,11 +134,12 @@ export default class PersistentSessionsStore {
    * @param {MediaKeySession} session
    */
   public add(
-    initData : IInitializationDataInfo,
+    initData : IProcessedProtectionData,
+    keyIds : Uint8Array[] | undefined,
     session : MediaKeySession|ICustomMediaKeySession
   ) : void {
     if (isNullOrUndefined(session) || !isNonEmptyString(session.sessionId)) {
-      log.warn("EME-PSS: Invalid Persisten Session given.");
+      log.warn("DRM-PSS: Invalid Persisten Session given.");
       return;
     }
     const { sessionId } = session;
@@ -180,45 +147,60 @@ export default class PersistentSessionsStore {
     if (currentEntry !== null && currentEntry.sessionId === sessionId) {
       return;
     } else if (currentEntry !== null) { // currentEntry has a different sessionId
-      this.delete(initData);
+      this.delete(currentEntry.sessionId);
     }
 
-    log.info("EME-PSS: Add new session", sessionId);
+    log.info("DRM-PSS: Add new session", sessionId);
 
-    this._entries.push({ version: 3,
-                         sessionId,
-                         values: this._formatValuesForStore(initData.values),
-                         initDataType: initData.type });
+    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 initialization
-   * data.
+   * Delete stored MediaKeySession information based on its session id.
    * @param {Uint8Array}  initData
    * @param {string|undefined} initDataType
    */
-  public delete(initData : IInitializationDataInfo) : void {
-    const index = this._getIndex(initData);
+  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("EME-PSS: initData to delete not found.");
+      log.warn("DRM-PSS: initData to delete not found.");
       return;
     }
     const entry = this._entries[index];
-    log.warn("EME-PSS: Delete session from store", entry.sessionId);
+    log.warn("DRM-PSS: Delete session from store", entry.sessionId);
     this._entries.splice(index, 1);
     this._save();
   }
 
   public deleteOldSessions(sessionsToDelete : number) : void {
-    log.info(`EME-PSS: Deleting last ${sessionsToDelete} sessions.`);
+    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("EME-PSS: Asked to remove more information that it contains",
+      log.warn("DRM-PSS: Asked to remove more information that it contains",
                sessionsToDelete,
                this._entries.length);
       this._entries = [];
@@ -237,46 +219,85 @@ export default class PersistentSessionsStore {
   /**
    * Retrieve index of an entry.
    * Returns `-1` if not found.
-   * @param {Uint8Array}  initData
-   * @param {string|undefined} initDataType
+   * @param {Object} initData
    * @returns {number}
    */
-  private _getIndex(initData : IInitializationDataInfo) : number {
-    const formatted = this._formatValuesForStore(initData.values);
-
+  private _getIndex(initData : IProcessedProtectionData) : number {
     // Older versions of the format include a concatenation of all
     // initialization data and its hash.
-    const concatInitData = concat(...initData.values.map(i => i.data));
-    const concatInitDataHash = hashBuffer(concatInitData);
+    // 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 (areKeyIdsEqual(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:
-            if (entry.initDataHash === concatInitDataHash) {
+          case 2: {
+            const { initData: concatInitData,
+                    initDataHash: concatHash } = getConcatenatedInitDataInfo();
+            if (entry.initDataHash === concatHash) {
               try {
                 const decodedInitData : Uint8Array = typeof entry.initData === "string" ?
-                  InitDataContainer.decode(entry.initData) :
+                  SerializableBytes.decode(entry.initData) :
                   entry.initData.initData;
                 if (areArraysOfNumbersEqual(decodedInitData, concatInitData)) {
                   return i;
                 }
               } catch (e) {
-                log.warn("EME-PSS: Could not decode initialization data.", e);
+                log.warn("DRM-PSS: Could not decode initialization data.", e);
               }
             }
             break;
+          }
 
-          case 1:
-            if (entry.initDataHash === concatInitDataHash) {
+          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
@@ -288,11 +309,14 @@ export default class PersistentSessionsStore {
               }
             }
             break;
+          }
 
-          default:
-            if (entry.initData === concatInitDataHash) {
+          default: {
+            const { initDataHash: concatHash } = getConcatenatedInitDataInfo();
+            if (entry.initData === concatHash) {
               return i;
             }
+          }
         }
       }
     }
@@ -306,31 +330,25 @@ export default class PersistentSessionsStore {
     try {
       this._storage.save(this._entries);
     } catch (e) {
-      log.warn("EME-PSS: Could not save licenses in localStorage");
+      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>}
-   */
-  private _formatValuesForStore(
-    initialValues : Array<{ systemId : string | undefined;
-                            data : Uint8Array; }>
-  ) : Array<{ systemId : string | undefined;
-              hash : number;
-              data : InitDataContainer; }> {
-    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 : new InitDataContainer(data),
-                                      hash : hashBuffer(data) }));
-  }
+/**
+ * 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/{eme/utils/init_data_container.ts → decrypt/utils/serializable_bytes.ts}

@@ -19,14 +19,17 @@ import {
   bytesToBase64,
 } from "../../../utils/base64";
 
-/** Wrap initialization data and allow serialization of it into base64. */
-export default class InitDataContainer {
-  /** The initData itself. */
+/** 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 container, wrapping the initialization data given and allowing
-   * linearization into base64.
+   * Create a new `SerializableBytes`, wrapping the initialization data
+   * given and allowing serialization into base64.
    * @param {Uint8Array}
    */
   constructor(initData : Uint8Array) {

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

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-import { ICustomMediaKeys } from "../../compat";
-import hashBuffer from "../../utils/hash_buffer";
+import { ICustomMediaKeys } from "../../../compat";
+import hashBuffer from "../../../utils/hash_buffer";
 
 /**
  * Keep track of server certificate which have been set for a MediaKeys.

package/src/core/fetchers/manifest/manifest_fetcher.ts

@@ -30,7 +30,6 @@ import {
   ITransportPipelines,
 } from "../../../transports";
 import assert from "../../../utils/assert";
-import PPromise from "../../../utils/promise";
 import TaskCanceller from "../../../utils/task_canceller";
 import errorSelector from "../utils/error_selector";
 import {
@@ -38,10 +37,6 @@ import {
   tryRequestPromiseWithBackoff,
 } from "../utils/try_urls_with_backoff";
 
-const { DEFAULT_MAX_MANIFEST_REQUEST_RETRY,
-        DEFAULT_MAX_REQUESTS_RETRY_ON_OFFLINE,
-        INITIAL_BACKOFF_DELAY_BASE,
-        MAX_BACKOFF_DELAY_BASE } = config;
 
 /** What will be sent once parsed. */
 export interface IManifestFetcherParsedResult {
@@ -407,6 +402,10 @@ export default class ManifestFetcher {
    * @returns {Object}
    */
   private _getBackoffSetting(onRetry : (err : unknown) => void) : IBackoffSettings {
+    const { DEFAULT_MAX_MANIFEST_REQUEST_RETRY,
+            DEFAULT_MAX_REQUESTS_RETRY_ON_OFFLINE,
+            INITIAL_BACKOFF_DELAY_BASE,
+            MAX_BACKOFF_DELAY_BASE } = config.getCurrent();
     const { lowLatencyMode,
             maxRetryRegular : ogRegular,
             maxRetryOffline : ogOffline } = this._settings;
@@ -431,6 +430,5 @@ export default class ManifestFetcher {
  * @returns {boolean}
  */
 function isPromise<T>(val : T | Promise<T>) : val is Promise<T> {
-  return val instanceof PPromise ||
-         val instanceof Promise;
+  return val instanceof Promise;
 }

package/src/core/fetchers/segment/segment_fetcher.ts

@@ -53,10 +53,6 @@ import { IBufferType } from "../../segment_buffers";
 import errorSelector from "../utils/error_selector";
 import { tryURLsWithBackoff } from "../utils/try_urls_with_backoff";
 
-const { DEFAULT_MAX_REQUESTS_RETRY_ON_ERROR,
-        DEFAULT_MAX_REQUESTS_RETRY_ON_OFFLINE,
-        INITIAL_BACKOFF_DELAY_BASE,
-        MAX_BACKOFF_DELAY_BASE } = config;
 
 const generateRequestID = idGenerator();
 
@@ -446,6 +442,10 @@ export function getSegmentFetcherOptions(
                          maxRetryOffline? : number | undefined;
                          lowLatencyMode : boolean; }
 ) : ISegmentFetcherOptions {
+  const { DEFAULT_MAX_REQUESTS_RETRY_ON_ERROR,
+          DEFAULT_MAX_REQUESTS_RETRY_ON_OFFLINE,
+          INITIAL_BACKOFF_DELAY_BASE,
+          MAX_BACKOFF_DELAY_BASE } = config.getCurrent();
   return { maxRetryRegular: bufferType === "image" ? 0 :
                             maxRetryRegular ?? DEFAULT_MAX_REQUESTS_RETRY_ON_ERROR,
            maxRetryOffline: maxRetryOffline ?? DEFAULT_MAX_REQUESTS_RETRY_ON_OFFLINE,

package/src/core/fetchers/segment/segment_fetcher_creator.ts

@@ -30,8 +30,6 @@ import createSegmentFetcher, {
   ISegmentFetcherEvent,
 } from "./segment_fetcher";
 
-const { MIN_CANCELABLE_PRIORITY,
-        MAX_HIGH_PRIORITY_LEVEL } = config;
 
 /**
  * Interact with the transport pipelines to download segments with the right
@@ -91,6 +89,8 @@ export default class SegmentFetcherCreator {
     transport : ITransportPipelines,
     options : ISegmentFetcherCreatorBackoffOptions
   ) {
+    const { MIN_CANCELABLE_PRIORITY,
+            MAX_HIGH_PRIORITY_LEVEL } = config.getCurrent();
     this._transport = transport;
     this._prioritizer = new ObservablePrioritizer({
       prioritySteps: { high: MAX_HIGH_PRIORITY_LEVEL,

package/src/core/fetchers/utils/try_urls_with_backoff.ts

@@ -24,7 +24,6 @@ import {
 import log from "../../../log";
 import cancellableSleep from "../../../utils/cancellable_sleep";
 import getFuzzedDelay from "../../../utils/get_fuzzed_delay";
-import PPromise from "../../../utils/promise";
 import TaskCanceller, {
   CancellationSignal,
 } from "../../../utils/task_canceller";
@@ -171,7 +170,7 @@ export function tryURLsWithBackoff<T>(
   cancellationSignal : CancellationSignal
 ) : Promise<T> {
   if (cancellationSignal.isCancelled) {
-    return PPromise.reject(cancellationSignal.cancellationError);
+    return Promise.reject(cancellationSignal.cancellationError);
   }
 
   const { baseDelay,
@@ -185,7 +184,7 @@ export function tryURLsWithBackoff<T>(
   const urlsToTry = urls.slice();
   if (urlsToTry.length === 0) {
     log.warn("Fetchers: no URL given to `tryURLsWithBackoff`.");
-    return PPromise.reject(new Error("No URL to request"));
+    return Promise.reject(new Error("No URL to request"));
   }
   return tryURLsRecursively(urlsToTry[0], 0);
 

package/src/core/init/get_initial_time.ts

@@ -18,7 +18,6 @@ import config from "../../config";
 import log from "../../log";
 import Manifest from "../../manifest";
 
-const { DEFAULT_LIVE_GAP } = config;
 
 export interface IInitialTimeOptions { position? : number;
                                        wallClockTime? : number;
@@ -90,6 +89,8 @@ export default function getInitialTime(
             clockOffset } = manifest;
     const maximumPosition = manifest.getMaximumPosition();
     let liveTime : number;
+    const { DEFAULT_LIVE_GAP } = config.getCurrent();
+
     if (clockOffset == null) {
       log.info("Init: no clock offset found for a live content, " +
                "starting close to maximum available position");

package/src/core/init/initialize_directfile.ts

@@ -39,16 +39,22 @@ import log from "../../log";
 import deferSubscriptions from "../../utils/defer_subscriptions";
 import { IReadOnlySharedReference } from "../../utils/reference";
 import { PlaybackObserver } from "../api";
-import { IKeySystemOption } from "../eme";
-import createEMEManager from "./create_eme_manager";
+import { IKeySystemOption } from "../decrypt";
 import emitLoadedEvent from "./emit_loaded_event";
 import { IInitialTimeOptions } from "./get_initial_time";
 import initialSeekAndPlay from "./initial_seek_and_play";
+import linkDrmAndContent from "./link_drm_and_content";
 import StallAvoider from "./stall_avoider";
 import throwOnMediaError from "./throw_on_media_error";
 import { IDirectfileEvent } from "./types";
 import updatePlaybackRate from "./update_playback_rate";
 
+// NOTE As of now (RxJS 7.4.0), RxJS defines `ignoreElements` default
+// first type parameter as `any` instead of the perfectly fine `unknown`,
+// leading to linter issues, as it forbids the usage of `any`.
+// This is why we're disabling the eslint rule.
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+
 /**
  * calculate initial time as a position in seconds.
  * @param {HTMLMediaElement} mediaElement
@@ -136,10 +142,11 @@ export default function initializeDirectfileContent({
                                                 startTime: initialTime,
                                                 mustAutoPlay: autoPlay });
 
-  // Create EME Manager, an observable which will manage every EME-related
-  // issue.
-  const emeManager$ = linkURL$.pipe(
-    mergeMap(() => createEMEManager(mediaElement, keySystems, EMPTY)),
+  /** Initialize decryption capabilities and the HTMLMediaElement's src attribute. */
+  const drmEvents$ = linkDrmAndContent(mediaElement,
+                                       keySystems,
+                                       EMPTY,
+                                       linkURL$).pipe(
     deferSubscriptions(),
     share()
   );
@@ -154,11 +161,6 @@ export default function initializeDirectfileContent({
   // little longer while the buffer is empty.
   const playbackRate$ =
     updatePlaybackRate(mediaElement, speed, observation$)
-      // NOTE As of now (RxJS 7.4.0), RxJS defines `ignoreElements` default
-      // first type parameter as `any` instead of the perfectly fine `unknown`,
-      // leading to linter issues, as it forbids the usage of `any`.
-      // This is why we're disabling the eslint rule.
-      /* eslint-disable-next-line @typescript-eslint/no-unsafe-argument */
       .pipe(ignoreElements());
 
   /**
@@ -172,14 +174,9 @@ export default function initializeDirectfileContent({
    * media can begin playback.
    * Also emits warning events if issues arise when doing so.
    */
-  const loadingEvts$ = emeManager$.pipe(
-    filter(function isEMEReady(evt) {
-      if (evt.type === "created-media-keys") {
-        evt.value.canAttachMediaKeys.setValue(true);
-        return true;
-      }
-      return evt.type === "eme-disabled" || evt.type === "attached-media-keys";
-    }),
+  const loadingEvts$ = drmEvents$.pipe(
+    filter((evt) => evt.type === "decryption-ready" ||
+                    evt.type === "decryption-disabled"),
     take(1),
     mergeMap(() => seekAndPlay$),
     switchMap((evt) => {
@@ -190,7 +187,7 @@ export default function initializeDirectfileContent({
     }));
 
   return observableMerge(loadingEvts$,
-                         emeManager$,
+                         drmEvents$.pipe(ignoreElements()),
                          mediaError$,
                          playbackRate$,
                          stallAvoider$);