rx-player 4.4.1 → 4.5.0-dev.2026012301

package/src/main_thread/init/types.ts

@@ -101,8 +101,11 @@ export abstract class ContentInitializer extends EventEmitter<IContentInitialize
    * Stop playing the content linked to this `ContentInitializer` on the
    * `HTMLMediaElement` linked to it and dispose of every resources taken while
    * trying to do so.
+   * @param {string | undefined} reason - Human-inspectable reason behind the
+   * disposal. Might be used for debugging matters, especially for debug log
+   * inspection.
    */
-  public abstract dispose(): void;
+  public abstract dispose(reason: string | undefined): void;
 }
 
 /** Every events emitted by a `ContentInitializer`. */

package/src/main_thread/init/utils/create_core_playback_observer.ts

@@ -14,7 +14,8 @@
  * limitations under the License.
  */
 
-import getBufferedDataPerMediaBuffer from "../../../core/main/common/get_buffered_data_per_media_buffer";
+// TODO: move that file somewhere else
+import getBufferedDataPerMediaBuffer from "../../../core/entry/get_buffered_data_per_media_buffer";
 import type { IPausedPlaybackObservation } from "../../../core/types";
 import type { IManifestMetadata } from "../../../manifest";
 import { getMaximumSafePosition } from "../../../manifest";
