rx-player 4.1.0 → 4.2.0-dev.2024080600

package/src/core/fetchers/segment/segment_fetcher.ts

@@ -29,7 +29,9 @@ import type { ICdnMetadata } from "../../../parsers/manifest";
 import type { IPlayerError } from "../../../public_types";
 import type {
   IChunkCompleteInformation,
+  ISegmentContext,
   ISegmentLoader,
+  ISegmentLoaderOptions,
   ISegmentLoadingProgressInformation,
   ISegmentParserParsedInitChunk,
   ISegmentParserParsedMediaChunk,
@@ -48,6 +50,7 @@ import type {
   IRequestEndCallbackPayload,
   IRequestProgressCallbackPayload,
 } from "../../adaptive";
+import type CmcdDataBuilder from "../../cmcd";
 import type { IBufferType } from "../../segment_sinks";
 import type CdnPrioritizer from "../cdn_prioritizer";
 import errorSelector from "../utils/error_selector";
@@ -61,42 +64,36 @@ const generateRequestID = idGenerator();
  * Create an `ISegmentFetcher` object which will allow to easily fetch and parse
  * segments.
  * An `ISegmentFetcher` also implements a retry mechanism, based on the given
- * `options` argument, which may retry a segment request when it fails.
+ * `requestOptions` argument, which may retry a segment request when it fails.
  *
- * @param {string} bufferType - Type of  buffer concerned (e.g. `"audio"`,
- * `"video"`, `"text" etc.)
- * @param {Object} pipeline - The transport-specific logic allowing to load
- * segments of the given buffer type and transport protocol (e.g. DASH).
- * @param {Object|null} cdnPrioritizer - Abstraction allowing to synchronize,
- * update and keep track of the priorization of the CDN to use to load any given
- * segment, in cases where multiple ones are available.
- *
- * Can be set to `null` in which case a minimal priorization logic will be used
- * instead.
- * @param {Object} lifecycleCallbacks - Callbacks that can be registered to be
- * informed when new requests are made, ended, new metrics are available etc.
- * This should be mainly useful to implement an adaptive logic relying on those
- * metrics and events.
- * @param {Object} options - Various tweaking options allowing to configure the
- * behavior of the returned `ISegmentFetcher`.
+ * @param {Object} args
  * @returns {Function}
  */
-export default function createSegmentFetcher<TLoadedFormat, TSegmentDataType>(
-  bufferType: IBufferType,
-  pipeline: ISegmentPipeline<TLoadedFormat, TSegmentDataType>,
-  cdnPrioritizer: CdnPrioritizer | null,
-  lifecycleCallbacks: ISegmentFetcherLifecycleCallbacks,
-  options: ISegmentFetcherOptions,
-): ISegmentFetcher<TSegmentDataType> {
+export default function createSegmentFetcher<TLoadedFormat, TSegmentDataType>({
+  bufferType,
+  pipeline,
+  cdnPrioritizer,
+  cmcdDataBuilder,
+  eventListeners,
+  requestOptions,
+}: ISegmentFetcherArguments<
+  TLoadedFormat,
+  TSegmentDataType
+>): ISegmentFetcher<TSegmentDataType> {
   let connectionTimeout;
-  if (options.connectionTimeout === undefined || options.connectionTimeout < 0) {
+  if (
+    requestOptions.connectionTimeout === undefined ||
+    requestOptions.connectionTimeout < 0
+  ) {
     connectionTimeout = undefined;
   } else {
-    connectionTimeout = options.connectionTimeout;
+    connectionTimeout = requestOptions.connectionTimeout;
   }
-  const requestOptions = {
-    timeout: options.requestTimeout < 0 ? undefined : options.requestTimeout,
+  const pipelineRequestOptions: ISegmentLoaderOptions = {
+    timeout:
+      requestOptions.requestTimeout < 0 ? undefined : requestOptions.requestTimeout,
     connectionTimeout,
+    cmcdPayload: undefined,
   };
 
   /**
@@ -160,7 +157,7 @@ export default function createSegmentFetcher<TLoadedFormat, TSegmentDataType>(
     let metricsSent = false;
 
     /** Segment context given to the transport pipelines. */
-    const context = {
+    const context: ISegmentContext = {
       segment,
       type: adaptation.type,
       language: adaptation.language,
@@ -183,7 +180,7 @@ export default function createSegmentFetcher<TLoadedFormat, TSegmentDataType>(
           return; // request already termminated
         }
         if (info.totalSize !== undefined && info.size < info.totalSize) {
-          lifecycleCallbacks.onProgress?.({
+          eventListeners.onProgress?.({
             duration: info.duration,
             size: info.size,
             totalSize: info.totalSize,
@@ -213,7 +210,7 @@ export default function createSegmentFetcher<TLoadedFormat, TSegmentDataType>(
     }
 
     log.debug("SF: Beginning request", segmentIdString);
-    lifecycleCallbacks.onRequestBegin?.({
+    eventListeners.onRequestBegin?.({
       requestTimestamp: getTimestamp(),
       id: requestId,
       content,
@@ -226,7 +223,7 @@ export default function createSegmentFetcher<TLoadedFormat, TSegmentDataType>(
         content.representation.cdnMetadata,
         cdnPrioritizer,
         callLoaderWithUrl,
-        objectAssign({ onRetry }, options),
+        objectAssign({ onRetry }, requestOptions),
         cancellationSignal,
       );
 
@@ -254,7 +251,7 @@ export default function createSegmentFetcher<TLoadedFormat, TSegmentDataType>(
         // The current task could have been canceled as a result of one
         // of the previous callbacks call. In that case, we don't want to send
         // a "requestEnd" again as it has already been sent on cancellation.
-        lifecycleCallbacks.onRequestEnd?.({ id: requestId });
+        eventListeners.onRequestEnd?.({ id: requestId });
       }
       cancellationSignal.deregister(onCancellation);
     } catch (err) {
@@ -265,7 +262,7 @@ export default function createSegmentFetcher<TLoadedFormat, TSegmentDataType>(
         throw err;
       }
       log.debug("SF: Segment request failed", segmentIdString);
-      lifecycleCallbacks.onRequestEnd?.({ id: requestId });
+      eventListeners.onRequestEnd?.({ id: requestId });
       throw errorSelector(err);
     }
 
@@ -275,7 +272,7 @@ export default function createSegmentFetcher<TLoadedFormat, TSegmentDataType>(
       }
       log.debug("SF: Segment request cancelled", segmentIdString);
       requestInfo = null;
-      lifecycleCallbacks.onRequestEnd?.({ id: requestId });
+      eventListeners.onRequestEnd?.({ id: requestId });
     }
 
     /**
@@ -286,10 +283,12 @@ export default function createSegmentFetcher<TLoadedFormat, TSegmentDataType>(
     function callLoaderWithUrl(
       cdnMetadata: ICdnMetadata | null,
     ): ReturnType<ISegmentLoader<TLoadedFormat>> {
+      pipelineRequestOptions.cmcdPayload =
+        cmcdDataBuilder?.getCmcdDataForSegmentRequest(content);
       return loadSegment(
         cdnMetadata,
         context,
-        requestOptions,
+        pipelineRequestOptions,
         cancellationSignal,
         loaderCallbacks,
       );
@@ -367,7 +366,7 @@ export default function createSegmentFetcher<TLoadedFormat, TSegmentDataType>(
         parsedChunks.every((isParsed) => isParsed)
       ) {
         metricsSent = true;
-        lifecycleCallbacks.onMetrics?.({
+        eventListeners.onMetrics?.({
           size: requestInfo.size,
           requestDuration: requestInfo.requestDuration,
           content,
@@ -458,7 +457,7 @@ export interface ISegmentFetcherLifecycleCallbacks {
   onMetrics?: (arg: IMetricsCallbackPayload) => void;
 }
 
-/** Options allowing to configure an `ISegmentFetcher`'s behavior. */
+/** requestOptions allowing to configure an `ISegmentFetcher`'s behavior. */
 export interface ISegmentFetcherOptions {
   /**
    * Initial delay to wait if a request fails before making a new request, in
@@ -476,7 +475,7 @@ export interface ISegmentFetcherOptions {
    */
   maxRetry: number;
   /**
-   * Timeout after which request are aborted and, depending on other options,
+   * Timeout after which request are aborted and, depending on other requestOptions,
    * retried.
    * To set to `-1` for no timeout.
    */
@@ -490,11 +489,10 @@ export interface ISegmentFetcherOptions {
 }
 
 /**
- * @param {string} bufferType
- * @param {Object}
+ * @param {Object} baseOptions
  * @returns {Object}
  */
-export function getSegmentFetcherOptions({
+export function getSegmentFetcherRequestOptions({
   maxRetry,
   lowLatencyMode,
   requestTimeout,
@@ -526,3 +524,39 @@ export function getSegmentFetcherOptions({
       connectionTimeout === undefined ? DEFAULT_CONNECTION_TIMEOUT : connectionTimeout,
   };
 }
+
+export interface ISegmentFetcherArguments<TLoadedFormat, TSegmentDataType> {
+  /** Type of  buffer concerned (e.g. `"audio"`, `"video"`, `"text" etc.) */
+  bufferType: IBufferType;
+  /**
+   * The transport-specific logic allowing to load segments of the given buffer
+   * type and transport protocol (e.g. DASH).
+   */
+  pipeline: ISegmentPipeline<TLoadedFormat, TSegmentDataType>;
+  /**
+   * Abstraction allowing to synchronize, update and keep track of the
+   * priorization of the CDN to use to load any given segment, in cases where
+   * multiple ones are available.
+   *
+   * Can be set to `null` in which case a minimal priorization logic will be used
+   * instead.
+   */
+  cdnPrioritizer: CdnPrioritizer | null;
+  /**
+   * Optional module allowing to collect "Common Media Client Data" (a.k.a. CMCD)
+   * for the CDN.
+   */
+  cmcdDataBuilder: CmcdDataBuilder | null;
+  /**
+   * Callbacks that can be registered to be informed when new requests are made,
+   * ended, new metrics are available etc.
+   * This should be mainly useful to implement an adaptive logic relying on those
+   * metrics and events.
+   */
+  eventListeners: ISegmentFetcherLifecycleCallbacks;
+  /**
+   * Various tweaking requestOptions allowing to configure the behavior of the returned
+   * `ISegmentFetcher` regarding segment requests.
+   */
+  requestOptions: ISegmentFetcherOptions;
+}

