rx-player 4.4.1 → 4.5.0-dev.2026012301

package/src/compat/reset_media_element.ts

@@ -0,0 +1,50 @@
+/**
+ * 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 log from "../log";
+import type { IMediaElement } from "./browser_compatibility_types";
+import clearElementSrc from "./clear_element_src";
+
+/**
+ * Dispose of ressources taken by the MediaSource:
+ *   - Clear the MediaSource' SourceBuffers
+ *   - Clear the mediaElement's src (stop the mediaElement)
+ *   - Revoke MediaSource' URL
+ * @param {HTMLMediaElement} mediaElement
+ * @param {string|null} mediaSourceURL
+ */
+export default function resetMediaElement(
+  mediaElement: IMediaElement,
+  mediaSourceURL: string | null,
+): void {
+  if (mediaSourceURL !== null && mediaElement.src === mediaSourceURL) {
+    log.info("media", "Clearing HTMLMediaElement's src");
+    clearElementSrc(mediaElement);
+  }
+
+  if (mediaSourceURL !== null) {
+    try {
+      log.debug("media", "Revoking previous URL");
+      URL.revokeObjectURL(mediaSourceURL);
+    } catch (e) {
+      log.warn(
+        "media",
+        "Error while revoking the media source URL",
+        e instanceof Error ? e : "",
+      );
+    }
+  }
+}

package/src/core/adaptive/adaptive_representation_selector.ts

