rx-player 4.1.0 → 4.2.0-dev.2024080600

package/src/main_thread/init/utils/initialize_content_decryption.ts

@@ -1,3 +1,4 @@
+import type { IMediaElement } from "../../../compat/browser_compatibility_types";
 import { EncryptedMediaError } from "../../../errors";
 import features from "../../../features";
 import log from "../../../log";
@@ -7,7 +8,8 @@ import SharedReference from "../../../utils/reference";
 import TaskCanceller from "../../../utils/task_canceller";
 import type { CancellationSignal } from "../../../utils/task_canceller";
 import { ContentDecryptorState } from "../../decrypt";
-import type { IContentProtection, IProcessedProtectionData } from "../../decrypt";
+import type IContentDecryptor from "../../decrypt";
+import type { IProcessedProtectionData } from "../../decrypt";
 
 /**
  * Initialize content decryption capabilities on the given `HTMLMediaElement`.
@@ -22,20 +24,17 @@ import type { IContentProtection, IProcessedProtectionData } from "../../decrypt
  * decryption may be wanted.
  * @param {Array.<Object>} keySystems - Key system configuration(s) wanted
  * Empty array if no content decryption capability is wanted.
- * @param {Object} protectionRef - Reference through which content
  * protection initialization data will be sent through.
  * @param {Object} callbacks - Callbacks called at various decryption-related
  * events.
  * @param {Object} cancelSignal - When that signal emits, this function will
- * stop listening to various events as well as items sent through the
- * `protectionRef` parameter.
+ * stop listening to various events.
  * @returns {Object} - Reference emitting the current status regarding DRM
  * initialization.
  */
 export default function initializeContentDecryption(
-  mediaElement: HTMLMediaElement,
+  mediaElement: IMediaElement,
   keySystems: IKeySystemOption[],
-  protectionRef: IReadOnlySharedReference<null | IContentProtection>,
   callbacks: {
     onWarning: (err: IPlayerError) => void;
     onError: (err: Error) => void;
@@ -45,9 +44,21 @@ export default function initializeContentDecryption(
       blacklistedKeyIds: Uint8Array[];
       delistedKeyIds: Uint8Array[];
     }) => void;
+    onCodecSupportUpdate?: () => void;
   },
   cancelSignal: CancellationSignal,