package/src/core/fetchers/segment/segment_fetcher_creator.ts

@@ -17,12 +17,13 @@
 import config from "../../../config";
 import type { ISegmentPipeline, ITransportPipelines } from "../../../transports";
 import type { CancellationSignal } from "../../../utils/task_canceller";
+import type CmcdDataBuilder from "../../cmcd";
 import type { IBufferType } from "../../segment_sinks";
 import CdnPrioritizer from "../cdn_prioritizer";
 import type { IPrioritizedSegmentFetcher } from "./prioritized_segment_fetcher";
 import applyPrioritizerToSegmentFetcher from "./prioritized_segment_fetcher";
 import type { ISegmentFetcherLifecycleCallbacks } from "./segment_fetcher";
-import createSegmentFetcher, { getSegmentFetcherOptions } from "./segment_fetcher";
+import createSegmentFetcher, { getSegmentFetcherRequestOptions } from "./segment_fetcher";
 import TaskPrioritizer from "./task_prioritizer";
 
 /**
@@ -54,11 +55,14 @@ export default class SegmentFetcherCreator {
 
   private readonly _cdnPrioritizer: CdnPrioritizer;
 
+  private _cmcdDataBuilder: CmcdDataBuilder | null;
+
   /**
    * @param {Object} transport
    */
   constructor(
     transport: ITransportPipelines,
+    cmcdDataBuilder: CmcdDataBuilder | null,
     options: ISegmentFetcherCreatorBackoffOptions,
     cancelSignal: CancellationSignal,
   ) {
@@ -74,30 +78,32 @@ export default class SegmentFetcherCreator {
     });
     this._cdnPrioritizer = cdnPrioritizer;
     this._backoffOptions = options;
