CoreInterface and initializeWorkerMain are now part of the features o…

…bject

src/core/main/worker/index.ts

@@ -1,2 +1,4 @@
+import type { IMessageReceiverCallback } from "./worker_main";
 import initializeWorkerMain from "./worker_main";
 export default initializeWorkerMain;
+export type { IMessageReceiverCallback };

src/core/types.ts

@@ -7,6 +7,7 @@ import type {
   IManifestFetcherSettings,
   ISegmentQueueCreatorBackoffOptions,
 } from "./fetchers";
+import type { IMessageReceiverCallback } from "./main/worker";
 import type {
   IBufferedChunk,
   IBufferType,
@@ -48,4 +49,7 @@ export type {
   IStreamOrchestratorPlaybackObservation,
   IRepresentationsChoice,
   ITrackSwitchingMode,
+
+  // CoreMain
+  IMessageReceiverCallback,
 };

src/experimental/features/__tests__/local.test.ts

@@ -1,5 +1,7 @@
 import { describe, it, expect } from "vitest";
+import initializeWorkerMain from "../../../core/main/worker";
 import type { IFeaturesObject } from "../../../features/types";
+import { MonoThreadCoreInterface } from "../../../main_thread/core_interface/monothread";
 import MultiThreadContentInitializer from "../../../main_thread/init/multi_thread_content_initializer";
 import local from "../../../transports/local";
 import addLocalManifestFeature from "../local";
@@ -10,9 +12,16 @@ describe("Features list - LOCAL_MANIFEST", () => {
     addLocalManifestFeature(featureObject);
     expect(featureObject).toEqual({
       transports: { local },
-      mainThreadMediaSourceInit: MultiThreadContentInitializer,
+      monothread: {
+        init: MultiThreadContentInitializer,
+        coreInterface: MonoThreadCoreInterface,
+        workerMain: initializeWorkerMain,
+      },
     });
     expect(featureObject.transports.local).toBe(local);
-    expect(featureObject.mainThreadMediaSourceInit).toBe(MultiThreadContentInitializer);
+    expect(featureObject.monothread).not.toBe(null);
+    expect(featureObject.monothread?.init).toBe(MultiThreadContentInitializer);
+    expect(featureObject.monothread?.coreInterface).toBe(MonoThreadCoreInterface);
+    expect(featureObject.monothread?.workerMain).toBe(initializeWorkerMain);
   });
 });

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

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

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

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

src/experimental/features/local.ts

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

src/experimental/features/metaplaylist.ts

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

src/experimental/features/multi_thread.ts

@@ -1,12 +1,16 @@
 import type { IFeaturesObject } from "../../features/types";
+import { WorkerCoreInterface } from "../../main_thread/core_interface/multithread";
 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: MultiThreadContentInitializer };
+  features.multithread = {
+    init: MultiThreadContentInitializer,
+    coreInterface: WorkerCoreInterface,
+  };
 }
 
 export { addMultiThreadFeature as MULTI_THREAD };

src/features/features_object.ts

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

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

@@ -1,4 +1,6 @@
 import { describe, it, expect } from "vitest";
+import initializeWorkerMain from "../../../core/main/worker";
+import { MonoThreadCoreInterface } from "../../../main_thread/core_interface/monothread";
 import MultiThreadContentInitializer from "../../../main_thread/init/multi_thread_content_initializer";
 import nativeDashParser from "../../../parsers/manifest/dash/native-parser";
 import DASHFeature from "../../../transports/dash";
@@ -10,15 +12,22 @@ describe("Features list - DASH", () => {
     const featureObject = {
       transports: {},
       dashParsers: { fastJs: null, native: null, wasm: null },
-      mainThreadMediaSourceInit: null,
+      monothread: null,
     } as unknown as IFeaturesObject;
     addDASHFeature(featureObject);
     expect(featureObject).toEqual({
       transports: { dash: DASHFeature },
       dashParsers: { native: nativeDashParser, fastJs: null, wasm: null },
-      mainThreadMediaSourceInit: MultiThreadContentInitializer,
+      monothread: {
+        init: MultiThreadContentInitializer,
+        coreInterface: MonoThreadCoreInterface,
+        workerMain: initializeWorkerMain,
+      },
     });
     expect(featureObject.transports.dash).toBe(DASHFeature);
-    expect(featureObject.mainThreadMediaSourceInit).toBe(MultiThreadContentInitializer);
+    expect(featureObject.monothread).not.toBe(null);
+    expect(featureObject.monothread?.init).toBe(MultiThreadContentInitializer);
+    expect(featureObject.monothread?.coreInterface).toBe(MonoThreadCoreInterface);
+    expect(featureObject.monothread?.workerMain).toBe(initializeWorkerMain);
   });
 });

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

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

src/features/list/dash.ts

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

src/features/list/dash_wasm.ts

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