rx-player 4.4.1-dev.2025101500 → 4.4.1

package/src/experimental/features/__tests__/metaplaylist.test.ts

@@ -1,7 +1,5 @@
 import { describe, it, expect } from "vitest";
-import initializeCoreEntry from "../../../core/entry";
 import type { IFeaturesObject } from "../../../features/types";
-import { MonoThreadCoreInterface } from "../../../main_thread/core_interface/monothread";
 import MediaSourceContentInitializer from "../../../main_thread/init/media_source_content_initializer";
 import metaplaylist from "../../../transports/metaplaylist";
 import addLocalManifestFeature from "../metaplaylist";
@@ -12,16 +10,9 @@ describe("Features list - METAPLAYLIST", () => {
     addLocalManifestFeature(featureObject);
     expect(featureObject).toEqual({
       transports: { metaplaylist },
-      monothread: {
-        init: MediaSourceContentInitializer,
-        coreInterface: MonoThreadCoreInterface,
-        initializeCoreEntry,
-      },
+      mainThreadMediaSourceInit: MediaSourceContentInitializer,
     });
     expect(featureObject.transports.metaplaylist).toBe(metaplaylist);
-    expect(featureObject.monothread).not.toBe(null);
-    expect(featureObject.monothread?.init).toBe(MediaSourceContentInitializer);
-    expect(featureObject.monothread?.coreInterface).toBe(MonoThreadCoreInterface);
-    expect(featureObject.monothread?.initializeCoreEntry).toBe(initializeCoreEntry);
+    expect(featureObject.mainThreadMediaSourceInit).toBe(MediaSourceContentInitializer);
   });
 });

package/src/experimental/features/__tests__/multi_thread.test.ts

@@ -1,7 +1,6 @@
 import { describe, it, expect } from "vitest";
 import type { IFeaturesObject } from "../../../features/types";
-import { WorkerCoreInterface } from "../../../main_thread/core_interface/multithread";
-import MediaSourceContentInitializer from "../../../main_thread/init/media_source_content_initializer";
+import MultiThreadContentInitializer from "../../../main_thread/init/multi_thread_content_initializer";
 import addMultiThreadFeature from "../multi_thread";
 
 describe("Features list - EME", () => {
@@ -9,14 +8,10 @@ describe("Features list - EME", () => {
     const featureObject: IFeaturesObject = {} as IFeaturesObject;
     addMultiThreadFeature(featureObject);
     expect(featureObject).toEqual({
-      multithread: {
-        init: MediaSourceContentInitializer,
-        coreInterface: WorkerCoreInterface,
-      },
+      multithread: { init: MultiThreadContentInitializer },
     });
     expect(featureObject.multithread).not.toBe(null);
     expect(featureObject.multithread).not.toBe(undefined);
-    expect(featureObject.multithread?.init).toBe(MediaSourceContentInitializer);
-    expect(featureObject.multithread?.coreInterface).toBe(WorkerCoreInterface);
+    expect(featureObject.multithread?.init).toBe(MultiThreadContentInitializer);
   });
 });

package/src/experimental/features/local.ts

@@ -14,19 +14,13 @@
  * limitations under the License.
  */
 
-import initializeCoreEntry from "../../core/entry";
 import type { IFeaturesObject } from "../../features/types";
-import { MonoThreadCoreInterface } from "../../main_thread/core_interface/monothread";
 import MediaSourceContentInitializer from "../../main_thread/init/media_source_content_initializer";
 import local from "../../transports/local";
 
 function addLocalManifestFeature(features: IFeaturesObject): void {
   features.transports.local = local;
-  features.monothread = {
-    init: MediaSourceContentInitializer,
-    coreInterface: MonoThreadCoreInterface,
-    initializeCoreEntry,
-  };
+  features.mainThreadMediaSourceInit = MediaSourceContentInitializer;
 }
 
 export { addLocalManifestFeature as LOCAL_MANIFEST };

package/src/experimental/features/metaplaylist.ts

@@ -14,19 +14,13 @@
  * limitations under the License.
  */
 
-import initializeCoreEntry from "../../core/entry";
 import type { IFeaturesObject } from "../../features/types";