@@ -121,7 +122,7 @@ export default function createCorePlaybackObserver(
     observationRef: IReadOnlySharedReference<IPlaybackObservation>,
     parentObserverCancelSignal: CancellationSignal,
   ): IReadOnlySharedReference<ICorePlaybackObservation> {
-    const canceller = new TaskCanceller();
+    const canceller = new TaskCanceller("Core PlaybackObserver");
     canceller.linkToSignal(parentObserverCancelSignal);
     canceller.linkToSignal(fnCancelSignal);
     const newRef = new SharedReference(

package/src/main_thread/init/utils/get_loaded_reference.ts

@@ -39,7 +39,7 @@ export default function getLoadedReference(
   isDirectfile: boolean,
   cancelSignal: CancellationSignal,
 ): IReadOnlySharedReference<boolean> {
-  const listenCanceller = new TaskCanceller();
+  const listenCanceller = new TaskCanceller("Loaded Reference update");
   listenCanceller.linkToSignal(cancelSignal);
   const isLoaded = new SharedReference(false, listenCanceller.signal);
   playbackObserver.listen(
@@ -60,7 +60,7 @@ export default function getLoadedReference(
         }
         if (observation.duration > 0) {
           isLoaded.setValue(true);
-          listenCanceller.cancel();
+          listenCanceller.cancel("Content Loaded");
           return;
         }
       }
@@ -70,7 +70,7 @@ export default function getLoadedReference(
         if (observation.currentRange !== null || observation.ended) {
           if (!shouldValidateMetadata() || observation.duration > 0) {
             isLoaded.setValue(true);
-            listenCanceller.cancel();
+            listenCanceller.cancel("Content Loaded");
             return;
           }
         }

package/src/main_thread/init/utils/initialize_content_decryption.ts

@@ -66,7 +66,7 @@ export default function initializeContentDecryption(
     return createEmeDisabledReference("EME feature not activated.");
   }
 
-  const decryptorCanceller = new TaskCanceller();
+  const decryptorCanceller = new TaskCanceller("Init: Decryption Capabilities");
   decryptorCanceller.linkToSignal(cancelSignal);
   const drmStatusRef = new SharedReference<IDrmInitializationStatus>(
     {
@@ -125,7 +125,7 @@ export default function initializeContentDecryption(
   });
 
   contentDecryptor.addEventListener("error", (error) => {
-    decryptorCanceller.cancel();
+    decryptorCanceller.cancel("ContentDecryptor err");
     callbacks.onError(error);
   });
 
@@ -141,8 +141,8 @@ export default function initializeContentDecryption(
     callbacks.onKeyIdsCompatibilityUpdate(x);
   });
 
-  decryptorCanceller.signal.register(() => {
-    contentDecryptor.dispose();
+  decryptorCanceller.signal.register((err) => {
+    contentDecryptor.dispose(err.reason);
   });
 
   return {

package/src/main_thread/init/utils/main_thread_text_displayer_interface.ts

@@ -53,7 +53,7 @@ export default class MainThreadTextDisplayerInterface implements ITextDisplayerI
   /**
    * @see ITextDisplayerInterface
    */
-  public stop(): void {
-    this._displayer.stop();
+  public stop(reason?: string | undefined): void {
+    this._displayer.stop(reason);
   }
 }

package/src/main_thread/init/utils/rebuffering_controller.ts

@@ -79,7 +79,7 @@ export default class RebufferingController extends EventEmitter<IRebufferingCont
     this._speed = speed;
     this._discontinuitiesStore = [];
     this._isStarted = false;
-    this._canceller = new TaskCanceller();
+    this._canceller = new TaskCanceller("RebufferingController");
   }
 
   public start(): void {
@@ -92,8 +92,8 @@ export default class RebufferingController extends EventEmitter<IRebufferingCont
       this._playbackObserver,
       this._speed,
     );
-    this._canceller.signal.register(() => {
-      playbackRateUpdater.dispose();
+    this._canceller.signal.register((err) => {
+      playbackRateUpdater.dispose(err.reason);
     });
 
     this._playbackObserver.listen(
@@ -333,9 +333,12 @@ export default class RebufferingController extends EventEmitter<IRebufferingCont
   /**
    * Stops the `RebufferingController` from montoring stalling situations,
    * forever.
+   * @param {string | undefined} reason - Human-inspectable reason behind the
+   * dispose. Used for debugging matters, especially for debug log
+   * inspection.
    */
-  public destroy(): void {
-    this._canceller.cancel();
+  public destroy(reason: string | undefined): void {
+    this._canceller.cancel(reason ?? "RebufferingController destroy");
   }
 }
 
@@ -507,7 +510,7 @@ class PlaybackRateUpdater {
     playbackObserver: IMediaElementPlaybackObserver,
     speed: IReadOnlySharedReference<number>,
   ) {
-    this._speedUpdateCanceller = new TaskCanceller();
+    this._speedUpdateCanceller = new TaskCanceller("PlaybackRateUpdater speed updates");
     this._isRebuffering = false;
     this._playbackObserver = playbackObserver;
     this._isDisposed = false;
@@ -525,7 +528,7 @@ class PlaybackRateUpdater {
       return;
     }
     this._isRebuffering = true;
-    this._speedUpdateCanceller.cancel();
+    this._speedUpdateCanceller.cancel("start rebuffering");
     log.info("Init", "Pause playback to build buffer");
     this._playbackObserver.setPlaybackRate(0);
   }
@@ -541,7 +544,7 @@ class PlaybackRateUpdater {
       return;
     }
     this._isRebuffering = false;
-    this._speedUpdateCanceller = new TaskCanceller();
+    this._speedUpdateCanceller = new TaskCanceller("PlaybackRateUpdater speed updates");
     this._updateSpeed();
   }
 
@@ -551,9 +554,12 @@ class PlaybackRateUpdater {
    *
    * Consequently, you should call the `dispose` method, when you don't want the
    * `PlaybackRateUpdater` to have an effect anymore.
+   * @param {string | undefined} reason - Human-inspectable reason behind the
+   * cancellation. Used for debugging matters, especially for debug log
+   * inspection.
    */
-  public dispose() {
-    this._speedUpdateCanceller.cancel();
+  public dispose(reason: string | undefined) {
+    this._speedUpdateCanceller.cancel(reason ?? "PlaybackRateUpdater dispose");
     this._isDisposed = true;
   }
 

package/src/main_thread/init/utils/stream_events_emitter/stream_events_emitter.ts

@@ -78,13 +78,13 @@ export default class StreamEventsEmitter extends EventEmitter<IStreamEventsEmitt
     if (this._canceller !== null) {
       return;
     }
-    this._canceller = new TaskCanceller();
+    this._canceller = new TaskCanceller("StreamEventsEmitter");
 
     const cancelSignal = this._canceller.signal;
     const playbackObserver = this._playbackObserver;
 
     let isPollingEvents = false;
-    let cancelCurrentPolling = new TaskCanceller();
+    let cancelCurrentPolling = new TaskCanceller("StreamEventsEmitter Polling");
     cancelCurrentPolling.linkToSignal(cancelSignal);
 
     this._scheduledEventsRef.setValue(refreshScheduledEventsList([], this._manifest));
@@ -93,8 +93,8 @@ export default class StreamEventsEmitter extends EventEmitter<IStreamEventsEmitt
       ({ length: scheduledEventsLength }) => {
         if (scheduledEventsLength === 0) {
           if (isPollingEvents) {
-            cancelCurrentPolling.cancel();
-            cancelCurrentPolling = new TaskCanceller();
+            cancelCurrentPolling.cancel("no stream event");
+            cancelCurrentPolling = new TaskCanceller("StreamEventsEmitter Polling");
             cancelCurrentPolling.linkToSignal(cancelSignal);
             isPollingEvents = false;
           }
@@ -147,9 +147,14 @@ export default class StreamEventsEmitter extends EventEmitter<IStreamEventsEmitt
     this._scheduledEventsRef.setValue(refreshScheduledEventsList(prev, man));
   }
 
-  public stop(): void {
+  /**
+   * @param {string | undefined} reason - Human-inspectable reason behind the
+   * stop. Used for debugging matters, especially for debug log
+   * inspection.
+   */
+  public stop(reason: string | undefined): void {
     if (this._canceller !== null) {
-      this._canceller.cancel();
+      this._canceller.cancel(reason ?? "StreamEventsEmitter stop");
       this._canceller = null;
     }
   }

package/src/main_thread/init/utils/update_manifest_codec_support.ts

@@ -2,10 +2,10 @@ import type { IMediaElement } from "../../../compat/browser_compatibility_types"
 import isCodecSupported from "../../../compat/is_codec_supported";
 import type { IManifestMetadata } from "../../../manifest";
 import type Manifest from "../../../manifest/classes";
-import type { ICodecSupportInfo } from "../../../multithread_types";
 import isNullOrUndefined from "../../../utils/is_null_or_undefined";
 import type ContentDecryptor from "../../decrypt";
 import { ContentDecryptorState } from "../../decrypt";
+import type { ICodecSupportInfo } from "../../types";
 
 /**
  * Returns a list of all codecs that the support is not known yet on the given

package/src/main_thread/render_thumbnail.ts

@@ -50,19 +50,19 @@ export default async function renderThumbnail(
   }
 
   const { thumbnailRequestsInfo, currentContentCanceller } = contentInfos;
-  const canceller = new TaskCanceller();
+  const canceller = new TaskCanceller("Render Thumbnail");
   const unlinkCanceller = canceller.linkToSignal(currentContentCanceller.signal);
 
   let imageUrl: string | undefined;
 
   const olderTaskSameContainer = thumbnailRequestsInfo.pendingRequests.get(container);
-  olderTaskSameContainer?.cancel();
+  olderTaskSameContainer?.cancel("new thumbnail has same container");
 
   thumbnailRequestsInfo.pendingRequests.set(container, canceller);
 
   const onFinished = () => {
     unlinkCanceller();
-    canceller.cancel();
+    canceller.cancel("thumbnail request finished");
     thumbnailRequestsInfo.pendingRequests.delete(container);
 
     // Let's revoke the URL after a round-trip to the event loop just in case

package/src/main_thread/text_displayer/html/html_text_displayer.ts

@@ -110,8 +110,10 @@ export default class HTMLTextDisplayer implements ITextDisplayer {
 
     this._videoElement = videoElement;
     this._textTrackElement = textTrackElement;
-    this._sizeUpdateCanceller = new TaskCanceller();
-    this._subtitlesIntervalCanceller = new TaskCanceller();
+    this._sizeUpdateCanceller = new TaskCanceller("HTMLTextDisplayer size updates");
+    this._subtitlesIntervalCanceller = new TaskCanceller(
+      "HTMLTextDisplayer subtitles updates",
+    );
     this._buffer = new TextTrackCuesStore();
     this._currentCues = [];
     this._isAutoRefreshing = false;
@@ -231,8 +233,10 @@ export default class HTMLTextDisplayer implements ITextDisplayer {
     if (this._isAutoRefreshing && this._buffer.isEmpty()) {
       this.refreshSubtitles();
       this._isAutoRefreshing = false;
-      this._subtitlesIntervalCanceller.cancel();
-      this._subtitlesIntervalCanceller = new TaskCanceller();
+      this._subtitlesIntervalCanceller.cancel("HTMLTextDisplayer no cue");
+      this._subtitlesIntervalCanceller = new TaskCanceller(
+        "HTMLTextDisplayer subtitles updates",
+      );
     }
     return convertToRanges(this._buffered);
   }
@@ -247,27 +251,31 @@ export default class HTMLTextDisplayer implements ITextDisplayer {
 
   public reset(): void {
     log.debug("text", "Resetting HTMLTextDisplayer");
-    this.stop();
-    this._subtitlesIntervalCanceller = new TaskCanceller();
+    this.stop("HTMLTextDisplayer reset");
+    this._subtitlesIntervalCanceller = new TaskCanceller(
+      "HTMLTextDisplayer subtitles updates",
+    );
   }
 
-  public stop(): void {
+  public stop(reason: string | undefined): void {
     if (this._subtitlesIntervalCanceller.isUsed()) {
       return;
     }
     log.debug("text", "Stopping HTMLTextDisplayer");
-    this._disableCurrentCues();
+    this._disableCurrentCues(reason ?? "HTD stop");
     this._buffer.remove(0, Infinity);
     this._buffered.remove(0, Infinity);
     this._isAutoRefreshing = false;
-    this._subtitlesIntervalCanceller.cancel();
+    this._subtitlesIntervalCanceller.cancel(reason ?? "HTD stop");
   }
 
   /**
    * Remove the current cue from being displayed.
+   * @param {string} reason - Human-inspectable reason.
+   * Used for debugging matters, especially for debug log inspection.
    */
-  private _disableCurrentCues(): void {
-    this._sizeUpdateCanceller.cancel();
+  private _disableCurrentCues(reason: string): void {
+    this._sizeUpdateCanceller.cancel(reason);
     if (this._currentCues.length > 0) {
       for (const cue of this._currentCues) {
         safelyRemoveChild(this._textTrackElement, cue.element);
@@ -292,7 +300,7 @@ export default class HTMLTextDisplayer implements ITextDisplayer {
     // Remove and re-display everything
     // TODO More intelligent handling
 
-    this._sizeUpdateCanceller.cancel();
+    this._sizeUpdateCanceller.cancel("HTMLTextDisplayer display");
     for (const cue of this._currentCues) {
       safelyRemoveChild(this._textTrackElement, cue.element);
     }
@@ -314,7 +322,7 @@ export default class HTMLTextDisplayer implements ITextDisplayer {
     );
 
     if (proportionalCues.length > 0) {
-      this._sizeUpdateCanceller = new TaskCanceller();
+      this._sizeUpdateCanceller = new TaskCanceller("HTMLTextDisplayer size updates");
       this._sizeUpdateCanceller.linkToSignal(this._subtitlesIntervalCanceller.signal);
       const { TEXT_TRACK_SIZE_CHECKS_INTERVAL } = config.getCurrent();
       // update propertionally-sized elements periodically
@@ -353,14 +361,16 @@ export default class HTMLTextDisplayer implements ITextDisplayer {
     const stopAutoRefresh = () => {
       this._isAutoRefreshing = false;
       if (autoRefreshCanceller !== null) {
-        autoRefreshCanceller.cancel();
+        autoRefreshCanceller.cancel("HTMLTextDisplayer stop auto-refresh");
         autoRefreshCanceller = null;
       }
     };
     const startAutoRefresh = () => {
       stopAutoRefresh();
       this._isAutoRefreshing = true;
-      autoRefreshCanceller = new TaskCanceller();
+      autoRefreshCanceller = new TaskCanceller(
+        "HTMLTextDisplayer subtitles auto-refresh",
+      );
       autoRefreshCanceller.linkToSignal(cancellationSignal);
       const intervalId = setInterval(
         () => this.refreshSubtitles(),
@@ -376,7 +386,7 @@ export default class HTMLTextDisplayer implements ITextDisplayer {
       this._videoElement,
       () => {
         stopAutoRefresh();
-        this._disableCurrentCues();
+        this._disableCurrentCues("seek");
       },
       cancellationSignal,
     );
@@ -405,7 +415,7 @@ export default class HTMLTextDisplayer implements ITextDisplayer {
     }
     const cues = this._buffer.get(time);
     if (cues.length === 0) {
-      this._disableCurrentCues();
+      this._disableCurrentCues("no cue");
     } else {
       this._displayCues(cues);
     }

package/src/main_thread/text_displayer/types.ts

@@ -35,8 +35,10 @@ export interface ITextDisplayer {
   getBufferedRanges(): IRange[];
   /**
    * Stop the `ITextDisplayer` from running and using resources.
+   * @param {string | undefined} reason - Human-inspectable reason behind the
+   * stop. Used for debugging matters, especially for debug log inspection.
    */
-  stop(): void;
+  stop(reason: string | undefined): void;
 }
 
 /** Interface describing a timed text media data "chunk". */

package/src/main_thread/tracks_store/track_dispatcher.ts

@@ -89,7 +89,7 @@ export default class TrackDispatcher extends EventEmitter<ITrackDispatcherEvent>
    */
   constructor(adaptationRef: SharedReference<IAdaptationChoice | null | undefined>) {
     super();
-    this._canceller = new TaskCanceller();
+    this._canceller = new TaskCanceller("TrackDispatcher initial");
     this._adaptationRef = adaptationRef;
     this._updateToken = false;
     this._lastEmitted = undefined;
@@ -117,17 +117,17 @@ export default class TrackDispatcher extends EventEmitter<ITrackDispatcherEvent>
         return;
       }
       this._updateToken = false;
-      this._canceller.cancel();
+      this._canceller.cancel("track update null");
 
       // has no point but let's still create one for simplicity sake
-      this._canceller = new TaskCanceller();
+      this._canceller = new TaskCanceller("TrackDispatcher null");
       this._lastEmitted = null;
       this._adaptationRef.setValue(null);
       return;
     }
     const { adaptation, switchingMode, relativeResumingPosition } = newTrackInfo;
-    this._canceller.cancel();
-    this._canceller = new TaskCanceller();
+    this._canceller.cancel("track update");
+    this._canceller = new TaskCanceller("TrackDispatcher " + adaptation.type);
     const reference = this._constructLockedRepresentationsReference(newTrackInfo);
     if (!this._updateToken) {
       return;
@@ -235,10 +235,13 @@ export default class TrackDispatcher extends EventEmitter<ITrackDispatcherEvent>
   /**
    * Free the resources (e.g. `Manifest` event listeners) linked to this
    * `TrackDispatcher`.
+   * @param {string | undefined} reason - Human-inspectable reason behind the
+   * dispose. Used for debugging matters, especially for debug log
+   * inspection.
    */
-  public dispose(): void {
+  public dispose(reason: string | undefined): void {
     this.removeEventListener();
-    this._canceller.cancel();
+    this._canceller.cancel(reason ?? "TrackDispatcher dispose");
     this._adaptationRef.finish();
   }
 }

package/src/main_thread/tracks_store/tracks_store.ts

@@ -487,7 +487,7 @@ export default class TracksStore extends EventEmitter<ITracksStoreEvents> {
         bufferType,
         periodId: period.id,
       });
-      periodObj[bufferType].dispatcher.dispose();
+      periodObj[bufferType].dispatcher.dispose("TrackDispatcher double add issue");
     }
 
     const dispatcher = new TrackDispatcher(adaptationRef);
@@ -757,7 +757,7 @@ export default class TracksStore extends EventEmitter<ITracksStoreEvents> {
       return;
     }
 
-    choiceItem.dispatcher.dispose();
+    choiceItem.dispatcher.dispose("TrackDispatcher reference removal");
     choiceItem.dispatcher = null;
     if (isPeriodItemRemovable(periodObj)) {
       this._removePeriodObject(periodIndex);
@@ -835,11 +835,11 @@ export default class TracksStore extends EventEmitter<ITracksStoreEvents> {
     log.debug("Track", "Resetting Period Objects");
     for (let i = this._storedPeriodInfo.length - 1; i >= 0; i--) {
       const storedObj = this._storedPeriodInfo[i];
-      storedObj.audio.dispatcher?.dispose();
+      storedObj.audio.dispatcher?.dispose("TrackDispatcher reset");
       storedObj.audio.dispatcher = null;
-      storedObj.video.dispatcher?.dispose();
+      storedObj.video.dispatcher?.dispose("TrackDispatcher reset");
       storedObj.video.dispatcher = null;
-      storedObj.text.dispatcher?.dispose();
+      storedObj.text.dispatcher?.dispose("TrackDispatcher reset");
       storedObj.text.dispatcher = null;
       if (!storedObj.inManifest) {
         this._removePeriodObject(i);