Feat: Config

demo/src/App.tsx

@@ -158,7 +158,7 @@ function App() {
     if (!videoRef.current || !hlsEngine.current) return;
     const engine = hlsEngine.current;
     const hls = new window.Hls({
-      ...engine.getConfig(),
+      ...engine.getHlsConfig(),
     });
 
     engine.setHls(hls);
@@ -178,7 +178,7 @@ function App() {
         type: "customHls",
         customType: {
           customHls: (video: HTMLVideoElement) => {
-            const hls = new window.Hls(engine.getConfig());
+            const hls = new window.Hls(engine.getHlsConfig());
             engine.setHls(hls);
             hls.loadSource(url);
             hls.attachMedia(video);
@@ -202,7 +202,7 @@ function App() {
       source: url,
       playback: {
         hlsjsConfig: {
-          ...engine.getConfig(),
+          ...engine.getHlsConfig(),
         },
       },
       plugins: [window.LevelSelector],

packages/p2p-media-loader-core/src/core.ts

@@ -3,23 +3,25 @@ import {
   Stream,
   StreamWithSegments,
   Segment,
-  Settings,
+  CoreConfig,
   SegmentBase,
   BandwidthCalculators,
   StreamDetails,
   CoreEventMap,
+  DynamicConfig,
 } from "./types";
 import * as StreamUtils from "./utils/stream";
 import { BandwidthCalculator } from "./bandwidth-calculator";
 import { EngineCallbacks } from "./requests/engine-request";
 import { SegmentsMemoryStorage } from "./segments-storage";
 import { EventEmitter } from "./utils/event-emitter";
+import { deepConfigMerge } from "./utils/utils";
 
 export class Core<TStream extends Stream = Stream> {
   private readonly eventEmitter = new EventEmitter<CoreEventMap>();
   private manifestResponseUrl?: string;
   private readonly streams = new Map<string, StreamWithSegments<TStream>>();
-  private readonly settings: Settings = {
+  private config: CoreConfig = {
     simultaneousHttpDownloads: 3,
     simultaneousP2PDownloads: 3,
     highDemandTimeWindow: 15,
@@ -46,7 +48,18 @@ export class Core<TStream extends Stream = Stream> {
     activeLevelBitrate: 0,
   };
 
-  constructor() {}
+  constructor(config?: CoreConfig) {
+    this.applyConfig(config);
+  }
+
+  private applyConfig(config?: CoreConfig) {
+    if (!config) return;
+    this.config = deepConfigMerge(this.config, config);
+  }
+
+  applyDynamicConfig(dynamicConfig: DynamicConfig) {
+    this.config = deepConfigMerge(this.config, dynamicConfig);
+  }
 
   addEventListener<K extends keyof CoreEventMap>(
     eventName: K,
@@ -110,7 +123,7 @@ export class Core<TStream extends Stream = Stream> {
     if (!this.segmentStorage) {
       this.segmentStorage = new SegmentsMemoryStorage(
         this.manifestResponseUrl,
-        this.settings,
+        this.config,
       );
       await this.segmentStorage.initialize();
     }
@@ -183,7 +196,7 @@ export class Core<TStream extends Stream = Stream> {
         manifestResponseUrl,
         segment,
         this.streamDetails,
-        this.settings,
+        this.config,
         this.bandwidthCalculators,
         this.segmentStorage,
         this.eventEmitter,

packages/p2p-media-loader-core/src/http-loader.ts

@@ -1,10 +1,10 @@
-import { CoreEventMap, Settings } from "./types";
+import { CoreEventMap, CoreConfig } from "./types";
 import { Request as SegmentRequest, RequestControls } from "./requests/request";
 import { RequestError, HttpRequestErrorType } from "./types";
 import { EventEmitter } from "./utils/event-emitter";
 
-type HttpSettings = Pick<
-  Settings,
+type HttpConfig = Pick<
+  CoreConfig,
   "httpNotReceivingBytesTimeoutMs" | "httpRequestSetup"
 >;
 
@@ -17,7 +17,7 @@ export class HttpRequestExecutor {
 
   constructor(
     private readonly request: SegmentRequest,
-    private readonly settings: HttpSettings,
+    private readonly httpConfig: HttpConfig,
     eventEmitter: EventEmitter<CoreEventMap>,
   ) {
     this.onChunkDownloaded =
@@ -36,7 +36,7 @@ export class HttpRequestExecutor {
         this.request.totalBytes - this.request.loadedBytes;
     }
 
-    const { httpNotReceivingBytesTimeoutMs } = this.settings;
+    const { httpNotReceivingBytesTimeoutMs } = this.httpConfig;
     this.requestControls = this.request.start(
       { downloadSource: "http" },
       {
@@ -50,7 +50,7 @@ export class HttpRequestExecutor {
   private async fetch() {
     const { segment } = this.request;
     try {
-      let request = await this.settings.httpRequestSetup?.(
+      let request = await this.httpConfig.httpRequestSetup?.(
         segment.url,
         segment.byteRange,
         this.abortController.signal,

packages/p2p-media-loader-core/src/hybrid-loader.ts

@@ -2,7 +2,7 @@ import { Segment, StreamWithSegments } from "./index";
 import { HttpRequestExecutor } from "./http-loader";
 import { SegmentsMemoryStorage } from "./segments-storage";
 import {
-  Settings,
+  CoreConfig,
   Playback,
   BandwidthCalculators,
   StreamDetails,
@@ -38,7 +38,7 @@ export class HybridLoader {
     private streamManifestUrl: string,
     private lastRequestedSegment: Readonly<Segment>,
     private readonly streamDetails: Required<Readonly<StreamDetails>>,
-    private readonly settings: Settings,
+    private readonly config: CoreConfig,
     private readonly bandwidthCalculators: BandwidthCalculators,
     private readonly segmentStorage: SegmentsMemoryStorage,
     private readonly eventEmitter: EventEmitter<CoreEventMap>,
@@ -50,7 +50,7 @@ export class HybridLoader {
       this.requestProcessQueueMicrotask,
       this.bandwidthCalculators,
       this.playback,
-      this.settings,
+      this.config,
       this.eventEmitter,
     );
 
@@ -62,15 +62,15 @@ export class HybridLoader {
       return StreamUtils.isSegmentActualInPlayback(
         segment,
         this.playback,
-        this.settings,
+        this.config,
       );
     });
     this.p2pLoaders = new P2PLoadersContainer(
       this.streamManifestUrl,
       this.lastRequestedSegment.stream,
       this.requests,
       this.segmentStorage,
-      this.settings,
+      this.config,
       this.eventEmitter,
     );
 
@@ -139,7 +139,7 @@ export class HybridLoader {
     queueDownloadRatio: number,
   ) {
     const { stream } = this.lastRequestedSegment;
-    const { httpErrorRetries } = this.settings;
+    const { httpErrorRetries } = this.config;
     const now = performance.now();
     for (const request of this.requests.items()) {
       const {
@@ -221,7 +221,7 @@ export class HybridLoader {
       simultaneousHttpDownloads,
       simultaneousP2PDownloads,
       httpErrorRetries,
-    } = this.settings;
+    } = this.config;
 
     if (
       this.engineRequest?.shouldBeStartedImmediately &&
@@ -236,7 +236,7 @@ export class HybridLoader {
         request.status === "not-started" ||
         (request.status === "failed" &&
           request.failedAttempts.httpAttemptsCount <
-            this.settings.httpErrorRetries)
+            this.config.httpErrorRetries)
       ) {
         void this.loadThroughHttp(segment);
       }
@@ -325,7 +325,7 @@ export class HybridLoader {
 
   private loadThroughHttp(segment: Segment) {
     const request = this.requests.getOrCreateRequest(segment);
-    new HttpRequestExecutor(request, this.settings, this.eventEmitter);
+    new HttpRequestExecutor(request, this.config, this.eventEmitter);
     this.p2pLoaders.currentLoader.broadcastAnnouncement();
   }
 
@@ -334,7 +334,7 @@ export class HybridLoader {
   }
 
   private loadRandomThroughHttp() {
-    const { simultaneousHttpDownloads, httpErrorRetries } = this.settings;
+    const { simultaneousHttpDownloads, httpErrorRetries } = this.config;
     const p2pLoader = this.p2pLoaders.currentLoader;
 
     if (
@@ -348,7 +348,7 @@ export class HybridLoader {
     for (const { segment, statuses } of QueueUtils.generateQueue(
       this.lastRequestedSegment,
       this.playback,
-      this.settings,
+      this.config,
     )) {
       if (
         !statuses.isHttpDownloadable ||
@@ -417,7 +417,7 @@ export class HybridLoader {
     for (const item of QueueUtils.generateQueue(
       this.lastRequestedSegment,
       this.playback,
-      this.settings,
+      this.config,
     )) {
       maxPossibleLength++;
       const { segment } = item;

packages/p2p-media-loader-core/src/p2p/loader.ts

@@ -1,5 +1,10 @@
 import { Peer } from "./peer";
-import { CoreEventMap, Segment, Settings, StreamWithSegments } from "../types";
+import {
+  CoreEventMap,
+  Segment,
+  CoreConfig,
+  StreamWithSegments,
+} from "../types";
 import { SegmentsMemoryStorage } from "../segments-storage";
 import { RequestsContainer } from "../requests/request-container";
 import { Request } from "../requests/request";
@@ -17,7 +22,7 @@ export class P2PLoader {
     private readonly stream: StreamWithSegments,
     private readonly requests: RequestsContainer,
     private readonly segmentStorage: SegmentsMemoryStorage,
-    private readonly settings: Settings,
+    private readonly config: CoreConfig,
     eventEmmiter: EventEmitter<CoreEventMap>,
   ) {
     const streamExternalId = StreamUtils.getStreamExternalId(
@@ -33,7 +38,7 @@ export class P2PLoader {
         // eslint-disable-next-line @typescript-eslint/no-misused-promises
         onSegmentRequested: this.onSegmentRequested,
       },
-      this.settings,
+      this.config,
       eventEmmiter,
     );
 

packages/p2p-media-loader-core/src/p2p/loaders-container.ts

@@ -1,6 +1,6 @@
 import { P2PLoader } from "./loader";
 import debug from "debug";
-import { CoreEventMap, Settings, Stream, StreamWithSegments } from "../index";
+import { CoreEventMap, CoreConfig, Stream, StreamWithSegments } from "../index";
 import { RequestsContainer } from "../requests/request-container";
 import { SegmentsMemoryStorage } from "../segments-storage";
 import * as LoggerUtils from "../utils/logger";
@@ -23,7 +23,7 @@ export class P2PLoadersContainer {
     stream: StreamWithSegments,
     private readonly requests: RequestsContainer,
     private readonly segmentStorage: SegmentsMemoryStorage,
-    private readonly settings: Settings,
+    private readonly config: CoreConfig,
     private readonly eventEmmiter: EventEmitter<CoreEventMap>,
   ) {
     this.changeCurrentLoader(stream);
@@ -38,7 +38,7 @@ export class P2PLoadersContainer {
       stream,
       this.requests,
       this.segmentStorage,
-      this.settings,
+      this.config,
       this.eventEmmiter,
     );
     const loggerInfo = LoggerUtils.getStreamString(stream);
@@ -76,7 +76,7 @@ export class P2PLoadersContainer {
   private setLoaderDestroyTimeout(item: P2PLoaderContainerItem) {
     item.destroyTimeoutId = window.setTimeout(
       () => this.destroyAndRemoveLoader(item),
-      this.settings.p2pLoaderDestroyTimeoutMs,
+      this.config.p2pLoaderDestroyTimeoutMs,
     );
   }
 

packages/p2p-media-loader-core/src/p2p/peer-protocol.ts

@@ -1,11 +1,11 @@
 import { PeerConnection } from "bittorrent-tracker";
-import { CoreEventMap, Settings } from "../types";
+import { CoreEventMap, CoreConfig } from "../types";
 import * as Utils from "../utils/utils";
 import * as Command from "./commands";
 import { EventEmitter } from "../utils/event-emitter";
 
-export type PeerSettings = Pick<
-  Settings,
+export type PeerConfig = Pick<
+  CoreConfig,
   | "p2pNotReceivingBytesTimeoutMs"
   | "webRtcMaxMessageSize"
   | "p2pErrorRetries"
@@ -20,7 +20,7 @@ export class PeerProtocol {
 
   constructor(
     private readonly connection: PeerConnection,
-    private readonly settings: PeerSettings,
+    private readonly peerConfig: PeerConfig,
     private readonly eventHandlers: {
       onCommandReceived: (command: Command.PeerCommand) => void;
       onSegmentChunkReceived: (data: Uint8Array) => void;
@@ -46,7 +46,7 @@ export class PeerProtocol {
   sendCommand(command: Command.PeerCommand) {
     const binaryCommandBuffers = Command.serializePeerCommand(
       command,
-      this.settings.webRtcMaxMessageSize,
+      this.peerConfig.webRtcMaxMessageSize,
     );
     for (const buffer of binaryCommandBuffers) {
       this.connection.send(buffer);
@@ -62,7 +62,7 @@ export class PeerProtocol {
     if (this.uploadingContext) {
       throw new Error(`Some segment data is already uploading.`);
     }
-    const chunks = getBufferChunks(data, this.settings.webRtcMaxMessageSize);
+    const chunks = getBufferChunks(data, this.peerConfig.webRtcMaxMessageSize);
     const channel = this.connection._channel;
     const { promise, resolve, reject } = Utils.getControlledPromise<void>();