rx-player 3.28.0-dev.2022061700 → 3.28.0-dev.2022062000

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "rx-player",
   "author": "Canal+",
-  "version": "3.28.0-dev.2022061700",
+  "version": "3.28.0-dev.2022062000",
   "description": "Canal+ HTML5 Video Player",
   "main": "./dist/rx-player.js",
   "keywords": [

package/sonar-project.properties

@@ -1,7 +1,7 @@
 sonar.projectKey=rx-player
 sonar.organization=rx-player
 sonar.projectName=rx-player
-sonar.projectVersion=3.28.0-dev.2022061700
+sonar.projectVersion=3.28.0-dev.2022062000
 sonar.sources=./src,./demo,./tests
 sonar.exclusions=demo/full/bundle.js,demo/standalone/lib.js,demo/bundle.js
 sonar.host.url=https://sonarcloud.io

package/src/core/adaptive/adaptive_representation_selector.ts

@@ -52,8 +52,10 @@ import selectOptimalRepresentation from "./utils/select_optimal_representation";
 /**
  * Select the most adapted Representation according to the network and buffer
  * metrics it receives.
+ *
  * @param {Object} options - Initial configuration (see type definition)
- * @returns {Object} - Interface allowing to select a Representation
+ * @returns {Object} - Interface allowing to select a Representation.
+ * @see IRepresentationEstimator
  */
 export default function createAdaptiveRepresentationSelector(
   options : IAdaptiveRepresentationSelectorArguments
@@ -73,14 +75,13 @@ export default function createAdaptiveRepresentationSelector(
   /**
    * Returns Object emitting Representation estimates as well as callbacks
    * allowing to helping it produce them.
+   *
+   * @see IRepresentationEstimator
    * @param {Object} context
-   * @param {Object} currentRepresentation - Reference emitting the
-   * Representation currently loaded.
-   * @param {Object} representations - Reference emitting the list of available
-   * Representations to choose from.
-   * @param {Object} playbackObserver - Emits regularly playback conditions
-   * @param {Object} cancellationSignal - After this `CancellationSignal` emits,
-   * estimates will stop to be emitted.
+   * @param {Object} currentRepresentation
+   * @param {Object} representations
+   * @param {Object} playbackObserver
+   * @param {Object} stopAllEstimates
    * @returns {Array.<Object>}
    */
   return function getEstimates(
@@ -92,9 +93,8 @@ export default function createAdaptiveRepresentationSelector(
     playbackObserver : IReadOnlyPlaybackObserver<
       IRepresentationEstimatorPlaybackObservation
     >,
-    cancellationSignal : CancellationSignal
-  ) : [ IReadOnlySharedReference<IABREstimate>,
-        IRepresentationEstimatorCallbacks ] {
+    stopAllEstimates : CancellationSignal
+  ) : IRepresentationEstimatorResponse {
     const { type } = context.adaptation;
     const bandwidthEstimator = _getBandwidthEstimator(type);
     const manualBitrate = takeFirstSet<IReadOnlySharedReference<number>>(
@@ -127,7 +127,7 @@ export default function createAdaptiveRepresentationSelector(
                                   playbackObserver,
                                   representations,
                                   lowLatencyMode },
-                                cancellationSignal);
+                                stopAllEstimates);
   };
 
   /**
@@ -163,7 +163,7 @@ export default function createAdaptiveRepresentationSelector(
  *     events to help it doing those estimates.
  *
  * @param {Object} args
- * @param {Object} cancellationSignal
+ * @param {Object} stopAllEstimates
  * @returns {Array.<Object>}
  */
 function getEstimateReference(
@@ -178,10 +178,8 @@ function getEstimateReference(
     minAutoBitrate,
     playbackObserver,
     representations : representationsRef } : IRepresentationEstimatorArguments,
-  cancellationSignal : CancellationSignal
-) : [ IReadOnlySharedReference<IABREstimate>,
-      IRepresentationEstimatorCallbacks ] {
-
+  stopAllEstimates : CancellationSignal
+) : IRepresentationEstimatorResponse {
   const scoreCalculator = new RepresentationScoreCalculator();
   const networkAnalyzer = new NetworkAnalyzer(initialBitrate ?? 0, lowLatencyMode);
   const requestsStore = new PendingRequestsStore();
@@ -200,10 +198,7 @@ function getEstimateReference(
    * This TaskCanceller is used both for restarting estimates with a new
    * configuration and to cancel them altogether.
    */
-  let currentEstimatesCanceller = new TaskCanceller();
-  cancellationSignal.register(() => {
-    currentEstimatesCanceller.cancel();
-  });
+  let currentEstimatesCanceller = new TaskCanceller({ cancelOn: stopAllEstimates });
 
   // Create `ISharedReference` on which estimates will be emitted.
   const estimateRef = createEstimateReference(manualBitrate.getValue(),
@@ -211,11 +206,11 @@ function getEstimateReference(
                                               currentEstimatesCanceller.signal);
 
   manualBitrate.onUpdate(restartEstimatesProductionFromCurrentConditions,
-                         { clearSignal: currentEstimatesCanceller.signal });
+                         { clearSignal: stopAllEstimates });
   representationsRef.onUpdate(restartEstimatesProductionFromCurrentConditions,
-                              { clearSignal: currentEstimatesCanceller.signal });
+                              { clearSignal: stopAllEstimates });
 
-  return [estimateRef, callbacks];
+  return { estimates: estimateRef, callbacks };
 
   function createEstimateReference(
     manualBitrateVal : number,
@@ -475,12 +470,13 @@ function getEstimateReference(
     const manualBitrateVal = manualBitrate.getValue();
     const representations = representationsRef.getValue();
     currentEstimatesCanceller.cancel();
-    currentEstimatesCanceller = new TaskCanceller();
+    currentEstimatesCanceller = new TaskCanceller({ cancelOn: stopAllEstimates });
     const newRef = createEstimateReference(
       manualBitrateVal,
       representations,
       currentEstimatesCanceller.signal
     );
+
     newRef.onUpdate(function onNewEstimate(newEstimate : IABREstimate) : void {
       estimateRef.setValue(newEstimate);
     }, { clearSignal: currentEstimatesCanceller.signal,
@@ -700,11 +696,7 @@ export interface IABRFiltersObject {
   width?: number;
 }
 
-/**
- * Callbacks returned by `getEstimateReference`.
- * Those needs to be called as soon as the corresponding events to obtain
- * coherent Representation estimates.
- */
+/** Callbacks returned by `getEstimateReference`. */
 export interface IRepresentationEstimatorCallbacks {
   /** Callback to call when a segment has been completely pushed to the buffer. */
   addedSegment(val : IAddedSegmentCallbackPayload) : void;
@@ -832,17 +824,38 @@ export interface IRepresentationEstimatorArguments {
  * allowing to estimate the most adapted `Representation`.
  */
 export type IRepresentationEstimator = (
+  /** Information on the content for which a Representation will be chosen */
   context : { manifest : Manifest;
               period : Period;
               adaptation : Adaptation; },
+  /** Reference emitting the Representation currently loaded. */
   currentRepresentation : IReadOnlySharedReference<Representation | null>,
+  /** Reference emitting the list of available Representations to choose from. */
   representations : IReadOnlySharedReference<Representation[]>,
+  /** Regularly emits playback conditions */
   playbackObserver : IReadOnlyPlaybackObserver<
     IRepresentationEstimatorPlaybackObservation
   >,
-  cancellationSignal : CancellationSignal
-) => [ IReadOnlySharedReference<IABREstimate>,
-       IRepresentationEstimatorCallbacks ];
+  /**
+   * After this `CancellationSignal` emits, resources will be disposed and
+   * estimates will stop to be emitted.
+   */
+  stopAllEstimates : CancellationSignal
+) => IRepresentationEstimatorResponse;
+
+/** Value returned by an `IRepresentationEstimator` */
+export interface IRepresentationEstimatorResponse {
+  /**
+   * Regularly produces estimates of the best Representation to play (from the
+   * list given).
+   */
+  estimates: IReadOnlySharedReference<IABREstimate>;
+  /**
+   * Callback which need to be called as soon as the corresponding events to
+   * obtain accurate Representation estimates.
+   */
+  callbacks: IRepresentationEstimatorCallbacks;
+}
 
 /** Arguments received by `createAdaptiveRepresentationSelector`. */
 export interface IAdaptiveRepresentationSelectorArguments {

package/src/core/api/public_api.ts

@@ -429,7 +429,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     // See: https://bugzilla.mozilla.org/show_bug.cgi?id=1194624
     videoElement.preload = "auto";
 
-    this.version = /* PLAYER_VERSION */"3.28.0-dev.2022061700";
+    this.version = /* PLAYER_VERSION */"3.28.0-dev.2022062000";
     this.log = log;
     this.state = "STOPPED";
     this.videoElement = videoElement;
@@ -2941,7 +2941,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     return activeRepresentations[currentPeriod.id];
   }
 }
-Player.version = /* PLAYER_VERSION */"3.28.0-dev.2022061700";
+Player.version = /* PLAYER_VERSION */"3.28.0-dev.2022062000";
 
 /** Every events sent by the RxPlayer's public API. */
 interface IPublicAPIEvent {

package/src/core/decrypt/content_decryptor.ts

@@ -491,20 +491,13 @@ export default class ContentDecryptor extends EventEmitter<IContentDecryptorEven
               return;
           }
 
-          let linkedKeys;
-          if (sessionInfo.source === MediaKeySessionLoadingType.Created) {
-            // When the license has been fetched, there might be implicit key ids
-            // linked to the session depending on the `singleLicensePer` option.
-            linkedKeys = getFetchedLicenseKeysInfo(initializationData,
-                                                   options.singleLicensePer,
-                                                   evt.value.whitelistedKeyIds,
-                                                   evt.value.blacklistedKeyIDs);
-          } else {
-            // When the MediaKeySession is just a cached/persisted one, we don't
-            // have any concept of "implicit key id".
-            linkedKeys = { whitelisted: evt.value.whitelistedKeyIds,
-                           blacklisted: evt.value.blacklistedKeyIDs };
-          }
+          const linkedKeys = getKeyIdsLinkedToSession(
+            initializationData,
+            sessionInfo.record,
+            options.singleLicensePer,
+            sessionInfo.source === MediaKeySessionLoadingType.Created,
+            evt.value.whitelistedKeyIds,
+            evt.value.blacklistedKeyIDs);
 
           sessionInfo.record.associateKeyIds(linkedKeys.whitelisted);
           sessionInfo.record.associateKeyIds(linkedKeys.blacklisted);
@@ -1053,22 +1046,46 @@ interface IAttachedMediaKeysData {
 }
 
 /**
- * Returns information on all keys - explicit or implicit - that are linked to
- * a loaded license.
+ * Returns set of all usable and unusable keys - explicit or implicit - that are
+ * linked to a `MediaKeySession`.
  *
  * In the RxPlayer, there is a concept of "explicit" key ids, which are key ids
  * found in a license whose status can be known through the `keyStatuses`
  * property from a `MediaKeySession`, and of "implicit" key ids, which are key
  * ids which were expected to be in a fetched license, but apparently weren't.
- * @param {Object} initializationData
- * @param {string|undefined} singleLicensePer
- * @param {Array.<Uint8Array>} usableKeyIds
- * @param {Array.<Uint8Array>} unusableKeyIds
- * @returns {Object}
+ *
+ * @param {Object} initializationData - Initialization data object used to make
+ * the request for the current license.
+ * @param {Object} keySessionRecord - The `KeySessionRecord` associated with the
+ * session that has been loaded. It might give supplementary information on
+ * keys implicitly linked to the license.
+ * @param {string|undefined} singleLicensePer - Setting allowing to indicate the
+ * scope a given license should have.
+ * @param {boolean} isCurrentLicense - If `true` the license has been fetched
+ * especially for the current content.
+ *
+ * Knowing this allows to determine that if decryption keys that should have
+ * been referenced in the fetched license (according to the `singleLicensePer`
+ * setting) are missing, then the keys surely must have been voluntarly
+ * removed from the license.
+ *
+ * If it is however set to `false`, it means that the license is an older
+ * license that might have been linked to another content, thus we cannot make
+ * that assumption.
+ * @param {Array.<Uint8Array>} usableKeyIds - Key ids that are present in the
+ * license and can be used.
+ * @param {Array.<Uint8Array>} unusableKeyIds - Key ids that are present in the
+ * license yet cannot be used.
+ * @returns {Object} - Returns an object with the following properties:
+ *   - `whitelisted`: Array of key ids for keys that are known to be usable
+ *   - `blacklisted`: Array of key ids for keys that are considered unusable.
+ *     The qualities linked to those keys should not be played.
  */
-function getFetchedLicenseKeysInfo(
+function getKeyIdsLinkedToSession(
   initializationData : IProcessedProtectionData,
+  keySessionRecord : KeySessionRecord,
   singleLicensePer : undefined | "init-data" | "content" | "periods",
+  isCurrentLicense : boolean,
   usableKeyIds : Uint8Array[],
   unusableKeyIds : Uint8Array[]
 ) : { whitelisted : Uint8Array[];
@@ -1081,6 +1098,19 @@ function getFetchedLicenseKeysInfo(
   const associatedKeyIds = [...usableKeyIds,
                             ...unusableKeyIds];
 
+  // Add all key ids associated to the `KeySessionRecord` yet not in
+  // `usableKeyIds` nor in `unusableKeyIds`
+  const allKnownKeyIds = keySessionRecord.getAssociatedKeyIds();
+  for (const kid of allKnownKeyIds) {
+    if (!associatedKeyIds.some(ak => areKeyIdsEqual(ak, kid))) {
+      if (log.hasLevel("DEBUG")) {
+        log.debug("DRM: KeySessionRecord's key missing in the license, blacklisting it",
+                  bytesToHex(kid));
+      }
+      associatedKeyIds.push(kid);
+    }
+  }
+
   if (singleLicensePer !== undefined && singleLicensePer !== "init-data") {
     // We want to add the current key ids in the blacklist if it is
     // not already there.
@@ -1102,11 +1132,15 @@ function getFetchedLicenseKeysInfo(
         return !associatedKeyIds.some(k => areKeyIdsEqual(k, expected));
       });
       if (missingKeyIds.length > 0) {
+        if (log.hasLevel("DEBUG")) {
+          log.debug("DRM: init data keys missing in the license, blacklisting them",
+                    missingKeyIds.map(m => bytesToHex(m)).join(", "));
+        }
         associatedKeyIds.push(...missingKeyIds) ;
       }
     }
 
-    if (content !== undefined) {
+    if (isCurrentLicense && content !== undefined) {
       if (singleLicensePer === "content") {
         // Put it in a Set to automatically filter out duplicates (by ref)
         const contentKeys = new Set<Uint8Array>();

package/src/core/stream/adaptation/create_representation_estimator.ts

@@ -70,12 +70,12 @@ export default function getRepresentationEstimate(
   updateRepresentationsReference();
   manifest.addEventListener("decipherabilityUpdate", updateRepresentationsReference);
   const unregisterCleanUp = cancellationSignal.register(cleanUp);
-  const [ estimateRef,
-          abrCallbacks ] = representationEstimator(content,
-                                                   currentRepresentation,
-                                                   representations,
-                                                   playbackObserver,
-                                                   cancellationSignal);
+  const { estimates: estimateRef,
+          callbacks: abrCallbacks } = representationEstimator(content,
+                                                              currentRepresentation,
+                                                              representations,
+                                                              playbackObserver,
+                                                              cancellationSignal);
   return { abrCallbacks, estimateRef };
 
   function updateRepresentationsReference() : void {

package/src/utils/reference.ts

@@ -57,11 +57,26 @@ import { CancellationSignal } from "./task_canceller";
  * those use cases makes the intent of the corresponding code clearer.
  */
 export interface ISharedReference<T> {
-  /** Get the last set value for this shared reference. */
+  /**
+   * Get the last set value for this shared reference.
+   * @returns {*}
+   */
   getValue() : T;
 
-  /** Update the value of this shared reference. */
+  /**
+   * Update the value of this shared reference.
+   * @param {*} newVal
+   */
   setValue(newVal : T) : void;
+
+  /**
+   * Update the value of this shared reference only if the value changed.
+   *
+   * Note that this function only performs a strict equality reference through
+   * the "===" operator. Different objects that are structurally the same will
+   * thus be considered different.
+   * @param {*} newVal
+   */
   setValueIfChanged(newVal : T) : void;
 
   /**
@@ -72,25 +87,6 @@ export interface ISharedReference<T> {
    * @returns {Observable}
    */
   asObservable(skipCurrentValue? : boolean) : Observable<T>;
-  /**
-   * Triggers a callback each time this reference's value is updated.
-   *
-   * Can be given several options as argument:
-   *   - clearSignal: When the attach `CancellationSignal` emits, the given
-   *     callback will not be called anymore on reference updates.
-   *   - emitCurrentValue: If `true`, the callback will be called directly and
-   *     synchronously on this call with its current value.
-   * @param {Function} cb
-   * @param {Object} [options]
-   */
-  onUpdate(
-    cb : (val : T) => void,
-    options? : {
-      clearSignal?: CancellationSignal;
-      emitCurrentValue?: boolean;
-    },
-  ) : void;
-
   /**
    * Allows to register a callback to be called each time the value inside the
    * reference is updated.
@@ -109,7 +105,6 @@ export interface ISharedReference<T> {
       emitCurrentValue?: boolean;
     },
   ) : void;
-
   /**
    * Indicate that no new values will be emitted.
    * Allows to automatically close all Observables generated from this shared
@@ -217,7 +212,7 @@ export function createSharedReference<T>(initialValue : T) : ISharedReference<T>
 
     /**
      * Update the value of this shared reference.
-     * @param {*}
+     * @param {*} newVal
      */
     setValue(newVal : T) : void {
       if (isFinished) {
@@ -244,6 +239,10 @@ export function createSharedReference<T>(initialValue : T) : ISharedReference<T>
       }
     },
 
+    /**
+     * Update the value of this shared reference only if it changed.
+     * @param {*} newVal
+     */
     setValueIfChanged(newVal : T) : void {
       if (newVal !== value) {
         this.setValue(newVal);
@@ -353,6 +352,17 @@ export function createSharedReference<T>(initialValue : T) : ISharedReference<T>
   };
 }
 
+/**
+ * Create a new `ISharedReference` based on another one by mapping over its
+ * referenced value each time it is updated.
+ * @param {Object} originalRef - The Original `ISharedReference` you wish to map
+ * over.
+ * @param {Function} mappingFn - The mapping function which will receives
+ * `originalRef`'s value and outputs this new reference's value.
+ * @param {Object | undefined} [cancellationSignal] - Optionally, a
+ * `CancellationSignal` which will finish that reference when it emits.
+ * @returns {Object} - The new, mapped, reference.
+ */
 export function createMappedReference<T, U>(
   originalRef : IReadOnlySharedReference<T>,
   mappingFn : (x : T) => U,