rx-player 4.4.1-dev.2025101500 → 4.4.1

package/src/main_thread/init/media_source_content_initializer.ts

@@ -1,148 +1,150 @@
+/**
+ * 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 getEmeApiImplementation from "../../compat/eme";
+import isCodecSupported from "../../compat/is_codec_supported";
 import mayMediaElementFailOnUndecipherableData from "../../compat/may_media_element_fail_on_undecipherable_data";
 import shouldReloadMediaSourceOnDecipherabilityUpdate from "../../compat/should_reload_media_source_on_decipherability_update";
-import type { ISegmentSinkMetrics } from "../../core/segment_sinks/segment_sinks_store";
+import config from "../../config";
 import type {
   IAdaptiveRepresentationSelectorArguments,
-  IAdaptationChoice,
-  IResolutionInfo,
-  ICreateMediaSourceCoreMessage,
-  ISentError,
-  ICoreMessage,
-  ISentLogValue,
-} from "../../core/types";
-import { CoreMessageType } from "../../core/types";
+  IRepresentationEstimator,
+} from "../../core/adaptive";
+import AdaptiveRepresentationSelector from "../../core/adaptive";
+import CmcdDataBuilder from "../../core/cmcd";
 import {
-  EncryptedMediaError,
-  MediaError,
-  NetworkError,
-  OtherError,
-  SourceBufferError,
-} from "../../errors";
+  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";
 import features from "../../features";
 import log from "../../log";
-import type { IManifestMetadata } from "../../manifest";
-import {
-  replicateUpdatesOnManifestMetadata,
-  updateDecipherabilityFromKeyIds,
-  updateDecipherabilityFromProtectionData,
-} from "../../manifest";
-import MainMediaSourceInterface from "../../mse/main_media_source_interface";
-import type {
-  IReadOnlyPlaybackObserver,
-  IMediaElementPlaybackObserver,
-} from "../../playback_observer";
+import type { IManifest, IPeriodMetadata, ICodecSupportInfo } from "../../manifest";
+import type MainMediaSourceInterface from "../../mse/main_media_source_interface";
+import type { IMediaElementPlaybackObserver } from "../../playback_observer";
 import type {
   ICmcdOptions,
   IInitialManifest,
   IKeySystemOption,
   IPlayerError,
-  IRepresentationFilter,
 } from "../../public_types";
-import type { IThumbnailResponse, ITransportOptions } from "../../transports";
-import arrayFind from "../../utils/array_find";
+import type { IThumbnailResponse, ITransportPipelines } from "../../transports";
+import areArraysOfNumbersEqual from "../../utils/are_arrays_of_numbers_equal";
 import assert, { assertUnreachable } from "../../utils/assert";
-import idGenerator from "../../utils/id_generator";
+import createCancellablePromise from "../../utils/create_cancellable_promise";
 import isNullOrUndefined from "../../utils/is_null_or_undefined";
-import type { IAcceptedLogValue } from "../../utils/logger";
+import noop from "../../utils/noop";
 import objectAssign from "../../utils/object_assign";
 import type { IReadOnlySharedReference } from "../../utils/reference";
-import SharedReference from "../../utils/reference";
-import { RequestError } from "../../utils/request";
+import type { ISyncOrAsyncValue } from "../../utils/sync_or_async";
+import SyncOrAsync from "../../utils/sync_or_async";
 import type { CancellationSignal } 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 TaskCanceller from "../../utils/task_canceller";
 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 {
-  resetMediaElement,
-  disableRemotePlaybackOnManagedMediaSource,
-} from "./utils/create_media_source";
+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/stream_events_emitter";
+import StreamEventsEmitter from "./utils/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 _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;
+  private _initSettings: IInitializeArguments;
   /**
    * `TaskCanceller` allowing to abort everything that the
    * `MediaSourceContentInitializer` is doing.
    */
   private _initCanceller: TaskCanceller;
+  /** Interface allowing to fetch and refresh the Manifest. */
+  private _manifestFetcher: ManifestFetcher;
   /**
-   * `TaskCanceller` allowing to abort and clean-up every task and resource
-   * linked to the current `MediaSource` instance.
-   *
-   * It may be triggered either at content stop (and thus at the same time than
-   * the `_initCanceller`) or when reloading the content.
+   * 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 _currentMediaSourceCanceller: TaskCanceller;
+  private _manifest: ISyncOrAsyncValue<IManifest> | null;
 
-  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;
+  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.
+   *
+   *   - 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`.
+   */
+  private _decryptionCapabilities:
+    | {
+        status: "uninitialized";
+        value: null;
       }