-import { MonoThreadCoreInterface } from "../../main_thread/core_interface/monothread";
 import MediaSourceContentInitializer from "../../main_thread/init/media_source_content_initializer";
 import metaplaylist from "../../transports/metaplaylist";
 
 function addMetaPlaylistFeature(features: IFeaturesObject): void {
   features.transports.metaplaylist = metaplaylist;
-  features.monothread = {
-    init: MediaSourceContentInitializer,
-    coreInterface: MonoThreadCoreInterface,
-    initializeCoreEntry,
-  };
+  features.mainThreadMediaSourceInit = MediaSourceContentInitializer;
 }
 
 export { addMetaPlaylistFeature as METAPLAYLIST };

package/src/experimental/features/multi_thread.ts

@@ -1,16 +1,12 @@
 import type { IFeaturesObject } from "../../features/types";
-import { WorkerCoreInterface } from "../../main_thread/core_interface/multithread";
-import MediaSourceContentInitializer from "../../main_thread/init/media_source_content_initializer";
+import MultiThreadContentInitializer from "../../main_thread/init/multi_thread_content_initializer";
 
 /**
  * Add ability to run the RxPlayer's main buffering logic in a WebMultiThread.
  * @param {Object} features
  */
 function addMultiThreadFeature(features: IFeaturesObject): void {
-  features.multithread = {
-    init: MediaSourceContentInitializer,
-    coreInterface: WorkerCoreInterface,
-  };
+  features.multithread = { init: MultiThreadContentInitializer };
 }
 
 export { addMultiThreadFeature as MULTI_THREAD };

package/src/features/features_object.ts

@@ -27,7 +27,7 @@ const features: IFeaturesObject = {
   decrypt: null,
   htmlTextDisplayer: null,
   htmlTextTracksParsers: {},
-  monothread: null,
+  mainThreadMediaSourceInit: null,
   multithread: null,
   nativeTextDisplayer: null,
   nativeTextTracksParsers: {},

package/src/features/list/__tests__/dash.test.ts

@@ -1,6 +1,4 @@
 import { describe, it, expect } from "vitest";
-import initializeCoreEntry from "../../../core/entry";
-import { MonoThreadCoreInterface } from "../../../main_thread/core_interface/monothread";
 import MediaSourceContentInitializer from "../../../main_thread/init/media_source_content_initializer";
 import dashJsParser from "../../../parsers/manifest/dash/js-parser";
 import DASHFeature from "../../../transports/dash";
@@ -12,22 +10,15 @@ describe("Features list - DASH", () => {
     const featureObject = {
       transports: {},
       dashParsers: { js: null, wasm: null },
-      monothread: null,
+      mainThreadMediaSourceInit: null,
     } as unknown as IFeaturesObject;
     addDASHFeature(featureObject);
     expect(featureObject).toEqual({
       transports: { dash: DASHFeature },
       dashParsers: { js: dashJsParser, wasm: null },
-      monothread: {
-        init: MediaSourceContentInitializer,
-        coreInterface: MonoThreadCoreInterface,
-        initializeCoreEntry,
-      },
+      mainThreadMediaSourceInit: MediaSourceContentInitializer,
     });
     expect(featureObject.transports.dash).toBe(DASHFeature);
-    expect(featureObject.monothread).not.toBe(null);
-    expect(featureObject.monothread?.init).toBe(MediaSourceContentInitializer);
-    expect(featureObject.monothread?.coreInterface).toBe(MonoThreadCoreInterface);
-    expect(featureObject.monothread?.initializeCoreEntry).toBe(initializeCoreEntry);
+    expect(featureObject.mainThreadMediaSourceInit).toBe(MediaSourceContentInitializer);
   });
 });

package/src/features/list/__tests__/smooth.test.ts

@@ -1,6 +1,4 @@
 import { describe, it, expect } from "vitest";
-import initializeCoreEntry from "../../../core/entry";
-import { MonoThreadCoreInterface } from "../../../main_thread/core_interface/monothread";
 import MediaSourceContentInitializer from "../../../main_thread/init/media_source_content_initializer";
 import SmoothFeature from "../../../transports/smooth";
 import type { IFeaturesObject } from "../../types";
