rx-player 3.30.0-dev.2023020100 → 3.30.0-dev.2023030200

package/src/core/fetchers/cdn_prioritizer.ts

@@ -16,19 +16,22 @@
 
 import config from "../../config";
 import { ICdnMetadata } from "../../parsers/manifest";
-import { IPlayerError } from "../../public_types";
 import arrayFindIndex from "../../utils/array_find_index";
 import EventEmitter from "../../utils/event_emitter";
 import { CancellationSignal } from "../../utils/task_canceller";
 
 /**
- * Class signaling the priority between multiple CDN available for any given
- * resource.
+ * Class storing and signaling the priority between multiple CDN available for
+ * any given resource.
  *
- * This class might perform requests and schedule timeouts by itself to keep its
- * internal list of CDN priority up-to-date.
- * When it is not needed anymore, you should call the `dispose` method to clear
- * all resources.
+ * This class was first created to implement the complexities behind
+ * Content Steering features, though its handling hasn't been added yet as we
+ * wait for its specification to be both standardized and relied on in the wild.
+ * In the meantime, it acts as an abstraction for the simple concept of
+ * avoiding to request a CDN for any segment when an issue is encountered with
+ * one (e.g. HTTP 500 statuses) and several CDN exist for a given resource. It
+ * should be noted that this is also one of the planified features of the
+ * Content Steering specification.
  *
  * @class CdnPrioritizer
  */