+    this._cmcdDataBuilder = cmcdDataBuilder;
   }
 
   /**
    * Create a segment fetcher, allowing to easily perform segment requests.
    * @param {string} bufferType - The type of buffer concerned (e.g. "audio",
    * "video", etc.)
-   * @param {Object} callbacks
+   * @param {Object} eventListeners
    * @returns {Object}
    */
   createSegmentFetcher(
     bufferType: IBufferType,
-    callbacks: ISegmentFetcherLifecycleCallbacks,
+    eventListeners: ISegmentFetcherLifecycleCallbacks,
   ): IPrioritizedSegmentFetcher<unknown> {
-    const backoffOptions = getSegmentFetcherOptions(this._backoffOptions);
+    const requestOptions = getSegmentFetcherRequestOptions(this._backoffOptions);
     const pipelines = this._transport[bufferType];
 
     // Types are very complicated here as they are per-type of buffer.
-    const segmentFetcher = createSegmentFetcher<unknown, unknown>(
+    const segmentFetcher = createSegmentFetcher<unknown, unknown>({
       bufferType,
-      pipelines as ISegmentPipeline<unknown, unknown>,
-      this._cdnPrioritizer,
-      callbacks,
-      backoffOptions,
-    );
+      pipeline: pipelines as ISegmentPipeline<unknown, unknown>,
+      cdnPrioritizer: this._cdnPrioritizer,
+      cmcdDataBuilder: this._cmcdDataBuilder,
+      eventListeners,
+      requestOptions,
+    });
     return applyPrioritizerToSegmentFetcher(this._prioritizer, segmentFetcher);
   }
 }