@@ -12,16 +10,9 @@ describe("Features list - Smooth", () => {
     addSmoothFeature(featureObject);
     expect(featureObject).toEqual({
       transports: { smooth: SmoothFeature },
-      monothread: {
-        init: MediaSourceContentInitializer,
-        coreInterface: MonoThreadCoreInterface,
-        initializeCoreEntry,
-      },
+      mainThreadMediaSourceInit: MediaSourceContentInitializer,
     });
     expect(featureObject.transports.smooth).toBe(SmoothFeature);
-    expect(featureObject.monothread).not.toBe(null);
-    expect(featureObject.monothread?.init).toBe(MediaSourceContentInitializer);
-    expect(featureObject.monothread?.coreInterface).toBe(MonoThreadCoreInterface);
-    expect(featureObject.monothread?.initializeCoreEntry).toBe(initializeCoreEntry);
+    expect(featureObject.mainThreadMediaSourceInit).toBe(MediaSourceContentInitializer);
   });
 });

package/src/features/list/dash.ts

@@ -14,8 +14,6 @@
  * limitations under the License.
  */
 
-import initializeCoreEntry from "../../core/entry";
-import { MonoThreadCoreInterface } from "../../main_thread/core_interface/monothread";
 import MediaSourceContentInitializer from "../../main_thread/init/media_source_content_initializer";
 import dashJsParser from "../../parsers/manifest/dash/js-parser";
 import dash from "../../transports/dash";
@@ -30,11 +28,7 @@ function addDASHFeature(features: IFeaturesObject): void {
     features.transports.dash = dash;
   }
   features.dashParsers.js = dashJsParser;
-  features.monothread = {
-    init: MediaSourceContentInitializer,
-    coreInterface: MonoThreadCoreInterface,
-    initializeCoreEntry,
-  };
+  features.mainThreadMediaSourceInit = MediaSourceContentInitializer;
 }
 
 export { addDASHFeature as DASH };

package/src/features/list/dash_wasm.ts

@@ -14,9 +14,7 @@
  * limitations under the License.
  */
 
-import initializeCoreEntry from "../../core/entry";
 import type { IFeaturesObject } from "../../features/types";
-import { MonoThreadCoreInterface } from "../../main_thread/core_interface/monothread";
 import MediaSourceContentInitializer from "../../main_thread/init/media_source_content_initializer";
 import type { IDashWasmParserOptions } from "../../parsers/manifest/dash/wasm-parser";
 import DashWasmParser from "../../parsers/manifest/dash/wasm-parser";
@@ -29,11 +27,7 @@ const dashWasmFeature = {
       features.transports.dash = dash;
     }
     features.dashParsers.wasm = dashWasmParser;