-    >;
-    /**
-     * 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: "disabled";
+        value: EncryptedMediaError;
       }
-    >;
-  };
+    | {
+        status: "enabled";
+        value: ContentDecryptor;
+      };
 
   /**
    * Create a new `MediaSourceContentInitializer`, associated to the given
@@ -151,173 +153,78 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
    */
   constructor(settings: IInitializeArguments) {
     super();
-    this._settings = settings;
+    this._initSettings = settings;
     this._initCanceller = new TaskCanceller();
-    this._currentMediaSourceCanceller = new TaskCanceller();
-    this._currentMediaSourceCanceller.linkToSignal(this._initCanceller.signal);
-    this._currentContentInfo = null;
-    this._awaitingRequests = {
-      nextRequestId: 0,
-      pendingSinkMetrics: new Map(),
-      pendingThumbnailFetching: new Map(),
-    };
-    this._queuedCoreMessages = null;
+    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,
+    });
   }
 
   /**
    * Perform non-destructive preparation steps, to prepare a future content.
+   * For now, this mainly mean loading the Manifest document.
    */
   public prepare(): void {
-    if (this._currentContentInfo !== null || this._initCanceller.isUsed()) {
-      return;
-    }
-    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(() => {
-      coreInterface.sendMessage({
-        type: MainThreadMessageType.StopContent,
-        contentId,
-        value: null,
-      });
-    });
-    if (this._initCanceller.isUsed()) {
+    if (this._manifest !== null) {
       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._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();
     this._initCanceller.signal.register(() => {
-      log.debug("Init", "removeEventListener prepare for core message");
-      this._settings.coreInterface.removeMessageListener(onmessage);
-      this._settings.coreInterface.removeErrorListener(onmessageerror);
+      this._manifestFetcher.dispose();
     });
+  }
 
-    // Also bind all `SharedReference` objects:
+  /**
+   * @param {HTMLMediaElement} mediaElement
+   * @param {Object} playbackObserver
+   */
+  public start(
+    mediaElement: IMediaElement,
+    playbackObserver: IMediaElementPlaybackObserver,
+  ): void {
+    this.prepare(); // Load Manifest if not already done
 
-    const throttleVideoBitrate =
-      adaptiveOptions.throttlers.throttleBitrate.video ?? new SharedReference(Infinity);
-    bindNumberReferencesToCore(
-      coreInterface,
+    /** Translate errors coming from the media element into RxPlayer errors. */
+    listenToMediaError(
+      mediaElement,
+      (error: MediaError) => this._onFatalError(error),
       this._initCanceller.signal,
-      [wantedBufferAhead, "wantedBufferAhead"],
-      [maxVideoBufferSize, "maxVideoBufferSize"],
-      [maxBufferAhead, "maxBufferAhead"],
-      [maxBufferBehind, "maxBufferBehind"],
-      [throttleVideoBitrate, "throttleVideoBitrate"],
     );
 
-    const limitVideoResolution =
-      adaptiveOptions.throttlers.limitResolution.video ??
-      new SharedReference<IResolutionInfo>({
-        height: undefined,
-        width: undefined,
-        pixelRatio: 1,
+    this._setupInitialMediaSourceAndDecryption(mediaElement)
+      .then((initResult) =>
+        this._onInitialMediaSourceReady(
+          mediaElement,
+          initResult.mediaSource,
+          playbackObserver,
+          initResult.drmSystemId,
+          initResult.unlinkMediaSource,
+        ),
+      )
+      .catch((err) => {
+        this._onFatalError(err);
       });
-    limitVideoResolution.onUpdate(
-      (newVal) => {
-        coreInterface.sendMessage({
-          type: MainThreadMessageType.ReferenceUpdate,
-          value: { name: "limitVideoResolution", newVal },
-        });
-      },
-      { clearSignal: this._initCanceller.signal, emitCurrentValue: true },
-    );
   }
 
   /**
@@ -328,472 +235,589 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
    * DASH's MPD) will be refreshed immediately.
    */
   public updateContentUrls(urls: string[] | undefined, refreshNow: boolean): void {
-    if (this._currentContentInfo === null) {
-      return;
-    }
-    this._settings.coreInterface.sendMessage({
-      type: MainThreadMessageType.ContentUrlsUpdate,
-      contentId: this._currentContentInfo.contentId,
-      value: { urls, refreshNow },
-    });
+    this._manifestFetcher.updateContentUrls(urls, refreshNow);
   }
 
   /**
-   * @param {HTMLMediaElement} mediaElement
-   * @param {Object} playbackObserver
+   * Stop content and free all resources linked to this
+   * `MediaSourceContentInitializer`.
    */
-  public start(
-    mediaElement: IMediaElement,
-    playbackObserver: IMediaElementPlaybackObserver,
-  ): void {
-    this.prepare(); // Load Manifest if not already done
+  public dispose(): void {
+    this._initCanceller.cancel();
+  }
+
+  /**
+   * Callback called when an error interrupting playback arised.
+   * @param {*} err
+   */
+  private _onFatalError(err: unknown) {
     if (this._initCanceller.isUsed()) {
       return;
     }
+    this._initCanceller.cancel();
+    this.trigger("error", err);
+  }
 
-    let textDisplayer: ITextDisplayer | null = null;
-    if (
-      this._settings.textTrackOptions.textTrackMode === "html" &&
-      features.htmlTextDisplayer !== null
-    ) {
-      assert(this._hasTextBufferFeature());
-      textDisplayer = new features.htmlTextDisplayer(
+  /**
+   * 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(
         mediaElement,
-        this._settings.textTrackOptions.textTrackElement,
+        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 },
       );
-    } else if (features.nativeTextDisplayer !== null) {
-      assert(this._hasTextBufferFeature());
-      textDisplayer = new features.nativeTextDisplayer(mediaElement);
-    } else {
-      assert(!this._hasTextBufferFeature());
-    }
-    this._initCanceller.signal.register(() => {
-      textDisplayer?.stop();
     });
+  }
 
-    /** Translate errors coming from the media element into RxPlayer errors. */
-    listenToMediaError(
-      mediaElement,
-      (error: MediaError) => this._onFatalError(error),
-      this._initCanceller.signal,
+  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
+    }
+
+    manifest.addEventListener(
+      "manifestUpdate",
+      (updates) => {
+        this.trigger("manifestUpdate", updates);
+        this._refreshManifestCodecSupport(manifest, mediaElement);
+      },
+      initCanceller.signal,
     );
 
-    /**
-     * Send content protection initialization data.
-     * TODO remove and use ContentDecryptor directly when possible.
-     */
-    const lastContentProtection = new SharedReference<IContentProtection | null>(null);
+    manifest.addEventListener(
+      "decipherabilityUpdate",
+      (elts) => {
+        this.trigger("decipherabilityUpdate", elts);
+      },
+      initCanceller.signal,
+    );
 
-    const mediaSourceStatus = new SharedReference<MediaSourceInitializationStatus>(
-      MediaSourceInitializationStatus.Nothing,
+    manifest.addEventListener(
+      "supportUpdate",
+      () => {
+        this.trigger("codecSupportUpdate", null);
+      },
+      initCanceller.signal,
     );
 
-    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;
+    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,
+    );
+
+    const cdnPrioritizer = new CdnPrioritizer(initCanceller.signal);
+    const segmentQueueCreator = new SegmentQueueCreator(
+      transport,
+      cdnPrioritizer,
+      this._cmcdDataBuilder,
+      segmentRequestOptions,
+    );
+
+    this._refreshManifestCodecSupport(manifest, mediaElement);
+    this.trigger("manifestReady", manifest);
+    if (initCanceller.isUsed()) {
+      return;
     }
 
-    const playbackStartParams = {
-      mediaElement,
-      textDisplayer,
-      playbackObserver,
-      drmInitializationStatus,
-      mediaSourceStatus,
-    };
-    mediaSourceStatus.onUpdate(
-      (msInitStatus, stopListeningMSStatus) => {
-        if (msInitStatus === MediaSourceInitializationStatus.Attached) {
-          stopListeningMSStatus();
-          this._startPlaybackIfReady(playbackStartParams);
-        }
+    // handle initial load and reloads
+    this._setupContentWithNewMediaSource(
+      {
+        mediaElement,
+        playbackObserver,
+        mediaSource: initialMediaSource,
+        initialTime,
+        autoPlay,
+        manifest,
+        representationEstimator,
+        cdnPrioritizer,
+        segmentQueueCreator,
+        speed,
+        bufferOptions: subBufferOptions,
       },
-      { clearSignal: this._initCanceller.signal, emitCurrentValue: true },
+      initialMediaSourceCanceller,
     );
-    drmInitializationStatus.onUpdate(
-      (initializationStatus, stopListeningDrm) => {
-        if (initializationStatus.initializationState.type === "initialized") {
-          stopListeningDrm();
-          this._startPlaybackIfReady(playbackStartParams);
-        }
-      },
-      { emitCurrentValue: true, clearSignal: this._initCanceller.signal },
+  }
+
+  /**
+   * 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,
     );
+  }
 
-    /**
-     * 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;
-      }
-      if (
-        reloadingContentInfo === null ||
-        reloadingContentInfo.mediaSourceInfo === null
-      ) {
-        log.warn("Init", "Asked to reload when no MediaSource is active.");
+  /**
+   * 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()) {
         return;
       }
-
-      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.");
+      this.trigger("reloadingMediaSource", reloadOrder);
+      if (initCanceller.isUsed()) {
         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();
-            }
-            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);
-              }
+      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,
             },
-            { emitCurrentValue: true, clearSignal: this._initCanceller.signal },
+            newCanceller,
           );
-          break;
-        }
-
-        case CoreMessageType.Warning:
-          if (this._currentContentInfo?.contentId !== msgData.contentId) {
-            return;
-          }
-          this.trigger("warning", formatCoreError(msgData.value));
-          break;
-
-        case CoreMessageType.Error:
-          if (this._currentContentInfo?.contentId !== msgData.contentId) {
+        })
+        .catch((err) => {
+          if (newCanceller.isUsed()) {
             return;
           }
-          this._onFatalError(formatCoreError(msgData.value));
-          break;
-
-        case CoreMessageType.CreateMediaSource:
-          this._onCreateMediaSourceMessage(
-            msgData,
-            mediaElement,
-            mediaSourceStatus,
-            this._settings.coreInterface,
+          this._onFatalError(err);
+        });
+    };
+  }
+
+  /**
+   * 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();
+      });
+    }
+
+    /** Interface to create media buffers. */
+    const segmentSinksStore = new SegmentSinksStore(
+      mediaSource,
+      mediaElement.nodeName === "VIDEO",
+      textDisplayerInterface,
+    );
+
+    cancelSignal.register(() => {
+      segmentSinksStore.disposeAll();
+    });
+
+    const { autoPlayResult, initialPlayPerformed } = performInitialSeekAndPlay(
+      {
+        mediaElement,
+        playbackObserver,
+        startTime: initialTime,
+        mustAutoPlay: autoPlay,
+        onWarning: (err) => {
+          this.trigger("warning", err);
+        },
+        isDirectfile: false,
+      },
+      cancelSignal,
+    );
+
+    if (cancelSignal.isCancelled()) {
+      return;
+    }
+
+    initialPlayPerformed.onUpdate(
+      (isPerformed, stopListening) => {
+        if (isPerformed) {
+          stopListening();
+          const streamEventsEmitter = new StreamEventsEmitter(manifest, playbackObserver);
+          manifest.addEventListener(
+            "manifestUpdate",
+            () => {
+              streamEventsEmitter.onManifestUpdate(manifest);
+            },
+            cancelSignal,
           );
-          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(),
-                });
-              });
+          streamEventsEmitter.addEventListener(
+            "event",
+            (payload) => {
+              this.trigger("streamEvent", payload);
+            },
+            cancelSignal,
+          );
+          streamEventsEmitter.addEventListener(
+            "eventSkip",
+            (payload) => {
+              this.trigger("streamEventSkip", payload);
+            },
+            cancelSignal,
+          );
+          streamEventsEmitter.start();
+          cancelSignal.register(() => {
+            streamEventsEmitter.stop();
+          });
+        }
+      },
+      { 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);
           }
-          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(),
-                });
+        },
+        cancelSignal,
+      );
+    }
+
+    coreObserver.listen(
+      (observation) => {
+        synchronizeSegmentSinksOnObservation(observation, segmentSinksStore);
+        const freezeResolution = freezeResolver.onNewObservation(observation);
+        if (freezeResolution === null) {
+          return;
+        }
+
+        // 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 },
+    );
+
+    const contentTimeBoundariesObserver = createContentTimeBoundariesObserver(
+      manifest,
+      mediaSource,
+      coreObserver,
+      segmentSinksStore,
+      {
+        onWarning: (err: IPlayerError) => this.trigger("warning", err),
+        onPeriodChanged: (period: IPeriodMetadata) =>
+          this.trigger("activePeriodChanged", { period }),
+      },
+      cancelSignal,
+    );
+
+    /**
+     * 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,
+                  );
+                },
               });
-          }
-          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();
-          }
-          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();
-          }
-          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();
-          }
-          break;
+          },
+          { emitCurrentValue: true, clearSignal: cancelSignal },
+        );
+      })
+      .catch((err) => {
+        if (cancelSignal.isCancelled()) {
+          return; // Current loading cancelled, no need to trigger the error
+        }
+        this._onFatalError(err);
+      });
 
-        case CoreMessageType.NeedsBufferFlush: {
-          if (this._currentContentInfo?.contentId !== msgData.contentId) {
-            return;
-          }
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const self = this;
+    StreamOrchestrator(
+      { manifest, initialPeriod },
+      coreObserver,
+      representationEstimator,
+      segmentSinksStore,
+      segmentQueueCreator,
+      bufferOptions,
+      handleStreamOrchestratorCallbacks(),
+      cancelSignal,
+    );
+
+    /**
+     * 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 = msgData.value?.relativeResumingPosition ?? 0;
-          const canBeApproximateSeek = Boolean(
-            msgData.value?.relativePosHasBeenDefaulted,
-          );
-          let wantedSeekingTime: number;
+          const relativeResumingPosition = payload?.relativeResumingPosition ?? 0;
+          const canBeApproximateSeek = Boolean(payload?.relativePosHasBeenDefaulted);
 
           if (relativeResumingPosition === 0 && canBeApproximateSeek) {
             // in case relativeResumingPosition is 0, we still perform
@@ -803,886 +827,251 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
             wantedSeekingTime = currentTime + relativeResumingPosition;
           }
           playbackObserver.setCurrentTime(wantedSeekingTime);
-          break;
-        }
 
-        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,
+          // 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);
+              }
+            },
+            { includeLastObservation: false, clearSignal: cancelSignal },
           );
-          if (period !== undefined) {
-            this.trigger("activePeriodChanged", { period });
-          }
-          break;
-        }
+        },
 
-        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,
-            });
+        streamStatusUpdate(value) {
+          // Announce discontinuities if found
+          const { period, bufferType, imminentDiscontinuity, position } = value;
+          rebufferingController.updateDiscontinuityInfo({
+            period,
+            bufferType,
+            discontinuity: imminentDiscontinuity,
+            position,
+          });
+          if (cancelSignal.isCancelled()) {
+            return; // Previous call has stopped streams due to a side-effect
           }
-          break;
-        }
 
-        case CoreMessageType.RepresentationChanged: {
+          // 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.
           if (
-            this._currentContentInfo?.contentId !== msgData.contentId ||
-            this._currentContentInfo.manifest === null
+            manifest.isLastPeriodKnown &&
+            value.period.id === manifest.periods[manifest.periods.length - 1].id
           ) {
-            return;
-          }
-          const period = arrayFind(
-            this._currentContentInfo.manifest.periods,
-            (p) => p.id === msgData.value.periodId,
-          );
-          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,
-          );
-          if (adaptation === undefined) {
-            return;
-          }
-          const representation = arrayFind(
-            adaptation.representations,
-            (r) => r.id === msgData.value.representationId,
-          );
-          if (representation !== undefined) {
-            this.trigger("representationChange", {
-              period,
-              type: msgData.value.type,
-              representation,
-            });
+            const hasFinishedLoadingLastPeriod =
+              value.hasFinishedLoading || value.isEmptyStream;
+            if (hasFinishedLoadingLastPeriod) {
+              contentTimeBoundariesObserver.onLastSegmentFinishedLoading(
+                value.bufferType,
+              );
+            } else {
+              contentTimeBoundariesObserver.onLastSegmentLoadingResume(value.bufferType);
+            }
           }
-          break;
-        }
+        },
 
-        case CoreMessageType.EncryptionDataEncountered:
-          if (this._currentContentInfo?.contentId !== msgData.contentId) {
-            return;
-          }
-          lastContentProtection.setValue(msgData.value);
-          break;
+        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,
+          });
+        },
 
-        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;
-        }
+        lockedStream: (value) =>
+          rebufferingController.onLockedStream(value.bufferType, value.period),
 
-        case CoreMessageType.ManifestUpdate: {
-          if (this._currentContentInfo?.contentId !== msgData.contentId) {
-            return;
+        adaptationChange: (value) => {
+          self.trigger("adaptationChange", value);
+          if (cancelSignal.isCancelled()) {
+            return; // Previous call has stopped streams due to a side-effect
           }
-          const manifest = this._currentContentInfo?.manifest;
-          if (isNullOrUndefined(manifest)) {
-            log.error("Init", "Manifest update but no Manifest loaded");
-            return;
+          contentTimeBoundariesObserver.onAdaptationChange(
+            value.type,
+            value.period,
+            value.adaptation,
+          );
+        },
+
+        representationChange: (value) => {
+          self.trigger("representationChange", value);
+          if (cancelSignal.isCancelled()) {
+            return; // Previous call has stopped streams due to a side-effect
           }
+          contentTimeBoundariesObserver.onRepresentationChange(value.type, value.period);
+        },
 
-          replicateUpdatesOnManifestMetadata(
-            manifest,
-            msgData.value.manifest,
-            msgData.value.updates,
-          );
-          this._currentContentInfo?.streamEventsEmitter?.onManifestUpdate(manifest);
+        inbandEvent: (value) => self.trigger("inbandEvents", value),
 
-          this._updateCodecSupport(manifest, mediaElement);
-          this.trigger("manifestUpdate", msgData.value.updates);
-          break;
-        }
+        warning: (value) => self.trigger("warning", value),
 
-        case CoreMessageType.UpdatePlaybackRate:
-          if (this._currentContentInfo?.contentId !== msgData.contentId) {
-            return;
-          }
-          playbackObserver.setPlaybackRate(msgData.value);
-          break;
+        periodStreamReady: (value) => self.trigger("periodStreamReady", value),
 
-        case CoreMessageType.BitrateEstimateChange:
-          if (this._currentContentInfo?.contentId !== msgData.contentId) {
-            return;
+        periodStreamCleared: (value) => {
+          contentTimeBoundariesObserver.onPeriodCleared(value.type, value.period);
+          if (cancelSignal.isCancelled()) {
+            return; // Previous call has stopped streams due to a side-effect
           }
-          this.trigger("bitrateEstimateChange", {
-            type: msgData.value.bufferType,
-            bitrate: msgData.value.bitrate,
+          self.trigger("periodStreamCleared", {
+            type: value.type,
+            periodId: value.period.id,
           });
-          break;
+        },
 
-        case CoreMessageType.InbandEvent:
-          if (this._currentContentInfo?.contentId !== msgData.contentId) {
-            return;
+        bitrateEstimateChange: (value) => {
+          self._cmcdDataBuilder?.updateThroughput(value.type, value.bitrate);
+          self.trigger("bitrateEstimateChange", value);
+        },
+
+        needsMediaSourceReload: (payload) => {
+          reloadMediaSource(
+            payload.timeOffset,
+            payload.minimumPosition,
+            payload.maximumPosition,
+          );
+        },
+
+        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);
+            } else {
+              playbackObserver.setCurrentTime(position);
+            }
           }
-          this.trigger("inbandEvents", msgData.value);
-          break;
+        },
 
-        case CoreMessageType.LockedStream: {
-          if (
-            this._currentContentInfo?.contentId !== msgData.contentId ||
-            this._currentContentInfo.manifest === null
-          ) {
+        encryptionDataEncountered: (value) => {
+          if (self._decryptionCapabilities.status === "disabled") {
+            self._onFatalError(self._decryptionCapabilities.value);
+            return;
+          } else if (self._decryptionCapabilities.status === "uninitialized") {
+            // Should never happen
+            log.error(
+              "Init",
+              "received encryption data without known decryption capabilities",
+            );
             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,
-                      },
-                },
-              });
-            },
-            { clearSignal: this._initCanceller.signal },
-          );
-          this.trigger("periodStreamReady", {
-            period,
-            type: msgData.value.bufferType,
-            adaptationRef: ref,
-          });
-          break;
-        }
-
-        case CoreMessageType.PeriodStreamCleared: {
-          if (
-            this._currentContentInfo?.contentId !== msgData.contentId ||
-            this._currentContentInfo.manifest === null
-          ) {
-            return;
-          }
-          this.trigger("periodStreamCleared", {
-            periodId: msgData.value.periodId,
-            type: msgData.value.bufferType,
-          });
-          break;
-        }
-
-        case CoreMessageType.DiscontinuityUpdate: {
-          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) {
-            log.warn("Init", "Discontinuity's Period not found", {
-              periodId: msgData.value.periodId,
-            });
-            return;
-          }
-          this._currentContentInfo.rebufferingController?.updateDiscontinuityInfo({
-            period,
-            bufferType: msgData.value.bufferType,
-            discontinuity: msgData.value.discontinuity,
-            position: msgData.value.position,
-          });
-          break;
-        }
-
-        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;
-        }
-
-        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;
-        }
-
-        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;
-        }
-
-        case CoreMessageType.StopTextDisplayer: {
-          if (this._currentContentInfo?.contentId !== msgData.contentId) {
-            return;
-          }
-          if (textDisplayer === null) {
-            log.warn(
-              "text",
-              "Received StopTextDisplayer message but no text displayer exists",
-            );
-          } else {
-            textDisplayer.stop();
-          }
-          break;
-        }
-
-        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;
-
-            if (mediaSourceId !== msgData.mediaSourceId) {
-              return;
-            }
-            reloadMediaSource(
-              msgData.value.timeOffset,
-              msgData.value.minimumPosition,
-              msgData.value.maximumPosition,
-            );
-          }
-          break;
-
-        case CoreMessageType.NeedsDecipherabilityFlush:
-          {
-            if (this._currentContentInfo?.contentId !== msgData.contentId) {
-              return;
-            }
-
-            const keySystem = getKeySystemConfiguration(mediaElement);
-            if (shouldReloadMediaSourceOnDecipherabilityUpdate(keySystem?.[0])) {
-              notifyAndStartMediaSourceReload(0, undefined, undefined);
-            } else {
-              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;
-
-        case CoreMessageType.SegmentSinkStoreUpdate: {
-          if (this._currentContentInfo?.contentId !== msgData.contentId) {
-            return;
-          }
-          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;
-          }
-          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);
+          for (const protectionData of value) {
+            self._decryptionCapabilities.value.onInitializationData(protectionData);
+            if (cancelSignal.isCancelled()) {
+              return; // Previous call has stopped streams due to a side-effect
             }
-          } else {
-            log.error("Init", "Failed to send segment sink store update");
-          }
-          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(): void {
-    this._initCanceller.cancel();
-    if (this._currentContentInfo !== null) {
-      if (this._currentContentInfo.mediaSourceInfo?.type === "main") {
-        this._currentContentInfo.mediaSourceInfo.mediaSource.dispose();
-      }
-      this._currentContentInfo = null;
-    }
-  }
-
-  private _onFatalError(err: unknown) {
-    if (this._initCanceller.isUsed()) {
-      return;
-    }
-    this._initCanceller.cancel();
-    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 };
-    };
-
-    if (keySystems.length === 0) {
-      return createEmeDisabledReference("No `keySystems` option given.");
-    } else if (features.decrypt === null) {
-      return createEmeDisabledReference("EME feature not activated.");
-    }
-
-    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,
-        );
-      }
-    };
-    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,
-          })),
-        });
-      }
-      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(() => {
-      contentDecryptor.dispose();
-    });
-
-    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);
+        error: (err) => self._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();
-    this._currentMediaSourceCanceller = new TaskCanceller();
-    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;
+    /**
+     * 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);
+      }
+      if (maximumPosition !== undefined) {
+        position = Math.min(maximumPosition, position);
+      }
+      onReloadOrder({ position, autoPlay: !isPaused });
     }
+  }
 
-    /**
-     * Class trying to avoid various stalling situations, emitting "stalled"
-     * events when it cannot, as well as "unstalled" events when it get out of one.
-     */
+  /**
+   * 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 {
     const rebufferingController = new RebufferingController(
       playbackObserver,
       manifest,
       speed,
     );
+    // Bubble-up events
     rebufferingController.addEventListener("stalled", (evt) =>
       this.trigger("stalled", evt),
     );
@@ -1692,415 +1081,105 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
     rebufferingController.addEventListener("warning", (err) =>
       this.trigger("warning", err),
     );
-    cancelSignal.register(() => {
-      rebufferingController.destroy();
-    });
+    cancelSignal.register(() => rebufferingController.destroy());
     rebufferingController.start();
-    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(() => {
-            streamEventsEmitter.stop();
-          });
-        }
-      },
-      { 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;
+    return rebufferingController;
   }
 
   /**
-   * 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.
+   * Evaluates a list of codecs to determine their support status.
    *
-   * @param {Object} parameters
-   * @returns {boolean} - Returns `true` if all conditions where met for
-   * playback start.
+   * @param {Array} codecsToCheck - The list of codecs to check.
+   * @returns {Array} - The list of evaluated codecs with their support status updated.
    */
-  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(),
-    });
-    this._settings.coreInterface.sendMessage({
-      type: MainThreadMessageType.StartPreparedContent,
-      contentId,
-      value: {
-        initialTime,
-        initialObservation: sentInitialObservation,
-        drmSystemId: drmInitStatus.drmSystemId,
-        enableFastSwitching,
-        onCodecSwitch,
-      },
+  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,
+      };
     });