-): IReadOnlySharedReference<IDrmInitializationStatus> {
+): {
+  statusRef: IReadOnlySharedReference<IDrmInitializationStatus>;
+  contentDecryptor:
+    | {
+        enabled: true;
+        value: IContentDecryptor;
+      }
+    | {
+        enabled: false;
+        value: EncryptedMediaError;
+      };
+} {
   if (keySystems.length === 0) {
     return createEmeDisabledReference("No `keySystems` option given.");
   } else if (features.decrypt === null) {
@@ -73,6 +84,14 @@ export default function initializeContentDecryption(
   log.debug("Init: Creating ContentDecryptor");
   const contentDecryptor = new ContentDecryptor(mediaElement, keySystems);
 
+  const onStateChange = (state: ContentDecryptorState) => {
+    if (state > ContentDecryptorState.Initializing) {
+      callbacks.onCodecSupportUpdate?.();
+      contentDecryptor.removeEventListener("stateChange", onStateChange);
+    }
+  };
+  contentDecryptor.addEventListener("stateChange", onStateChange);
+
   contentDecryptor.addEventListener("stateChange", (state) => {
     if (state === ContentDecryptorState.WaitingForAttachment) {
       const isMediaLinked = new SharedReference(false);
@@ -120,41 +139,29 @@ export default function initializeContentDecryption(
     callbacks.onKeyIdsCompatibilityUpdate(x);
   });
 
-  protectionRef.onUpdate(
-    (data) => {
-      if (data === null) {
-        return;
-      }
-      contentDecryptor.onInitializationData(data);
-    },
-    { clearSignal: decryptorCanceller.signal },
-  );
-
   decryptorCanceller.signal.register(() => {
     contentDecryptor.dispose();
   });
 
-  return drmStatusRef;
-
-  function createEmeDisabledReference(errMsg: string) {
-    protectionRef.onUpdate(
-      (data, stopListening) => {
-        if (data === null) {
-          // initial value
-          return;
-        }
-        stopListening();
-        const err = new EncryptedMediaError("MEDIA_IS_ENCRYPTED_ERROR", errMsg);
-        callbacks.onError(err);
-      },
-      { clearSignal: cancelSignal },
-    );
+  return {
+    statusRef: drmStatusRef,
+    contentDecryptor: { enabled: true, value: contentDecryptor },
+  };
+
+  function createEmeDisabledReference(errMsg: string): {
+    statusRef: IReadOnlySharedReference<IDrmInitializationStatus>;
+    contentDecryptor: {
+      enabled: false;
+      value: EncryptedMediaError;
+    };
+  } {
+    const err = new EncryptedMediaError("MEDIA_IS_ENCRYPTED_ERROR", errMsg);
     const ref = new SharedReference({
       initializationState: { type: "initialized" as const, value: null },
       drmSystemId: undefined,
     });
     ref.finish(); // We know that no new value will be triggered
-    return ref;
+    return { statusRef: ref, contentDecryptor: { enabled: false, value: err } };
   }
 }
 

package/src/main_thread/init/utils/stream_events_emitter/stream_events_emitter.ts

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+import type { IMediaElement } from "../../../../compat/browser_compatibility_types";
 import config from "../../../../config";
 import type { IManifestMetadata } from "../../../../manifest";
 import { SeekingState } from "../../../../playback_observer";
@@ -43,7 +44,7 @@ interface IStreamEventsEmitterEvent {
  */
 export default class StreamEventsEmitter extends EventEmitter<IStreamEventsEmitterEvent> {
   private _manifest: IManifestMetadata;
-  private _mediaElement: HTMLMediaElement;
+  private _mediaElement: IMediaElement;
   private _playbackObserver: IReadOnlyPlaybackObserver<IPlaybackObservation>;
   private _scheduledEventsRef: SharedReference<
     Array<IStreamEventPayload | INonFiniteStreamEventPayload>
@@ -61,7 +62,7 @@ export default class StreamEventsEmitter extends EventEmitter<IStreamEventsEmitt
    */
   constructor(
     manifest: IManifestMetadata,
-    mediaElement: HTMLMediaElement,
+    mediaElement: IMediaElement,
     playbackObserver: IReadOnlyPlaybackObserver<IPlaybackObservation>,
   ) {
     super();

package/src/main_thread/init/utils/throw_on_media_error.ts

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+import type { IMediaElement } from "../../../compat/browser_compatibility_types";
 import { MediaError } from "../../../errors";
 import isNullOrUndefined from "../../../utils/is_null_or_undefined";
 import type { CancellationSignal } from "../../../utils/task_canceller";
@@ -24,7 +25,7 @@ import type { CancellationSignal } from "../../../utils/task_canceller";
  * @param {Object} cancelSignal
  */
 export default function listenToMediaError(
-  mediaElement: HTMLMediaElement,
+  mediaElement: IMediaElement,
   onError: (error: MediaError) => void,
   cancelSignal: CancellationSignal,
 ): void {
@@ -33,7 +34,6 @@ export default function listenToMediaError(
   }
 
   mediaElement.addEventListener("error", onMediaError);
-
   cancelSignal.register(() => {
     mediaElement.removeEventListener("error", onMediaError);
   });

package/src/main_thread/init/utils/update_manifest_codec_support.ts

@@ -0,0 +1,193 @@
+import isCodecSupported from "../../../compat/is_codec_supported";
+import { MediaError } from "../../../errors";
+import type { IManifestMetadata } from "../../../manifest";
+import type Manifest from "../../../manifest/classes";
+import type { ICodecSupportInfo } from "../../../multithread_types";
+import type { ITrackType } from "../../../public_types";
+import isNullOrUndefined from "../../../utils/is_null_or_undefined";
+import type ContentDecryptor from "../../decrypt";
+import { ContentDecryptorState } from "../../decrypt";
+
+/**
+ * Returns a list of all codecs that the support is not known yet on the given
+ * Manifest.
+ * If a representation with (`isSupported`) is undefined, we consider the
+ * codec support as unknown.
+ *
+ * This function iterates through all periods, adaptations, and representations,
+ * and collects unknown codecs.
+ *
+ * @returns {Array} The list of codecs with unknown support status.
+ */
+export function getCodecsWithUnknownSupport(
+  manifest: Manifest,
+): Array<{ mimeType: string; codec: string }>;
+export function getCodecsWithUnknownSupport(
+  manifest: IManifestMetadata,
+): Array<{ mimeType: string; codec: string }> {
+  const codecsWithUnknownSupport: Array<{ mimeType: string; codec: string }> = [];
+  for (const period of manifest.periods) {
+    const checkedAdaptations = [
+      ...(period.adaptations.video ?? []),
+      ...(period.adaptations.audio ?? []),
+    ];
+    for (const adaptation of checkedAdaptations) {
+      if (!adaptation.supportStatus.hasCodecWithUndefinedSupport) {
+        continue;
+      }
+      for (const representation of adaptation.representations) {
+        if (representation.isSupported === undefined) {
+          codecsWithUnknownSupport.push({
+            mimeType: representation.mimeType ?? "",
+            codec: representation.codecs?.[0] ?? "",
+          });
+        }
+      }
+    }
+  }
+  return codecsWithUnknownSupport;
+}
+
+/**
+ * Ensure that all `Representation` and `Adaptation` have a known status
+ * for their codec support and probe it for cases where that's not the
+ * case.
+ *
+ * Because probing for codec support is always synchronous in the main thread,
+ * calling this function ensures that support is now known.
+ *
+ * @param {Object} manifest
+ * @param {Object|null} contentDecryptor
+ * @returns {boolean}
+ */
+export function updateManifestCodecSupport(
+  manifest: IManifestMetadata,
+  contentDecryptor: ContentDecryptor | null,
+): ICodecSupportInfo[] {
+  const codecSupportMap: Map<
+    string,
+    {
+      isSupportedClear: boolean;
+      isSupportedEncrypted: boolean | undefined;
+    }
+  > = new Map();
+  const updatedCodecs: ICodecSupportInfo[] = [];
+
+  const efficientlyGetCodecSupport = (
+    mimeType: string | undefined,
+    codec: string | undefined,
+  ): {
+    isSupportedClear: boolean;
+    isSupportedEncrypted: boolean | undefined;
+  } => {
+    const inputCodec = `${mimeType ?? ""};codecs="${codec ?? ""}"`;
+    const baseData = codecSupportMap.get(inputCodec);
+    if (baseData !== undefined) {
+      return baseData;
+    }
+
+    let newData;
+    const isSupported = isCodecSupported(inputCodec);
+    if (!isSupported) {
+      newData = {
+        isSupportedClear: false,
+        isSupportedEncrypted: false,
+      };
+    } else if (isNullOrUndefined(contentDecryptor)) {
+      newData = {
+        isSupportedClear: true,
+        // This is ambiguous. Less assume that with no ContentDecryptor, an
+        // encrypted codec is supported
+        isSupportedEncrypted: true,
+      };
+    } else if (contentDecryptor.getState() === ContentDecryptorState.Initializing) {
+      newData = {
+        isSupportedClear: true,
+        isSupportedEncrypted: undefined,
+      };
+    } else {
+      newData = {
+        isSupportedClear: true,
+        isSupportedEncrypted:
+          contentDecryptor.isCodecSupported(mimeType ?? "", codec ?? "") ?? true,
+      };
+    }
+    codecSupportMap.set(inputCodec, newData);
+    updatedCodecs.push({
+      codec: codec ?? "",
+      mimeType: mimeType ?? "",
+      supported: newData.isSupportedClear,
+      supportedIfEncrypted: newData.isSupportedEncrypted,
+    });
+    return newData;
+  };
+
+  manifest.periods.forEach((p) => {
+    [
+      ...(p.adaptations.audio ?? []),
+      ...(p.adaptations.video ?? []),
+      ...(p.adaptations.text ?? []),
+    ].forEach((adaptation) => {
+      let hasSupportedCodec: boolean = false;
+      let hasCodecWithUndefinedSupport: boolean = false;
+      adaptation.representations.forEach((representation) => {
+        if (representation.isSupported !== undefined) {
+          if (representation.isSupported) {
+            hasSupportedCodec = true;
+          }
+          // We already knew the support for that one, continue to next one
+          return;
+        }
+
+        const isEncrypted = representation.contentProtections !== undefined;
+        const mimeType = representation.mimeType ?? "";
+        let codecs = representation.codecs ?? [];
+        if (codecs.length === 0) {
+          codecs = [""];
+        }
+        for (const codec of codecs) {
+          const codecSupportInfo = efficientlyGetCodecSupport(mimeType, codec);
+          if (!isEncrypted) {
+            representation.isSupported = codecSupportInfo.isSupportedClear;
+          } else if (
+            representation.isSupported !== codecSupportInfo.isSupportedEncrypted
+          ) {
+            representation.isSupported = codecSupportInfo.isSupportedEncrypted;
+          }
+
+          if (representation.isSupported === undefined) {
+            hasCodecWithUndefinedSupport = true;
+          } else if (representation.isSupported) {
+            hasSupportedCodec = true;
+            representation.codecs = [codec];
+
+            // Don't test subsequent codecs for that Representation
+            break;
+          }
+        }
+      });
+      adaptation.supportStatus.hasCodecWithUndefinedSupport =
+        hasCodecWithUndefinedSupport;
+      if (hasCodecWithUndefinedSupport && !hasSupportedCodec) {
+        adaptation.supportStatus.hasSupportedCodec = undefined;
+      } else {
+        adaptation.supportStatus.hasSupportedCodec = hasSupportedCodec;
+      }
+    });
+
+    ["audio" as const, "video" as const].forEach((ttype: ITrackType) => {
+      const forType = p.adaptations[ttype];
+      if (
+        forType !== undefined &&
+        forType.every((a) => a.supportStatus.hasSupportedCodec === false)
+      ) {
+        throw new MediaError(
+          "MANIFEST_INCOMPATIBLE_CODECS_ERROR",
+          "No supported " + ttype + " adaptations",
+          { tracks: undefined },
+        );
+      }
+    });
+  });
+  return updatedCodecs;
+}

package/src/main_thread/text_displayer/html/html_text_displayer.ts

@@ -1,3 +1,4 @@
+import type { IMediaElement } from "../../../compat/browser_compatibility_types";
 import { onEnded, onSeeked, onSeeking } from "../../../compat/event_listeners";
 import onHeightWidthChange from "../../../compat/on_height_width_change";
 import config from "../../../config";
@@ -55,7 +56,7 @@ export default class HTMLTextDisplayer implements ITextDisplayer {
    * The video element the cues refer to.
    * Used to know when the user is seeking, for example.
    */
-  private readonly _videoElement: HTMLMediaElement;
+  private readonly _videoElement: IMediaElement;
 
   /** Allows to cancel the interval at which subtitles are updated. */
   private _subtitlesIntervalCanceller: TaskCanceller;
@@ -100,7 +101,7 @@ export default class HTMLTextDisplayer implements ITextDisplayer {
    * @param {HTMLMediaElement} videoElement
    * @param {HTMLElement} textTrackElement
    */
-  constructor(videoElement: HTMLMediaElement, textTrackElement: HTMLElement) {
+  constructor(videoElement: IMediaElement, textTrackElement: HTMLElement) {
     log.debug("HTD: Creating HTMLTextDisplayer");
     this._buffered = new ManualTimeRanges();
 

package/src/main_thread/text_displayer/native/native_text_displayer.ts

@@ -1,5 +1,8 @@
 import addTextTrack from "../../../compat/add_text_track";
-import type { ICompatTextTrack } from "../../../compat/browser_compatibility_types";
+import type {
+  ICompatTextTrack,
+  IMediaElement,
+} from "../../../compat/browser_compatibility_types";
 import removeCue from "../../../compat/remove_cue";
 import log from "../../../log";
 import type { ITextTrackSegmentData } from "../../../transports";
@@ -16,7 +19,7 @@ import parseTextTrackToCues from "./native_parsers";
  * @class NativeTextDisplayer
  */
 export default class NativeTextDisplayer implements ITextDisplayer {
-  private readonly _videoElement: HTMLMediaElement;
+  private readonly _videoElement: IMediaElement;
   private readonly _track: ICompatTextTrack;
   private readonly _trackElement: HTMLTrackElement | undefined;
 
@@ -25,7 +28,7 @@ export default class NativeTextDisplayer implements ITextDisplayer {
   /**
    * @param {HTMLMediaElement} videoElement
    */
-  constructor(videoElement: HTMLMediaElement) {
+  constructor(videoElement: IMediaElement) {
     log.debug("NTD: Creating NativeTextDisplayer");
     const { track, trackElement } = addTextTrack(videoElement);
     this._buffered = new ManualTimeRanges();

package/src/main_thread/tracks_store/media_element_tracks_store.ts

@@ -22,10 +22,10 @@
 import type {
   ICompatAudioTrack,
   ICompatAudioTrackList,
-  ICompatHTMLMediaElement,
   ICompatTextTrackList,
   ICompatVideoTrack,
   ICompatVideoTrackList,
+  IMediaElement,
 } from "../../compat/browser_compatibility_types";
 import enableAudioTrack from "../../compat/enable_audio_track";
 import type { IRepresentation } from "../../manifest";
@@ -236,13 +236,13 @@ export default class MediaElementTracksStore extends EventEmitter<IMediaElementT
    */
   private _videoTrackLockedOn: ICompatVideoTrack | undefined | null;
 
-  constructor(mediaElement: HTMLMediaElement) {
+  constructor(mediaElement: IMediaElement) {
     super();
     // TODO In practice, the audio/video/text tracks API are not always implemented on
     // the media element, although Typescript HTMLMediaElement types tend to mean
     // that can't be undefined.
-    this._nativeAudioTracks = (mediaElement as ICompatHTMLMediaElement).audioTracks;
-    this._nativeVideoTracks = (mediaElement as ICompatHTMLMediaElement).videoTracks;
+    this._nativeAudioTracks = mediaElement.audioTracks;
+    this._nativeVideoTracks = mediaElement.videoTracks;
     this._nativeTextTracks = mediaElement.textTracks as ICompatTextTrackList | undefined;
 
     this._audioTracks =

package/src/main_thread/tracks_store/track_dispatcher.ts

@@ -91,36 +91,18 @@ export default class TrackDispatcher extends EventEmitter<ITrackDispatcherEvent>
     this._canceller = new TaskCanceller();
     this._adaptationRef = adaptationRef;
     this._updateToken = false;
+    this._lastEmitted = undefined;
     this.refresh = noop;
   }
 
   /**
-   * @param {Object|null} initialTrackInfo
+   * Returns `true` if the initial track choice has been sent by this
+   * `TrackDispatcher`.
+   * Returns `false` if that's not the case yet.
+   * @returns {boolean}
    */
-  public start(initialTrackInfo: ITrackSetting | null): void {
-    this._updateToken = true;
-    if (initialTrackInfo === null) {
-      this._lastEmitted = null;
-      this._updateToken = false;
-      this._adaptationRef.setValue(null);
-      return;
-    }
-    const reference = this._constructLockedRepresentationsReference(initialTrackInfo);
-    if (!this._updateToken) {
-      return;
-    }
-    this._lastEmitted = {
-      adaptation: initialTrackInfo.adaptation,
-      switchingMode: initialTrackInfo.switchingMode,
-      lockedRepresentations: null,
-    };
-    this._updateToken = false;
-    this._adaptationRef.setValue({
-      adaptationId: initialTrackInfo.adaptation.id,
-      switchingMode: initialTrackInfo.switchingMode,
-      representations: reference,
-      relativeResumingPosition: undefined,
-    });
+  public hasSetTrack(): boolean {
+    return this._adaptationRef.getValue() !== undefined;
   }
 
   /**
@@ -228,7 +210,6 @@ export default class TrackDispatcher extends EventEmitter<ITrackDispatcherEvent>
         }
       }
       if (playableRepresentations.length <= 0) {
-        trackInfo.adaptation.isSupported = false;
         self.trigger("noPlayableRepresentation", null);
         return;
       }