@@ -195,7 +195,7 @@ function getEstimateReference(
    * This TaskCanceller is used both for restarting estimates with a new
    * configuration and to cancel them altogether.
    */
-  let currentEstimatesCanceller = new TaskCanceller();
+  let currentEstimatesCanceller = new TaskCanceller("ABR " + context.adaptation.type);
   currentEstimatesCanceller.linkToSignal(stopAllEstimates);
 
   // Create `SharedReference` on which estimates will be emitted.
@@ -495,8 +495,8 @@ function getEstimateReference(
    */
   function restartEstimatesProductionFromCurrentConditions(): void {
     const representations = representationsRef.getValue();
-    currentEstimatesCanceller.cancel();
-    currentEstimatesCanceller = new TaskCanceller();
+    currentEstimatesCanceller.cancel("restart");
+    currentEstimatesCanceller = new TaskCanceller("ABR " + context.adaptation.type);
     currentEstimatesCanceller.linkToSignal(stopAllEstimates);
     const newRef = createEstimateReference(
       representations,

package/src/core/cmcd/cmcd_data_builder.ts

@@ -133,8 +133,8 @@ export default class CmcdDataBuilder {
   public startMonitoringPlayback(
     playbackObserver: IReadOnlyPlaybackObserver<ICmcdDataBuilderPlaybackObservation>,
   ): void {
-    this._canceller?.cancel();
-    this._canceller = new TaskCanceller();
+    this._canceller?.cancel("CmcdDataBuilder start");
+    this._canceller = new TaskCanceller("CMCD monitoring");
     this._playbackObserver = playbackObserver;
     playbackObserver.listen(
       (obs) => {
@@ -151,7 +151,7 @@ export default class CmcdDataBuilder {
    * `stopMonitoringPlayback` call.
    */
   public stopMonitoringPlayback(): void {
-    this._canceller?.cancel();
+    this._canceller?.cancel("CmcdDataBuilder stop");
     this._canceller = null;
     this._playbackObserver = null;
   }

package/src/core/{main/common → entry}/FreezeResolver.ts

@@ -1,14 +1,14 @@
-import { config } from "../../../experimental";
-import log from "../../../log";
-import type { IAdaptation, IPeriod, IRepresentation } from "../../../manifest";
+import { config } from "../../experimental";
+import log from "../../log";
+import type { IAdaptation, IPeriod, IRepresentation } from "../../manifest";
 import type {
   IFreezingStatus,
   IRebufferingStatus,
   ObservationPosition,
-} from "../../../playback_observer";
-import getMonotonicTimeStamp from "../../../utils/monotonic_timestamp";
-import type SegmentSinksStore from "../../segment_sinks";
-import type { IBufferedChunk } from "../../segment_sinks";
+} from "../../playback_observer";
+import getMonotonicTimeStamp from "../../utils/monotonic_timestamp";
+import type SegmentSinksStore from "../segment_sinks";
+import type { IBufferedChunk } from "../segment_sinks";
 
 /**
  * "Freezing" is a complex situation indicating that playback is not advancing

package/src/core/{main → entry}/README.md

@@ -6,7 +6,7 @@
 | Multithread environment | Should be runnable in a WebWorker entirely |
 
 [1] In a Multithreading mode, no file from that directory should ever be imported by
-external code but the `WorkerMain` to generate the worker bundle. In a monothreading mode,
+external code but the `CoreEntry` to generate the worker bundle. In a monothreading mode,
 any file may be directly imported.
 
 ## Overview

package/src/core/{main/worker → entry}/content_preparer.ts

@@ -1,41 +1,39 @@
-import { MediaSource_ } from "../../../compat/browser_compatibility_types";
-import features from "../../../features";
-import log from "../../../log";
-import type { IManifest, IManifestMetadata } from "../../../manifest";
-import { createRepresentationFilterFromFnString } from "../../../manifest";
-import type Manifest from "../../../manifest/classes";
-import type { IMediaSourceInterface } from "../../../mse";
-import MainMediaSourceInterface from "../../../mse/main_media_source_interface";
-import WorkerMediaSourceInterface from "../../../mse/worker_media_source_interface";
+import { MediaSource_ } from "../../compat/browser_compatibility_types";
+import features from "../../features";
+import log from "../../log";
+import type { IContentInitializationData } from "../../main_thread/types";
+import type { IManifest } from "../../manifest";
+import { createRepresentationFilterFromFnString } from "../../manifest";
+import type Manifest from "../../manifest/classes";
+import type { IMediaSourceInterface } from "../../mse";
+import MainMediaSourceInterface from "../../mse/main_media_source_interface";
+import WorkerMediaSourceInterface from "../../mse/worker_media_source_interface";
 import type {
-  IAttachMediaSourceWorkerMessagePayload,
-  IContentInitializationData,
-} from "../../../multithread_types";
-import { WorkerMessageType } from "../../../multithread_types";
-import type { IPlayerError } from "../../../public_types";
-import assert from "../../../utils/assert";
-import idGenerator from "../../../utils/id_generator";
-import isNullOrUndefined from "../../../utils/is_null_or_undefined";
-import objectAssign from "../../../utils/object_assign";
-import type {
-  CancellationError,
-  CancellationSignal,
-} from "../../../utils/task_canceller";
-import TaskCanceller from "../../../utils/task_canceller";
-import type { IRepresentationEstimator } from "../../adaptive";
-import createAdaptiveRepresentationSelector from "../../adaptive";
-import CmcdDataBuilder from "../../cmcd";
-import type { IManifestRefreshSettings } from "../../fetchers";
-import { ManifestFetcher, SegmentQueueCreator } from "../../fetchers";
-import CdnPrioritizer from "../../fetchers/cdn_prioritizer";
-import createThumbnailFetcher from "../../fetchers/thumbnails/thumbnail_fetcher";
-import type { IThumbnailFetcher } from "../../fetchers/thumbnails/thumbnail_fetcher";
-import SegmentSinksStore from "../../segment_sinks";
-import FreezeResolver from "../common/FreezeResolver";
-import { limitVideoResolution, throttleVideoBitrate } from "./globals";
-import sendMessage, { formatErrorForSender } from "./send_message";
+  IPlayerError,
+  IRepresentationFilter,
+  ISegmentLoader,
+  IManifestLoader,
+} from "../../public_types";
+import idGenerator from "../../utils/id_generator";
+import isNullOrUndefined from "../../utils/is_null_or_undefined";
+import type { CancellationError, CancellationSignal } from "../../utils/task_canceller";
+import TaskCanceller from "../../utils/task_canceller";
+import type { IRepresentationEstimator } from "../adaptive";
+import createAdaptiveRepresentationSelector from "../adaptive";
+import type { IRepresentationEstimatorThrottlers } from "../adaptive/adaptive_representation_selector";
+import CmcdDataBuilder from "../cmcd";
+import type { IManifestRefreshSettings } from "../fetchers";
+import { ManifestFetcher, SegmentQueueCreator } from "../fetchers";
+import CdnPrioritizer from "../fetchers/cdn_prioritizer";
+import createThumbnailFetcher from "../fetchers/thumbnails/thumbnail_fetcher";
+import type { IThumbnailFetcher } from "../fetchers/thumbnails/thumbnail_fetcher";
+import SegmentSinksStore from "../segment_sinks";
+import type { IAttachMediaSourceCoreMessagePayload, ICoreMessage } from "../types";
+import { CoreMessageType } from "../types";
+import CoreTextDisplayerInterface from "./core_text_displayer_interface";
+import FreezeResolver from "./FreezeResolver";
 import TrackChoiceSetter from "./track_choice_setter";
-import WorkerTextDisplayerInterface from "./worker_text_displayer_interface";
+import { formatErrorForSender } from "./utils";
 
 /** Function allowing to associate a unique identifier to all created `MediaSource` */
 const generateMediaSourceId = idGenerator();
@@ -92,9 +90,9 @@ export default class ContentPreparer {
    */
   constructor({ hasVideo }: { hasVideo: boolean }) {
     this._currentContent = null;
-    this._currentMediaSourceCanceller = new TaskCanceller();
+    this._currentMediaSourceCanceller = new TaskCanceller("ContentPreparer MediaSource");
     this._hasVideo = hasVideo;
-    const contentCanceller = new TaskCanceller();
+    const contentCanceller = new TaskCanceller("ContentPreparer");
     this._contentCanceller = contentCanceller;
   }
 
@@ -108,15 +106,23 @@ export default class ContentPreparer {
    * Reject if it failed to do so.
    * @param {Object} context - Information on the content that should be
    * initialized.
+   * @param {Object} corePlugins - Callbacks that may have been registered by
+   * the application if it loaded the core independently as a worker.
    * @returns {Promise.<Object>}
    */
   public initializeNewContent(
+    sendMessage: (msg: ICoreMessage, transferables?: Transferable[]) => void,
     context: IContentInitializationData,
-  ): Promise<IManifestMetadata> {
+    /** Allows to filter which Representations can be choosen. */
+    throttlers: IRepresentationEstimatorThrottlers,
+    corePlugins: ICorePlugins,
+  ): Promise<IManifest> {
     return new Promise((res, rej) => {
-      this.disposeCurrentContent();
+      this.disposeCurrentContent("new init");
       const contentCanceller = this._contentCanceller;
-      const currentMediaSourceCanceller = new TaskCanceller();
+      const currentMediaSourceCanceller = new TaskCanceller(
+        "ContentPreparer MediaSource",
+      );
       this._currentMediaSourceCanceller = currentMediaSourceCanceller;
 
       currentMediaSourceCanceller.linkToSignal(contentCanceller.signal);
@@ -128,28 +134,31 @@ export default class ContentPreparer {
         transportOptions,
         useMseInWorker,
         enableRepresentationAvoidance,
+        transport,
       } = context;
       let manifest: IManifest | null = null;
 
-      // TODO better way
-      assert(
-        features.transports.dash !== undefined,
-        "Multithread RxPlayer should have access to the DASH feature",
-      );
-      const representationFilter =
-        typeof transportOptions.representationFilter === "string"
-          ? createRepresentationFilterFromFnString(transportOptions.representationFilter)
-          : undefined;
-      const dashPipelines = features.transports.dash({
+      const transportFn = features.transports[transport];
+      if (typeof transportFn !== "function") {
+        rej(
+          new Error(
+            `transport "${transport}" not supported. ` +
+              "Did you add the corresponding feature?",
+          ),
+        );
+        return;
+      }
+
+      const transportPipelines = transportFn({
         ...transportOptions,
-        representationFilter,
+        ...extractExternalPlugins(transportOptions, corePlugins),
       });
 
       const cmcdDataBuilder =
         context.cmcd === undefined ? null : new CmcdDataBuilder(context.cmcd);
       const manifestFetcher = new ManifestFetcher(
         url === undefined ? undefined : [url],
-        dashPipelines,
+        transportPipelines,
         {
           cmcdDataBuilder,
           ...context.manifestRetryOptions,
@@ -161,10 +170,7 @@ export default class ContentPreparer {
           video: context.initialVideoBitrate ?? 0,
         },
         lowLatencyMode: transportOptions.lowLatencyMode,
-        throttlers: {
-          limitResolution: { video: limitVideoResolution },
-          throttleBitrate: { video: throttleVideoBitrate },
-        },
+        throttlers,
       });
 
       const unbindRejectOnCancellation = currentMediaSourceCanceller.signal.register(
@@ -175,20 +181,21 @@ export default class ContentPreparer {
 
       const cdnPrioritizer = new CdnPrioritizer(contentCanceller.signal);
       const segmentQueueCreator = new SegmentQueueCreator(
-        dashPipelines,
+        transportPipelines,
         cdnPrioritizer,
         cmcdDataBuilder,
         context.segmentRetryOptions,
       );
       const fetchThumbnailData = createThumbnailFetcher(
-        dashPipelines.thumbnails,
+        transportPipelines.thumbnails,
         cdnPrioritizer,
       );
 
       const trackChoiceSetter = new TrackChoiceSetter();
 
-      const [mediaSource, segmentSinksStore, workerTextSender] =
+      const [mediaSource, segmentSinksStore, coreTextSender] =
         createMediaSourceInterfaceAndSegmentSinksStore(
+          sendMessage,
           contentId,
           {
             useMseInWorker,
@@ -210,7 +217,7 @@ export default class ContentPreparer {
         segmentSinksStore,
         segmentQueueCreator,
         fetchThumbnailData,
-        workerTextSender,
+        coreTextSender,
         trackChoiceSetter,
         useMseInWorker,
       };
@@ -222,14 +229,14 @@ export default class ContentPreparer {
         currentMediaSourceCanceller.signal,
       );
 
-      contentCanceller.signal.register(() => {
-        manifestFetcher.dispose();
+      contentCanceller.signal.register((err) => {
+        manifestFetcher.dispose(err.reason);
       });
       manifestFetcher.addEventListener(
         "warning",
         (err: IPlayerError) => {
           sendMessage({
-            type: WorkerMessageType.Warning,
+            type: CoreMessageType.Warning,
             contentId,
             value: formatErrorForSender(err),
           });
@@ -255,7 +262,7 @@ export default class ContentPreparer {
         "error",
         (err: unknown) => {
           sendMessage({
-            type: WorkerMessageType.Error,
+            type: CoreMessageType.Error,
             contentId,
             value: formatErrorForSender(err),
           });
@@ -274,7 +281,6 @@ export default class ContentPreparer {
           return;
         }
         updateCodecSupportInWorkerMode(manifest);
-        const sentManifest = manifest.getMetadataSnapshot();
         manifest.addEventListener(
           "manifestUpdate",
           (updates) => {
@@ -282,22 +288,16 @@ export default class ContentPreparer {
               // TODO log warn?
               return;
             }
-
-            // Remove `periods` key to reduce cost of an unnecessary manifest
-            // clone.
-            const snapshot = objectAssign(manifest.getMetadataSnapshot(), {
-              periods: [],
-            });
             sendMessage({
-              type: WorkerMessageType.ManifestUpdate,
+              type: CoreMessageType.ManifestUpdate,
               contentId,
-              value: { manifest: snapshot, updates },
+              value: { manifest, updates },
             });
           },
           contentCanceller.signal,
         );
         unbindRejectOnCancellation();
-        res(sentManifest);
+        res(manifest);
       }
     });
   }
@@ -324,33 +324,39 @@ export default class ContentPreparer {
   }
 
   /**
-   * Signal the ContentPreparer that the MediaSource is "reloading".
+   * Change the MediaSource attached for the current content.
+   * It is assumed that main thread is already notified that such a reload is
+   * happening.
    *
    * The returned Promise resolves when it restarts being ready.
+   * @param {Function} sendMessage
    * @returns {Promise}
    */
-  public reloadMediaSource(): Promise<void> {
-    this._currentMediaSourceCanceller.cancel();
+  public reloadMediaSource(
+    sendMessage: (msg: ICoreMessage, transferables?: Transferable[]) => void,
+  ): Promise<void> {
+    this._currentMediaSourceCanceller.cancel("ContentPreparer MediaSource reload");
     if (this._currentContent === null) {
       return Promise.reject(new Error("CP: No content anymore"));
     }
     this._currentContent.trackChoiceSetter.reset();
-    this._currentMediaSourceCanceller = new TaskCanceller();
+    this._currentMediaSourceCanceller = new TaskCanceller("ContentPreparer MediaSource");
 
-    const [mediaSourceInterface, segmentSinksStore, workerTextSender] =
+    const [mediaSourceInterface, segmentSinksStore, coreTextSender] =
       createMediaSourceInterfaceAndSegmentSinksStore(
+        sendMessage,
         this._currentContent.contentId,
         {
           useMseInWorker: this._currentContent.useMseInWorker,
           hasVideo: this._hasVideo,
-          hasText: this._currentContent.workerTextSender !== null,
+          hasText: this._currentContent.coreTextSender !== null,
         },
         this._currentMediaSourceCanceller.signal,
       );
     this._currentContent.mediaSource = mediaSourceInterface;
     this._currentContent.segmentSinksStore = segmentSinksStore;
     this._currentContent.freezeResolver = new FreezeResolver(segmentSinksStore);
-    this._currentContent.workerTextSender = workerTextSender;
+    this._currentContent.coreTextSender = coreTextSender;
     return new Promise((res, rej) => {
       mediaSourceInterface.addEventListener(
         "mediaSourceOpen",
@@ -375,10 +381,13 @@ export default class ContentPreparer {
   /**
    * Dispose all resources linked to the currently preopared content if one and
    * stop linking it to this `ContentPreparer`.
+   * @param {string | undefined} reason - Human-inspectable reason behind the
+   * dispose. Used for debugging matters, especially for debug log
+   * inspection.
    */
-  public disposeCurrentContent() {
-    this._contentCanceller.cancel();
-    this._contentCanceller = new TaskCanceller();
+  public disposeCurrentContent(reason: string | undefined) {
+    this._contentCanceller.cancel(reason);
+    this._contentCanceller = new TaskCanceller("ContentPreparer");
   }
 }
 
@@ -433,7 +442,7 @@ export interface IPreparedContentData {
    */
   segmentSinksStore: SegmentSinksStore;
   /** Allows to send timed text media data so it can be rendered. */
-  workerTextSender: WorkerTextDisplayerInterface | null;
+  coreTextSender: CoreTextDisplayerInterface | null;
   /**
    * Allows to create `SegmentQueue` which simplifies complex media segment
    * fetching.
@@ -454,7 +463,14 @@ export interface IPreparedContentData {
   useMseInWorker: boolean;
 }
 
+export interface ICorePlugins {
+  representationFilters: Map<string, IRepresentationFilter>;
+  segmentLoaders: Map<string, ISegmentLoader>;
+  manifestLoaders: Map<string, IManifestLoader>;
+}
+
 /**
+ * @param {Function} sendMessage
  * @param {string} contentId
  * @param {Object} capabilities
  * @param {boolean} capabilities.useMseInWorker
@@ -464,6 +480,7 @@ export interface IPreparedContentData {
  * @returns {Array.<Object>}
  */
 function createMediaSourceInterfaceAndSegmentSinksStore(
+  sendMessage: (msg: ICoreMessage, transferables?: Transferable[]) => void,
   contentId: string,
   capabilities: {
     useMseInWorker: boolean;
@@ -471,13 +488,13 @@ function createMediaSourceInterfaceAndSegmentSinksStore(
     hasText: boolean;
   },
   cancelSignal: CancellationSignal,
-): [IMediaSourceInterface, SegmentSinksStore, WorkerTextDisplayerInterface | null] {
+): [IMediaSourceInterface, SegmentSinksStore, CoreTextDisplayerInterface | null] {
   let mediaSourceInterface: IMediaSourceInterface;
   if (capabilities.useMseInWorker) {
     const mainMediaSource = new MainMediaSourceInterface(generateMediaSourceId());
     mediaSourceInterface = mainMediaSource;
 
-    let sentMediaSourceLink: IAttachMediaSourceWorkerMessagePayload;
+    let sentMediaSourceLink: IAttachMediaSourceCoreMessagePayload;
     const handle = mainMediaSource.handle;
     if (handle.type === "handle") {
       sentMediaSourceLink = { type: "handle" as const, value: handle.value };
@@ -491,7 +508,7 @@ function createMediaSourceInterfaceAndSegmentSinksStore(
 
     sendMessage(
       {
-        type: WorkerMessageType.AttachMediaSource,
+        type: CoreMessageType.AttachMediaSource,
         contentId,
         value: sentMediaSourceLink,
         mediaSourceId: mediaSourceInterface.id,
@@ -507,7 +524,7 @@ function createMediaSourceInterfaceAndSegmentSinksStore(
   }
 
   const textSender = capabilities.hasText
-    ? new WorkerTextDisplayerInterface(contentId, sendMessage)
+    ? new CoreTextDisplayerInterface(contentId, sendMessage)
     : null;
   const { hasVideo } = capabilities;
   const segmentSinksStore = new SegmentSinksStore(
@@ -515,10 +532,10 @@ function createMediaSourceInterfaceAndSegmentSinksStore(
     hasVideo,
     textSender,
   );
-  cancelSignal.register(() => {
-    segmentSinksStore.disposeAll();
-    textSender?.stop();
-    mediaSourceInterface.dispose();
+  cancelSignal.register((err) => {
+    segmentSinksStore.disposeAll(err.reason);
+    textSender?.stop(err.reason);
+    mediaSourceInterface.dispose(err.reason);
   });
 
   return [mediaSourceInterface, segmentSinksStore, textSender];
@@ -554,3 +571,73 @@ function updateCodecSupportInWorkerMode(manifestToUpdate: Manifest) {
     }
   }
 }
+
+/**
+ * Some functions may be defined by the API, we call those "plugins".
+ * This function parses and extract the actual function from the different
+ * ways an application can provide it to us.
+ * @param {Object} input - The API input
+ * @param {Object} corePlugins - Context on what identified functions are
+ * defined right now.
+ * @returns {Function}
+ */
+function extractExternalPlugins(
+  input: {
+    manifestLoader:
+      | {
+          fn?: IManifestLoader | undefined;
+          workerId?: string | undefined;
+        }
+      | undefined;
+    segmentLoader:
+      | {
+          fn?: ISegmentLoader | undefined;
+          workerId?: string | undefined;
+        }
+      | undefined;
+    representationFilter:
+      | undefined
+      | {
+          fn?: IRepresentationFilter | undefined;
+          eval?: string | undefined;
+          workerId?: string | undefined;
+        };
+  },
+  corePlugins: ICorePlugins,
+): {
+  manifestLoader: IManifestLoader | undefined;
+  segmentLoader: ISegmentLoader | undefined;
+  representationFilter: IRepresentationFilter | undefined;
+} {
+  let manifestLoader;
+  let segmentLoader;
+  let representationFilter;
+  if (typeof input.representationFilter?.fn === "function") {
+    representationFilter = input.representationFilter.fn;
+  } else if (typeof input.representationFilter?.eval === "string") {
+    representationFilter = createRepresentationFilterFromFnString(
+      input.representationFilter.eval,
+    );
+  } else if (typeof input.representationFilter?.workerId === "string") {
+    representationFilter = corePlugins.representationFilters.get(
+      input.representationFilter.workerId,
+    );
+  }
+
+  if (typeof input.manifestLoader?.fn === "function") {
+    manifestLoader = input.manifestLoader.fn;
+  } else if (typeof input.manifestLoader?.workerId === "string") {
+    manifestLoader = corePlugins.manifestLoaders.get(input.manifestLoader.workerId);
+  }
+
+  if (typeof input.segmentLoader?.fn === "function") {
+    segmentLoader = input.segmentLoader.fn;
+  } else if (typeof input.segmentLoader?.workerId === "string") {
+    segmentLoader = corePlugins.segmentLoaders.get(input.segmentLoader.workerId);
+  }
+  return {
+    manifestLoader,
+    segmentLoader,
+    representationFilter,
+  };
+}

package/src/core/{main/common → entry}/content_time_boundaries_observer.ts

@@ -17,21 +17,21 @@
 import type {
   IStreamOrchestratorPlaybackObservation,
   IBufferType,
-} from "../../../core/types";
-import { MediaError } from "../../../errors";
+} from "../../core/types";
+import { MediaError } from "../../errors";
 import type {
   IManifest,
   IAdaptation,
   IRepresentationIndex,
   IPeriod,
-} from "../../../manifest";
-import type { IReadOnlyPlaybackObserver } from "../../../playback_observer";
-import type { IPlayerError } from "../../../public_types";
-import EventEmitter from "../../../utils/event_emitter";
-import isNullOrUndefined from "../../../utils/is_null_or_undefined";
-import queueMicrotask from "../../../utils/queue_microtask";
-import SortedList from "../../../utils/sorted_list";
-import TaskCanceller from "../../../utils/task_canceller";
+} from "../../manifest";
+import type { IReadOnlyPlaybackObserver } from "../../playback_observer";
+import type { IPlayerError } from "../../public_types";
+import EventEmitter from "../../utils/event_emitter";
+import isNullOrUndefined from "../../utils/is_null_or_undefined";
+import queueMicrotask from "../../utils/queue_microtask";
+import SortedList from "../../utils/sorted_list";
+import TaskCanceller from "../../utils/task_canceller";
 
 /**
  * Observes what's being played and take care of media events relating to time
@@ -81,7 +81,7 @@ export default class ContentTimeBoundariesObserver extends EventEmitter<IContent
   ) {
     super();
 
-    this._canceller = new TaskCanceller();
+    this._canceller = new TaskCanceller("Boundaries Observation");
     this._manifest = manifest;
     this._activeStreams = new Map();
     this._allBufferTypes = bufferTypes;
@@ -262,10 +262,13 @@ export default class ContentTimeBoundariesObserver extends EventEmitter<IContent
   /**
    * Free all resources used by the `ContentTimeBoundariesObserver` and cancels
    * all recurring processes it performs.
+   * @param {string | undefined} reason - Human-inspectable reason behind the
+   * dispose. Used for debugging matters, especially for debug log
+   * inspection.
    */
-  public dispose() {
+  public dispose(reason: string | undefined) {
     this.removeEventListener();
-    this._canceller.cancel();
+    this._canceller.cancel(reason ?? "ContentTimeBoundariesObserver dispose");
   }
 
   private _addActivelyLoadedPeriod(period: IPeriod, bufferType: IBufferType): void {