-
-    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;
+    return codecsSupportInfo;
   }
 
   /**
-   * 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.
+   * 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
    */
-  private _onCreateMediaSourceMessage(
-    msg: ICreateMediaSourceCoreMessage,
+  private _refreshManifestCodecSupport(
+    manifest: IManifest,
     mediaElement: IMediaElement,
-    mediaSourceStatus: SharedReference<MediaSourceInitializationStatus>,
-    coreInterface: CoreInterface,
   ): void {
-    if (this._currentContentInfo?.contentId !== msg.contentId) {
-      log.info("Init", "Ignoring MediaSource attachment due to wrong `contentId`");
-    } else {
-      const { mediaSourceId } = msg;
+    const codecsToTest = manifest.getCodecsWithUnknownSupport();
+    const codecsSupportInfo = this.getCodecsSupportInfo(codecsToTest, mediaElement);
+    if (codecsSupportInfo.length > 0) {
       try {
-        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();
-              }
-              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(() => {
-                mediaSource.dispose();
-                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);
+        manifest.updateCodecSupport(codecsSupportInfo);
+      } catch (err) {
+        this._onFatalError(err);
       }
     }
   }
 }
 
-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;
+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;
 }
 
 /** 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. */
@@ -2137,14 +1216,6 @@ 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"> & {
-    representationFilter?: IRepresentationFilter | string | undefined;
-  };
   /** Settings linked to Manifest requests. */
   manifestRequestSettings: {
     /** Maximum number of time a request on error will be retried. */
@@ -2170,6 +1241,8 @@ 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;
@@ -2198,151 +1271,196 @@ export interface IInitializeArguments {
   url: string | undefined;
 }
 
-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 {
-  /**
-   * The `MediaSource` is not attached to the `HTMLMediaElement` and shouldn't
-   * be yet.
-   */
-  Nothing,
+/** 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;
   /**
-   * 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.
+   * Interface allowing to prioritize CDN between one another depending on past
+   * performances, content steering, etc.
    */
-  AttachNow,
-  /** The `MediaSource` is attached to the `HTMLMediaElement`. */
-  Attached,
+  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;
 }
 
-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;
+/**
+ * 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;
+  });
 }
 
-/** 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);
-  }
+/**
+ * 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;
+  });
 }
 
 /**
- * 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 {*}
+ * 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.
  */
-function formatSentLogObject(arg: ISentLogValue): IAcceptedLogValue {
-  if (typeof arg !== "object") {
-    return arg;
-  }
+type IReloadMediaSourceCallback = (reloadOrder: {
+  position: number;
+  autoPlay: boolean;
+}) => void;
 
-  if (arg?.isSerializedError === true) {
-    return formatCoreError(arg as ISentError);
+/**
+ * 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);
   }
-  return arg as Exclude<ISentLogValue, ISentError>;
 }