rx-player 4.4.1 → 4.5.0-dev.2026012301

package/src/main_thread/init/media_source_content_initializer.ts

@@ -1,150 +1,149 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
 import type { IMediaElement } from "../../compat/browser_compatibility_types";
-import isCodecSupported from "../../compat/is_codec_supported";
+import disableRemotePlaybackOnManagedMediaSource from "../../compat/disable_remote_playback_on_managed_media_source";
+import getEmeApiImplementation from "../../compat/eme";
 import mayMediaElementFailOnUndecipherableData from "../../compat/may_media_element_fail_on_undecipherable_data";
+import resetMediaElement from "../../compat/reset_media_element";
 import shouldReloadMediaSourceOnDecipherabilityUpdate from "../../compat/should_reload_media_source_on_decipherability_update";
-import config from "../../config";
+import type { ISegmentSinkMetrics } from "../../core/segment_sinks/segment_sinks_store";
 import type {
   IAdaptiveRepresentationSelectorArguments,
-  IRepresentationEstimator,
-} from "../../core/adaptive";
-import AdaptiveRepresentationSelector from "../../core/adaptive";
-import CmcdDataBuilder from "../../core/cmcd";
+  IAdaptationChoice,
+  IResolutionInfo,
+  ICreateMediaSourceCoreMessage,
+  ISentError,
+  ICoreMessage,
+  ISentLogValue,
+} from "../../core/types";
+import { CoreMessageType } from "../../core/types";
 import {
-  CdnPrioritizer,
-  createThumbnailFetcher,
-  ManifestFetcher,
-  SegmentQueueCreator,
-} from "../../core/fetchers";
-import createContentTimeBoundariesObserver from "../../core/main/common/create_content_time_boundaries_observer";
-import type { IFreezeResolution } from "../../core/main/common/FreezeResolver";
-import FreezeResolver from "../../core/main/common/FreezeResolver";
-import getThumbnailData from "../../core/main/common/get_thumbnail_data";
-import synchronizeSegmentSinksOnObservation from "../../core/main/common/synchronize_sinks_on_observation";
-import SegmentSinksStore from "../../core/segment_sinks";
-import type {
-  IStreamOrchestratorOptions,
-  IStreamOrchestratorCallbacks,
-  INeedsBufferFlushPayload,
-} from "../../core/stream";
-import StreamOrchestrator from "../../core/stream";
-import type { ITextDisplayerInterface } from "../../core/types";
-import type { EncryptedMediaError } from "../../errors";
-import { MediaError } from "../../errors";
+  EncryptedMediaError,
+  MediaError,
+  NetworkError,
+  OtherError,
+  SourceBufferError,
+} from "../../errors";
 import features from "../../features";
 import log from "../../log";
-import type { IManifest, IPeriodMetadata, ICodecSupportInfo } from "../../manifest";
-import type MainMediaSourceInterface from "../../mse/main_media_source_interface";
-import type { IMediaElementPlaybackObserver } from "../../playback_observer";
+import type { IManifestMetadata } from "../../manifest";
+import {
+  ManifestMetadataFormat,
+  replicateUpdatesOnManifestMetadata,
+  updateDecipherabilityFromKeyIds,
+  updateDecipherabilityFromProtectionData,
+} from "../../manifest";
+import MainMediaSourceInterface from "../../mse/main_media_source_interface";
+import type {
+  IReadOnlyPlaybackObserver,
+  IMediaElementPlaybackObserver,
+} from "../../playback_observer";
 import type {
   ICmcdOptions,
   IInitialManifest,
   IKeySystemOption,
   IPlayerError,
+  IRepresentationFilter,
+  IManifestLoader,
+  ISegmentLoader,
 } from "../../public_types";
-import type { IThumbnailResponse, ITransportPipelines } from "../../transports";
-import areArraysOfNumbersEqual from "../../utils/are_arrays_of_numbers_equal";
+import type { IThumbnailResponse, ITransportOptions } from "../../transports";
+import arrayFind from "../../utils/array_find";
 import assert, { assertUnreachable } from "../../utils/assert";
-import createCancellablePromise from "../../utils/create_cancellable_promise";
+import idGenerator from "../../utils/id_generator";
 import isNullOrUndefined from "../../utils/is_null_or_undefined";
-import noop from "../../utils/noop";
+import type { IAcceptedLogValue } from "../../utils/logger";
 import objectAssign from "../../utils/object_assign";
 import type { IReadOnlySharedReference } from "../../utils/reference";
-import type { ISyncOrAsyncValue } from "../../utils/sync_or_async";
-import SyncOrAsync from "../../utils/sync_or_async";
+import SharedReference from "../../utils/reference";
+import { RequestError } from "../../utils/request";
 import type { CancellationSignal } from "../../utils/task_canceller";
-import TaskCanceller from "../../utils/task_canceller";
+import TaskCanceller, { CancellationError } from "../../utils/task_canceller";
+import type CoreInterface from "../core_interface/types";
+import type { IContentProtection } from "../decrypt";
+import type IContentDecryptor from "../decrypt";
 import { ContentDecryptorState, getKeySystemConfiguration } from "../decrypt";
-import type { IProcessedProtectionData } from "../decrypt";
-import type ContentDecryptor from "../decrypt";
 import type { ITextDisplayer } from "../text_displayer";
+import { MainThreadMessageType } from "../types";
 import type { ITextDisplayerOptions } from "./types";
 import { ContentInitializer } from "./types";
+import type { ICorePlaybackObservation } from "./utils/create_core_playback_observer";
 import createCorePlaybackObserver from "./utils/create_core_playback_observer";
-import createMediaSource from "./utils/create_media_source";
 import type { IInitialTimeOptions } from "./utils/get_initial_time";
 import getInitialTime from "./utils/get_initial_time";
 import getLoadedReference from "./utils/get_loaded_reference";
 import performInitialSeekAndPlay from "./utils/initial_seek_and_play";
-import initializeContentDecryption from "./utils/initialize_content_decryption";
-import MainThreadTextDisplayerInterface from "./utils/main_thread_text_displayer_interface";
 import RebufferingController from "./utils/rebuffering_controller";
-import StreamEventsEmitter from "./utils/stream_events_emitter";
+import StreamEventsEmitter from "./utils/stream_events_emitter/stream_events_emitter";
 import listenToMediaError from "./utils/throw_on_media_error";
