rx-player 4.4.0-dev.2025092200 → 4.4.0

package/src/compat/__tests__/is_codec_supported.test.ts

@@ -14,8 +14,8 @@ describe("Compat - isCodecSupported", () => {
     });
     const isCodecSupported = (await vi.importActual("../is_codec_supported"))
       .default as typeof IIsCodecSupported;
-    expect(isCodecSupported("foo")).toEqual(false);
-    expect(isCodecSupported("")).toEqual(false);
+    expect(isCodecSupported(document.createElement("video"), "foo")).toEqual(false);
+    expect(isCodecSupported(document.createElement("video"), "")).toEqual(false);
   });
 
   it("should return true in any case if the MediaSource does not have the right function", async () => {
@@ -26,8 +26,8 @@ describe("Compat - isCodecSupported", () => {
     });
     const isCodecSupported = (await vi.importActual("../is_codec_supported"))
       .default as typeof IIsCodecSupported;
-    expect(isCodecSupported("foo")).toEqual(true);
-    expect(isCodecSupported("")).toEqual(true);
+    expect(isCodecSupported(document.createElement("video"), "foo")).toEqual(true);
+    expect(isCodecSupported(document.createElement("video"), "")).toEqual(true);
   });
 
   it("should return true if MediaSource.isTypeSupported returns true", async () => {
@@ -42,8 +42,8 @@ describe("Compat - isCodecSupported", () => {
     });
     const isCodecSupported = (await vi.importActual("../is_codec_supported"))
       .default as typeof IIsCodecSupported;
-    expect(isCodecSupported("foo")).toEqual(true);
-    expect(isCodecSupported("")).toEqual(true);
+    expect(isCodecSupported(document.createElement("video"), "foo")).toEqual(true);
+    expect(isCodecSupported(document.createElement("video"), "")).toEqual(true);
   });
 
   it("should return false if MediaSource.isTypeSupported returns false", async () => {
@@ -58,7 +58,7 @@ describe("Compat - isCodecSupported", () => {
     });
     const isCodecSupported = (await vi.importActual("../is_codec_supported"))
       .default as typeof IIsCodecSupported;
-    expect(isCodecSupported("foo")).toEqual(false);
-    expect(isCodecSupported("")).toEqual(false);
+    expect(isCodecSupported(document.createElement("video"), "foo")).toEqual(false);
+    expect(isCodecSupported(document.createElement("video"), "")).toEqual(false);
   });
 });

package/src/compat/is_codec_supported.ts

@@ -14,10 +14,12 @@
  * limitations under the License.
  */
 
+import type DummyMediaElement from "../experimental/tools/DummyMediaElement";
 import log from "../log";
 import isNullOrUndefined from "../utils/is_null_or_undefined";
 import isWorker from "../utils/is_worker";
 import { MediaSource_ } from "./browser_compatibility_types";
+import type { IMediaElement } from "./browser_compatibility_types";
 
 /**
  * Setting this value limit the number of entries in the support map
@@ -33,13 +35,24 @@ const supportMap: Map<string, boolean> = new Map();
 /**
  * Returns true if the given codec is supported by the browser's MediaSource
  * implementation.
+ * @param {HTMLMediaElement} mediaElement
  * @param {string} mimeType - The MIME media type that you want to test support
  * for in the current browser.
  * This may include the codecs parameter to provide added details about the
  * codecs used within the file.
  * @returns {Boolean}
  */