@@ -41,7 +44,7 @@ export default class CdnPrioritizer extends EventEmitter<ICdnPrioritizerEvents>
   private _downgradedCdnList : {
     /**
      * Metadata of downgraded CDN, sorted by the time at which they have
-     * been downgraded.
+     * been downgraded ascending.
      */
     metadata : ICdnMetadata[];
     /**
@@ -174,8 +177,14 @@ export default class CdnPrioritizer extends EventEmitter<ICdnPrioritizerEvents>
   }
 }
 
+/** Events sent by a `CdnPrioritizer` */
 export interface ICdnPrioritizerEvents {
-  warnings : IPlayerError[];
+  /**
+   * The priority of one or several CDN changed.
+   *
+   * You might want to re-check if a CDN should still be used when this event
+   * is triggered.
+   */
   priorityChange : null;
 }
 

package/src/core/fetchers/manifest/manifest_fetcher.ts

@@ -155,7 +155,7 @@ export default class ManifestFetcher extends EventEmitter<IManifestFetcherEvent>
     manifestProm
       .then((val : IManifestFetcherParsedResult) => {
         this.trigger("manifestReady", val.manifest);
-        if (!this._canceller.isUsed) {
+        if (!this._canceller.isUsed()) {
           this._recursivelyRefreshManifest(val.manifest, val);
         }
       })
@@ -362,7 +362,7 @@ export default class ManifestFetcher extends EventEmitter<IManifestFetcherEvent>
      */
     function onWarnings(warnings : Error[]) : void {
       for (const warning of warnings) {
-        if (cancelSignal.isCancelled) {
+        if (cancelSignal.isCancelled()) {
           return;
         }
         const formattedError = formatError(warning, {
@@ -470,7 +470,8 @@ export default class ManifestFetcher extends EventEmitter<IManifestFetcherEvent>
      * be effectively considered.
      * `nextRefreshCanceller` will allow to cancel every other when one is triggered.
      */
-    const nextRefreshCanceller = new TaskCanceller({ cancelOn: this._canceller.signal });
+    const nextRefreshCanceller = new TaskCanceller();
+    nextRefreshCanceller.linkToSignal(this._canceller.signal);
 
     /* Function to manually schedule a Manifest refresh */
     this.scheduleManualRefresh = (settings : IManifestRefreshSettings) => {
@@ -669,7 +670,7 @@ export default class ManifestFetcher extends EventEmitter<IManifestFetcherEvent>
   }
 
   private _onFatalError(err : unknown) : void {
-    if (this._canceller.isUsed) {
+    if (this._canceller.isUsed()) {
       return;
     }
     this.trigger("error", err);

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

@@ -64,10 +64,22 @@ const generateRequestID = idGenerator();
  * An `ISegmentFetcher` also implements a retry mechanism, based on the given
  * `options` argument, which may retry a segment request when it fails.
  *
- * @param {string} bufferType
- * @param {Object} pipeline
- * @param {Object} lifecycleCallbacks
- * @param {Object} options
+ * @param {string} bufferType - Type of  buffer concerned (e.g. `"audio"`,
+ * `"video"`, `"text" etc.)
+ * @param {Object} pipeline - The transport-specific logic allowing to load
+ * segments of the given buffer type and transport protocol (e.g. DASH).
+ * @param {Object|null} cdnPrioritizer - Abstraction allowing to synchronize,
+ * update and keep track of the priorization of the CDN to use to load any given
+ * segment, in cases where multiple ones are available.
+ *
+ * Can be set to `null` in which case a minimal priorization logic will be used
+ * instead.
+ * @param {Object} lifecycleCallbacks - Callbacks that can be registered to be
+ * informed when new requests are made, ended, new metrics are available etc.
+ * This should be mainly useful to implement an adaptive logic relying on those
+ * metrics and events.
+ * @param {Object} options - Various tweaking options allowing to configure the
+ * behavior of the returned `ISegmentFetcher`.
  * @returns {Function}
  */
 export default function createSegmentFetcher<TLoadedFormat, TSegmentDataType>(
@@ -184,14 +196,7 @@ export default function createSegmentFetcher<TLoadedFormat, TSegmentDataType>(
                                           id: requestId,
                                           content });
 
-    cancellationSignal.register(() => {
-      if (requestInfo !== undefined) {
-        return; // Request already terminated
-      }
-      log.debug("SF: Segment request cancelled", segmentIdString);
-      requestInfo = null;
-      lifecycleCallbacks.onRequestEnd?.({ id: requestId });
-    });
+    cancellationSignal.register(onCancellation);
 
     try {
       const res = await scheduleRequestWithCdns(content.representation.cdnMetadata,
@@ -220,22 +225,34 @@ export default function createSegmentFetcher<TLoadedFormat, TSegmentDataType>(
         requestInfo = null;
       }
 
-      if (!cancellationSignal.isCancelled) {
+      if (!cancellationSignal.isCancelled()) {
         // The current task could have been canceled as a result of one
         // of the previous callbacks call. In that case, we don't want to send
         // a "requestEnd" again as it has already been sent on cancellation.
         lifecycleCallbacks.onRequestEnd?.({ id: requestId });
       }
+      cancellationSignal.deregister(onCancellation);
     } catch (err) {
+      cancellationSignal.deregister(onCancellation);
       requestInfo = null;
       if (err instanceof CancellationError) {
         log.debug("SF: Segment request aborted", segmentIdString);
         throw err;
       }
       log.debug("SF: Segment request failed", segmentIdString);
+      lifecycleCallbacks.onRequestEnd?.({ id: requestId });
       throw errorSelector(err);
     }
 
+    function onCancellation() {
+      if (requestInfo !== undefined) {
+        return; // Request already terminated
+      }
+      log.debug("SF: Segment request cancelled", segmentIdString);
+      requestInfo = null;
+      lifecycleCallbacks.onRequestEnd?.({ id: requestId });
+    }
+
     /**
      * Call a segment loader for the given URL with the right arguments.
      * @param {Object|null} cdnMetadata
@@ -360,11 +377,16 @@ export interface ISegmentFetcherCallbacks<TSegmentDataType> {
   /**
    * Callback called when all decodable chunks of the loaded segment have been
    * communicated through the `onChunk` callback.
+   *
+   * This callback is called before the corresponding `ISegmentFetcher`'s
+   * returned Promise is resolved.
    */
   onAllChunksReceived() : void;
 
   /**
-   * Callback called when the segment request has to restart from scratch. */
+   * Callback called when the segment request has to restart from scratch, e.g.
+   * due to a request error.
+   */
   onRetry(error : IPlayerError) : void;
 }
 

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

@@ -1,5 +1,6 @@
 import log from "../../../log";
 import arrayFindIndex from "../../../utils/array_find_index";
+import createCancellablePromise from "../../../utils/create_cancellable_promise";
 import TaskCanceller, {
   CancellationError,
   CancellationSignal,
@@ -64,19 +65,34 @@ export default class TaskPrioritizer<T> {
     cancelSignal: CancellationSignal
   ): Promise<T> {
     let newTask: IPrioritizerTask<T>;
-
-    return new Promise<T>((resolve, reject) => {
+    return createCancellablePromise<T>(cancelSignal, (resolve, reject) => {
       /** Function allowing to start the underlying Promise. */
       const trigger = () => {
         if (newTask.hasEnded) {
-          unregisterCancelSignal();
           return;
         }
-        const interrupter =  new TaskCanceller({ cancelOn: cancelSignal });
+        const finishTask = () => {
+          unlinkInterrupter();
+          this._endTask(newTask);
+        };
+
+        const onResolve = (value: T) => {
+          callbacks.beforeEnded();
+          finishTask();
+          resolve(value);
+        };
+
+        const onReject = (err: unknown) => {
+          finishTask();
+          reject(err);
+        };
+
+        const interrupter =  new TaskCanceller();
+        const unlinkInterrupter = interrupter.linkToSignal(cancelSignal);
         newTask.interrupter = interrupter;
         interrupter.signal.register(() => {
           newTask.interrupter = null;
-          if (!cancelSignal.isCancelled) {
+          if (!cancelSignal.isCancelled()) {
             callbacks.beforeInterrupted();
           }
         });
@@ -89,8 +105,8 @@ export default class TaskPrioritizer<T> {
         newTask.taskFn(interrupter.signal)
           .then(onResolve)
           .catch((err) => {
-            if (!cancelSignal.isCancelled &&
-                interrupter.isUsed &&
+            if (!cancelSignal.isCancelled() &&
+                interrupter.isUsed() &&
                 err instanceof CancellationError)
             {
               return;
@@ -99,29 +115,6 @@ export default class TaskPrioritizer<T> {
           });
       };
 
-      const unregisterCancelSignal = cancelSignal.register(
-        (cancellationError: CancellationError) => {
-          this._endTask(newTask);
-          reject(cancellationError);
-        }
-      );
-
-      const finishTask = () => {
-        unregisterCancelSignal();
-        this._endTask(newTask);
-      };
-
-      const onResolve = (value: T) => {
-        callbacks.beforeEnded();
-        finishTask();
-        resolve(value);
-      };
-
-      const onReject = (err: unknown) => {
-        finishTask();
-        reject(err);
-      };
-
       newTask = {
         hasEnded: false,
         priority,
@@ -146,6 +139,8 @@ export default class TaskPrioritizer<T> {
           this._interruptCancellableTasks();
         }
       }
+
+      return () => this._endTask(newTask);
     });
   }
 

package/src/core/fetchers/utils/schedule_request.ts

@@ -315,7 +315,7 @@ export async function scheduleRequestWithCdns<T>(
   async function retryWithNextCdn(prevRequestError : unknown) : Promise<T> {
     const nextCdn = getCdnToRequest();
 
-    if (cancellationSignal.isCancelled) {
+    if (cancellationSignal.isCancelled()) {
       throw cancellationSignal.cancellationError;
     }
 
@@ -324,7 +324,7 @@ export async function scheduleRequestWithCdns<T>(
     }
 
     onRetry(prevRequestError);
-    if (cancellationSignal.isCancelled) {
+    if (cancellationSignal.isCancelled()) {
       throw cancellationSignal.cancellationError;
     }
 
@@ -358,26 +358,37 @@ export async function scheduleRequestWithCdns<T>(
       return requestCdn(nextWantedCdn);
     }
 
-    const canceller = new TaskCanceller({ cancelOn: cancellationSignal });
+    const canceller = new TaskCanceller();
+    const unlinkCanceller = canceller.linkToSignal(cancellationSignal);
     return new Promise<T>((res, rej) => {
       /* eslint-disable-next-line @typescript-eslint/no-misused-promises */
       cdnPrioritizer?.addEventListener("priorityChange", () => {
         const updatedPrioritaryCdn = getCdnToRequest();
-        if (cancellationSignal.isCancelled) {
+        if (cancellationSignal.isCancelled()) {
           throw cancellationSignal.cancellationError;
         }
         if (updatedPrioritaryCdn === undefined) {
-          return rej(prevRequestError);
+          return cleanAndReject(prevRequestError);
         }
         if (updatedPrioritaryCdn !== nextWantedCdn) {
           canceller.cancel();
           waitPotentialBackoffAndRequest(updatedPrioritaryCdn, prevRequestError)
-            .then(res, rej);
+            .then(cleanAndResolve, cleanAndReject);
         }
       }, canceller.signal);
 
       cancellableSleep(blockedFor, canceller.signal)
-        .then(() => requestCdn(nextWantedCdn).then(res, rej), noop);
+        .then(() => requestCdn(nextWantedCdn)
+          .then(cleanAndResolve, cleanAndReject), noop);
+
+      function cleanAndResolve(response : T) {
+        unlinkCanceller();
+        res(response);
+      }
+      function cleanAndReject(err : unknown) {
+        unlinkCanceller();
+        rej(err);
+      }
     });
   }
 

package/src/core/init/directfile_content_initializer.ts

@@ -167,7 +167,7 @@ export default class DirectFileContentInitializer extends ContentInitializer {
             }
           }, { emitCurrentValue: true, clearSignal: cancelSignal }))
       .catch((err) => {
-        if (!cancelSignal.isCancelled) {
+        if (!cancelSignal.isCancelled()) {
           this._onFatalError(err);
         }
       });

package/src/core/init/media_source_content_initializer.ts

@@ -25,13 +25,13 @@ import {
 } from "../../public_types";
 import { ITransportPipelines } from "../../transports";
 import assert from "../../utils/assert";
+import createCancellablePromise from "../../utils/create_cancellable_promise";
 import objectAssign from "../../utils/object_assign";
 import createSharedReference, {
   IReadOnlySharedReference,
   ISharedReference,
 } from "../../utils/reference";
 import TaskCanceller, {
-  CancellationError,
   CancellationSignal,
 } from "../../utils/task_canceller";
 import AdaptiveRepresentationSelector, {
@@ -125,21 +125,22 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
     if (this._initialManifestProm !== null) {
       return;
     }
-    this._initialManifestProm = new Promise((res, rej) => {
-      this._initCanceller.signal.register((err : CancellationError) => {
-        this._manifestFetcher.dispose();
-        rej(err);
-      });
-      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._initialManifestProm = 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._manifestFetcher.start();
+    this._initCanceller.signal.register(() => {
+      this._manifestFetcher.dispose();
     });
   }
 
@@ -192,7 +193,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
   }
 
   private _onFatalError(err : unknown) {
-    if (this._initCanceller.isUsed) {
+    if (this._initCanceller.isUsed()) {
       return;
     }
     this._initCanceller.cancel();
@@ -206,13 +207,9 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
                 drmSystemId : string | undefined;
                 unlinkMediaSource : TaskCanceller; }>
   {
-    return new Promise((resolve, reject) => {
+    const initCanceller = this._initCanceller;
+    return createCancellablePromise(initCanceller.signal, (resolve) => {
       const { keySystems } = this._settings;
-      const initCanceller = this._initCanceller;
-
-      const unregisterReject = initCanceller.signal.register((err) => {
-        reject(err);
-      });
 
       /** Initialize decryption capabilities. */
       const drmInitRef =
@@ -227,9 +224,8 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
         }
         stopListeningToDrmUpdates();
 
-        const mediaSourceCanceller = new TaskCanceller({
-          cancelOn: initCanceller.signal,
-        });
+        const mediaSourceCanceller = new TaskCanceller();
+        mediaSourceCanceller.linkToSignal(initCanceller.signal);
         openMediaSource(mediaElement, mediaSourceCanceller.signal)
           .then((mediaSource) => {
             const lastDrmStatus = drmInitRef.getValue();
@@ -238,7 +234,6 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
               drmInitRef.onUpdate((newDrmStatus, stopListeningToDrmUpdatesAgain) => {
                 if (newDrmStatus.initializationState.type === "initialized") {
                   stopListeningToDrmUpdatesAgain();
-                  unregisterReject();
                   resolve({ mediaSource,
                             drmSystemId: newDrmStatus.drmSystemId,
                             unlinkMediaSource: mediaSourceCanceller });
@@ -246,7 +241,6 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
                 }
               }, { emitCurrentValue: true, clearSignal: initCanceller.signal });
             } else if (drmStatus.initializationState.type === "initialized") {
-              unregisterReject();
               resolve({ mediaSource,
                         drmSystemId: drmStatus.drmSystemId,
                         unlinkMediaSource: mediaSourceCanceller });
@@ -254,7 +248,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
             }
           })
           .catch((err) => {
-            if (mediaSourceCanceller.isUsed) {
+            if (mediaSourceCanceller.isUsed()) {
               return;
             }
             this._onFatalError(err);
@@ -311,7 +305,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
                                                             initCanceller.signal);
 
     this.trigger("manifestReady", manifest);
-    if (initCanceller.isUsed) {
+    if (initCanceller.isUsed()) {
       return ;
     }
 
@@ -359,15 +353,16 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
                         autoPlay : boolean; }
       ) : void {
         currentCanceller.cancel();
-        if (initCanceller.isUsed) {
+        if (initCanceller.isUsed()) {
           return;
         }
         triggerEvent("reloadingMediaSource", null);
-        if (initCanceller.isUsed) {
+        if (initCanceller.isUsed()) {
           return;
         }
 
-        const newCanceller = new TaskCanceller({ cancelOn: initCanceller.signal });
+        const newCanceller = new TaskCanceller();
+        newCanceller.linkToSignal(initCanceller.signal);
         openMediaSource(mediaElement, newCanceller.signal)
           .then(newMediaSource => {
             recursivelyLoadOnMediaSource(newMediaSource,
@@ -376,7 +371,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
                                          newCanceller);
           })
           .catch((err) => {
-            if (newCanceller.isUsed) {
+            if (newCanceller.isUsed()) {
               return;
             }
             onFatalError(err);
@@ -431,7 +426,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
                                 (err) => this.trigger("warning", err),
                                 cancelSignal);
 
-    if (cancelSignal.isCancelled) {
+    if (cancelSignal.isCancelled()) {
       return;
     }
 
@@ -483,7 +478,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
           }, { emitCurrentValue: true, clearSignal: cancelSignal });
       })
       .catch((err) => {
-        if (cancelSignal.isCancelled) {
+        if (cancelSignal.isCancelled()) {
           return; // Current loading cancelled, no need to trigger the error
         }
         this._onFatalError(err);
@@ -519,7 +514,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
             discontinuity: imminentDiscontinuity,
             position,
           });
-          if (cancelSignal.isCancelled) {
+          if (cancelSignal.isCancelled()) {
             return; // Previous call has stopped streams due to a side-effect
           }
 
@@ -560,7 +555,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
 
         adaptationChange: (value) => {
           self.trigger("adaptationChange", value);
-          if (cancelSignal.isCancelled) {
+          if (cancelSignal.isCancelled()) {
             return; // Previous call has stopped streams due to a side-effect
           }
           contentTimeBoundariesObserver.onAdaptationChange(value.type,
@@ -570,7 +565,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
 
         representationChange: (value) => {
           self.trigger("representationChange", value);
-          if (cancelSignal.isCancelled) {
+          if (cancelSignal.isCancelled()) {
             return; // Previous call has stopped streams due to a side-effect
           }
           contentTimeBoundariesObserver.onRepresentationChange(value.type, value.period);
@@ -584,7 +579,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
 
         periodStreamCleared: (value) => {
           contentTimeBoundariesObserver.onPeriodCleared(value.type, value.period);
-          if (cancelSignal.isCancelled) {
+          if (cancelSignal.isCancelled()) {
             return; // Previous call has stopped streams due to a side-effect
           }
           self.trigger("periodStreamCleared", value);
@@ -615,7 +610,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
         encryptionDataEncountered: (value) => {
           for (const protectionData of value) {
             protectionRef.setValue(protectionData);
-            if (cancelSignal.isCancelled) {
+            if (cancelSignal.isCancelled()) {
               return; // Previous call has stopped streams due to a side-effect
             }
           }
@@ -674,7 +669,8 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
     });
     contentTimeBoundariesObserver.addEventListener("endOfStream", () => {
       if (endOfStreamCanceller === null) {
-        endOfStreamCanceller = new TaskCanceller({ cancelOn: cancelSignal });
+        endOfStreamCanceller = new TaskCanceller();
+        endOfStreamCanceller.linkToSignal(cancelSignal);
         log.debug("Init: end-of-stream order received.");
         maintainEndOfStream(mediaSource, endOfStreamCanceller.signal);
       }

package/src/core/init/utils/content_time_boundaries_observer.ts

@@ -112,7 +112,7 @@ export default class ContentTimeBoundariesObserver
 
     manifest.addEventListener("manifestUpdate", () => {
       this.trigger("durationUpdate", getManifestDuration());
-      if (cancelSignal.isCancelled) {
+      if (cancelSignal.isCancelled()) {
         return;
       }
       this._checkEndOfStream();
@@ -161,7 +161,7 @@ export default class ContentTimeBoundariesObserver
         }
       }
     }
-    if (this._canceller.isUsed) {
+    if (this._canceller.isUsed()) {
       return;
     }
     if (adaptation === null) {

package/src/core/init/utils/create_media_source.ts

@@ -21,10 +21,9 @@ import {
 } from "../../../compat";
 import { MediaError } from "../../../errors";
 import log from "../../../log";
+import createCancellablePromise from "../../../utils/create_cancellable_promise";
 import isNonEmptyString from "../../../utils/is_non_empty_string";
-import TaskCanceller, {
-  CancellationSignal,
-} from "../../../utils/task_canceller";
+import { CancellationSignal } from "../../../utils/task_canceller";
 
 /**
  * Dispose of ressources taken by the MediaSource:
@@ -128,21 +127,10 @@ export default function openMediaSource(
   mediaElement : HTMLMediaElement,
   unlinkSignal : CancellationSignal
 ) : Promise<MediaSource> {
-  return new Promise((resolve, reject) => {
-    let hasResolved = false;
+  return createCancellablePromise(unlinkSignal, (resolve) => {
     const mediaSource = createMediaSource(mediaElement, unlinkSignal);
-    const eventListenerCanceller = new TaskCanceller({ cancelOn: unlinkSignal });
-
     events.onSourceOpen(mediaSource, () => {
-      eventListenerCanceller.cancel();
-      hasResolved = true;
       resolve(mediaSource);
-    }, eventListenerCanceller.signal);
-
-    unlinkSignal.register((error) => {
-      if (!hasResolved) {
-        reject(error);
-      }
-    });
+    }, unlinkSignal);
   });
 }

package/src/core/init/utils/end_of_stream.ts

@@ -70,7 +70,8 @@ export default function triggerEndOfStream(
 
   log.debug("Init: Waiting SourceBuffers to be updated before calling endOfStream.");
 
-  const innerCanceller = new TaskCanceller({ cancelOn: cancelSignal });
+  const innerCanceller = new TaskCanceller();
+  innerCanceller.linkToSignal(cancelSignal);
   for (const sourceBuffer of updatingSourceBuffers) {
     onSourceBufferUpdate(sourceBuffer, () => {
       innerCanceller.cancel();
@@ -94,10 +95,12 @@ export function maintainEndOfStream(
   mediaSource : MediaSource,
   cancelSignal : CancellationSignal
 ) : void {
-  let endOfStreamCanceller = new TaskCanceller({ cancelOn: cancelSignal });
+  let endOfStreamCanceller = new TaskCanceller();
+  endOfStreamCanceller.linkToSignal(cancelSignal);
   onSourceOpen(mediaSource, () => {
     endOfStreamCanceller.cancel();
-    endOfStreamCanceller = new TaskCanceller({ cancelOn: cancelSignal });
+    endOfStreamCanceller = new TaskCanceller();
+    endOfStreamCanceller.linkToSignal(cancelSignal);
     triggerEndOfStream(mediaSource, endOfStreamCanceller.signal);
   }, cancelSignal);
   triggerEndOfStream(mediaSource, endOfStreamCanceller.signal);

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

@@ -43,7 +43,8 @@ export default function getLoadedReference(
   isDirectfile : boolean,
   cancelSignal : CancellationSignal
 ) : IReadOnlySharedReference<boolean> {
-  const listenCanceller = new TaskCanceller({ cancelOn: cancelSignal });
+  const listenCanceller = new TaskCanceller();
+  listenCanceller.linkToSignal(cancelSignal);
   const isLoaded = createSharedReference(false, listenCanceller.signal);
   playbackObserver.listen((observation) => {
     if (observation.rebuffering !== null ||