-    features.monothread = {
-      init: MediaSourceContentInitializer,
-      coreInterface: MonoThreadCoreInterface,
-      initializeCoreEntry,
-    };
+    features.mainThreadMediaSourceInit = MediaSourceContentInitializer;
   },
 
   initialize(opts: IDashWasmParserOptions): Promise<void> {

package/src/features/list/media_source_main.ts

@@ -1,5 +1,3 @@
-import initializeCoreEntry from "../../core/entry";
-import { MonoThreadCoreInterface } from "../../main_thread/core_interface/monothread";
 import MediaSourceContentInitializer from "../../main_thread/init/media_source_content_initializer";
 import type { IFeaturesObject } from "../types";
 
@@ -8,11 +6,7 @@ import type { IFeaturesObject } from "../types";
  * @param {Object} features
  */
 function addMediaSourceMainFeature(features: IFeaturesObject): void {
-  features.monothread = {
-    init: MediaSourceContentInitializer,
-    coreInterface: MonoThreadCoreInterface,
-    initializeCoreEntry,
-  };
+  features.mainThreadMediaSourceInit = MediaSourceContentInitializer;
 }
 
 export { addMediaSourceMainFeature as MEDIA_SOURCE_MAIN };

package/src/features/list/smooth.ts

@@ -14,8 +14,6 @@
  * limitations under the License.
  */
 
-import initializeCoreEntry from "../../core/entry";
-import { MonoThreadCoreInterface } from "../../main_thread/core_interface/monothread";
 import MediaSourceContentInitializer from "../../main_thread/init/media_source_content_initializer";
 import smooth from "../../transports/smooth";
 import type { IFeaturesObject } from "../types";
@@ -28,11 +26,7 @@ function addSmoothFeature(features: IFeaturesObject): void {
   if (features.transports.smooth === undefined) {
     features.transports.smooth = smooth;
   }
-  features.monothread = {
-    init: MediaSourceContentInitializer,
-    coreInterface: MonoThreadCoreInterface,
-    initializeCoreEntry,
-  };
+  features.mainThreadMediaSourceInit = MediaSourceContentInitializer;
 }
 
 export { addSmoothFeature as SMOOTH };

package/src/features/types.ts

@@ -15,15 +15,11 @@
  */
 
 import type { IMediaElement } from "../compat/browser_compatibility_types";
-import type IInitializeCoreEntry from "../core/entry";
 import type { SegmentSink } from "../core/segment_sinks";
-import type {
-  WorkerCoreInterface,
-  MonoThreadCoreInterface,
-} from "../main_thread/core_interface/types";
 import type ContentDecryptor from "../main_thread/decrypt";
 import type DirectFileContentInitializer from "../main_thread/init/directfile_content_initializer";
 import type MediaSourceContentInitializer from "../main_thread/init/media_source_content_initializer";
+import type MultiThreadContentInitializer from "../main_thread/init/multi_thread_content_initializer";
 import type HTMLTextDisplayer from "../main_thread/text_displayer/html";
 import type NativeTextDisplayer from "../main_thread/text_displayer/native/native_text_displayer";
 import type MediaElementTracksStore from "../main_thread/tracks_store/media_element_tracks_store";
@@ -118,29 +114,14 @@ export interface IFeaturesObject {
    * Feature allowing to load contents through MediaSource API through the
    * main thread.
    */
-  monothread: {
-    /** Class to load a content through the MediaSource API. */
-    init: typeof MediaSourceContentInitializer;
-    /** The RxPlayer's core logic. */
-    initializeCoreEntry: typeof IInitializeCoreEntry;
-    /**
-     * Class allowing to exchange messages with the RxPlayer's `core`, here
-     * running in `coreEntry`
-     */
-    coreInterface: typeof MonoThreadCoreInterface;
-  } | null;
+  mainThreadMediaSourceInit: typeof MediaSourceContentInitializer | null;
   /**
    * Features allowing to load contents through MediaSource API through
    * a WebWorker.
    */
   multithread: {
-    /** Class to load a content through the MediaSource API. */
-    init: typeof MediaSourceContentInitializer;
-    /**
-     * Class allowing to exchange messages with the RxPlayer's `core`, here
-     * running in another thread.
-     */
-    coreInterface: typeof WorkerCoreInterface;
+    /** Class to load a content through MediaSource API via a WebWorker. */
+    init: typeof MultiThreadContentInitializer;
   } | null;
   /**
    * Function for loading and parsing contents through various protocols, by

package/src/main_thread/README.md

@@ -27,14 +27,6 @@ Those modules are:
   Negotiate content decryption. Only used for contents with DRM (Digital Right
   Management).
 
-- **the `CoreInterface` (./core_interface)**
-
-  Provide an interface allowing to communicate to the central RxPlayer logic in the `core`
-  directory (`../core/`), which may run in another thread.
-
-  That interface depends on the context (e.g. depending on if we are playing in a
-  mono-threaded mode or a multithreaded mode).
-
 - **the `TracksStore` (or `MediaElementTracksStore`) (./tracks_store)**
 
   Ease up text/audio/video track switching to provide a simple-to-use API.

package/src/main_thread/api/public_api.ts

@@ -38,9 +38,7 @@ import type {
   IInbandEvent,
   IABRThrottlers,
   IBufferType,
-  ICoreMessage,
 } from "../../core/types";
-import { CoreMessageType } from "../../core/types";
 import type { IDefaultConfig } from "../../default_config";
 import type { IErrorCode, IErrorType } from "../../errors";
 import { ErrorCodes, ErrorTypes, formatError, MediaError } from "../../errors";
@@ -62,10 +60,13 @@ import {
   getMaximumSafePosition,
   getMinimumSafePosition,
   ManifestMetadataFormat,
+  createRepresentationFilterFromFnString,
   getPeriodForTime,
   toVideoRepresentation,
   toAudioRepresentation,
 } from "../../manifest";
+import type { IWorkerMessage } from "../../multithread_types";
+import { MainThreadMessageType, WorkerMessageType } from "../../multithread_types";
 import type { IPlaybackObservation } from "../../playback_observer";
 import MediaElementPlaybackObserver from "../../playback_observer/media_element_playback_observer";
 import type {
@@ -132,7 +133,6 @@ import type { ContentInitializer } from "../init";
 import renderThumbnail from "../render_thumbnail";
 import type { IMediaElementTracksStore, ITSPeriodObject } from "../tracks_store";
 import TracksStore from "../tracks_store";
-import { MainThreadMessageType } from "../types";
 import type { IParsedLoadVideoOptions, IParsedStartAtOption } from "./option_utils";
 import {
   checkReloadOptions,
@@ -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.1-dev.2025101500";
+    this.version = /* PLAYER_VERSION */ "4.4.1";
     this.log = log;
     this.state = "STOPPED";
     this.videoElement = videoElement;
@@ -572,8 +572,8 @@ class Player extends EventEmitter<IPublicAPIEvent> {
         );
       };
       const handleInitMessages = (msg: MessageEvent) => {
-        const msgData = msg.data as unknown as ICoreMessage;
-        if (msgData.type === CoreMessageType.InitError) {
+        const msgData = msg.data as unknown as IWorkerMessage;
+        if (msgData.type === WorkerMessageType.InitError) {
           log.warn("API", "Processing InitError worker message: detaching worker");
           if (this._priv_worker !== null) {
             this._priv_worker.removeEventListener("message", handleInitMessages);
@@ -586,7 +586,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
               "Worker parser initialization failed: " + msgData.value.errorMessage,
             ),
           );
-        } else if (msgData.type === CoreMessageType.InitSuccess) {
+        } else if (msgData.type === WorkerMessageType.InitSuccess) {
           log.info("API", "InitSuccess received from worker.");
           if (this._priv_worker !== null) {
             this._priv_worker.removeEventListener("message", handleInitMessages);
@@ -1034,19 +1034,6 @@ class Player extends EventEmitter<IPublicAPIEvent> {
         connectionTimeout: requestConfig.segment?.connectionTimeout,
       };
 
-      const transportOptions = {
-        lowLatencyMode,
-        checkMediaSegmentIntegrity,
-        checkManifestIntegrity,
-        referenceDateTime,
-        serverSyncInfos,
-        manifestLoader,
-        segmentLoader,
-        representationFilter: options.representationFilter,
-        __priv_manifestUpdateUrl,
-        __priv_patchLastSegmentInSidx,
-      };
-
       const canRunInMultiThread =
         features.multithread !== null &&
         this._priv_worker !== null &&
@@ -1057,33 +1044,39 @@ class Player extends EventEmitter<IPublicAPIEvent> {
         ) &&
         typeof options.representationFilter !== "function";
       if (mode === "main" || (mode === "auto" && !canRunInMultiThread)) {
-        if (features.monothread === null) {
+        if (features.mainThreadMediaSourceInit === null) {
           throw new Error(
             "Cannot load video, neither in a WebWorker nor with the " +
               "`MEDIA_SOURCE_MAIN` feature",
           );
         }
+        const transportFn = features.transports[transport];
+        if (typeof transportFn !== "function") {
+          // Stop previous content and reset its state
+          this.stop();
+          this._priv_currentError = null;
+          throw new Error(`transport "${transport}" not supported`);
+        }
+
+        const representationFilter =
+          typeof options.representationFilter === "string"
+            ? createRepresentationFilterFromFnString(options.representationFilter)
+            : options.representationFilter;
+
         log.info("API", "Initializing MediaSource mode in the main thread");
-        const coreInterface = new features.monothread.coreInterface();
-        const coreInterfaceCallbacks = coreInterface.getCallbacks();
-        features.monothread.initializeCoreEntry(
-          coreInterfaceCallbacks.setCoreMessageReceiver,
-          coreInterfaceCallbacks.sendCoreMessage,
-        );
-        coreInterface.sendMessage({
-          type: MainThreadMessageType.Init,
-          value: {
-            dashWasmUrl: undefined,
-            hasVideo: this.videoElement?.nodeName.toLowerCase() === "video",
-            logLevel: log.getLevel(),
-            logFormat: log.getFormat(),
-            sendBackLogs: false,
-            date: Date.now(),
-            timestamp: getMonotonicTimeStamp(),
-          },
+        const transportPipelines = transportFn({
+          lowLatencyMode,
+          checkMediaSegmentIntegrity,
+          checkManifestIntegrity,
+          manifestLoader,
+          referenceDateTime,
+          representationFilter,
+          segmentLoader,
+          serverSyncInfos,
+          __priv_manifestUpdateUrl,
+          __priv_patchLastSegmentInSidx,
         });
-        initializer = new features.monothread.init({
-          coreInterface,
+        initializer = new features.mainThreadMediaSourceInit({
           adaptiveOptions,
           autoPlay,
           bufferOptions,
@@ -1092,15 +1085,13 @@ class Player extends EventEmitter<IPublicAPIEvent> {
             experimentalOptions.enableRepresentationAvoidance,
           keySystems,
           lowLatencyMode,
-          transport,
-          transportOptions,
+          transport: transportPipelines,
           manifestRequestSettings,
           segmentRequestOptions,
           speed: this._priv_speed,
           startAt,
           textTrackOptions,
           url,
-          useMseInWorker: false,
         });
       } else {
         if (features.multithread === null) {
@@ -1117,8 +1108,19 @@ class Player extends EventEmitter<IPublicAPIEvent> {
         assert(typeof options.representationFilter !== "function");
         useWorker = true;
         log.info("API", "Initializing MediaSource mode in a WebWorker");
+        const transportOptions = {
+          lowLatencyMode,
+          checkMediaSegmentIntegrity,
+          checkManifestIntegrity,
+          referenceDateTime,
+          serverSyncInfos,
+          manifestLoader: undefined,
+          segmentLoader: undefined,
+          representationFilter: options.representationFilter,
+          __priv_manifestUpdateUrl,
+          __priv_patchLastSegmentInSidx,
+        };
         initializer = new features.multithread.init({
-          coreInterface: new features.multithread.coreInterface(this._priv_worker),
           adaptiveOptions,
           autoPlay,
           bufferOptions,
@@ -1127,13 +1129,13 @@ class Player extends EventEmitter<IPublicAPIEvent> {
             experimentalOptions.enableRepresentationAvoidance,
           keySystems,
           lowLatencyMode,
-          transport,
           transportOptions,
           manifestRequestSettings,
           segmentRequestOptions,
           speed: this._priv_speed,
           startAt,
           textTrackOptions,
+          worker: this._priv_worker,
           url,
           useMseInWorker: hasMseInWorker,
         });
@@ -1164,7 +1166,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     }
 
     /** Global "playback observer" which will emit playback conditions */
-    const playbackObserver = new MediaElementPlaybackObserver(videoElement, {
+    const playbackObserver = new MediaElementPlaybackObserver({
       withMediaSource: !isDirectFile,
       lowLatencyMode,
     });
@@ -1287,6 +1289,8 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     //     content.
     this.stop();
 
+    playbackObserver.attachMediaElement(videoElement);
+
     // Update the RxPlayer's state at the right events
     const playerStateRef = constructPlayerStateReference(
       initializer,
@@ -3574,7 +3578,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     }
   }
 }
-Player.version = /* PLAYER_VERSION */ "4.4.1-dev.2025101500";
+Player.version = /* PLAYER_VERSION */ "4.4.1";
 
 /** Every events sent by the RxPlayer's public API. */
 interface IPublicAPIEvent {