-export default function isCodecSupported(mimeType: string): boolean {
+export default function isCodecSupported(
+  mediaElement: IMediaElement,
+  mimeType: string,
+): boolean {
+  // TODO: We only added that as a hotfix for now, to allow support of the right codecs
+  // on a dummy media element
+  if ((mediaElement as DummyMediaElement).isDummy) {
+    return (mediaElement as DummyMediaElement).FORCED_MEDIA_SOURCE.isTypeSupported(
+      mimeType,
+    );
+  }
   if (isNullOrUndefined(MediaSource_)) {
     if (isWorker) {
       log.error("mse", "Cannot request codec support in a worker without MSE.");

package/src/main_thread/api/public_api.ts

@@ -445,7 +445,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     // See: https://bugzilla.mozilla.org/show_bug.cgi?id=1194624
     videoElement.preload = "auto";
 
-    this.version = /* PLAYER_VERSION */ "4.4.0-dev.2025092200";
+    this.version = /* PLAYER_VERSION */ "4.4.0";
     this.log = log;
     this.state = "STOPPED";
     this.videoElement = videoElement;
@@ -3576,7 +3576,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     }
   }
 }
-Player.version = /* PLAYER_VERSION */ "4.4.0-dev.2025092200";
+Player.version = /* PLAYER_VERSION */ "4.4.0";
 
 /** Every events sent by the RxPlayer's public API. */
 interface IPublicAPIEvent {

package/src/main_thread/init/media_source_content_initializer.ts

@@ -317,10 +317,10 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
                 if (this._initCanceller.isUsed()) {
                   return;
                 }
-                this._refreshManifestCodecSupport(loadedManifest);
+                this._refreshManifestCodecSupport(loadedManifest, mediaElement);
               }, noop);
             } else {
-              this._refreshManifestCodecSupport(syncManifest);
+              this._refreshManifestCodecSupport(syncManifest, mediaElement);
             }
           },
         },
@@ -419,7 +419,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
       "manifestUpdate",
       (updates) => {
         this.trigger("manifestUpdate", updates);
-        this._refreshManifestCodecSupport(manifest);
+        this._refreshManifestCodecSupport(manifest, mediaElement);
       },
       initCanceller.signal,
     );
@@ -459,7 +459,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
       segmentRequestOptions,
     );
 