+import { updateManifestCodecSupport } from "./utils/update_manifest_codec_support";
+
+const generateContentId = idGenerator();
 
 /**
- * Allows to load a new content thanks to the MediaSource Extensions (a.k.a. MSE)
- * Web APIs.
- *
- * Through this `ContentInitializer`, a Manifest will be fetched (and depending
- * on the situation, refreshed), a `MediaSource` instance will be linked to the
- * wanted `HTMLMediaElement` and chunks of media data, called segments, will be
- * pushed on buffers associated to this `MediaSource` instance.
- *
  * @class MediaSourceContentInitializer
  */
 export default class MediaSourceContentInitializer extends ContentInitializer {
   /** Constructor settings associated to this `MediaSourceContentInitializer`. */
-  private _initSettings: IInitializeArguments;
+  private _settings: IInitializeArguments;
+
+  /**
+   * The Core may be sending messages as soon as we're preparing the content but
+   * the `MediaSourceContentInitializer` is only able to handle all of them only
+   * once `start`ed.
+   *
+   * As such `_queuedCoreMessages` is set to an Array  when `prepare` has been
+   * called but not `start` yet, and contains all core messages that have to
+   * be processed when `start` is called.
+   *
+   * It is set to `null` when there's no need to rely on that queue (either not
+   * yet `prepare`d or already `start`ed).
+   */
+  private _queuedCoreMessages: ICoreMessage[] | null;
+
+  /**
+   * Information relative to the current loaded content.
+   *
+   * `null` when no content is prepared yet.
+   */
+  private _currentContentInfo: IMediaSourceContentInitializerContentInfos | null;
   /**
    * `TaskCanceller` allowing to abort everything that the
    * `MediaSourceContentInitializer` is doing.
    */
   private _initCanceller: TaskCanceller;
-  /** Interface allowing to fetch and refresh the Manifest. */
-  private _manifestFetcher: ManifestFetcher;
-  /**
-   * Reference to the `Manifest` Object:
-   *   - as an asynchronous value if it is still in the process of being loaded.
-   *   - as an synchronous value if it has been loaded
-   *   - `null` if the load task has not started yet.
-   */
-  private _manifest: ISyncOrAsyncValue<IManifest> | null;
-
-  private _cmcdDataBuilder: CmcdDataBuilder | null;
-
   /**
-   * Describes the decryption capabilities on the current content, discriminated
-   * by a `status` property:
-   *
-   *   - If set to `"uninitialized"`, decryption capabilities have not been
-   *     set up yet.
+   * `TaskCanceller` allowing to abort and clean-up every task and resource
+   * linked to the current `MediaSource` instance.
    *
-   *   - If set to `"disabled"`, decryption capabilities are explicitely
-   *     disabled. If encrypted content needs to be decrypted, the accompanying
-   *     error `value` describes the reason why decryption is not enabled.
-   *
-   *   - If set to `"enabled"`, decryption capabilities are available, and
-   *     `value` points to the corresponding `ContentDecryptor`.
+   * It may be triggered either at content stop (and thus at the same time than
+   * the `_initCanceller`) or when reloading the content.
    */
-  private _decryptionCapabilities:
-    | {
-        status: "uninitialized";
-        value: null;
+  private _currentMediaSourceCanceller: TaskCanceller;
+
+  private _awaitingRequests: {
+    nextRequestId: number;
+    /**
+     * Stores the resolvers and the current messageId that is sent to the core to
+     * receive segment sink metrics.
+     * The purpose of collecting metrics is for monitoring and debugging.
+     */
+    pendingSinkMetrics: Map<
+      number /* request id */,
+      {
+        resolve: (value: ISegmentSinkMetrics | undefined) => void;
       }
-    | {
-        status: "disabled";
-        value: EncryptedMediaError;
+    >;
+    /**
+     * Stores the resolvers and the current messageId that is sent to the web worker to
+     * receive image thumbnails.
+     */
+    pendingThumbnailFetching: Map<
+      number /* request id */,
+      {
+        resolve: (value: IThumbnailResponse) => void;
+        reject: (error: Error) => void;
       }
-    | {
-        status: "enabled";
-        value: ContentDecryptor;
-      };
+    >;
+  };
 
   /**
    * Create a new `MediaSourceContentInitializer`, associated to the given
@@ -153,78 +152,173 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
    */
   constructor(settings: IInitializeArguments) {
     super();
-    this._initSettings = settings;
-    this._initCanceller = new TaskCanceller();
-    this._manifest = null;
-    this._decryptionCapabilities = { status: "uninitialized", value: null };
-    const urls = settings.url === undefined ? undefined : [settings.url];
-    this._cmcdDataBuilder =
-      settings.cmcd === undefined ? null : new CmcdDataBuilder(settings.cmcd);
-    this._manifestFetcher = new ManifestFetcher(urls, settings.transport, {
-      ...settings.manifestRequestSettings,
-      lowLatencyMode: settings.lowLatencyMode,
-      cmcdDataBuilder: this._cmcdDataBuilder,
-    });
+    this._settings = settings;
+    this._initCanceller = new TaskCanceller("Init");
+    this._currentMediaSourceCanceller = new TaskCanceller("Init MediaSource");
+    this._currentMediaSourceCanceller.linkToSignal(this._initCanceller.signal);
+    this._currentContentInfo = null;
+    this._awaitingRequests = {
+      nextRequestId: 0,
+      pendingSinkMetrics: new Map(),
+      pendingThumbnailFetching: new Map(),
+    };
+    this._queuedCoreMessages = null;
   }
 
   /**
    * Perform non-destructive preparation steps, to prepare a future content.
-   * For now, this mainly mean loading the Manifest document.
    */
   public prepare(): void {
-    if (this._manifest !== null) {
+    if (this._currentContentInfo !== null || this._initCanceller.isUsed()) {
       return;
     }
-    this._manifest = SyncOrAsync.createAsync(
-      createCancellablePromise(this._initCanceller.signal, (res, rej) => {
-        this._manifestFetcher.addEventListener("warning", (err: IPlayerError) =>
-          this.trigger("warning", err),
-        );
-        this._manifestFetcher.addEventListener("error", (err: unknown) => {
-          this.trigger("error", err);
-          rej(err);
-        });
-        this._manifestFetcher.addEventListener("manifestReady", (manifest) => {
-          res(manifest);
-        });
-      }),
-    );
-    this._manifestFetcher.start();
+    const contentId = generateContentId();
+    const {
+      adaptiveOptions,
+      transport,
+      transportOptions,
+      useMseInWorker,
+      coreInterface,
+    } = this._settings;
+    const { wantedBufferAhead, maxVideoBufferSize, maxBufferAhead, maxBufferBehind } =
+      this._settings.bufferOptions;
+    const initialVideoBitrate = adaptiveOptions.initialBitrates.video;
+    const initialAudioBitrate = adaptiveOptions.initialBitrates.audio;
+    this._currentContentInfo = {
+      contentId,
+      contentDecryptor: null,
+      manifest: null,
+      mediaSourceInfo: null,
+      rebufferingController: null,
+      streamEventsEmitter: null,
+      initialTime: undefined,
+      autoPlay: undefined,
+      initialPlayPerformed: null,
+      useMseInWorker,
+    };
+    coreInterface.sendMessage({
+      type: MainThreadMessageType.PrepareContent,
+      value: {
+        contentId,
+        cmcd: this._settings.cmcd,
+        enableRepresentationAvoidance: this._settings.enableRepresentationAvoidance,
+        url: this._settings.url,
+        hasText: this._hasTextBufferFeature(),
+        transport,
+        transportOptions,
+        initialVideoBitrate,
+        initialAudioBitrate,
+        manifestRetryOptions: {
+          ...this._settings.manifestRequestSettings,
+          lowLatencyMode: this._settings.lowLatencyMode,
+        },
+        segmentRetryOptions: this._settings.segmentRequestOptions,
+        useMseInWorker,
+      },
+    });
     this._initCanceller.signal.register(() => {
-      this._manifestFetcher.dispose();
+      coreInterface.sendMessage({
+        type: MainThreadMessageType.StopContent,
+        contentId,
+        value: null,
+      });
+    });
+    if (this._initCanceller.isUsed()) {
+      return;
+    }
+    this._queuedCoreMessages = [];
+    log.debug("Init", "addEventListener prepare buffering core messages");
+    const onmessage = (msgData: ICoreMessage): void => {
+      if (msgData.type !== CoreMessageType.LogMessage) {
+        log.debug("Init", "Core message received", msgData.type);
+      }
+      const type = msgData.type;
+      switch (type) {
+        case CoreMessageType.LogMessage: {
+          const formatted: IAcceptedLogValue[] = msgData.value.logs.map((l) => {
+            switch (typeof l) {
+              case "string":
+              case "number":
+              case "boolean":
+              case "undefined":
+                return l;
+              case "object":
+                if (l === null) {
+                  return null;
+                }
+                return formatSentLogObject(l);
+              default:
+                assertUnreachable(l);
+            }
+          });
+          switch (msgData.value.logLevel) {
+            case "NONE":
+              break;
+            case "ERROR":
+              log.error(msgData.value.namespace, ...formatted);
+              break;
+            case "WARNING":
+              log.warn(msgData.value.namespace, ...formatted);
+              break;
+            case "INFO":
+              log.info(msgData.value.namespace, ...formatted);
+              break;
+            case "DEBUG":
+              log.debug(msgData.value.namespace, ...formatted);
+              break;
+            default:
+              assertUnreachable(msgData.value.logLevel);
+          }
+          break;
+        }
+        default:
+          if (this._queuedCoreMessages !== null) {
+            this._queuedCoreMessages.push(msgData);
+          }
+          break;
+      }
+    };
+    this._settings.coreInterface.addMessageListener(onmessage);
+    const onmessageerror = () => {
+      log.error("Init", "Error when receiving message from core.");
+    };
+    this._settings.coreInterface.addErrorListener(onmessageerror);
+    this._initCanceller.signal.register(() => {
+      log.debug("Init", "removeEventListener prepare for core message");
+      this._settings.coreInterface.removeMessageListener(onmessage);
+      this._settings.coreInterface.removeErrorListener(onmessageerror);
     });
-  }
 
-  /**
-   * @param {HTMLMediaElement} mediaElement
-   * @param {Object} playbackObserver
-   */
-  public start(
-    mediaElement: IMediaElement,
-    playbackObserver: IMediaElementPlaybackObserver,
-  ): void {
-    this.prepare(); // Load Manifest if not already done
+    // Also bind all `SharedReference` objects:
 
-    /** Translate errors coming from the media element into RxPlayer errors. */
-    listenToMediaError(
-      mediaElement,
-      (error: MediaError) => this._onFatalError(error),
+    const throttleVideoBitrate =
+      adaptiveOptions.throttlers.throttleBitrate.video ?? new SharedReference(Infinity);
+    bindNumberReferencesToCore(
+      coreInterface,
       this._initCanceller.signal,
+      [wantedBufferAhead, "wantedBufferAhead"],
+      [maxVideoBufferSize, "maxVideoBufferSize"],
+      [maxBufferAhead, "maxBufferAhead"],
+      [maxBufferBehind, "maxBufferBehind"],
+      [throttleVideoBitrate, "throttleVideoBitrate"],
     );
 
-    this._setupInitialMediaSourceAndDecryption(mediaElement)
-      .then((initResult) =>
-        this._onInitialMediaSourceReady(
-          mediaElement,
-          initResult.mediaSource,
-          playbackObserver,
-          initResult.drmSystemId,
-          initResult.unlinkMediaSource,
-        ),
-      )
-      .catch((err) => {
-        this._onFatalError(err);
+    const limitVideoResolution =
+      adaptiveOptions.throttlers.limitResolution.video ??
+      new SharedReference<IResolutionInfo>({
+        height: undefined,
+        width: undefined,
+        pixelRatio: 1,
       });
+    limitVideoResolution.onUpdate(
+      (newVal) => {
+        coreInterface.sendMessage({
+          type: MainThreadMessageType.ReferenceUpdate,
+          value: { name: "limitVideoResolution", newVal },
+        });
+      },
+      { clearSignal: this._initCanceller.signal, emitCurrentValue: true },
+    );
   }
 
   /**
@@ -235,843 +329,1373 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
    * DASH's MPD) will be refreshed immediately.
    */
   public updateContentUrls(urls: string[] | undefined, refreshNow: boolean): void {
-    this._manifestFetcher.updateContentUrls(urls, refreshNow);
-  }
-
-  /**
-   * Stop content and free all resources linked to this
-   * `MediaSourceContentInitializer`.
-   */
-  public dispose(): void {
-    this._initCanceller.cancel();
+    if (this._currentContentInfo === null) {
+      return;
+    }
+    this._settings.coreInterface.sendMessage({
+      type: MainThreadMessageType.ContentUrlsUpdate,
+      contentId: this._currentContentInfo.contentId,
+      value: { urls, refreshNow },
+    });
   }
 
   /**
-   * Callback called when an error interrupting playback arised.
-   * @param {*} err
+   * @param {HTMLMediaElement} mediaElement
+   * @param {Object} playbackObserver
    */
-  private _onFatalError(err: unknown) {
+  public start(
+    mediaElement: IMediaElement,
+    playbackObserver: IMediaElementPlaybackObserver,
+  ): void {
+    this.prepare(); // Load Manifest if not already done
     if (this._initCanceller.isUsed()) {
       return;
     }
-    this._initCanceller.cancel();
-    this.trigger("error", err);
-  }
 
-  /**
-   * Initialize decryption mechanisms if needed and begin creating and relying
-   * on the initial `MediaSourceInterface` for this content.
-   * @param {HTMLMediaElement|null} mediaElement
-   * @returns {Promise.<Object>}
-   */
-  private _setupInitialMediaSourceAndDecryption(mediaElement: IMediaElement): Promise<{
-    mediaSource: MainMediaSourceInterface;
-    drmSystemId: string | undefined;
-    unlinkMediaSource: TaskCanceller;
-  }> {
-    const initCanceller = this._initCanceller;
-    return createCancellablePromise(initCanceller.signal, (resolve) => {
-      const { keySystems } = this._initSettings;
-
-      /** Initialize decryption capabilities. */
-      const { statusRef: drmInitRef, contentDecryptor } = initializeContentDecryption(
+    let textDisplayer: ITextDisplayer | null = null;
+    if (
+      this._settings.textTrackOptions.textTrackMode === "html" &&
+      features.htmlTextDisplayer !== null
+    ) {
+      assert(this._hasTextBufferFeature());
+      textDisplayer = new features.htmlTextDisplayer(
         mediaElement,
-        keySystems,
-        {
-          onWarning: (err: IPlayerError) => this.trigger("warning", err),
-          onError: (err: Error) => this._onFatalError(err),
-          onBlackListProtectionData: (val) => {
-            // Ugly IIFE workaround to allow async event listener
-            (async () => {
-              if (this._manifest === null) {
-                return;
-              }
-              const manifest =
-                this._manifest.syncValue ?? (await this._manifest.getValueAsAsync());
-              blackListProtectionDataOnManifest(manifest, val);
-            })().catch(noop);
-          },
-          onKeyIdsCompatibilityUpdate: (updates) => {
-            // Ugly IIFE workaround to allow async event listener
-            (async () => {
-              if (this._manifest === null) {
-                return;
-              }
-              const manifest =
-                this._manifest.syncValue ?? (await this._manifest.getValueAsAsync());
-              updateKeyIdsDecipherabilityOnManifest(
-                manifest,
-                updates.whitelistedKeyIds,
-                updates.blacklistedKeyIds,
-                updates.delistedKeyIds,
-              );
-            })().catch(noop);
-          },
-
-          onCodecSupportUpdate: () => {
-            const syncManifest = this._manifest?.syncValue;
-            if (isNullOrUndefined(syncManifest)) {
-              // The Manifest is not yet fetched, but we will be able to check
-              // the codecs once it is the case
-              this._manifest?.getValueAsAsync().then((loadedManifest) => {
-                if (this._initCanceller.isUsed()) {
-                  return;
-                }
-                this._refreshManifestCodecSupport(loadedManifest, mediaElement);
-              }, noop);
-            } else {
-              this._refreshManifestCodecSupport(syncManifest, mediaElement);
-            }
-          },
-        },
-        initCanceller.signal,
-      );
-
-      if (contentDecryptor.enabled) {
-        this._decryptionCapabilities = {
-          status: "enabled",
-          value: contentDecryptor.value,
-        };
-      } else {
-        this._decryptionCapabilities = {
-          status: "disabled",
-          value: contentDecryptor.value,
-        };
-      }
-
-      drmInitRef.onUpdate(
-        (drmStatus, stopListeningToDrmUpdates) => {
-          if (drmStatus.initializationState.type === "uninitialized") {
-            return;
-          }
-          stopListeningToDrmUpdates();
-
-          const mediaSourceCanceller = new TaskCanceller();
-          mediaSourceCanceller.linkToSignal(initCanceller.signal);
-          createMediaSource(mediaElement, mediaSourceCanceller.signal)
-            .then((mediaSource) => {
-              const lastDrmStatus = drmInitRef.getValue();
-              if (lastDrmStatus.initializationState.type === "awaiting-media-link") {
-                lastDrmStatus.initializationState.value.isMediaLinked.setValue(true);
-                drmInitRef.onUpdate(
-                  (newDrmStatus, stopListeningToDrmUpdatesAgain) => {
-                    if (newDrmStatus.initializationState.type === "initialized") {
-                      stopListeningToDrmUpdatesAgain();
-                      resolve({
-                        mediaSource,
-                        drmSystemId: newDrmStatus.drmSystemId,
-                        unlinkMediaSource: mediaSourceCanceller,
-                      });
-                      return;
-                    }
-                  },
-                  { emitCurrentValue: true, clearSignal: initCanceller.signal },
-                );
-              } else if (drmStatus.initializationState.type === "initialized") {
-                resolve({
-                  mediaSource,
-                  drmSystemId: drmStatus.drmSystemId,
-                  unlinkMediaSource: mediaSourceCanceller,
-                });
-                return;
-              }
-            })
-            .catch((err) => {
-              if (mediaSourceCanceller.isUsed()) {
-                return;
-              }
-              this._onFatalError(err);
-            });
-        },
-        { emitCurrentValue: true, clearSignal: initCanceller.signal },
+        this._settings.textTrackOptions.textTrackElement,
       );
-    });
-  }
-
-  private async _onInitialMediaSourceReady(
-    mediaElement: IMediaElement,
-    initialMediaSource: MainMediaSourceInterface,
-    playbackObserver: IMediaElementPlaybackObserver,
-    drmSystemId: string | undefined,
-    initialMediaSourceCanceller: TaskCanceller,
-  ): Promise<void> {
-    const {
-      adaptiveOptions,
-      autoPlay,
-      bufferOptions,
-      lowLatencyMode,
-      segmentRequestOptions,
-      speed,
-      startAt,
-      textTrackOptions,
-      transport,
-    } = this._initSettings;
-    const initCanceller = this._initCanceller;
-    assert(this._manifest !== null);
-    let manifest: IManifest;
-    try {
-      manifest = this._manifest.syncValue ?? (await this._manifest.getValueAsAsync());
-    } catch (_e) {
-      return; // The error should already have been processed through an event listener
+    } else if (features.nativeTextDisplayer !== null) {
+      assert(this._hasTextBufferFeature());
+      textDisplayer = new features.nativeTextDisplayer(mediaElement);
+    } else {
+      assert(!this._hasTextBufferFeature());
     }
+    this._initCanceller.signal.register((err) => {
+      textDisplayer?.stop(err.reason);
+    });
 
-    manifest.addEventListener(
-      "manifestUpdate",
-      (updates) => {
-        this.trigger("manifestUpdate", updates);
-        this._refreshManifestCodecSupport(manifest, mediaElement);
-      },
-      initCanceller.signal,
-    );
-
-    manifest.addEventListener(
-      "decipherabilityUpdate",
-      (elts) => {
-        this.trigger("decipherabilityUpdate", elts);
-      },
-      initCanceller.signal,
-    );
-
-    manifest.addEventListener(
-      "supportUpdate",
-      () => {
-        this.trigger("codecSupportUpdate", null);
-      },
-      initCanceller.signal,
+    /** Translate errors coming from the media element into RxPlayer errors. */
+    listenToMediaError(
+      mediaElement,
+      (error: MediaError) => this._onFatalError(error),
+      this._initCanceller.signal,
     );
 
-    log.debug("Init", "Calculating initial time");
-    const initialTime = getInitialTime(manifest, lowLatencyMode, startAt);
-    log.debug("Init", "Initial time calculated", { initialTime });
-
-    /** Choose the right "Representation" for a given "Adaptation". */
-    const representationEstimator = AdaptiveRepresentationSelector(adaptiveOptions);
-    const subBufferOptions = objectAssign(
-      { textTrackOptions, drmSystemId },
-      bufferOptions,
-    );
+    /**
+     * Send content protection initialization data.
+     * TODO remove and use ContentDecryptor directly when possible.
+     */
+    const lastContentProtection = new SharedReference<IContentProtection | null>(null);
 
-    const cdnPrioritizer = new CdnPrioritizer(initCanceller.signal);
-    const segmentQueueCreator = new SegmentQueueCreator(
-      transport,
-      cdnPrioritizer,
-      this._cmcdDataBuilder,
-      segmentRequestOptions,
+    const mediaSourceStatus = new SharedReference<MediaSourceInitializationStatus>(
+      MediaSourceInitializationStatus.Nothing,
     );
 
-    this._refreshManifestCodecSupport(manifest, mediaElement);
-    this.trigger("manifestReady", manifest);
-    if (initCanceller.isUsed()) {
-      return;
+    const { statusRef: drmInitializationStatus, contentDecryptor } =
+      this._initializeContentDecryption(
+        mediaElement,
+        lastContentProtection,
+        mediaSourceStatus,
+        () => notifyAndStartMediaSourceReload(0, undefined, undefined),
+        this._initCanceller.signal,
+      );
+    const contentInfo = this._currentContentInfo;
+    if (contentInfo !== null) {
+      contentInfo.contentDecryptor = contentDecryptor;
     }
 
-    // handle initial load and reloads
-    this._setupContentWithNewMediaSource(
-      {
-        mediaElement,
-        playbackObserver,
-        mediaSource: initialMediaSource,
-        initialTime,
-        autoPlay,
-        manifest,
-        representationEstimator,
-        cdnPrioritizer,
-        segmentQueueCreator,
-        speed,
-        bufferOptions: subBufferOptions,
+    const playbackStartParams = {
+      mediaElement,
+      textDisplayer,
+      playbackObserver,
+      drmInitializationStatus,
+      mediaSourceStatus,
+    };
+    mediaSourceStatus.onUpdate(
+      (msInitStatus, stopListeningMSStatus) => {
+        if (msInitStatus === MediaSourceInitializationStatus.Attached) {
+          stopListeningMSStatus();
+          this._startPlaybackIfReady(playbackStartParams);
+        }
       },
-      initialMediaSourceCanceller,
+      { clearSignal: this._initCanceller.signal, emitCurrentValue: true },
     );
-  }
-
-  /**
-   * Load the content defined by the Manifest in the mediaSource given at the
-   * given position and playing status.
-   * This function recursively re-call itself when a MediaSource reload is
-   * wanted.
-   * @param {Object} args
-   * @param {Object} currentCanceller
-   */
-  private _setupContentWithNewMediaSource(
-    args: IBufferingMediaSettings,
-    currentCanceller: TaskCanceller,
-  ): void {
-    this._startLoadingContentOnMediaSource(
-      args,
-      this._createReloadMediaSourceCallback(args, currentCanceller),
-      currentCanceller.signal,
+    drmInitializationStatus.onUpdate(
+      (initializationStatus, stopListeningDrm) => {
+        if (initializationStatus.initializationState.type === "initialized") {
+          stopListeningDrm();
+          this._startPlaybackIfReady(playbackStartParams);
+        }
+      },
+      { emitCurrentValue: true, clearSignal: this._initCanceller.signal },
     );
-  }
 
-  /**
-   * Create `IReloadMediaSourceCallback` allowing to handle reload orders.
-   * @param {Object} args
-   * @param {Object} currentCanceller
-   */
-  private _createReloadMediaSourceCallback(
-    args: IBufferingMediaSettings,
-    currentCanceller: TaskCanceller,
-  ): IReloadMediaSourceCallback {
-    const initCanceller = this._initCanceller;
-    return (reloadOrder: { position: number; autoPlay: boolean }): void => {
-      currentCanceller.cancel();
-      if (initCanceller.isUsed()) {
+    /**
+     * Reset directly (synchronously) the current `MediaSource` and signal to
+     * the core that we did so.
+     * @param {number} deltaPosition - Position you want to seek to after
+     * reloading, as a delta in seconds from the last polled playing position.
+     * @param {number|undefined} minimumPosition - If set, minimum time bound
+     * in seconds after `deltaPosition` has been applied.
+     * @param {number|undefined} maximumPosition - If set, minimum time bound
+     * in seconds after `deltaPosition` has been applied.
+     */
+    const notifyAndStartMediaSourceReload = (
+      deltaPosition: number,
+      minimumPosition: number | undefined,
+      maximumPosition: number | undefined,
+    ): void => {
+      const reloadingContentInfo = this._currentContentInfo;
+      if (reloadingContentInfo === null) {
+        log.warn("Init", "Asked to reload when no content is loaded.");
         return;
       }
-      this.trigger("reloadingMediaSource", reloadOrder);
-      if (initCanceller.isUsed()) {
+      if (
+        reloadingContentInfo === null ||
+        reloadingContentInfo.mediaSourceInfo === null
+      ) {
+        log.warn("Init", "Asked to reload when no MediaSource is active.");
         return;
       }
 
-      const newCanceller = new TaskCanceller();
-      newCanceller.linkToSignal(initCanceller.signal);
-      createMediaSource(args.mediaElement, newCanceller.signal)
-        .then((newMediaSource) => {
-          this._setupContentWithNewMediaSource(
-            {
-              ...args,
-              mediaSource: newMediaSource,
-              initialTime: reloadOrder.position,
-              autoPlay: reloadOrder.autoPlay,
+      const mediaSourceId =
+        reloadingContentInfo.mediaSourceInfo.type === "main"
+          ? reloadingContentInfo.mediaSourceInfo.mediaSource.id
+          : reloadingContentInfo.mediaSourceInfo.mediaSourceId;
+      this._settings.coreInterface.sendMessage({
+        type: MainThreadMessageType.MediaSourceReload,
+        mediaSourceId,
+        value: null,
+      });
+      reloadMediaSource(deltaPosition, minimumPosition, maximumPosition);
+    };
+
+    /**
+     * Reset directly (synchronously) the current `MediaSource`.
+     *
+     * It is assumed that `core` already knows about this action. If not, call
+     * `notifyAndStartMediaSourceReload` instead.
+     * @param {number} deltaPosition - Position you want to seek to after
+     * reloading, as a delta in seconds from the last polled playing position.
+     * @param {number|undefined} minimumPosition - If set, minimum time bound
+     * in seconds after `deltaPosition` has been applied.
+     * @param {number|undefined} maximumPosition - If set, minimum time bound
+     * in seconds after `deltaPosition` has been applied.
+     */
+    const reloadMediaSource = (
+      deltaPosition: number,
+      minimumPosition: number | undefined,
+      maximumPosition: number | undefined,
+    ): void => {
+      const reloadingContentInfo = this._currentContentInfo;
+      if (reloadingContentInfo === null) {
+        log.warn("Init", "Asked to reload when no content is loaded.");
+        return;
+      }
+      const lastObservation = playbackObserver.getReference().getValue();
+      const currentPosition = lastObservation.position.getWanted();
+      const isPaused =
+        reloadingContentInfo.initialPlayPerformed?.getValue() === true ||
+        reloadingContentInfo.autoPlay === undefined
+          ? lastObservation.paused
+          : !reloadingContentInfo.autoPlay;
+      let position = currentPosition + deltaPosition;
+      if (minimumPosition !== undefined) {
+        position = Math.max(minimumPosition, position);
+      }
+      if (maximumPosition !== undefined) {
+        position = Math.min(maximumPosition, position);
+      }
+
+      this._reload(
+        mediaElement,
+        textDisplayer,
+        playbackObserver,
+        mediaSourceStatus,
+        position,
+        !isPaused,
+      );
+    };
+
+    const onmessage = (msgData: ICoreMessage) => {
+      switch (msgData.type) {
+        case CoreMessageType.AttachMediaSource: {
+          if (this._currentContentInfo?.contentId !== msgData.contentId) {
+            return;
+          }
+          if (this._currentContentInfo !== null) {
+            if (this._currentContentInfo.mediaSourceInfo?.type === "main") {
+              this._currentContentInfo.mediaSourceInfo.mediaSource.dispose(
+                "new AttachMediaSource message",
+              );
+            }
+            this._currentContentInfo.mediaSourceInfo = {
+              type: "core",
+              mediaSourceId: msgData.mediaSourceId,
+            };
+          }
+          const mediaSourceLink = msgData.value;
+          mediaSourceStatus.onUpdate(
+            (currStatus, stopListening) => {
+              if (currStatus === MediaSourceInitializationStatus.AttachNow) {
+                stopListening();
+                log.info("media", "Attaching MediaSource URL to the media element");
+                if (mediaSourceLink.type === "handle") {
+                  mediaElement.srcObject = mediaSourceLink.value;
+                  this._currentMediaSourceCanceller.signal.register(() => {
+                    mediaElement.srcObject = null;
+                  });
+                } else {
+                  mediaElement.src = mediaSourceLink.value;
+                  this._currentMediaSourceCanceller.signal.register(() => {
+                    resetMediaElement(mediaElement, mediaSourceLink.value);
+                  });
+                }
+                disableRemotePlaybackOnManagedMediaSource(
+                  mediaElement,
+                  this._currentMediaSourceCanceller.signal,
+                );
+                mediaSourceStatus.setValue(MediaSourceInitializationStatus.Attached);
+              }
             },
-            newCanceller,
+            { emitCurrentValue: true, clearSignal: this._initCanceller.signal },
           );
-        })
-        .catch((err) => {
-          if (newCanceller.isUsed()) {
+          break;
+        }
+
+        case CoreMessageType.Warning:
+          if (this._currentContentInfo?.contentId !== msgData.contentId) {
             return;
           }
-          this._onFatalError(err);
-        });
-    };
-  }
+          this.trigger("warning", formatCoreError(msgData.value));
+          break;
 
-  /**
-   * Buffer the content on the given MediaSource.
-   * @param {Object} args
-   * @param {function} onReloadOrder
-   * @param {Object} cancelSignal
-   */
-  private _startLoadingContentOnMediaSource(
-    args: IBufferingMediaSettings,
-    onReloadOrder: IReloadMediaSourceCallback,
-    cancelSignal: CancellationSignal,
-  ): void {
-    const {
-      autoPlay,
-      bufferOptions,
-      initialTime,
-      manifest,
-      mediaElement,
-      mediaSource,
-      playbackObserver,
-      representationEstimator,
-      cdnPrioritizer,
-      segmentQueueCreator,
-      speed,
-    } = args;
-    const { transport } = this._initSettings;
-
-    const initialPeriod =
-      manifest.getPeriodForTime(initialTime) ?? manifest.getNextPeriod(initialTime);
-    if (initialPeriod === undefined) {
-      const error = new MediaError(
-        "MEDIA_STARTING_TIME_NOT_FOUND",
-        "Wanted starting time not found in the Manifest.",
-      );
-      return this._onFatalError(error);
-    }
-
-    let textDisplayerInterface: ITextDisplayerInterface | null = null;
-    const textDisplayer = createTextDisplayer(
-      mediaElement,
-      this._initSettings.textTrackOptions,
-    );
-    if (textDisplayer !== null) {
-      const sender = new MainThreadTextDisplayerInterface(textDisplayer);
-      textDisplayerInterface = sender;
-      cancelSignal.register(() => {
-        sender.stop();
-        textDisplayer?.stop();
-      });
-    }
+        case CoreMessageType.Error:
+          if (this._currentContentInfo?.contentId !== msgData.contentId) {
+            return;
+          }
+          this._onFatalError(formatCoreError(msgData.value));
+          break;
+
+        case CoreMessageType.CreateMediaSource:
+          this._onCreateMediaSourceMessage(
+            msgData,
+            mediaElement,
+            mediaSourceStatus,
+            this._settings.coreInterface,
+          );
+          break;
+
+        case CoreMessageType.AddSourceBuffer:
+          {
+            if (
+              this._currentContentInfo?.mediaSourceInfo?.type !== "main" ||
+              this._currentContentInfo.mediaSourceInfo.mediaSource.id !==
+                msgData.mediaSourceId
+            ) {
+              return;
+            }
+            const { mediaSource } = this._currentContentInfo.mediaSourceInfo;
+            mediaSource.addSourceBuffer(
+              msgData.value.sourceBufferType,
+              msgData.value.codec,
+            );
+          }
+          break;
+
+        case CoreMessageType.SourceBufferAppend:
+          {
+            if (
+              this._currentContentInfo?.mediaSourceInfo?.type !== "main" ||
+              this._currentContentInfo.mediaSourceInfo.mediaSource.id !==
+                msgData.mediaSourceId
+            ) {
+              return;
+            }
+            const { mediaSource } = this._currentContentInfo.mediaSourceInfo;
+            const sourceBuffer = arrayFind(
+              mediaSource.sourceBuffers,
+              (s) => s.type === msgData.sourceBufferType,
+            );
+            if (sourceBuffer === undefined) {
+              return;
+            }
+            sourceBuffer
+              .appendBuffer(msgData.value.data, msgData.value.params)
+              .then((buffered) => {
+                this._settings.coreInterface.sendMessage({
+                  type: MainThreadMessageType.SourceBufferSuccess,
+                  mediaSourceId: mediaSource.id,
+                  sourceBufferType: sourceBuffer.type,
+                  operationId: msgData.operationId,
+                  value: { buffered },
+                });
+              })
+              .catch((error) => {
+                this._settings.coreInterface.sendMessage({
+                  type: MainThreadMessageType.SourceBufferError,
+                  mediaSourceId: mediaSource.id,
+                  sourceBufferType: sourceBuffer.type,
+                  operationId: msgData.operationId,
+                  value:
+                    error instanceof CancellationError
+                      ? { errorName: "CancellationError" }
+                      : formatSourceBufferError(error).serialize(),
+                });
+              });
+          }
+          break;
+
+        case CoreMessageType.SourceBufferRemove:
+          {
+            if (
+              this._currentContentInfo?.mediaSourceInfo?.type !== "main" ||
+              this._currentContentInfo.mediaSourceInfo.mediaSource.id !==
+                msgData.mediaSourceId
+            ) {
+              return;
+            }
+            const { mediaSource } = this._currentContentInfo.mediaSourceInfo;
+            const sourceBuffer = arrayFind(
+              mediaSource.sourceBuffers,
+              (s) => s.type === msgData.sourceBufferType,
+            );
+            if (sourceBuffer === undefined) {
+              return;
+            }
+            sourceBuffer
+              .remove(msgData.value.start, msgData.value.end)
+              .then((buffered) => {
+                this._settings.coreInterface.sendMessage({
+                  type: MainThreadMessageType.SourceBufferSuccess,
+                  mediaSourceId: mediaSource.id,
+                  sourceBufferType: sourceBuffer.type,
+                  operationId: msgData.operationId,
+                  value: { buffered },
+                });
+              })
+              .catch((error) => {
+                this._settings.coreInterface.sendMessage({
+                  type: MainThreadMessageType.SourceBufferError,
+                  mediaSourceId: mediaSource.id,
+                  sourceBufferType: sourceBuffer.type,
+                  operationId: msgData.operationId,
+                  value:
+                    error instanceof CancellationError
+                      ? { errorName: "CancellationError" }
+                      : formatSourceBufferError(error).serialize(),
+                });
+              });
+          }
+          break;
+
+        case CoreMessageType.AbortSourceBuffer:
+          {
+            if (
+              this._currentContentInfo?.mediaSourceInfo?.type !== "main" ||
+              this._currentContentInfo.mediaSourceInfo.mediaSource.id !==
+                msgData.mediaSourceId
+            ) {
+              return;
+            }
+            const { mediaSource } = this._currentContentInfo.mediaSourceInfo;
+            const sourceBuffer = arrayFind(
+              mediaSource.sourceBuffers,
+              (s) => s.type === msgData.sourceBufferType,
+            );
+            if (sourceBuffer === undefined) {
+              return;
+            }
+            sourceBuffer.abort("received AbortSourceBuffer message");
+          }
+          break;
+
+        case CoreMessageType.UpdateMediaSourceDuration:
+          {
+            if (
+              this._currentContentInfo?.mediaSourceInfo?.type !== "main" ||
+              this._currentContentInfo.mediaSourceInfo.mediaSource.id !==
+                msgData.mediaSourceId
+            ) {
+              return;
+            }
+            const { mediaSource } = this._currentContentInfo.mediaSourceInfo;
+            if (mediaSource?.id !== msgData.mediaSourceId) {
+              return;
+            }
+            mediaSource.setDuration(msgData.value.duration, msgData.value.isRealEndKnown);
+          }
+          break;
+
+        case CoreMessageType.InterruptMediaSourceDurationUpdate:
+          {
+            if (
+              this._currentContentInfo?.mediaSourceInfo?.type !== "main" ||
+              this._currentContentInfo.mediaSourceInfo.mediaSource.id !==
+                msgData.mediaSourceId
+            ) {
+              return;
+            }
+            const { mediaSource } = this._currentContentInfo.mediaSourceInfo;
+            if (mediaSource?.id !== msgData.mediaSourceId) {
+              return;
+            }
+            mediaSource.interruptDurationSetting(
+              "received InterrupMediaSourceDurationUpdate message",
+            );
+          }
+          break;
+
+        case CoreMessageType.EndOfStream:
+          {
+            if (
+              this._currentContentInfo?.mediaSourceInfo?.type !== "main" ||
+              this._currentContentInfo.mediaSourceInfo.mediaSource.id !==
+                msgData.mediaSourceId
+            ) {
+              return;
+            }
+            const { mediaSource } = this._currentContentInfo.mediaSourceInfo;
+            mediaSource.maintainEndOfStream();
+          }
+          break;
+
+        case CoreMessageType.InterruptEndOfStream:
+          {
+            if (
+              this._currentContentInfo?.mediaSourceInfo?.type !== "main" ||
+              this._currentContentInfo.mediaSourceInfo.mediaSource.id !==
+                msgData.mediaSourceId
+            ) {
+              return;
+            }
+            const { mediaSource } = this._currentContentInfo.mediaSourceInfo;
+            mediaSource.stopEndOfStream();
+          }
+          break;
+
+        case CoreMessageType.DisposeMediaSource:
+          {
+            if (
+              this._currentContentInfo?.mediaSourceInfo?.type !== "main" ||
+              this._currentContentInfo.mediaSourceInfo.mediaSource.id !==
+                msgData.mediaSourceId
+            ) {
+              return;
+            }
+            const { mediaSource } = this._currentContentInfo.mediaSourceInfo;
+            mediaSource.dispose("DisposeMediaSource message");
+          }
+          break;
 
-    /** Interface to create media buffers. */
-    const segmentSinksStore = new SegmentSinksStore(
-      mediaSource,
-      mediaElement.nodeName === "VIDEO",
-      textDisplayerInterface,
-    );
+        case CoreMessageType.NeedsBufferFlush: {
+          if (this._currentContentInfo?.contentId !== msgData.contentId) {
+            return;
+          }
+          const lastObservation = playbackObserver.getReference().getValue();
+          const currentTime = lastObservation.position.isAwaitingFuturePosition()
+            ? lastObservation.position.getWanted()
+            : mediaElement.currentTime;
+          const relativeResumingPosition = msgData.value?.relativeResumingPosition ?? 0;
+          const canBeApproximateSeek = Boolean(
+            msgData.value?.relativePosHasBeenDefaulted,
+          );
+          let wantedSeekingTime: number;
 
-    cancelSignal.register(() => {
-      segmentSinksStore.disposeAll();
-    });
+          if (relativeResumingPosition === 0 && canBeApproximateSeek) {
+            // in case relativeResumingPosition is 0, we still perform
+            // a tiny seek to be sure that the browser will correclty reload the video.
+            wantedSeekingTime = currentTime + 0.001;
+          } else {
+            wantedSeekingTime = currentTime + relativeResumingPosition;
+          }
+          playbackObserver.setCurrentTime(wantedSeekingTime);
+          break;
+        }
 
-    const { autoPlayResult, initialPlayPerformed } = performInitialSeekAndPlay(
-      {
-        mediaElement,
-        playbackObserver,
-        startTime: initialTime,
-        mustAutoPlay: autoPlay,
-        onWarning: (err) => {
-          this.trigger("warning", err);
-        },
-        isDirectfile: false,
-      },
-      cancelSignal,
-    );
+        case CoreMessageType.ActivePeriodChanged: {
+          if (
+            this._currentContentInfo?.contentId !== msgData.contentId ||
+            this._currentContentInfo.manifest === null
+          ) {
+            return;
+          }
+          const period = arrayFind(
+            this._currentContentInfo.manifest.periods,
+            (p) => p.id === msgData.value.periodId,
+          );
+          if (period !== undefined) {
+            this.trigger("activePeriodChanged", { period });
+          }
+          break;
+        }
 
-    if (cancelSignal.isCancelled()) {
-      return;
-    }
+        case CoreMessageType.AdaptationChanged: {
+          if (
+            this._currentContentInfo?.contentId !== msgData.contentId ||
+            this._currentContentInfo.manifest === null
+          ) {
+            return;
+          }
+          const period = arrayFind(
+            this._currentContentInfo.manifest.periods,
+            (p) => p.id === msgData.value.periodId,
+          );
+          if (period === undefined) {
+            return;
+          }
+          if (msgData.value.adaptationId === null) {
+            this.trigger("adaptationChange", {
+              period,
+              adaptation: null,
+              type: msgData.value.type,
+            });
+            return;
+          }
+          const adaptations = period.adaptations[msgData.value.type] ?? [];
+          const adaptation = arrayFind(
+            adaptations,
+            (a) => a.id === msgData.value.adaptationId,
+          );
+          if (adaptation !== undefined) {
+            this.trigger("adaptationChange", {
+              period,
+              adaptation,
+              type: msgData.value.type,
+            });
+          }
+          break;
+        }
 
-    initialPlayPerformed.onUpdate(
-      (isPerformed, stopListening) => {
-        if (isPerformed) {
-          stopListening();
-          const streamEventsEmitter = new StreamEventsEmitter(manifest, playbackObserver);
-          manifest.addEventListener(
-            "manifestUpdate",
-            () => {
-              streamEventsEmitter.onManifestUpdate(manifest);
-            },
-            cancelSignal,
+        case CoreMessageType.RepresentationChanged: {
+          if (
+            this._currentContentInfo?.contentId !== msgData.contentId ||
+            this._currentContentInfo.manifest === null
+          ) {
+            return;
+          }
+          const period = arrayFind(
+            this._currentContentInfo.manifest.periods,
+            (p) => p.id === msgData.value.periodId,
           );
-          streamEventsEmitter.addEventListener(
-            "event",
-            (payload) => {
-              this.trigger("streamEvent", payload);
-            },
-            cancelSignal,
+          if (period === undefined) {
+            return;
+          }
+          if (msgData.value.representationId === null) {
+            this.trigger("representationChange", {
+              period,
+              type: msgData.value.type,
+              representation: null,
+            });
+            return;
+          }
+          const adaptations = period.adaptations[msgData.value.type] ?? [];
+          const adaptation = arrayFind(
+            adaptations,
+            (a) => a.id === msgData.value.adaptationId,
           );
-          streamEventsEmitter.addEventListener(
-            "eventSkip",
-            (payload) => {
-              this.trigger("streamEventSkip", payload);
-            },
-            cancelSignal,
+          if (adaptation === undefined) {
+            return;
+          }
+          const representation = arrayFind(
+            adaptation.representations,
+            (r) => r.id === msgData.value.representationId,
           );
-          streamEventsEmitter.start();
-          cancelSignal.register(() => {
-            streamEventsEmitter.stop();
-          });
+          if (representation !== undefined) {
+            this.trigger("representationChange", {
+              period,
+              type: msgData.value.type,
+              representation,
+            });
+          }
+          break;
         }
-      },
-      { clearSignal: cancelSignal, emitCurrentValue: true },
-    );
 
-    const coreObserver = createCorePlaybackObserver(
-      playbackObserver,
-      {
-        autoPlay,
-        manifest,
-        mediaSource,
-        textDisplayer,
-        initialPlayPerformed,
-        speed,
-      },
-      cancelSignal,
-    );
-
-    this._cmcdDataBuilder?.startMonitoringPlayback(coreObserver);
-    cancelSignal.register(() => {
-      this._cmcdDataBuilder?.stopMonitoringPlayback();
-    });
-
-    const rebufferingController = this._createRebufferingController(
-      playbackObserver,
-      manifest,
-      speed,
-      cancelSignal,
-    );
-    const freezeResolver = new FreezeResolver(segmentSinksStore);
-
-    if (mayMediaElementFailOnUndecipherableData()) {
-      // On some devices, just reload immediately when data become undecipherable
-      manifest.addEventListener(
-        "decipherabilityUpdate",
-        (elts) => {
-          if (elts.some((e) => e.representation.decipherable !== true)) {
-            reloadMediaSource(0, undefined, undefined);
+        case CoreMessageType.EncryptionDataEncountered:
+          if (this._currentContentInfo?.contentId !== msgData.contentId) {
+            return;
           }
-        },
-        cancelSignal,
-      );
-    }
+          lastContentProtection.setValue(msgData.value);
+          break;
 
-    coreObserver.listen(
-      (observation) => {
-        synchronizeSegmentSinksOnObservation(observation, segmentSinksStore);
-        const freezeResolution = freezeResolver.onNewObservation(observation);
-        if (freezeResolution === null) {
-          return;
+        case CoreMessageType.ManifestReady: {
+          if (this._currentContentInfo?.contentId !== msgData.contentId) {
+            return;
+          }
+          const manifest = msgData.value.manifest;
+          this._currentContentInfo.manifest = manifest;
+          this._updateCodecSupport(manifest, mediaElement);
+          this._startPlaybackIfReady(playbackStartParams);
+          break;
         }
 
-        // TODO: The following method looks generic, we may be able to factorize
-        // it with other reload handlers after some work.
-        const triggerReload = () => {
-          const lastObservation = playbackObserver.getReference().getValue();
-          const position = lastObservation.position.isAwaitingFuturePosition()
-            ? lastObservation.position.getWanted()
-            : (coreObserver.getCurrentTime() ?? lastObservation.position.getPolled());
-          const autoplay = initialPlayPerformed.getValue()
-            ? !playbackObserver.getIsPaused()
-            : autoPlay;
-          onReloadOrder({ position, autoPlay: autoplay });
-        };
-
-        handleFreezeResolution(freezeResolution, {
-          enableRepresentationAvoidance: this._initSettings.enableRepresentationAvoidance,
-          manifest,
-          triggerReload,
-          playbackObserver,
-        });
-      },
-      { clearSignal: cancelSignal },
-    );
+        case CoreMessageType.ManifestUpdate: {
+          if (this._currentContentInfo?.contentId !== msgData.contentId) {
+            return;
+          }
+          const manifest = this._currentContentInfo?.manifest;
+          if (isNullOrUndefined(manifest)) {
+            log.error("Init", "Manifest update but no Manifest loaded");
+            return;
+          }
 
-    const contentTimeBoundariesObserver = createContentTimeBoundariesObserver(
-      manifest,
-      mediaSource,
-      coreObserver,
-      segmentSinksStore,
-      {
-        onWarning: (err: IPlayerError) => this.trigger("warning", err),
-        onPeriodChanged: (period: IPeriodMetadata) =>
-          this.trigger("activePeriodChanged", { period }),
-      },
-      cancelSignal,
-    );
+          if (manifest.manifestFormat === ManifestMetadataFormat.MetadataObject) {
+            // If we're currently in possession of an `IManifestMetadata`, we need
+            // to replicate the updates sent by the Core on it.
+            // If we rely on **the** `Manifest` instance directly however, we already
+            // share it with Core and as such don't need to replicate the updates.
+            replicateUpdatesOnManifestMetadata(
+              manifest,
+              msgData.value.manifest,
+              msgData.value.updates,
+            );
+          }
+          this._currentContentInfo?.streamEventsEmitter?.onManifestUpdate(manifest);
 
-    /**
-     * Emit a "loaded" events once the initial play has been performed and the
-     * media can begin playback.
-     * Also emits warning events if issues arise when doing so.
-     */
-    autoPlayResult
-      .then(() => {
-        getLoadedReference(playbackObserver, false, cancelSignal).onUpdate(
-          (isLoaded, stopListening) => {
-            if (isLoaded) {
-              const fetchThumbnails = createThumbnailFetcher(
-                transport.thumbnails,
-                cdnPrioritizer,
-              );
-              stopListening();
-              this.trigger("loaded", {
-                getSegmentSinkMetrics: async () => {
-                  return new Promise((resolve) =>
-                    resolve(segmentSinksStore.getSegmentSinksMetrics()),
-                  );
-                },
-                getThumbnailData: async (
-                  periodId: string,
-                  thumbnailTrackId: string,
-                  time: number,
-                ): Promise<IThumbnailResponse> => {
-                  return getThumbnailData(
-                    fetchThumbnails,
-                    manifest,
-                    periodId,
-                    thumbnailTrackId,
-                    time,
-                  );
-                },
-              });
-            }
-          },
-          { emitCurrentValue: true, clearSignal: cancelSignal },
-        );
-      })
-      .catch((err) => {
-        if (cancelSignal.isCancelled()) {
-          return; // Current loading cancelled, no need to trigger the error
+          this._updateCodecSupport(manifest, mediaElement);
+          this.trigger("manifestUpdate", msgData.value.updates);
+          break;
         }
-        this._onFatalError(err);
-      });
 
-    // eslint-disable-next-line @typescript-eslint/no-this-alias
-    const self = this;
-    StreamOrchestrator(
-      { manifest, initialPeriod },
-      coreObserver,
-      representationEstimator,
-      segmentSinksStore,
-      segmentQueueCreator,
-      bufferOptions,
-      handleStreamOrchestratorCallbacks(),
-      cancelSignal,
-    );
+        case CoreMessageType.UpdatePlaybackRate:
+          if (this._currentContentInfo?.contentId !== msgData.contentId) {
+            return;
+          }
+          playbackObserver.setPlaybackRate(msgData.value);
+          break;
 
-    /**
-     * Returns Object handling the callbacks from a `StreamOrchestrator`, which
-     * are basically how it communicates about events.
-     * @returns {Object}
-     */
-    function handleStreamOrchestratorCallbacks(): IStreamOrchestratorCallbacks {
-      return {
-        needsBufferFlush: (payload?: INeedsBufferFlushPayload) => {
-          let wantedSeekingTime: number;
-          const lastObservation = playbackObserver.getReference().getValue();
-          const currentTime = lastObservation.position.isAwaitingFuturePosition()
-            ? lastObservation.position.getWanted()
-            : mediaElement.currentTime;
-          const relativeResumingPosition = payload?.relativeResumingPosition ?? 0;
-          const canBeApproximateSeek = Boolean(payload?.relativePosHasBeenDefaulted);
+        case CoreMessageType.BitrateEstimateChange:
+          if (this._currentContentInfo?.contentId !== msgData.contentId) {
+            return;
+          }
+          this.trigger("bitrateEstimateChange", {
+            type: msgData.value.bufferType,
+            bitrate: msgData.value.bitrate,
+          });
+          break;
 
-          if (relativeResumingPosition === 0 && canBeApproximateSeek) {
-            // in case relativeResumingPosition is 0, we still perform
-            // a tiny seek to be sure that the browser will correclty reload the video.
-            wantedSeekingTime = currentTime + 0.001;
-          } else {
-            wantedSeekingTime = currentTime + relativeResumingPosition;
+        case CoreMessageType.InbandEvent:
+          if (this._currentContentInfo?.contentId !== msgData.contentId) {
+            return;
           }
-          playbackObserver.setCurrentTime(wantedSeekingTime);
+          this.trigger("inbandEvents", msgData.value);
+          break;
 
-          // Seek again once data begins to be buffered.
-          // This is sadly necessary on some browsers to avoid decoding
-          // issues after a flush.
-          //
-          // NOTE: there's in theory a potential race condition in the following
-          // logic as the callback could be called when media data is still
-          // being removed by the browser - which is an asynchronous process.
-          // The following condition checking for buffered data could thus lead
-          // to a false positive where we're actually checking previous data.
-          // For now, such scenario is avoided by setting the
-          // `includeLastObservation` option to `false` and calling
-          // `needsBufferFlush` once MSE media removal operations have been
-          // explicitely validated by the browser, but that's a complex and easy
-          // to break system.
-          playbackObserver.listen(
-            (obs, stopListening) => {
-              if (
-                // Data is buffered around the current position
-                obs.currentRange !== null ||
-                // Or, for whatever reason, we have no buffer but we're already advancing
-                obs.position.getPolled() > wantedSeekingTime + 0.1
-              ) {
-                stopListening();
-                playbackObserver.setCurrentTime(obs.position.getWanted() + 0.001);
+        case CoreMessageType.LockedStream: {
+          if (
+            this._currentContentInfo?.contentId !== msgData.contentId ||
+            this._currentContentInfo.manifest === null
+          ) {
+            return;
+          }
+          const period = arrayFind(
+            this._currentContentInfo.manifest.periods,
+            (p) => p.id === msgData.value.periodId,
+          );
+          if (period === undefined) {
+            return;
+          }
+          this._currentContentInfo.rebufferingController?.onLockedStream(
+            msgData.value.bufferType,
+            period,
+          );
+          break;
+        }
+
+        case CoreMessageType.PeriodStreamReady: {
+          if (
+            this._currentContentInfo?.contentId !== msgData.contentId ||
+            this._currentContentInfo.manifest === null
+          ) {
+            return;
+          }
+          const period = arrayFind(
+            this._currentContentInfo.manifest.periods,
+            (p) => p.id === msgData.value.periodId,
+          );
+          if (period === undefined) {
+            return;
+          }
+          const ref = new SharedReference<IAdaptationChoice | null | undefined>(
+            undefined,
+          );
+          ref.onUpdate(
+            (adapChoice) => {
+              if (this._currentContentInfo === null) {
+                ref.finish();
+                return;
+              }
+              if (!isNullOrUndefined(adapChoice)) {
+                adapChoice.representations.onUpdate(
+                  (repChoice, stopListening) => {
+                    if (this._currentContentInfo === null) {
+                      stopListening();
+                      return;
+                    }
+                    this._settings.coreInterface.sendMessage({
+                      type: MainThreadMessageType.RepresentationUpdate,
+                      contentId: this._currentContentInfo.contentId,
+                      value: {
+                        periodId: msgData.value.periodId,
+                        adaptationId: adapChoice.adaptationId,
+                        bufferType: msgData.value.bufferType,
+                        choice: repChoice,
+                      },
+                    });
+                  },
+                  { clearSignal: this._initCanceller.signal },
+                );
               }
+              this._settings.coreInterface.sendMessage({
+                type: MainThreadMessageType.TrackUpdate,
+                contentId: this._currentContentInfo.contentId,
+                value: {
+                  periodId: msgData.value.periodId,
+                  bufferType: msgData.value.bufferType,
+                  choice: isNullOrUndefined(adapChoice)
+                    ? adapChoice
+                    : {
+                        adaptationId: adapChoice.adaptationId,
+                        switchingMode: adapChoice.switchingMode,
+                        initialRepresentations: adapChoice.representations.getValue(),
+                        relativeResumingPosition: adapChoice.relativeResumingPosition,
+                      },
+                },
+              });
             },
-            { includeLastObservation: false, clearSignal: cancelSignal },
+            { clearSignal: this._initCanceller.signal },
           );
-        },
-
-        streamStatusUpdate(value) {
-          // Announce discontinuities if found
-          const { period, bufferType, imminentDiscontinuity, position } = value;
-          rebufferingController.updateDiscontinuityInfo({
+          this.trigger("periodStreamReady", {
             period,
-            bufferType,
-            discontinuity: imminentDiscontinuity,
-            position,
+            type: msgData.value.bufferType,
+            adaptationRef: ref,
           });
-          if (cancelSignal.isCancelled()) {
-            return; // Previous call has stopped streams due to a side-effect
-          }
+          break;
+        }
 
-          // If the status for the last Period indicates that segments are all loaded
-          // or on the contrary that the loading resumed, announce it to the
-          // ContentTimeBoundariesObserver.
+        case CoreMessageType.PeriodStreamCleared: {
           if (
-            manifest.isLastPeriodKnown &&
-            value.period.id === manifest.periods[manifest.periods.length - 1].id
+            this._currentContentInfo?.contentId !== msgData.contentId ||
+            this._currentContentInfo.manifest === null
           ) {
-            const hasFinishedLoadingLastPeriod =
-              value.hasFinishedLoading || value.isEmptyStream;
-            if (hasFinishedLoadingLastPeriod) {
-              contentTimeBoundariesObserver.onLastSegmentFinishedLoading(
-                value.bufferType,
-              );
-            } else {
-              contentTimeBoundariesObserver.onLastSegmentLoadingResume(value.bufferType);
-            }
+            return;
           }
-        },
-
-        needsManifestRefresh: () =>
-          self._manifestFetcher.scheduleManualRefresh({
-            enablePartialRefresh: true,
-            canUseUnsafeMode: true,
-          }),
-
-        manifestMightBeOufOfSync: () => {
-          const { OUT_OF_SYNC_MANIFEST_REFRESH_DELAY } = config.getCurrent();
-          self._manifestFetcher.scheduleManualRefresh({
-            enablePartialRefresh: false,
-            canUseUnsafeMode: false,
-            delay: OUT_OF_SYNC_MANIFEST_REFRESH_DELAY,
+          this.trigger("periodStreamCleared", {
+            periodId: msgData.value.periodId,
+            type: msgData.value.bufferType,
           });
-        },
-
-        lockedStream: (value) =>
-          rebufferingController.onLockedStream(value.bufferType, value.period),
+          break;
+        }
 
-        adaptationChange: (value) => {
-          self.trigger("adaptationChange", value);
-          if (cancelSignal.isCancelled()) {
-            return; // Previous call has stopped streams due to a side-effect
+        case CoreMessageType.DiscontinuityUpdate: {
+          if (
+            this._currentContentInfo?.contentId !== msgData.contentId ||
+            this._currentContentInfo.manifest === null
+          ) {
+            return;
           }
-          contentTimeBoundariesObserver.onAdaptationChange(
-            value.type,
-            value.period,
-            value.adaptation,
+          const period = arrayFind(
+            this._currentContentInfo.manifest.periods,
+            (p) => p.id === msgData.value.periodId,
           );
-        },
-
-        representationChange: (value) => {
-          self.trigger("representationChange", value);
-          if (cancelSignal.isCancelled()) {
-            return; // Previous call has stopped streams due to a side-effect
+          if (period === undefined) {
+            log.warn("Init", "Discontinuity's Period not found", {
+              periodId: msgData.value.periodId,
+            });
+            return;
           }
-          contentTimeBoundariesObserver.onRepresentationChange(value.type, value.period);
-        },
+          this._currentContentInfo.rebufferingController?.updateDiscontinuityInfo({
+            period,
+            bufferType: msgData.value.bufferType,
+            discontinuity: msgData.value.discontinuity,
+            position: msgData.value.position,
+          });
+          break;
+        }
 
-        inbandEvent: (value) => self.trigger("inbandEvents", value),
+        case CoreMessageType.PushTextData: {
+          if (this._currentContentInfo?.contentId !== msgData.contentId) {
+            return;
+          }
+          if (textDisplayer === null) {
+            log.warn("text", "Received AddTextData message but no text displayer exists");
+          } else {
+            try {
+              const ranges = textDisplayer.pushTextData(msgData.value);
+              this._settings.coreInterface.sendMessage({
+                type: MainThreadMessageType.PushTextDataSuccess,
+                contentId: msgData.contentId,
+                value: { ranges },
+              });
+            } catch (err) {
+              const message = err instanceof Error ? err.message : "Unknown error";
+              this._settings.coreInterface.sendMessage({
+                type: MainThreadMessageType.PushTextDataError,
+                contentId: msgData.contentId,
+                value: { message },
+              });
+            }
+          }
+          break;
+        }
 
-        warning: (value) => self.trigger("warning", value),
+        case CoreMessageType.RemoveTextData: {
+          if (this._currentContentInfo?.contentId !== msgData.contentId) {
+            return;
+          }
+          if (textDisplayer === null) {
+            log.warn(
+              "text",
+              "Received RemoveTextData message but no text displayer exists",
+            );
+          } else {
+            try {
+              const ranges = textDisplayer.removeBuffer(
+                msgData.value.start,
+                msgData.value.end,
+              );
+              this._settings.coreInterface.sendMessage({
+                type: MainThreadMessageType.RemoveTextDataSuccess,
+                contentId: msgData.contentId,
+                value: { ranges },
+              });
+            } catch (err) {
+              const message = err instanceof Error ? err.message : "Unknown error";
+              this._settings.coreInterface.sendMessage({
+                type: MainThreadMessageType.RemoveTextDataError,
+                contentId: msgData.contentId,
+                value: { message },
+              });
+            }
+          }
+          break;
+        }
 
-        periodStreamReady: (value) => self.trigger("periodStreamReady", value),
+        case CoreMessageType.ResetTextDisplayer: {
+          if (this._currentContentInfo?.contentId !== msgData.contentId) {
+            return;
+          }
+          if (textDisplayer === null) {
+            log.warn(
+              "text",
+              "Received ResetTextDisplayer message but no text displayer exists",
+            );
+          } else {
+            textDisplayer.reset();
+          }
+          break;
+        }
 
-        periodStreamCleared: (value) => {
-          contentTimeBoundariesObserver.onPeriodCleared(value.type, value.period);
-          if (cancelSignal.isCancelled()) {
-            return; // Previous call has stopped streams due to a side-effect
+        case CoreMessageType.StopTextDisplayer: {
+          if (this._currentContentInfo?.contentId !== msgData.contentId) {
+            return;
           }
-          self.trigger("periodStreamCleared", {
-            type: value.type,
-            periodId: value.period.id,
-          });
-        },
+          if (textDisplayer === null) {
+            log.warn(
+              "text",
+              "Received StopTextDisplayer message but no text displayer exists",
+            );
+          } else {
+            textDisplayer.stop("received StopTextDisplayer message");
+          }
+          break;
+        }
 
-        bitrateEstimateChange: (value) => {
-          self._cmcdDataBuilder?.updateThroughput(value.type, value.bitrate);
-          self.trigger("bitrateEstimateChange", value);
-        },
+        case CoreMessageType.ReloadingMediaSource:
+          {
+            if (
+              this._currentContentInfo === null ||
+              this._currentContentInfo.mediaSourceInfo === null
+            ) {
+              return;
+            }
+            const mediaSourceId =
+              this._currentContentInfo.mediaSourceInfo.type === "main"
+                ? this._currentContentInfo.mediaSourceInfo.mediaSource.id
+                : this._currentContentInfo.mediaSourceInfo.mediaSourceId;
 
-        needsMediaSourceReload: (payload) => {
-          reloadMediaSource(
-            payload.timeOffset,
-            payload.minimumPosition,
-            payload.maximumPosition,
-          );
-        },
+            if (mediaSourceId !== msgData.mediaSourceId) {
+              return;
+            }
+            reloadMediaSource(
+              msgData.value.timeOffset,
+              msgData.value.minimumPosition,
+              msgData.value.maximumPosition,
+            );
+          }
+          break;
 
-        needsDecipherabilityFlush() {
-          const keySystem = getKeySystemConfiguration(mediaElement);
-          if (shouldReloadMediaSourceOnDecipherabilityUpdate(keySystem?.[0])) {
-            const lastObservation = coreObserver.getReference().getValue();
-            const position = lastObservation.position.isAwaitingFuturePosition()
-              ? lastObservation.position.getWanted()
-              : (coreObserver.getCurrentTime() ?? lastObservation.position.getPolled());
-            const isPaused =
-              lastObservation.paused.pending ??
-              coreObserver.getIsPaused() ??
-              lastObservation.paused.last;
-            onReloadOrder({ position, autoPlay: !isPaused });
-          } else {
-            const lastObservation = coreObserver.getReference().getValue();
-            const position = lastObservation.position.isAwaitingFuturePosition()
-              ? lastObservation.position.getWanted()
-              : (coreObserver.getCurrentTime() ?? lastObservation.position.getPolled());
-            // simple seek close to the current position
-            // to flush the buffers
-            if (position + 0.001 < lastObservation.duration) {
-              playbackObserver.setCurrentTime(mediaElement.currentTime + 0.001);
+        case CoreMessageType.NeedsDecipherabilityFlush:
+          {
+            if (this._currentContentInfo?.contentId !== msgData.contentId) {
+              return;
+            }
+
+            const keySystem = getKeySystemConfiguration(mediaElement);
+            if (shouldReloadMediaSourceOnDecipherabilityUpdate(keySystem?.[0])) {
+              notifyAndStartMediaSourceReload(0, undefined, undefined);
             } else {
-              playbackObserver.setCurrentTime(position);
+              const lastObservation = playbackObserver.getReference().getValue();
+
+              const currentPosition = lastObservation.position.getWanted();
+
+              // simple seek close to the current position
+              // to flush the buffers
+              if (currentPosition + 0.001 < lastObservation.duration) {
+                playbackObserver.setCurrentTime(mediaElement.currentTime + 0.001);
+              } else {
+                playbackObserver.setCurrentTime(currentPosition);
+              }
             }
           }
-        },
+          break;
 
-        encryptionDataEncountered: (value) => {
-          if (self._decryptionCapabilities.status === "disabled") {
-            self._onFatalError(self._decryptionCapabilities.value);
+        case CoreMessageType.SegmentSinkStoreUpdate: {
+          if (this._currentContentInfo?.contentId !== msgData.contentId) {
             return;
-          } else if (self._decryptionCapabilities.status === "uninitialized") {
-            // Should never happen
-            log.error(
-              "Init",
-              "received encryption data without known decryption capabilities",
-            );
+          }
+          const sinkObj = this._awaitingRequests.pendingSinkMetrics.get(
+            msgData.value.requestId,
+          );
+          if (sinkObj !== undefined) {
+            sinkObj.resolve(msgData.value.segmentSinkMetrics);
+          } else {
+            log.error("Init", "Failed to send segment sink store update");
+          }
+          break;
+        }
+
+        case CoreMessageType.InitSuccess:
+        case CoreMessageType.InitError:
+          // Should already be handled by the API
+          break;
+
+        case CoreMessageType.LogMessage:
+          // Already handled by prepare's handler
+          break;
+        case CoreMessageType.ThumbnailDataResponse: {
+          if (this._currentContentInfo?.contentId !== msgData.contentId) {
             return;
           }
-          for (const protectionData of value) {
-            self._decryptionCapabilities.value.onInitializationData(protectionData);
-            if (cancelSignal.isCancelled()) {
-              return; // Previous call has stopped streams due to a side-effect
+          const tObj = this._awaitingRequests.pendingThumbnailFetching.get(
+            msgData.value.requestId,
+          );
+          if (tObj !== undefined) {
+            if (msgData.value.status === "error") {
+              tObj.reject(formatCoreError(msgData.value.error));
+            } else {
+              tObj.resolve(msgData.value.data);
             }
+          } else {
+            log.error("Init", "Failed to send segment sink store update");
           }
+          break;
+        }
+        case CoreMessageType.AppDefined:
+          break;
+        default:
+          assertUnreachable(msgData);
+      }
+    };
+
+    log.debug("Init", "addEventListener for core message");
+    if (this._queuedCoreMessages !== null) {
+      const bufferedMessages = this._queuedCoreMessages.slice();
+      log.debug("Init", "Processing buffered messages", {
+        ammount: bufferedMessages.length,
+      });
+      for (const message of bufferedMessages) {
+        onmessage(message);
+      }
+      this._queuedCoreMessages = null;
+    }
+    this._settings.coreInterface.addMessageListener(onmessage);
+    this._initCanceller.signal.register(() => {
+      log.debug("Init", "removeEventListener for core message");
+      this._settings.coreInterface.removeMessageListener(onmessage);
+    });
+  }
+
+  public dispose(reason: string | undefined): void {
+    this._initCanceller.cancel("Init dispose");
+    if (this._currentContentInfo !== null) {
+      if (this._currentContentInfo.mediaSourceInfo?.type === "main") {
+        this._currentContentInfo.mediaSourceInfo.mediaSource.dispose(reason);
+      }
+      this._currentContentInfo = null;
+    }
+  }
+
+  private _onFatalError(err: unknown) {
+    if (this._initCanceller.isUsed()) {
+      return;
+    }
+    this._initCanceller.cancel("Init dispose due to fatal Error");
+    this.trigger("error", err);
+  }
+
+  private _initializeContentDecryption(
+    mediaElement: IMediaElement,
+    lastContentProtection: IReadOnlySharedReference<null | IContentProtection>,
+    mediaSourceStatus: SharedReference<MediaSourceInitializationStatus>,
+    reloadMediaSource: () => void,
+    cancelSignal: CancellationSignal,
+  ): {
+    statusRef: IReadOnlySharedReference<IDrmInitializationStatus>;
+    contentDecryptor: IContentDecryptor | null;
+  } {
+    const { keySystems } = this._settings;
+
+    // TODO private?
+    const createEmeDisabledReference = (errMsg: string) => {
+      mediaSourceStatus.setValue(MediaSourceInitializationStatus.AttachNow);
+      lastContentProtection.onUpdate(
+        (data, stopListening) => {
+          if (data === null) {
+            // initial value
+            return;
+          }
+          stopListening();
+          const err = new EncryptedMediaError("MEDIA_IS_ENCRYPTED_ERROR", errMsg, {
+            keyStatuses: undefined,
+            keySystemConfiguration: undefined,
+            keySystem: undefined,
+          });
+          this._onFatalError(err);
         },
+        { clearSignal: cancelSignal },
+      );
+      const ref = new SharedReference({
+        initializationState: {
+          type: "initialized" as const,
+          value: null,
+        },
+        contentDecryptor: null,
+        drmSystemId: undefined,
+      });
+      ref.finish(); // We know that no new value will be triggered
+      return { statusRef: ref, contentDecryptor: null };
+    };
 
-        error: (err) => self._onFatalError(err),
-      };
+    if (keySystems.length === 0) {
+      return createEmeDisabledReference("No `keySystems` option given.");
+    } else if (features.decrypt === null) {
+      return createEmeDisabledReference("EME feature not activated.");
     }
 
-    /**
-     * Callback allowing to reload the current content.
-     * @param {number} deltaPosition - Position you want to seek to after
-     * reloading, as a delta in seconds from the last polled playing position.
-     * @param {number|undefined} minimumPosition - If set, minimum time bound
-     * in seconds after `deltaPosition` has been applied.
-     * @param {number|undefined} maximumPosition - If set, minimum time bound
-     * in seconds after `deltaPosition` has been applied.
-     */
-    function reloadMediaSource(
-      deltaPosition: number,
-      minimumPosition: number | undefined,
-      maximumPosition: number | undefined,
-    ): void {
-      const lastObservation = coreObserver.getReference().getValue();
-      const currentPosition = lastObservation.position.isAwaitingFuturePosition()
-        ? lastObservation.position.getWanted()
-        : (coreObserver.getCurrentTime() ?? lastObservation.position.getPolled());
-      const isPaused =
-        lastObservation.paused.pending ??
-        coreObserver.getIsPaused() ??
-        lastObservation.paused.last;
-      let position = currentPosition + deltaPosition;
-      if (minimumPosition !== undefined) {
-        position = Math.max(minimumPosition, position);
+    const emeApi = mediaElement.FORCED_EME_API ?? getEmeApiImplementation("auto");
+    if (emeApi === null) {
+      return createEmeDisabledReference("EME API not available on the current page.");
+    }
+
+    log.debug("Init", "Creating ContentDecryptor");
+
+    const ContentDecryptor = features.decrypt;
+    const contentDecryptor = new ContentDecryptor(emeApi, mediaElement, keySystems);
+    const drmStatusRef = new SharedReference<IDrmInitializationStatus>(
+      {
+        initializationState: { type: "uninitialized", value: null },
+        drmSystemId: undefined,
+      },
+      cancelSignal,
+    );
+
+    const updateCodecSupportOnStateChange = (state: ContentDecryptorState) => {
+      if (state > ContentDecryptorState.Initializing) {
+        const manifest = this._currentContentInfo?.manifest;
+        if (isNullOrUndefined(manifest)) {
+          return;
+        }
+        this._updateCodecSupport(manifest, mediaElement);
+        contentDecryptor.removeEventListener(
+          "stateChange",
+          updateCodecSupportOnStateChange,
+        );
       }
-      if (maximumPosition !== undefined) {
-        position = Math.min(maximumPosition, position);
+    };
+    contentDecryptor.addEventListener("stateChange", updateCodecSupportOnStateChange);
+
+    contentDecryptor.addEventListener("keyIdsCompatibilityUpdate", (updates) => {
+      if (
+        this._currentContentInfo === null ||
+        this._currentContentInfo.manifest === null
+      ) {
+        return;
+      }
+      const manUpdates = updateDecipherabilityFromKeyIds(
+        this._currentContentInfo.manifest,
+        updates,
+      );
+      if (
+        mayMediaElementFailOnUndecipherableData() &&
+        manUpdates.some((e) => e.representation.decipherable !== true)
+      ) {
+        reloadMediaSource();
+      } else {
+        this._settings.coreInterface.sendMessage({
+          type: MainThreadMessageType.DecipherabilityStatusUpdate,
+          contentId: this._currentContentInfo.contentId,
+          value: manUpdates.map((s) => ({
+            representationUniqueId: s.representation.uniqueId,
+            decipherable: s.representation.decipherable,
+          })),
+        });
       }
-      onReloadOrder({ position, autoPlay: !isPaused });
+      this.trigger("decipherabilityUpdate", manUpdates);
+    });
+    contentDecryptor.addEventListener("blackListProtectionData", (protData) => {
+      if (
+        this._currentContentInfo === null ||
+        this._currentContentInfo.manifest === null
+      ) {
+        return;
+      }
+      const manUpdates = updateDecipherabilityFromProtectionData(
+        this._currentContentInfo.manifest,
+        protData,
+      );
+      if (
+        mayMediaElementFailOnUndecipherableData() &&
+        manUpdates.some((e) => e.representation.decipherable !== true)
+      ) {
+        reloadMediaSource();
+      } else {
+        this._settings.coreInterface.sendMessage({
+          type: MainThreadMessageType.DecipherabilityStatusUpdate,
+          contentId: this._currentContentInfo.contentId,
+          value: manUpdates.map((s) => ({
+            representationUniqueId: s.representation.uniqueId,
+            decipherable: s.representation.decipherable,
+          })),
+        });
+      }
+      this.trigger("decipherabilityUpdate", manUpdates);
+    });
+    contentDecryptor.addEventListener("stateChange", (state) => {
+      if (state === ContentDecryptorState.WaitingForAttachment) {
+        mediaSourceStatus.onUpdate(
+          (currStatus, stopListening) => {
+            if (currStatus === MediaSourceInitializationStatus.Nothing) {
+              mediaSourceStatus.setValue(MediaSourceInitializationStatus.AttachNow);
+            } else if (currStatus === MediaSourceInitializationStatus.Attached) {
+              stopListening();
+              if (state === ContentDecryptorState.WaitingForAttachment) {
+                contentDecryptor.attach();
+              }
+            }
+          },
+          { clearSignal: cancelSignal, emitCurrentValue: true },
+        );
+      } else if (state === ContentDecryptorState.ReadyForContent) {
+        drmStatusRef.setValue({
+          initializationState: { type: "initialized", value: null },
+          drmSystemId: contentDecryptor.systemId,
+        });
+        contentDecryptor.removeEventListener("stateChange");
+      }
+    });
+
+    contentDecryptor.addEventListener("error", (error) => {
+      this._onFatalError(error);
+    });
+
+    contentDecryptor.addEventListener("warning", (error) => {
+      this.trigger("warning", error);
+    });
+
+    lastContentProtection.onUpdate(
+      (data) => {
+        if (data === null) {
+          return;
+        }
+        contentDecryptor.onInitializationData(data);
+      },
+      { clearSignal: cancelSignal },
+    );
+
+    cancelSignal.register((err) => {
+      contentDecryptor.dispose(err.reason);
+    });
+
+    return { statusRef: drmStatusRef, contentDecryptor };
+  }
+  /**
+   * Retrieves all unknown codecs from the current manifest, checks these unknown codecs
+   * to determine if they are supported, updates the manifest with the support
+   * status of these codecs, and forwards the list of supported codecs to core.
+   * @param manifest
+   */
+  private _updateCodecSupport(manifest: IManifestMetadata, mediaElement: IMediaElement) {
+    try {
+      const updatedCodecs = updateManifestCodecSupport(
+        manifest,
+        this._currentContentInfo?.contentDecryptor ?? null,
+        mediaElement,
+        this._currentContentInfo?.useMseInWorker ?? false,
+      );
+      if (updatedCodecs.length > 0) {
+        this._settings.coreInterface.sendMessage({
+          type: MainThreadMessageType.CodecSupportUpdate,
+          value: updatedCodecs,
+        });
+        // TODO what if one day the core updates codec support by itself?
+        // We wouldn't know...
+        this.trigger("codecSupportUpdate", null);
+      }
+    } catch (err) {
+      this._onFatalError(err);
+    }
+  }
+
+  private _hasTextBufferFeature(): boolean {
+    return (
+      (this._settings.textTrackOptions.textTrackMode === "html" &&
+        features.htmlTextDisplayer !== null) ||
+      features.nativeTextDisplayer !== null
+    );
+  }
+
+  private _reload(
+    mediaElement: IMediaElement,
+    textDisplayer: ITextDisplayer | null,
+    playbackObserver: IMediaElementPlaybackObserver,
+    mediaSourceStatus: SharedReference<MediaSourceInitializationStatus>,
+    position: number,
+    autoPlay: boolean,
+  ) {
+    this._currentMediaSourceCanceller.cancel("Init MediaSource Reload");
+    this._currentMediaSourceCanceller = new TaskCanceller("Init MediaSource");
+    this._currentMediaSourceCanceller.linkToSignal(this._initCanceller.signal);
+    mediaSourceStatus.setValue(MediaSourceInitializationStatus.AttachNow);
+    this.trigger("reloadingMediaSource", { position, autoPlay });
+
+    mediaSourceStatus.onUpdate(
+      (status, stopListeningMSStatusUpdates) => {
+        if (status !== MediaSourceInitializationStatus.Attached) {
+          return;
+        }
+        stopListeningMSStatusUpdates();
+        const corePlaybackObserver = this._setUpModulesOnNewMediaSource(
+          {
+            initialTime: position,
+            autoPlay,
+            mediaElement,
+            textDisplayer,
+            playbackObserver,
+          },
+          this._currentMediaSourceCanceller.signal,
+        );
+
+        if (
+          !this._currentMediaSourceCanceller.isUsed() &&
+          corePlaybackObserver !== null &&
+          this._currentContentInfo !== null
+        ) {
+          const contentId = this._currentContentInfo.contentId;
+          corePlaybackObserver.listen(
+            (obs) => {
+              this._settings.coreInterface.sendMessage({
+                type: MainThreadMessageType.PlaybackObservation,
+                contentId,
+                value: objectAssign(obs, {
+                  position: obs.position.serialize(),
+                }),
+              });
+            },
+            {
+              includeLastObservation: true,
+              clearSignal: this._currentMediaSourceCanceller.signal,
+            },
+          );
+        }
+      },
+      {
+        clearSignal: this._currentMediaSourceCanceller.signal,
+        emitCurrentValue: true,
+      },
+    );
+  }
+
+  /**
+   * Start-up modules and mechanisms (initial seek, auto-play etc.) needed each
+   * time a content is loaded AND re-loaded on a `HTMLMediaElement`, when the
+   * manifest is known.
+   *
+   * Note that this does not include reacting to incoming core messages nor
+   * sending them, those actions have to be handled separately.
+   *
+   * @param {Object} parameters
+   * @param {Object} cancelSignal
+   * @returns {Object|null} - Playback Observer created for this content. `null`
+   * only if playback initialization failed (most likely because it has been
+   * cancelled).
+   */
+  private _setUpModulesOnNewMediaSource(
+    parameters: {
+      initialTime: number;
+      autoPlay: boolean;
+      mediaElement: IMediaElement;
+      textDisplayer: ITextDisplayer | null;
+      playbackObserver: IMediaElementPlaybackObserver;
+    },
+    cancelSignal: CancellationSignal,
+  ): IReadOnlyPlaybackObserver<ICorePlaybackObservation> | null {
+    if (cancelSignal.isCancelled()) {
+      return null;
+    }
+    if (this._currentContentInfo === null) {
+      log.error("Init", "Setting up modules without a contentId");
+      return null;
+    }
+    if (this._currentContentInfo.manifest === null) {
+      log.error("Init", "Setting up modules without a loaded Manifest");
+      return null;
+    }
+
+    const { manifest, mediaSourceInfo } = this._currentContentInfo;
+    const { speed } = this._settings;
+    const { initialTime, autoPlay, mediaElement, textDisplayer, playbackObserver } =
+      parameters;
+    this._currentContentInfo.initialTime = initialTime;
+    this._currentContentInfo.autoPlay = autoPlay;
+
+    const { autoPlayResult, initialPlayPerformed } = performInitialSeekAndPlay(
+      {
+        mediaElement,
+        playbackObserver,
+        startTime: initialTime,
+        mustAutoPlay: autoPlay,
+        onWarning: (err) => this.trigger("warning", err),
+        isDirectfile: false,
+      },
+      cancelSignal,
+    );
+    this._currentContentInfo.initialPlayPerformed = initialPlayPerformed;
+    const corePlaybackObserver = createCorePlaybackObserver(
+      playbackObserver,
+      {
+        autoPlay,
+        initialPlayPerformed,
+        manifest,
+        mediaSource:
+          mediaSourceInfo?.type === "main" ? mediaSourceInfo.mediaSource : null,
+        speed,
+        textDisplayer,
+      },
+      cancelSignal,
+    );
+
+    if (cancelSignal.isCancelled()) {
+      return null;
     }
-  }
 
-  /**
-   * Creates a `RebufferingController`, a class trying to avoid various stalling
-   * situations (such as rebuffering periods), and returns it.
-   *
-   * Various methods from that class need then to be called at various events
-   * (see `RebufferingController` definition).
-   *
-   * This function also handles the `RebufferingController`'s events:
-   *   - emit "stalled" events when stalling situations cannot be prevented,
-   *   - emit "unstalled" events when we could get out of one,
-   *   - emit "warning" on various rebuffering-related minor issues
-   *     like discontinuity skipping.
-   * @param {Object} playbackObserver
-   * @param {Object} manifest
-   * @param {Object} speed
-   * @param {Object} cancelSignal
-   * @returns {Object}
-   */
-  private _createRebufferingController(
-    playbackObserver: IMediaElementPlaybackObserver,
-    manifest: IManifest,
-    speed: IReadOnlySharedReference<number>,
-    cancelSignal: CancellationSignal,
-  ): RebufferingController {
+    /**
+     * Class trying to avoid various stalling situations, emitting "stalled"
+     * events when it cannot, as well as "unstalled" events when it get out of one.
+     */
     const rebufferingController = new RebufferingController(
       playbackObserver,
       manifest,
       speed,
     );
-    // Bubble-up events
     rebufferingController.addEventListener("stalled", (evt) =>
       this.trigger("stalled", evt),
     );
@@ -1081,105 +1705,417 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
     rebufferingController.addEventListener("warning", (err) =>
       this.trigger("warning", err),
     );
-    cancelSignal.register(() => rebufferingController.destroy());
+    cancelSignal.register((err) => {
+      rebufferingController.destroy(err.reason);
+    });
     rebufferingController.start();
-    return rebufferingController;
+    this._currentContentInfo.rebufferingController = rebufferingController;
+
+    const currentContentInfo = this._currentContentInfo;
+    initialPlayPerformed.onUpdate(
+      (isPerformed, stopListening) => {
+        if (isPerformed) {
+          stopListening();
+          const streamEventsEmitter = new StreamEventsEmitter(manifest, playbackObserver);
+          currentContentInfo.streamEventsEmitter = streamEventsEmitter;
+          streamEventsEmitter.addEventListener(
+            "event",
+            (payload) => {
+              this.trigger("streamEvent", payload);
+            },
+            cancelSignal,
+          );
+          streamEventsEmitter.addEventListener(
+            "eventSkip",
+            (payload) => {
+              this.trigger("streamEventSkip", payload);
+            },
+            cancelSignal,
+          );
+          streamEventsEmitter.start();
+          cancelSignal.register((err) => {
+            streamEventsEmitter.stop(err.reason);
+          });
+        }
+      },
+      { clearSignal: cancelSignal, emitCurrentValue: true },
+    );
+
+    const _getSegmentSinkMetrics = async (): Promise<ISegmentSinkMetrics | undefined> => {
+      this._awaitingRequests.nextRequestId++;
+      const requestId = this._awaitingRequests.nextRequestId;
+      this._settings.coreInterface.sendMessage({
+        type: MainThreadMessageType.PullSegmentSinkStoreInfos,
+        value: { requestId },
+      });
+      return new Promise((resolve, reject) => {
+        const rejectFn = (err: CancellationError) => {
+          cancelSignal.deregister(rejectFn);
+          this._awaitingRequests.pendingSinkMetrics.delete(requestId);
+          return reject(err);
+        };
+        this._awaitingRequests.pendingSinkMetrics.set(requestId, {
+          resolve: (value: ISegmentSinkMetrics | undefined) => {
+            cancelSignal.deregister(rejectFn);
+            this._awaitingRequests.pendingSinkMetrics.delete(requestId);
+            resolve(value);
+          },
+        });
+        cancelSignal.register(rejectFn);
+      });
+    };
+    const _getThumbnailsData = async (
+      periodId: string,
+      thumbnailTrackId: string,
+      time: number,
+    ): Promise<IThumbnailResponse> => {
+      if (this._currentContentInfo === null) {
+        return Promise.reject(new Error("Cannot fetch thumbnails: No content loaded."));
+      }
+      this._awaitingRequests.nextRequestId++;
+      const requestId = this._awaitingRequests.nextRequestId;
+      this._settings.coreInterface.sendMessage({
+        type: MainThreadMessageType.ThumbnailDataRequest,
+        contentId: this._currentContentInfo.contentId,
+        value: { requestId, periodId, thumbnailTrackId, time },
+      });
+
+      return new Promise((resolve, reject) => {
+        const rejectFn = (err: CancellationError) => {
+          cleanUp();
+          reject(err);
+        };
+        const cleanUp = () => {
+          cancelSignal.deregister(rejectFn);
+          this._awaitingRequests.pendingThumbnailFetching.delete(requestId);
+        };
+
+        this._awaitingRequests.pendingThumbnailFetching.set(requestId, {
+          resolve: (value: IThumbnailResponse) => {
+            cleanUp();
+            resolve(value);
+          },
+          reject: (value: unknown) => {
+            cleanUp();
+            reject(value);
+          },
+        });
+        cancelSignal.register(rejectFn);
+      });
+    };
+    /**
+     * Emit a "loaded" events once the initial play has been performed and the
+     * media can begin playback.
+     * Also emits warning events if issues arise when doing so.
+     */
+    autoPlayResult
+      .then(() => {
+        getLoadedReference(playbackObserver, false, cancelSignal).onUpdate(
+          (isLoaded, stopListening) => {
+            if (isLoaded) {
+              stopListening();
+              this.trigger("loaded", {
+                getSegmentSinkMetrics: _getSegmentSinkMetrics,
+                getThumbnailData: _getThumbnailsData,
+              });
+            }
+          },
+          { emitCurrentValue: true, clearSignal: cancelSignal },
+        );
+      })
+      .catch((err) => {
+        if (cancelSignal.isCancelled()) {
+          return;
+        }
+        this._onFatalError(err);
+      });
+
+    return corePlaybackObserver;
   }
 
   /**
-   * Evaluates a list of codecs to determine their support status.
+   * Initialize content playback if and only if those conditions are filled:
+   *   - The Manifest is fetched and stored in `this._currentContentInfo`.
+   *   - `drmInitializationStatus` indicates that DRM matters are initialized.
+   *   - `mediaSourceStatus` indicates that the MediaSource is attached to the
+   *     `mediaElement`.
+   *
+   * In other cases, this method will do nothing.
+   *
+   * To call when any of those conditions might become `true`, to start-up
+   * playback.
    *
-   * @param {Array} codecsToCheck - The list of codecs to check.
-   * @returns {Array} - The list of evaluated codecs with their support status updated.
+   * @param {Object} parameters
+   * @returns {boolean} - Returns `true` if all conditions where met for
+   * playback start.
    */
-  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(mediaElement, inputCodec);
-      if (!isSupported) {
-        return {
-          mimeType: codecToCheck.mimeType,
-          codec: codecToCheck.codec,
-          supported: false,
-          supportedIfEncrypted: false,
-        };
-      }
-      /**
-       * `true` if the codec is supported when encrypted, `false` if it is not
-       * supported, or `undefined` if we cannot obtain that information.
-       */
-      let supportedIfEncrypted: boolean | undefined;
-      if (this._decryptionCapabilities.status === "uninitialized") {
-        supportedIfEncrypted = undefined;
-      } else if (this._decryptionCapabilities.status === "disabled") {
-        // It's ambiguous here, but let's say that no ContentDecryptor means that
-        // the codec is supported by it.
-        supportedIfEncrypted = true;
-      } else {
-        const contentDecryptor = this._decryptionCapabilities.value;
-        if (contentDecryptor.getState() !== ContentDecryptorState.Initializing) {
-          // No information is available regarding the support status.
-          // Defaulting to assume the codec is supported.
-          supportedIfEncrypted =
-            contentDecryptor.isCodecSupported(
-              codecToCheck.mimeType,
-              codecToCheck.codec,
-            ) ?? true;
-        }
-      }
-      return {
-        mimeType: codecToCheck.mimeType,
-        codec: codecToCheck.codec,
-        supported: isSupported,
-        supportedIfEncrypted,
-      };
+  private _startPlaybackIfReady(parameters: {
+    mediaElement: IMediaElement;
+    textDisplayer: ITextDisplayer | null;
+    playbackObserver: IMediaElementPlaybackObserver;
+    drmInitializationStatus: IReadOnlySharedReference<IDrmInitializationStatus>;
+    mediaSourceStatus: IReadOnlySharedReference<MediaSourceInitializationStatus>;
+  }): boolean {
+    if (this._currentContentInfo === null || this._currentContentInfo.manifest === null) {
+      return false;
+    }
+    const drmInitStatus = parameters.drmInitializationStatus.getValue();
+    if (drmInitStatus.initializationState.type !== "initialized") {
+      return false;
+    }
+    const msInitStatus = parameters.mediaSourceStatus.getValue();
+    if (msInitStatus !== MediaSourceInitializationStatus.Attached) {
+      return false;
+    }
+
+    const { contentId, manifest } = this._currentContentInfo;
+    log.debug("Init", "Calculating initial time");
+    const initialTime = getInitialTime(
+      manifest,
+      this._settings.lowLatencyMode,
+      this._settings.startAt,
+    );
+    log.debug("Init", "Initial time calculated", { initialTime });
+    const { enableFastSwitching, onCodecSwitch } = this._settings.bufferOptions;
+    const corePlaybackObserver = this._setUpModulesOnNewMediaSource(
+      {
+        initialTime,
+        autoPlay: this._settings.autoPlay,
+        mediaElement: parameters.mediaElement,
+        textDisplayer: parameters.textDisplayer,
+        playbackObserver: parameters.playbackObserver,
+      },
+      this._currentMediaSourceCanceller.signal,
+    );
+
+    if (this._currentMediaSourceCanceller.isUsed() || corePlaybackObserver === null) {
+      return true;
+    }
+    const initialObservation = corePlaybackObserver.getReference().getValue();
+    const sentInitialObservation = objectAssign(initialObservation, {
+      position: initialObservation.position.serialize(),
     });
-    return codecsSupportInfo;
+    this._settings.coreInterface.sendMessage({
+      type: MainThreadMessageType.StartPreparedContent,
+      contentId,
+      value: {
+        initialTime,
+        initialObservation: sentInitialObservation,
+        drmSystemId: drmInitStatus.drmSystemId,
+        enableFastSwitching,
+        onCodecSwitch,
+      },
+    });
+
+    corePlaybackObserver.listen(
+      (obs) => {
+        this._settings.coreInterface.sendMessage({
+          type: MainThreadMessageType.PlaybackObservation,
+          contentId,
+          value: objectAssign(obs, { position: obs.position.serialize() }),
+        });
+      },
+      {
+        includeLastObservation: false,
+        clearSignal: this._currentMediaSourceCanceller.signal,
+      },
+    );
+    this.trigger("manifestReady", manifest);
+    return true;
   }
 
   /**
-   * Update the support status of all Representations in the Manifest.
-   *
-   * To call anytime either the Manifest is linked to new codecs or new means
-   * to test for codec support are available.
-   * @param {Object} manifest
+   * Handles core messages asking to create a MediaSource.
+   * @param {Object} msg - The core's message received.
+   * @param {HTMLMediaElement} mediaElement - HTMLMediaElement on which the
+   * content plays.
+   * @param {Object} coreInterface - The interface to the core.
    */
-  private _refreshManifestCodecSupport(
-    manifest: IManifest,
+  private _onCreateMediaSourceMessage(
+    msg: ICreateMediaSourceCoreMessage,
     mediaElement: IMediaElement,
+    mediaSourceStatus: SharedReference<MediaSourceInitializationStatus>,
+    coreInterface: CoreInterface,
   ): void {
-    const codecsToTest = manifest.getCodecsWithUnknownSupport();
-    const codecsSupportInfo = this.getCodecsSupportInfo(codecsToTest, mediaElement);
-    if (codecsSupportInfo.length > 0) {
+    if (this._currentContentInfo?.contentId !== msg.contentId) {
+      log.info("Init", "Ignoring MediaSource attachment due to wrong `contentId`");
+    } else {
+      const { mediaSourceId } = msg;
       try {
-        manifest.updateCodecSupport(codecsSupportInfo);
-      } catch (err) {
-        this._onFatalError(err);
+        mediaSourceStatus.onUpdate(
+          (currStatus, stopListening) => {
+            if (this._currentContentInfo === null) {
+              stopListening();
+              return;
+            }
+            if (currStatus === MediaSourceInitializationStatus.AttachNow) {
+              stopListening();
+              const mediaSource = new MainMediaSourceInterface(
+                mediaSourceId,
+                "FORCED_MEDIA_SOURCE" in mediaElement
+                  ? mediaElement.FORCED_MEDIA_SOURCE
+                  : undefined,
+              );
+              if (this._currentContentInfo.mediaSourceInfo?.type === "main") {
+                this._currentContentInfo.mediaSourceInfo.mediaSource.dispose(
+                  "Attaching new MediaSource",
+                );
+              }
+              this._currentContentInfo.mediaSourceInfo = {
+                type: "main",
+                mediaSource,
+              };
+              mediaSource.addEventListener("mediaSourceOpen", () => {
+                coreInterface.sendMessage({
+                  type: MainThreadMessageType.MediaSourceReadyStateChange,
+                  mediaSourceId,
+                  value: "open",
+                });
+              });
+              mediaSource.addEventListener("mediaSourceEnded", () => {
+                coreInterface.sendMessage({
+                  type: MainThreadMessageType.MediaSourceReadyStateChange,
+                  mediaSourceId,
+                  value: "ended",
+                });
+              });
+              mediaSource.addEventListener("mediaSourceClose", () => {
+                coreInterface.sendMessage({
+                  type: MainThreadMessageType.MediaSourceReadyStateChange,
+                  mediaSourceId,
+                  value: "closed",
+                });
+              });
+              let url: string | null = null;
+              if (mediaSource.handle.type === "handle") {
+                mediaElement.srcObject = mediaSource.handle.value;
+              } else {
+                url = URL.createObjectURL(mediaSource.handle.value);
+                mediaElement.src = url;
+              }
+              this._currentMediaSourceCanceller.signal.register((err) => {
+                mediaSource.dispose(err.reason);
+                resetMediaElement(mediaElement, url);
+              });
+              mediaSourceStatus.setValue(MediaSourceInitializationStatus.Attached);
+              disableRemotePlaybackOnManagedMediaSource(
+                mediaElement,
+                this._currentMediaSourceCanceller.signal,
+              );
+            }
+          },
+          {
+            emitCurrentValue: true,
+            clearSignal: this._currentMediaSourceCanceller.signal,
+          },
+        );
+      } catch (_err) {
+        const error = new OtherError(
+          "NONE",
+          "Unknown error when creating the MediaSource",
+        );
+        this._onFatalError(error);
       }
     }
   }
 }
 
-function createTextDisplayer(
-  mediaElement: IMediaElement,
-  textTrackOptions: ITextDisplayerOptions,
-): ITextDisplayer | null {
-  if (textTrackOptions.textTrackMode === "html" && features.htmlTextDisplayer !== null) {
-    return new features.htmlTextDisplayer(
-      mediaElement,
-      textTrackOptions.textTrackElement,
-    );
-  } else if (features.nativeTextDisplayer !== null) {
-    return new features.nativeTextDisplayer(mediaElement);
-  }
-  return null;
+export interface IMediaSourceContentInitializerContentInfos {
+  /**
+   * "contentId", which is the identifier for the currently loaded content.
+   * Allows to ensure that the Core is referencing the current content, not
+   * a previously stopped one.
+   */
+  contentId: string;
+  /**
+   * Current parsed Manifest.
+   * `null` if not fetched / parsed yet.
+   */
+  manifest: IManifestMetadata | null;
+
+  /**
+   * Current MediaSource linked to the content.
+   *
+   * `null` if no MediaSource is currently created for the content.
+   */
+  mediaSourceInfo:
+    | {
+        type: "main";
+        mediaSource: MainMediaSourceInterface;
+      }
+    | {
+        type: "core";
+        mediaSourceId: string;
+      }
+    | null;
+  /**
+   * Current `RebufferingController` linked to the content, allowing to
+   * detect and handle rebuffering situations.
+   *
+   * `null` if none is currently created for the content.
+   */
+  rebufferingController: RebufferingController | null;
+  /**
+   * Current `StreamEventsEmitter` linked to the content, allowing to
+   * send events found in the Manifest.
+   *
+   * `null` if none is currently created for the content.
+   */
+  streamEventsEmitter: StreamEventsEmitter | null;
+  /**
+   * The initial position to seek to in seconds once the content is loadeed.
+   * `undefined` if unknown yet.
+   */
+  initialTime: number | undefined;
+  /**
+   * Whether to automatically play once the content is loaded.
+   * `undefined` if unknown yet.
+   */
+  autoPlay: boolean | undefined;
+  /**
+   * Set to `true` once the initial play (or skipping the initial play when
+   * autoplay is not enabled) has been done.
+   * Set to `false` when it hasn't been done yet.
+   *
+   * Set to `null` when those considerations are not taken yet.
+   */
+  initialPlayPerformed: IReadOnlySharedReference<boolean> | null;
+  /**
+   * Set to the initialized `ContentDecryptor` instance linked to that content.
+   *
+   * Set to `null` when those considerations are not taken.
+   */
+  contentDecryptor: IContentDecryptor | null;
+  /**
+   * If `true`, MSE API should be used in the core part of the RxPlayer (in the
+   * WebWorker).
+   * If `false`, they should be relied on on main thread.
+   */
+  useMseInWorker: boolean;
 }
 
 /** Arguments to give to the `InitializeOnMediaSource` function. */
 export interface IInitializeArguments {
+  /**
+   * The `MediaSourceContentInitializer` will interact with the RxPlayer's core
+   * logic (the one loading media data) by exchanging messages through an
+   * interface called the `CoreInterface`.
+   *
+   * This `CoreInterface` allows to abstract its actual current implementation.
+   * E.g., the core logic could be running in a WebWorker or in main thread, in
+   * which cases message exchanging mechanisms would be different.
+   */
+  coreInterface: CoreInterface;
+  /**
+   * If `true`, MSE API should be used in the core part of the RxPlayer (in the
+   * WebWorker).
+   * If `false`, they should be relied on on main thread.
+   *
+   * This might depend on both browser capabilities and preferences. It is
+   * assumed that the caller perform all those checks, the `ContentInitializer`
+   * won't check again the validity of this value.
+   */
+  useMseInWorker: boolean;
   /** Options concerning the ABR logic. */
   adaptiveOptions: IAdaptiveRepresentationSelectorArguments;
   /** `true` if we should play when loaded. */
@@ -1216,6 +2152,35 @@ export interface IInitializeArguments {
   keySystems: IKeySystemOption[];
   /** `true` to play low-latency contents optimally. */
   lowLatencyMode: boolean;
+  /**
+   * The type of "transport" wanted, e.g. "dash" or "smooth".
+   */
+  transport: string;
+  /** Options relative to the streaming protocol. */
+  transportOptions: Omit<
+    ITransportOptions,
+    "representationFilter" | "manifestLoader" | "segmentLoader"
+  > & {
+    manifestLoader:
+      | undefined
+      | {
+          fn?: IManifestLoader | undefined;
+          workerId?: string | undefined;
+        };
+    segmentLoader:
+      | undefined
+      | {
+          fn?: ISegmentLoader | undefined;
+          workerId?: string | undefined;
+        };
+    representationFilter:
+      | undefined
+      | {
+          fn?: IRepresentationFilter | undefined;
+          eval?: string | undefined;
+          workerId?: string | undefined;
+        };
+  };
   /** Settings linked to Manifest requests. */
   manifestRequestSettings: {
     /** Maximum number of time a request on error will be retried. */
@@ -1241,8 +2206,6 @@ export interface IInitializeArguments {
      */
     initialManifest: IInitialManifest | undefined;
   };
-  /** Logic linked Manifest and segment loading and parsing. */
-  transport: ITransportPipelines;
   /** Configuration for the segment requesting logic. */
   segmentRequestOptions: {
     lowLatencyMode: boolean;
@@ -1271,196 +2234,151 @@ export interface IInitializeArguments {
   url: string | undefined;
 }
 
-/** Arguments needed when starting to buffer media on a specific MediaSource. */
-interface IBufferingMediaSettings {
-  /** Various stream-related options. */
-  bufferOptions: IStreamOrchestratorOptions;
-  /* Manifest of the content we want to play. */
-  manifest: IManifest;
-  /** Media Element on which the content will be played. */
-  mediaElement: IMediaElement;
-  /** Emit playback conditions regularly. */
-  playbackObserver: IMediaElementPlaybackObserver;
-  /** Estimate the right Representation. */
-  representationEstimator: IRepresentationEstimator;
+function bindNumberReferencesToCore(
+  coreInterface: CoreInterface,
+  cancellationSignal: CancellationSignal,
+  ...refs: Array<
+    [
+      IReadOnlySharedReference<number>,
+      (
+        | "wantedBufferAhead"
+        | "maxVideoBufferSize"
+        | "maxBufferBehind"
+        | "maxBufferAhead"
+        | "throttleVideoBitrate"
+      ),
+    ]
+  >
+): void {
+  for (const ref of refs) {
+    ref[0].onUpdate(
+      (newVal) => {
+        // NOTE: The TypeScript checks have already been made by this function's
+        // overload, but the body here is not aware of that.
+        coreInterface.sendMessage({
+          type: MainThreadMessageType.ReferenceUpdate,
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-explicit-any
+          value: { name: ref[1] as any, newVal: newVal as any },
+        });
+      },
+      { clearSignal: cancellationSignal, emitCurrentValue: true },
+    );
+  }
+}
+
+function formatCoreError(sentError: ISentError): IPlayerError {
+  switch (sentError.name) {
+    case "NetworkError":
+      return new NetworkError(
+        sentError.code,
+        new RequestError(
+          sentError.baseError.url,
+          sentError.baseError.status,
+          sentError.baseError.type,
+        ),
+      );
+    case "MediaError":
+      // eslint-disable-next-line
+      return new MediaError(sentError.code as any, sentError.reason, {
+        tracks: sentError.tracks,
+      });
+    case "EncryptedMediaError":
+      // We assume that everything have already been checked Worker-side here
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+      return new EncryptedMediaError(sentError.code, sentError.reason, {
+        keyStatuses: sentError.keyStatuses,
+        keySystemConfiguration: sentError.keySystemConfiguration,
+        keySystem: sentError.keySystem,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      } as any);
+    case "OtherError":
+      return new OtherError(sentError.code, sentError.reason);
+  }
+}
+
+/** Enume allowing to state what is the current status of MediaSource initialization. */
+const enum MediaSourceInitializationStatus {
   /**
-   * Interface allowing to prioritize CDN between one another depending on past
-   * performances, content steering, etc.
+   * The `MediaSource` is not attached to the `HTMLMediaElement` and shouldn't
+   * be yet.
    */
-  cdnPrioritizer: CdnPrioritizer;
-  /** Module to facilitate segment fetching. */
-  segmentQueueCreator: SegmentQueueCreator;
-  /** Last wanted playback rate. */
-  speed: IReadOnlySharedReference<number>;
-  /** `MediaSource` element on which the media will be buffered. */
-  mediaSource: MainMediaSourceInterface;
-  /** The initial position to seek to in media time, in seconds. */
-  initialTime: number;
-  /** If `true` it should automatically play once enough data is loaded. */
-  autoPlay: boolean;
+  Nothing,
+  /**
+   * The `MediaSource` is not yet attached to the `HTMLMediaElement` but it
+   * now can and should be.
+   *
+   * The purpose of this enum variant is to be set when wanting to indicate
+   * that `MediaSource` attachment has to be done, in code that do not have
+   * the capability to do so.
+   *
+   * The code that can do so would then read that value and then set this enum
+   * to `Attached` once the `MediaSource` is attached.
+   */
+  AttachNow,
+  /** The `MediaSource` is attached to the `HTMLMediaElement`. */
+  Attached,
 }
 
-/**
- * Change the decipherability of Representations which have their key id in one
- * of the given Arrays:
- *
- *   - Those who have a key id listed in `whitelistedKeyIds` will have their
- *     decipherability updated to `true`
- *
- *   - Those who have a key id listed in `blacklistedKeyIds` will have their
- *     decipherability updated to `false`
- *
- *   - Those who have a key id listed in `delistedKeyIds` will have their
- *     decipherability updated to `undefined`.
- *
- * @param {Object} manifest
- * @param {Array.<Uint8Array>} whitelistedKeyIds
- * @param {Array.<Uint8Array>} blacklistedKeyIds
- * @param {Array.<Uint8Array>} delistedKeyIds
- */
-function updateKeyIdsDecipherabilityOnManifest(
-  manifest: IManifest,
-  whitelistedKeyIds: Uint8Array[],
-  blacklistedKeyIds: Uint8Array[],
-  delistedKeyIds: Uint8Array[],
-): void {
-  manifest.updateRepresentationsDeciperability((ctx) => {
-    const { representation } = ctx;
-    if (representation.contentProtections === undefined) {
-      return representation.decipherable;
-    }
-    const contentKIDs = representation.contentProtections.keyIds;
-    if (contentKIDs !== undefined) {
-      for (const elt of contentKIDs) {
-        for (const blacklistedKeyId of blacklistedKeyIds) {
-          if (areArraysOfNumbersEqual(blacklistedKeyId, elt)) {
-            return false;
-          }
-        }
-        for (const whitelistedKeyId of whitelistedKeyIds) {
-          if (areArraysOfNumbersEqual(whitelistedKeyId, elt)) {
-            return true;
-          }
-        }
-        for (const delistedKeyId of delistedKeyIds) {
-          if (areArraysOfNumbersEqual(delistedKeyId, elt)) {
-            return undefined;
-          }
-        }
-      }
-    }
-    return representation.decipherable;
-  });
+interface IDrmInitializationStatus {
+  /** Current initialization state the decryption logic is in. */
+  initializationState: IDecryptionInitializationState;
+  /**
+   * If set, corresponds to the hex string describing the current key system
+   * used.
+   * `undefined` if unknown or if it does not apply.
+   */
+  drmSystemId: string | undefined;
 }
 
-/**
- * Update decipherability to `false` to any Representation which is linked to
- * the given initialization data.
- * @param {Object} manifest
- * @param {Object} initData
- */
-function blackListProtectionDataOnManifest(
-  manifest: IManifest,
-  initData: IProcessedProtectionData,
-) {
-  manifest.updateRepresentationsDeciperability((ctx) => {
-    const rep = ctx.representation;
-    if (rep.decipherable === false) {
-      return false;
-    }
-    const segmentProtections = rep.contentProtections?.initData ?? [];
-    for (const protection of segmentProtections) {
-      if (initData.type === undefined || protection.type === initData.type) {
-        const containedInitData = initData.values
-          .getFormattedValues()
-          .every((undecipherableVal) => {
-            return protection.values.some((currVal) => {
-              return (
-                (undecipherableVal.systemId === undefined ||
-                  currVal.systemId === undecipherableVal.systemId) &&
-                areArraysOfNumbersEqual(currVal.data, undecipherableVal.data)
-              );
-            });
-          });
-        if (containedInitData) {
-          return false;
-        }
-      }
-    }
-    return rep.decipherable;
-  });
+/** Initialization steps to add decryption capabilities to an `HTMLMediaElement`. */
+type IDecryptionInitializationState =
+  /**
+   * Decryption capabilities have not been initialized yet.
+   * You should wait before performing any action on the concerned
+   * `HTMLMediaElement` (such as linking a content / `MediaSource` to it).
+   */
+  | { type: "uninitialized"; value: null }
+  /**
+   * The `MediaSource` or media url can be linked AND segments can be pushed to
+   * the `HTMLMediaElement` on which decryption capabilities were wanted.
+   */
+  | {
+      type: "initialized";
+      value: null;
+    };
+
+function formatSourceBufferError(error: unknown): SourceBufferError {
+  if (error instanceof SourceBufferError) {
+    return error;
+  } else if (error instanceof Error) {
+    return new SourceBufferError(
+      error.name,
+      error.message,
+      error.name === "QuotaExceededError",
+    );
+  } else {
+    return new SourceBufferError("Error", "Unknown SourceBufferError Error", false);
+  }
 }
 
 /**
- * Function to call when you want to "reload" the MediaSource: basically
- * restarting playback on a new MediaSource for the same content (it may
- * be for varied reasons, such as ensuring data buffers are empty, or
- * restarting after some kind of fatal error).
- * @param {Object} reloadOrder
- * @param {number} reloadOrder.position - Position in seconds at which we
- * should restart from when playback restarts.
- * @param {boolean} reloadOrder.autoPlay - If `true` we will directly play
- * once enough data is re-loaded.
+ * The Core might send back logs. In that situation, the message might be
+ * formatted slightly differently to be able to cross threads (so a
+ * serializable format has to be sent).
+ *
+ * This function translates that Core format to what's expected by the
+ * logger.
+ *
+ * @param {*} arg
+ * @returns {*}
  */
-type IReloadMediaSourceCallback = (reloadOrder: {
-  position: number;
-  autoPlay: boolean;
-}) => void;
+function formatSentLogObject(arg: ISentLogValue): IAcceptedLogValue {
+  if (typeof arg !== "object") {
+    return arg;
+  }
 
-/**
- * Handle accordingly an `IFreezeResolution` object.
- * @param {Object|null} freezeResolution - The `IFreezeResolution` suggested.
- * @param {Object} param - Parameters that might be needed to implement the
- * resolution.
- * @param {Object} param.manifest - The current content's Manifest object.
- * @param {Object} param.playbackObserver - Object regularly emitting playback
- * conditions.
- * @param {Function} param.triggerReload - Function to call if we need to ask
- * for a "MediaSource reload".
- * @param {Boolean} param.enableRepresentationAvoidance - If `true`, this
- * function is authorized to mark `Representation` as "to avoid" if the
- * `IFreezeResolution` object suggest it.
- */
-function handleFreezeResolution(
-  freezeResolution: IFreezeResolution,
-  {
-    playbackObserver,
-    enableRepresentationAvoidance,
-    manifest,
-    triggerReload,
-  }: {
-    playbackObserver: IMediaElementPlaybackObserver;
-    enableRepresentationAvoidance: boolean;
-    manifest: IManifest;
-    triggerReload: () => void;
-  },
-): void {
-  switch (freezeResolution.type) {
-    case "reload": {
-      log.info("Init", "Planning reload due to freeze");
-      triggerReload();
-      break;
-    }
-    case "flush": {
-      log.info("Init", "Flushing buffer due to freeze");
-      const observation = playbackObserver.getReference().getValue();
-      const currentTime = observation.position.isAwaitingFuturePosition()
-        ? observation.position.getWanted()
-        : playbackObserver.getCurrentTime();
-      const relativeResumingPosition = freezeResolution.value.relativeSeek;
-      const wantedSeekingTime = currentTime + relativeResumingPosition;
-      playbackObserver.setCurrentTime(wantedSeekingTime);
-      break;
-    }
-    case "avoid-representations": {
-      const contents = freezeResolution.value;
-      if (enableRepresentationAvoidance) {
-        manifest.addRepresentationsToAvoid(contents);
-      }
-      triggerReload();
-      break;
-    }
-    default:
-      assertUnreachable(freezeResolution);
+  if (arg?.isSerializedError === true) {
+    return formatCoreError(arg as ISentError);
   }
+  return arg as Exclude<ISentLogValue, ISentError>;
 }