rx-player 4.1.0 → 4.2.0-dev.2024080600

package/src/main_thread/decrypt/utils/media_keys_infos_store.ts

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+import type { IMediaElement } from "../../../compat/browser_compatibility_types";
 import type {
   ICustomMediaKeys,
   ICustomMediaKeySystemAccess,
@@ -47,7 +48,7 @@ export interface IMediaElementMediaKeysInfos {
 
 // Store the MediaKeys infos attached to a media element.
 const currentMediaState = new WeakMap<
-  HTMLMediaElement,
+  IMediaElement,
   IMediaElementMediaKeysInfos | null
 >();
 
@@ -57,10 +58,7 @@ export default {
    * @param {HTMLMediaElement} mediaElement
    * @param {Object} state
    */
-  setState(
-    mediaElement: HTMLMediaElement,
-    state: IMediaElementMediaKeysInfos | null,
-  ): void {
+  setState(mediaElement: IMediaElement, state: IMediaElementMediaKeysInfos | null): void {
     currentMediaState.set(mediaElement, state);
   },
 
@@ -69,7 +67,7 @@ export default {
    * @param {HTMLMediaElement} mediaElement
    * @returns {Object}
    */
-  getState(mediaElement: HTMLMediaElement): IMediaElementMediaKeysInfos | null {
+  getState(mediaElement: IMediaElement): IMediaElementMediaKeysInfos | null {
     const currentState = currentMediaState.get(mediaElement);
     return currentState === undefined ? null : currentState;
   },
@@ -78,7 +76,7 @@ export default {
    * Remove MediaKeys infos currently set on a HMTLMediaElement
    * @param {HTMLMediaElement} mediaElement
    */
-  clearState(mediaElement: HTMLMediaElement): void {
+  clearState(mediaElement: IMediaElement): void {
     currentMediaState.set(mediaElement, null);
   },
 };

package/src/main_thread/init/directfile_content_initializer.ts

@@ -19,6 +19,7 @@
  * It always should be imported through the `features` object.
  */
 
+import type { IMediaElement } from "../../compat/browser_compatibility_types";
 import clearElementSrc from "../../compat/clear_element_src";
 import type { MediaError } from "../../errors";
 import log from "../../log";
@@ -28,7 +29,6 @@ import assert from "../../utils/assert";
 import isNullOrUndefined from "../../utils/is_null_or_undefined";
 import noop from "../../utils/noop";
 import type { IReadOnlySharedReference } from "../../utils/reference";
-import SharedReference from "../../utils/reference";
 import TaskCanceller from "../../utils/task_canceller";
 import { ContentInitializer } from "./types";
 import type { IInitialTimeOptions } from "./utils/get_initial_time";
@@ -85,7 +85,7 @@ export default class DirectFileContentInitializer extends ContentInitializer {
    * information.
    */
   public start(
-    mediaElement: HTMLMediaElement,
+    mediaElement: IMediaElement,
     playbackObserver: IMediaElementPlaybackObserver,
   ): void {
     const cancelSignal = this._initCanceller.signal;
@@ -93,17 +93,9 @@ export default class DirectFileContentInitializer extends ContentInitializer {
 
     clearElementSrc(mediaElement);
 
-    /**
-     * Create dummy encryption data emitter, as those are not sent from the
-     * RxPlayer for directfile contents.
-     */
-    const decryptionRef = new SharedReference(null);
-    decryptionRef.finish();
-
-    const drmInitRef = initializeContentDecryption(
+    const { statusRef: drmInitRef } = initializeContentDecryption(
       mediaElement,
       keySystems,
-      decryptionRef,
       {
         onError: (err) => this._onFatalError(err),
         onWarning: (err: IPlayerError) => this.trigger("warning", err),
@@ -210,7 +202,7 @@ export default class DirectFileContentInitializer extends ContentInitializer {
    * @param {Object} playbackObserver
    */
   private _seekAndPlay(
-    mediaElement: HTMLMediaElement,
+    mediaElement: IMediaElement,
     playbackObserver: IMediaElementPlaybackObserver,
   ): void {
     const cancelSignal = this._initCanceller.signal;
@@ -260,7 +252,7 @@ export default class DirectFileContentInitializer extends ContentInitializer {
  * @returns {number}
  */
 function getDirectFileInitialTime(
-  mediaElement: HTMLMediaElement,
+  mediaElement: IMediaElement,
   startAt?: IInitialTimeOptions,
 ): number {
   if (isNullOrUndefined(startAt)) {

package/src/main_thread/init/media_source_content_initializer.ts

@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 
+import type { IMediaElement } from "../../compat/browser_compatibility_types";
+import isCodecSupported from "../../compat/is_codec_supported";
 import mayMediaElementFailOnUndecipherableData from "../../compat/may_media_element_fail_on_undecipherable_data";
 import shouldReloadMediaSourceOnDecipherabilityUpdate from "../../compat/should_reload_media_source_on_decipherability_update";
 import config from "../../config";
@@ -22,7 +24,7 @@ import type {
   IRepresentationEstimator,
 } from "../../core/adaptive";
 import AdaptiveRepresentationSelector from "../../core/adaptive";
-import type { IManifestFetcherSettings } from "../../core/fetchers";
+import CmcdDataBuilder from "../../core/cmcd";
 import { ManifestFetcher, SegmentFetcherCreator } from "../../core/fetchers";
 import createContentTimeBoundariesObserver from "../../core/main/common/create_content_time_boundaries_observer";
 import DecipherabilityFreezeDetector from "../../core/main/common/DecipherabilityFreezeDetector";
@@ -34,27 +36,34 @@ import type {
 } from "../../core/stream";
 import StreamOrchestrator from "../../core/stream";
 import type { ITextDisplayerInterface } from "../../core/types";
+import type { EncryptedMediaError } from "../../errors";
 import { MediaError } from "../../errors";
 import features from "../../features";
 import log from "../../log";
-import type { IManifest, IPeriodMetadata } from "../../manifest";
+import type { IManifest, IPeriodMetadata, ICodecSupportInfo } from "../../manifest";
 import type MainMediaSourceInterface from "../../mse/main_media_source_interface";
 import type { IMediaElementPlaybackObserver } from "../../playback_observer";
-import type { IKeySystemOption, IPlayerError } from "../../public_types";
+import type {
+  ICmcdOptions,
+  IInitialManifest,
+  IKeySystemOption,
+  IPlayerError,
+} from "../../public_types";
 import type { ITransportPipelines } from "../../transports";
 import areArraysOfNumbersEqual from "../../utils/are_arrays_of_numbers_equal";
 import assert from "../../utils/assert";
 import createCancellablePromise from "../../utils/create_cancellable_promise";
+import isNullOrUndefined from "../../utils/is_null_or_undefined";
 import noop from "../../utils/noop";
 import objectAssign from "../../utils/object_assign";
 import type { IReadOnlySharedReference } from "../../utils/reference";
-import SharedReference from "../../utils/reference";
 import type { ISyncOrAsyncValue } from "../../utils/sync_or_async";
 import SyncOrAsync from "../../utils/sync_or_async";
 import type { CancellationSignal } from "../../utils/task_canceller";
 import TaskCanceller from "../../utils/task_canceller";
-import type { IContentProtection, IProcessedProtectionData } from "../decrypt";
-import { getKeySystemConfiguration } from "../decrypt";
+import { ContentDecryptorState, getKeySystemConfiguration } from "../decrypt";
+import type { IProcessedProtectionData } from "../decrypt";
+import type ContentDecryptor from "../decrypt";
 import type { ITextDisplayer } from "../text_displayer";
 import type { ITextDisplayerOptions } from "./types";
 import { ContentInitializer } from "./types";
@@ -99,6 +108,36 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
    */
   private _manifest: ISyncOrAsyncValue<IManifest> | null;
 
+  private _cmcdDataBuilder: CmcdDataBuilder | null;
+
+  /**
+   * Describes the decryption capabilities on the current content, discriminated
+   * by a `status` property:
+   *
+   *   - If set to `"uninitialized"`, decryption capabilities have not been
+   *     set up yet.
+   *
+   *   - If set to `"disabled"`, decryption capabilities are explicitely
+   *     disabled. If encrypted content needs to be decrypted, the accompanying
+   *     error `value` describes the reason why decryption is not enabled.
+   *
+   *   - If set to `"enabled"`, decryption capabilities are available, and
+   *     `value` points to the corresponding `ContentDecryptor`.
+   */
+  private _decryptionCapabilities:
+    | {
+        status: "uninitialized";
+        value: null;
+      }
+    | {
+        status: "disabled";
+        value: EncryptedMediaError;
+      }
+    | {
+        status: "enabled";
+        value: ContentDecryptor;
+      };
+
   /**
    * Create a new `MediaSourceContentInitializer`, associated to the given
    * settings.
@@ -109,12 +148,15 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
     this._settings = settings;
     this._initCanceller = new TaskCanceller();
     this._manifest = null;
+    this._decryptionCapabilities = { status: "uninitialized", value: null };
     const urls = settings.url === undefined ? undefined : [settings.url];
-    this._manifestFetcher = new ManifestFetcher(
-      urls,
-      settings.transport,
-      settings.manifestRequestSettings,
-    );
+    this._cmcdDataBuilder =
+      settings.cmcd === undefined ? null : new CmcdDataBuilder(settings.cmcd);
+    this._manifestFetcher = new ManifestFetcher(urls, settings.transport, {
+      ...settings.manifestRequestSettings,
+      lowLatencyMode: settings.lowLatencyMode,
+      cmcdDataBuilder: this._cmcdDataBuilder,
+    });
   }
 
   /**
@@ -150,7 +192,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
    * @param {Object} playbackObserver
    */
   public start(
-    mediaElement: HTMLMediaElement,
+    mediaElement: IMediaElement,
     playbackObserver: IMediaElementPlaybackObserver,
   ): void {
     this.prepare(); // Load Manifest if not already done
@@ -162,20 +204,13 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
       this._initCanceller.signal,
     );
 
-    /** Send content protection initialization data to the decryption logic. */
-    const protectionRef = new SharedReference<IContentProtection | null>(
-      null,
-      this._initCanceller.signal,
-    );
-
-    this._initializeMediaSourceAndDecryption(mediaElement, protectionRef)
+    this._initializeMediaSourceAndDecryption(mediaElement)
       .then((initResult) =>
         this._onInitialMediaSourceReady(
           mediaElement,
           initResult.mediaSource,
           playbackObserver,
           initResult.drmSystemId,
-          protectionRef,
           initResult.unlinkMediaSource,
         ),
       )
@@ -207,10 +242,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
     this.trigger("error", err);
   }
 
-  private _initializeMediaSourceAndDecryption(
-    mediaElement: HTMLMediaElement,
-    protectionRef: IReadOnlySharedReference<IContentProtection | null>,
-  ): Promise<{
+  private _initializeMediaSourceAndDecryption(mediaElement: IMediaElement): Promise<{
     mediaSource: MainMediaSourceInterface;
     drmSystemId: string | undefined;
     unlinkMediaSource: TaskCanceller;
@@ -220,10 +252,9 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
       const { keySystems } = this._settings;
 
       /** Initialize decryption capabilities. */
-      const drmInitRef = initializeContentDecryption(
+      const { statusRef: drmInitRef, contentDecryptor } = initializeContentDecryption(
         mediaElement,
         keySystems,
-        protectionRef,
         {
           onWarning: (err: IPlayerError) => this.trigger("warning", err),
           onError: (err: Error) => this._onFatalError(err),
@@ -254,10 +285,38 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
               );
             })().catch(noop);
           },
+
+          onCodecSupportUpdate: () => {
+            const syncManifest = this._manifest?.syncValue;
+            if (isNullOrUndefined(syncManifest)) {
+              // The Manifest is not yet fetched, but we will be able to check
+              // the codecs once it is the case
+              this._manifest?.getValueAsAsync().then((loadedManifest) => {
+                if (this._initCanceller.isUsed()) {
+                  return;
+                }
+                this._refreshManifestCodecSupport(loadedManifest);
+              }, noop);
+            } else {
+              this._refreshManifestCodecSupport(syncManifest);
+            }
+          },
         },
         initCanceller.signal,
       );
 
+      if (contentDecryptor.enabled) {
+        this._decryptionCapabilities = {
+          status: "enabled",
+          value: contentDecryptor.value,
+        };
+      } else {
+        this._decryptionCapabilities = {
+          status: "disabled",
+          value: contentDecryptor.value,
+        };
+      }
+
       drmInitRef.onUpdate(
         (drmStatus, stopListeningToDrmUpdates) => {
           if (drmStatus.initializationState.type === "uninitialized") {
@@ -308,11 +367,10 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
   }
 
   private async _onInitialMediaSourceReady(
-    mediaElement: HTMLMediaElement,
+    mediaElement: IMediaElement,
     initialMediaSource: MainMediaSourceInterface,
     playbackObserver: IMediaElementPlaybackObserver,
     drmSystemId: string | undefined,
-    protectionRef: SharedReference<IContentProtection | null>,
     initialMediaSourceCanceller: TaskCanceller,
   ): Promise<void> {
     const {
@@ -339,6 +397,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
       "manifestUpdate",
       (updates) => {
         this.trigger("manifestUpdate", updates);
+        this._refreshManifestCodecSupport(manifest);
       },
       initCanceller.signal,
     );
@@ -351,6 +410,14 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
       initCanceller.signal,
     );
 
+    manifest.addEventListener(
+      "supportUpdate",
+      () => {
+        this.trigger("codecSupportUpdate", null);
+      },
+      initCanceller.signal,
+    );
+
     log.debug("Init: Calculating initial time");
     const initialTime = getInitialTime(manifest, lowLatencyMode, startAt);
     log.debug("Init: Initial time calculated:", initialTime);
@@ -364,10 +431,12 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
 
     const segmentFetcherCreator = new SegmentFetcherCreator(
       transport,
+      this._cmcdDataBuilder,
       segmentRequestOptions,
       initCanceller.signal,
     );
 
+    this._refreshManifestCodecSupport(manifest);
     this.trigger("manifestReady", manifest);
     if (initCanceller.isUsed()) {
       return;
@@ -411,7 +480,6 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
         representationEstimator,
         segmentFetcherCreator,
         speed,
-        protectionRef,
         bufferOptions: subBufferOptions,
       };
       bufferOnMediaSource(opts, onReloadMediaSource, currentCanceller.signal);
@@ -469,7 +537,6 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
       mediaElement,
       mediaSource,
       playbackObserver,
-      protectionRef,
       representationEstimator,
       segmentFetcherCreator,
       speed,
@@ -588,6 +655,11 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
       cancelSignal,
     );
 
+    this._cmcdDataBuilder?.startMonitoringPlayback(coreObserver);
+    cancelSignal.register(() => {
+      this._cmcdDataBuilder?.stopMonitoringPlayback();
+    });
+
     const rebufferingController = this._createRebufferingController(
       playbackObserver,
       manifest,
@@ -838,7 +910,10 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
           self.trigger("periodStreamCleared", value);
         },
 
-        bitrateEstimateChange: (value) => self.trigger("bitrateEstimateChange", value),
+        bitrateEstimateChange: (value) => {
+          self._cmcdDataBuilder?.updateThroughput(value.type, value.bitrate);
+          self.trigger("bitrateEstimateChange", value);
+        },
 
         needsMediaSourceReload: (payload) => {
           reloadMediaSource(
@@ -854,7 +929,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
             const lastObservation = coreObserver.getReference().getValue();
             const position = lastObservation.position.isAwaitingFuturePosition()
               ? lastObservation.position.getWanted()
-              : coreObserver.getCurrentTime() ?? lastObservation.position.getPolled();
+              : (coreObserver.getCurrentTime() ?? lastObservation.position.getPolled());
             const isPaused =
               lastObservation.paused.pending ??
               coreObserver.getIsPaused() ??
@@ -864,7 +939,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
             const lastObservation = coreObserver.getReference().getValue();
             const position = lastObservation.position.isAwaitingFuturePosition()
               ? lastObservation.position.getWanted()
-              : coreObserver.getCurrentTime() ?? lastObservation.position.getPolled();
+              : (coreObserver.getCurrentTime() ?? lastObservation.position.getPolled());
             // simple seek close to the current position
             // to flush the buffers
             if (position + 0.001 < lastObservation.duration) {
@@ -876,8 +951,18 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
         },
 
         encryptionDataEncountered: (value) => {
+          if (self._decryptionCapabilities.status === "disabled") {
+            self._onFatalError(self._decryptionCapabilities.value);
+            return;
+          } else if (self._decryptionCapabilities.status === "uninitialized") {
+            // Should never happen
+            log.error(
+              "Init: received encryption data without known decryption capabilities",
+            );
+            return;
+          }
           for (const protectionData of value) {
-            protectionRef.setValue(protectionData);
+            self._decryptionCapabilities.value.onInitializationData(protectionData);
             if (cancelSignal.isCancelled()) {
               return; // Previous call has stopped streams due to a side-effect
             }
@@ -905,7 +990,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
       const lastObservation = coreObserver.getReference().getValue();
       const currentPosition = lastObservation.position.isAwaitingFuturePosition()
         ? lastObservation.position.getWanted()
-        : coreObserver.getCurrentTime() ?? lastObservation.position.getPolled();
+        : (coreObserver.getCurrentTime() ?? lastObservation.position.getPolled());
       const isPaused =
         lastObservation.paused.pending ??
         coreObserver.getIsPaused() ??
@@ -964,6 +1049,78 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
     rebufferingController.start();
     return rebufferingController;
   }
+
+  /**
+   * Evaluates a list of codecs to determine their support status.
+   *
+   * @param {Array} codecsToCheck - The list of codecs to check.
+   * @returns {Array} - The list of evaluated codecs with their support status updated.
+   */
+  private getCodecsSupportInfo(
+    codecsToCheck: Array<{ mimeType: string; codec: string }>,
+  ): ICodecSupportInfo[] {
+    const codecsSupportInfo: ICodecSupportInfo[] = codecsToCheck.map((codecToCheck) => {
+      const inputCodec = `${codecToCheck.mimeType};codecs="${codecToCheck.codec}"`;
+      const isSupported = isCodecSupported(inputCodec);
+      if (!isSupported) {
+        return {
+          mimeType: codecToCheck.mimeType,
+          codec: codecToCheck.codec,
+          supported: false,
+          supportedIfEncrypted: false,
+        };
+      }
+      /**
+       * `true` if the codec is supported when encrypted, `false` if it is not
+       * supported, or `undefined` if we cannot obtain that information.
+       */
+      let supportedIfEncrypted: boolean | undefined;
+      if (this._decryptionCapabilities.status === "uninitialized") {
+        supportedIfEncrypted = undefined;
+      } else if (this._decryptionCapabilities.status === "disabled") {
+        // It's ambiguous here, but let's say that no ContentDecryptor means that
+        // the codec is supported by it.
+        supportedIfEncrypted = true;
+      } else {
+        const contentDecryptor = this._decryptionCapabilities.value;
+        if (contentDecryptor.getState() !== ContentDecryptorState.Initializing) {
+          // No information is available regarding the support status.
+          // Defaulting to assume the codec is supported.
+          supportedIfEncrypted =
+            contentDecryptor.isCodecSupported(
+              codecToCheck.mimeType,
+              codecToCheck.codec,
+            ) ?? true;
+        }
+      }
+      return {
+        mimeType: codecToCheck.mimeType,
+        codec: codecToCheck.codec,
+        supported: isSupported,
+        supportedIfEncrypted,
+      };
+    });
+    return codecsSupportInfo;
+  }
+
+  /**
+   * Update the support status of all Representations in the Manifest.
+   *
+   * To call anytime either the Manifest is linked to new codecs or new means
+   * to test for codec support are available.
+   * @param {Object} manifest
+   */
+  private _refreshManifestCodecSupport(manifest: IManifest): void {
+    const codecsToTest = manifest.getCodecsWithUnknownSupport();
+    const codecsSupportInfo = this.getCodecsSupportInfo(codecsToTest);
+    if (codecsSupportInfo.length > 0) {
+      try {
+        manifest.updateCodecSupport(codecsSupportInfo);
+      } catch (err) {
+        this._onFatalError(err);
+      }
+    }
+  }
 }
 
 /** Arguments to give to the `InitializeOnMediaSource` function. */
@@ -990,12 +1147,39 @@ export interface IInitializeArguments {
     /** Behavior when a new video and/or audio codec is encountered. */
     onCodecSwitch: "continue" | "reload";
   };
+  /**
+   * When set to an object, enable "Common Media Client Data", or "CMCD".
+   */
+  cmcd?: ICmcdOptions | undefined;
   /** Every encryption configuration set. */
   keySystems: IKeySystemOption[];
   /** `true` to play low-latency contents optimally. */
   lowLatencyMode: boolean;
   /** Settings linked to Manifest requests. */
-  manifestRequestSettings: IManifestFetcherSettings;
+  manifestRequestSettings: {
+    /** Maximum number of time a request on error will be retried. */
+    maxRetry: number | undefined;
+    /**
+     * Timeout after which request are aborted and, depending on other options,
+     * retried.
+     * To set to `-1` for no timeout.
+     * `undefined` will lead to a default, large, timeout being used.
+     */
+    requestTimeout: number | undefined;
+    /**
+     * Connection timeout, in milliseconds, after which the request is canceled
+     * if the responses headers has not being received.
+     * Do not set or set to "undefined" to disable it.
+     */
+    connectionTimeout: number | undefined;
+    /** Limit the frequency of Manifest updates. */
+    minimumManifestUpdateInterval: number;
+    /**
+     * Potential first Manifest to rely on, allowing to skip the initial Manifest
+     * request.
+     */
+    initialManifest: IInitialManifest | undefined;
+  };
   /** Logic linked Manifest and segment loading and parsing. */
   transport: ITransportPipelines;
   /** Configuration for the segment requesting logic. */
@@ -1033,7 +1217,7 @@ interface IBufferingMediaSettings {
   /* Manifest of the content we want to play. */
   manifest: IManifest;
   /** Media Element on which the content will be played. */
-  mediaElement: HTMLMediaElement;
+  mediaElement: IMediaElement;
   /** Emit playback conditions regularly. */
   playbackObserver: IMediaElementPlaybackObserver;
   /** Estimate the right Representation. */
@@ -1042,11 +1226,6 @@ interface IBufferingMediaSettings {
   segmentFetcherCreator: SegmentFetcherCreator;
   /** Last wanted playback rate. */
   speed: IReadOnlySharedReference<number>;
-  /**
-   * Reference through which decryption initialization information can be
-   * communicated.
-   */
-  protectionRef: SharedReference<IContentProtection | null>;
   /** `MediaSource` element on which the media will be buffered. */
   mediaSource: MainMediaSourceInterface;
   /** The initial position to seek to in media time, in seconds. */