-    this._refreshManifestCodecSupport(manifest);
+    this._refreshManifestCodecSupport(manifest, mediaElement);
     this.trigger("manifestReady", manifest);
     if (initCanceller.isUsed()) {
       return;
@@ -1094,10 +1094,11 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
    */
   private getCodecsSupportInfo(
     codecsToCheck: Array<{ mimeType: string; codec: string }>,
+    mediaElement: IMediaElement,
   ): ICodecSupportInfo[] {
     const codecsSupportInfo: ICodecSupportInfo[] = codecsToCheck.map((codecToCheck) => {
       const inputCodec = `${codecToCheck.mimeType};codecs="${codecToCheck.codec}"`;
-      const isSupported = isCodecSupported(inputCodec);
+      const isSupported = isCodecSupported(mediaElement, inputCodec);
       if (!isSupported) {
         return {
           mimeType: codecToCheck.mimeType,
@@ -1146,9 +1147,12 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
    * to test for codec support are available.
    * @param {Object} manifest
    */
-  private _refreshManifestCodecSupport(manifest: IManifest): void {
+  private _refreshManifestCodecSupport(
+    manifest: IManifest,
+    mediaElement: IMediaElement,
+  ): void {
     const codecsToTest = manifest.getCodecsWithUnknownSupport();
-    const codecsSupportInfo = this.getCodecsSupportInfo(codecsToTest);
+    const codecsSupportInfo = this.getCodecsSupportInfo(codecsToTest, mediaElement);
     if (codecsSupportInfo.length > 0) {
       try {
         manifest.updateCodecSupport(codecsSupportInfo);

package/src/main_thread/init/multi_thread_content_initializer.ts

@@ -910,7 +910,7 @@ export default class MultiThreadContentInitializer extends ContentInitializer {
           }
           const manifest = msgData.value.manifest;
           this._currentContentInfo.manifest = manifest;
-          this._updateCodecSupport(manifest);
+          this._updateCodecSupport(manifest, mediaElement);
           this._startPlaybackIfReady(playbackStartParams);
           break;
         }
@@ -932,7 +932,7 @@ export default class MultiThreadContentInitializer extends ContentInitializer {
           );
           this._currentContentInfo?.streamEventsEmitter?.onManifestUpdate(manifest);
 
-          this._updateCodecSupport(manifest);
+          this._updateCodecSupport(manifest, mediaElement);
           this.trigger("manifestUpdate", msgData.value.updates);
           break;
         }
@@ -1381,7 +1381,7 @@ export default class MultiThreadContentInitializer extends ContentInitializer {
         if (isNullOrUndefined(manifest)) {
           return;
         }
-        this._updateCodecSupport(manifest);
+        this._updateCodecSupport(manifest, mediaElement);
         contentDecryptor.removeEventListener(
           "stateChange",
           updateCodecSupportOnStateChange,
@@ -1500,11 +1500,12 @@ export default class MultiThreadContentInitializer extends ContentInitializer {
    * status of these codecs, and forwards the list of supported codecs to the web worker.
    * @param manifest
    */
-  private _updateCodecSupport(manifest: IManifestMetadata) {
+  private _updateCodecSupport(manifest: IManifestMetadata, mediaElement: IMediaElement) {
     try {
       const updatedCodecs = updateManifestCodecSupport(
         manifest,
         this._currentContentInfo?.contentDecryptor ?? null,
+        mediaElement,
         this._currentContentInfo?.useMseInWorker ?? false,
       );
       if (updatedCodecs.length > 0) {

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

@@ -196,7 +196,12 @@ describe("init - utils - updateManifestCodecSupport", () => {
     const emeImplem = getEmeApiImplementation("auto");
     assert(emeImplem !== null);
     const contentDecryptor = new ContentDecryptor(emeImplem, video, [keySystem1]);
-    updateManifestCodecSupport(manifest, contentDecryptor, true);
+    updateManifestCodecSupport(
+      manifest,
+      contentDecryptor,
+      document.createElement("video"),
+      true,
+    );
     expect(representationAVC.isSupported).toBe(true);
     expect(representationHEVC.isSupported).toBe(true);
     expect(representationVP9.isSupported).toBe(false); // Not Supported by MSE
@@ -280,7 +285,12 @@ describe("init - utils - updateManifestCodecSupport", () => {
     const contentDecryptor = new ContentDecryptor(emeImplem, video, [keySystem1]);
     await sleep(100);
     contentDecryptor.attach();
-    updateManifestCodecSupport(manifest, contentDecryptor, true);
+    updateManifestCodecSupport(
+      manifest,
+      contentDecryptor,
+      document.createElement("video"),
+      true,
+    );
     expect(encryptedRepresentationAVC.isSupported).toBe(true);
     expect(encryptedRepresentationHEVC.isSupported).toBe(false); // Not supported by EME
     expect(encryptedRepresentationVP9.isSupported).toBe(false); // Not supported by MSE
@@ -327,7 +337,12 @@ describe("init - utils - updateManifestCodecSupport", () => {
     const emeImplem = getEmeApiImplementation("auto");
     assert(emeImplem !== null);
     const contentDecryptor = new ContentDecryptor(emeImplem, video, []);
-    updateManifestCodecSupport(manifest, contentDecryptor, true);
+    updateManifestCodecSupport(
+      manifest,
+      contentDecryptor,
+      document.createElement("video"),
+      true,
+    );
     expect(representationAVC.isSupported).toBe(true);
     expect(representationHEVC.isSupported).toBe(false); // not supported with MSE in worker
     expect(representationMP4A.isSupported).toBe(true);

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

@@ -1,3 +1,4 @@
+import type { IMediaElement } from "../../../compat/browser_compatibility_types";
 import isCodecSupported from "../../../compat/is_codec_supported";
 import type { IManifestMetadata } from "../../../manifest";
 import type Manifest from "../../../manifest/classes";
@@ -62,6 +63,7 @@ export function getCodecsWithUnknownSupport(
 export function updateManifestCodecSupport(
   manifest: IManifestMetadata,
   contentDecryptor: ContentDecryptor | null,
+  mediaElement: IMediaElement,
   isPlayingWithMSEinWorker: boolean,
 ): ICodecSupportInfo[] {
   const codecSupportMap: Map<
@@ -87,7 +89,7 @@ export function updateManifestCodecSupport(
     }
 
     let newData;
-    const isSupported = isCodecSupported(inputCodec);
+    const isSupported = isCodecSupported(mediaElement, inputCodec);
     if (!isSupported) {
       newData = {
         isSupportedClear: false,