package/src/core/main/README.md

@@ -7,11 +7,11 @@
 
 [1] In a Multithreading mode, no file from that directory should ever be imported by
 external code but the `WorkerMain` to generate the worker bundle. In a monothreading mode,
-any files may be directly imported.
+any file may be directly imported.
 
 ## Overview
 
-The Core Main serves as the entry point of the `core` code, which may optionally runs in a
+The Core Main serves as the entry point of the `core` code, which may optionally run in a
 WebWorker.
 
 When in monothreading mode, files declared here may be imported directly to make the link

package/src/core/main/worker/content_preparer.ts

@@ -21,6 +21,7 @@ import type {
 import TaskCanceller from "../../../utils/task_canceller";
 import type { IRepresentationEstimator } from "../../adaptive";
 import createAdaptiveRepresentationSelector from "../../adaptive";
+import CmcdDataBuilder from "../../cmcd";
 import type { IManifestRefreshSettings } from "../../fetchers";
 import { ManifestFetcher, SegmentFetcherCreator } from "../../fetchers";
 import SegmentSinksStore from "../../segment_sinks";
@@ -99,10 +100,16 @@ export default class ContentPreparer {
         ...transportOptions,
         representationFilter,
       });
+
+      const cmcdDataBuilder =
+        context.cmcd === undefined ? null : new CmcdDataBuilder(context.cmcd);
       const manifestFetcher = new ManifestFetcher(
         url === undefined ? undefined : [url],
         dashPipelines,
-        context.manifestRetryOptions,
+        {
+          cmcdDataBuilder,
+          ...context.manifestRetryOptions,
+        },
       );
       const representationEstimator = createAdaptiveRepresentationSelector({
         initialBitrates: {
@@ -124,6 +131,7 @@ export default class ContentPreparer {
 
       const segmentFetcherCreator = new SegmentFetcherCreator(
         dashPipelines,
+        cmcdDataBuilder,
         context.segmentRetryOptions,
         contentCanceller.signal,
       );
@@ -144,6 +152,7 @@ export default class ContentPreparer {
         segmentSinksStore,
       );
       this._currentContent = {
+        cmcdDataBuilder,
         contentId,
         decipherabilityFreezeDetector,
         mediaSource,
@@ -313,6 +322,12 @@ export interface IPreparedContentData {
    * Protects against all kind of race conditions or asynchronous issues.
    */
   contentId: string;
+  /**
+   * Perform data collection and retrieval for the "Common Media Client Data"
+   * scheme, which is a specification allowing to communicate about playback
+   * conditions with a CDN.
+   */
+  cmcdDataBuilder: CmcdDataBuilder | null;
   /**
    * Interface to the MediaSource implementation, allowing to buffer audio
    * and video media segments.

package/src/core/main/worker/worker_main.ts

@@ -3,8 +3,6 @@ import { MediaError, OtherError } from "../../../errors";
 import features from "../../../features";
 import log from "../../../log";
 import Manifest, { Adaptation, Period, Representation } from "../../../manifest/classes";
-import MainCodecSupportProber from "../../../mse/main_codec_support_prober";
-import WorkerCodecSupportProber from "../../../mse/worker_codec_support_prober";
 import type {
   IContentInitializationData,
   IDiscontinuityUpdateWorkerMessagePayload,
@@ -21,7 +19,7 @@ import type { IPlayerError, ITrackType } from "../../../public_types";
 import createDashPipelines from "../../../transports/dash";
 import arrayFind from "../../../utils/array_find";
 import assert, { assertUnreachable } from "../../../utils/assert";
-import type { ILoggerLevel } from "../../../utils/logger";
+import type { ILogFormat, ILoggerLevel } from "../../../utils/logger";
 import { scaleTimestamp } from "../../../utils/monotonic_timestamp";
 import objectAssign from "../../../utils/object_assign";
 import type { IReadOnlySharedReference } from "../../../utils/reference";
@@ -91,7 +89,11 @@ export default function initializeWorkerMain() {
         assert(!isInitialized);
         isInitialized = true;
         scaleTimestamp(msg.value);
-        updateLoggerLevel(msg.value.logLevel, msg.value.sendBackLogs);
+        updateLoggerLevel(
+          msg.value.logLevel,
+          msg.value.logFormat,
+          msg.value.sendBackLogs,
+        );
         if (msg.value.dashWasmUrl !== undefined && dashWasmParser.isCompatible()) {
           dashWasmParser.initialize({ wasmUrl: msg.value.dashWasmUrl }).catch((err) => {
             const error = err instanceof Error ? err.toString() : "Unknown Error";
@@ -107,15 +109,15 @@ export default function initializeWorkerMain() {
           });
         }
 
-        features.codecSupportProber = msg.value.hasMseInWorker
-          ? MainCodecSupportProber
-          : WorkerCodecSupportProber;
-
         sendMessage({ type: WorkerMessageType.InitSuccess, value: null });
         break;
 
       case MainThreadMessageType.LogLevelUpdate:
-        updateLoggerLevel(msg.value.logLevel, msg.value.sendBackLogs);
+        updateLoggerLevel(
+          msg.value.logLevel,
+          msg.value.logFormat,
+          msg.value.sendBackLogs,
+        );
         break;
 
       case MainThreadMessageType.PrepareContent:
@@ -283,13 +285,9 @@ export default function initializeWorkerMain() {
         if (preparedContent === null || preparedContent.manifest === null) {
           return;
         }
-        if (typeof features.codecSupportProber?.updateCache === "function") {
-          for (const { mimeType, codec, result } of msg.value) {
-            features.codecSupportProber.updateCache(mimeType, codec, result);
-          }
-        }
+        const newEvaluatedCodecs = msg.value;
         try {
-          const warning = preparedContent.manifest.refreshCodecSupport(msg.value);
+          const warning = preparedContent.manifest.updateCodecSupport(newEvaluatedCodecs);
           if (warning !== null) {
             sendMessage({
               type: WorkerMessageType.Warning,
@@ -508,6 +506,7 @@ function loadOrReloadPreparedContent(
   }
   const {
     contentId,
+    cmcdDataBuilder,
     manifest,
     mediaSource,
     representationEstimator,
@@ -554,6 +553,10 @@ function loadOrReloadPreparedContent(
     sendMessage,
     currentLoadCanceller.signal,
   );
+  cmcdDataBuilder?.startMonitoringPlayback(playbackObserver);
+  currentLoadCanceller.signal.register(() => {
+    cmcdDataBuilder?.stopMonitoringPlayback();
+  });
 
   const contentTimeBoundariesObserver = createContentTimeBoundariesObserver(
     manifest,
@@ -750,6 +753,13 @@ function loadOrReloadPreparedContent(
       },
 
       bitrateEstimateChange(payload) {
+        if (preparedContent !== null) {
+          preparedContent.cmcdDataBuilder?.updateThroughput(
+            payload.type,
+            payload.bitrate,
+          );
+        }
+
         // TODO for low-latency contents it is __VERY__ frequent.
         // Considering this is only for an unimportant undocumented API, we may
         // throttle such messages. (e.g. max one per 2 seconds for each type?).
@@ -883,11 +893,17 @@ function loadOrReloadPreparedContent(
   }
 }
 
-function updateLoggerLevel(logLevel: ILoggerLevel, sendBackLogs: boolean): void {
+function updateLoggerLevel(
+  logLevel: ILoggerLevel,
+  logFormat: ILogFormat,
+  sendBackLogs: boolean,
+): void {
   if (!sendBackLogs) {
-    log.setLevel(logLevel);
+    log.setLevel(logLevel, logFormat);
   } else {
-    log.setLevel(logLevel, (levelStr, logs) => {
+    // Here we force the log format to "standard" as the full formatting will be
+    // performed on main thread.
+    log.setLevel(logLevel, "standard", (levelStr, logs) => {
       const sentLogs = logs.map((e) => {
         if (e instanceof Error) {
           return formatErrorForSender(e);

package/src/core/segment_sinks/README.md

@@ -33,7 +33,7 @@ Here's a simplified architecture schema of the code in that directory:
    +--------------------------------------------------------------------------+
                                 |       ^
  Ask to get / create / remove   |       | Returns created SegmentSink or
- SegmentSink for a given type |       | wanted information
+ SegmentSink for a given type   |       | wanted information
  or get information about the   |       |
  available types                |       |
                                 |       |

package/src/core/segment_sinks/inventory/segment_inventory.ts

@@ -1353,7 +1353,7 @@ function prettyPrintInventory(inventory: IBufferedChunk[]): string {
         currentLetter = generateNewLetter(chunk.infos);
         encounteredPeriod[representationId] = currentLetter;
       } else {
-        currentLetter = encounteredPeriod[representationId] as string;
+        currentLetter = encounteredPeriod[representationId];
       }
 
       if (lastChunk === null) {

package/src/default_config.ts

@@ -845,6 +845,7 @@ const DEFAULT_CONFIG = {
   EME_DEFAULT_VIDEO_CODECS: [
     'video/mp4;codecs="avc1.4d401e"',
     'video/mp4;codecs="avc1.42e01e"',
+    'video/mp4;codecs="hvc1.1.6.L93.B0"',
     'video/webm;codecs="vp8"',
   ],
 

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

@@ -1,7 +1,6 @@
 import { describe, it, expect } from "vitest";
 import type { IFeaturesObject } from "../../../features/types";
 import MediaSourceContentInitializer from "../../../main_thread/init/media_source_content_initializer";
-import mainCodecSupportProber from "../../../mse/main_codec_support_prober";
 import local from "../../../transports/local";
 import addLocalManifestFeature from "../local";
 
@@ -12,10 +11,8 @@ describe("Features list - LOCAL_MANIFEST", () => {
     expect(featureObject).toEqual({
       transports: { local },
       mainThreadMediaSourceInit: MediaSourceContentInitializer,
-      codecSupportProber: mainCodecSupportProber,
     });
     expect(featureObject.transports.local).toBe(local);
     expect(featureObject.mainThreadMediaSourceInit).toBe(MediaSourceContentInitializer);
-    expect(featureObject.codecSupportProber).toBe(mainCodecSupportProber);
   });
 });

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

@@ -1,7 +1,6 @@
 import { describe, it, expect } from "vitest";
 import type { IFeaturesObject } from "../../../features/types";
 import MediaSourceContentInitializer from "../../../main_thread/init/media_source_content_initializer";
-import mainCodecSupportProber from "../../../mse/main_codec_support_prober";
 import metaplaylist from "../../../transports/metaplaylist";
 import addLocalManifestFeature from "../metaplaylist";
 
@@ -12,10 +11,8 @@ describe("Features list - METAPLAYLIST", () => {
     expect(featureObject).toEqual({
       transports: { metaplaylist },
       mainThreadMediaSourceInit: MediaSourceContentInitializer,
-      codecSupportProber: mainCodecSupportProber,
     });
     expect(featureObject.transports.metaplaylist).toBe(metaplaylist);
     expect(featureObject.mainThreadMediaSourceInit).toBe(MediaSourceContentInitializer);
-    expect(featureObject.codecSupportProber).toBe(mainCodecSupportProber);
   });
 });

package/src/experimental/features/local.ts

@@ -16,13 +16,11 @@
 
 import type { IFeaturesObject } from "../../features/types";
 import MediaSourceContentInitializer from "../../main_thread/init/media_source_content_initializer";
-import mainCodecSupportProber from "../../mse/main_codec_support_prober";
 import local from "../../transports/local";
 
 function addLocalManifestFeature(features: IFeaturesObject): void {
   features.transports.local = local;
   features.mainThreadMediaSourceInit = MediaSourceContentInitializer;
-  features.codecSupportProber = mainCodecSupportProber;
 }
 
 export { addLocalManifestFeature as LOCAL_MANIFEST };

package/src/experimental/features/metaplaylist.ts

@@ -16,13 +16,11 @@
 
 import type { IFeaturesObject } from "../../features/types";
 import MediaSourceContentInitializer from "../../main_thread/init/media_source_content_initializer";
-import mainCodecSupportProber from "../../mse/main_codec_support_prober";
 import metaplaylist from "../../transports/metaplaylist";
 
 function addMetaPlaylistFeature(features: IFeaturesObject): void {
   features.transports.metaplaylist = metaplaylist;
   features.mainThreadMediaSourceInit = MediaSourceContentInitializer;
-  features.codecSupportProber = mainCodecSupportProber;
 }
 
 export { addMetaPlaylistFeature as METAPLAYLIST };

package/src/experimental/tools/VideoThumbnailLoader/prepare_source_buffer.ts

@@ -15,6 +15,7 @@
  */
 
 import { MediaSource_ } from "../../../compat/browser_compatibility_types";
+import type { IMediaElement } from "../../../compat/browser_compatibility_types";
 import log from "../../../log";
 import { resetMediaElement } from "../../../main_thread/init/utils/create_media_source";
 import { SourceBufferType } from "../../../mse";
@@ -36,7 +37,7 @@ const generateMediaSourceId = idGenerator();
  * @returns {Promise.<Object>}
  */
 export default function prepareSourceBuffer(
-  videoElement: HTMLVideoElement,
+  videoElement: IMediaElement,
   codec: string,
   cleanUpSignal: CancellationSignal,
 ): Promise<MainSourceBufferInterface> {

package/src/experimental/tools/VideoThumbnailLoader/remove_buffer_around_time.ts

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+import type { IMediaElement } from "../../../compat/browser_compatibility_types";
 import type { MainSourceBufferInterface } from "../../../mse/main_media_source_interface";
 
 /**
@@ -28,7 +29,7 @@ import type { MainSourceBufferInterface } from "../../../mse/main_media_source_i
  * @returns {Promise}
  */
 export default function removeBufferAroundTime(
-  videoElement: HTMLMediaElement,
+  videoElement: IMediaElement,
   sourceBufferInterface: MainSourceBufferInterface,
   time: number,
   margin: number | undefined,

package/src/experimental/tools/VideoThumbnailLoader/video_thumbnail_loader.ts

@@ -180,20 +180,21 @@ export default class VideoThumbnailLoader {
     let lastRepInfo: IVideoThumbnailLoaderRepresentationInfo;
     if (this._lastRepresentationInfo === null) {
       const lastRepInfoCleaner = new TaskCanceller();
-      const segmentFetcher = createSegmentFetcher(
-        "video",
-        loader.video,
-        null,
-        // We don't care about the SegmentFetcher's lifecycle events
-        {},
-        {
+      const segmentFetcher = createSegmentFetcher({
+        bufferType: "video",
+        pipeline: loader.video,
+        cdnPrioritizer: null,
+        cmcdDataBuilder: null,
+        requestOptions: {
           baseDelay: 0,
           maxDelay: 0,
           maxRetry: 0,
           requestTimeout: config.getCurrent().DEFAULT_REQUEST_TIMEOUT,
           connectionTimeout: config.getCurrent().DEFAULT_CONNECTION_TIMEOUT,
         },
-      ) as ISegmentFetcher<ArrayBuffer | Uint8Array>;
+        // We don't care about the SegmentFetcher's lifecycle events
+        eventListeners: {},
+      }) as ISegmentFetcher<ArrayBuffer | Uint8Array>;
       const initSegment = content.representation.index.getInitSegment();
       const initSegmentUniqueId =
         initSegment !== null ? content.representation.uniqueId : null;