rx-player 4.0.0-beta.0 → 4.0.0-beta.2

package/src/core/decrypt/__tests__/__global__/utils.ts

@@ -40,48 +40,68 @@ import {
 import { CancellationSignal } from "../../../../utils/task_canceller";
 
 /** Default MediaKeySystemAccess configuration used by the RxPlayer. */
-export const defaultKSConfig = [{
-  audioCapabilities: [ { contentType: "audio/mp4;codecs=\"mp4a.40.2\"" },
-                       { contentType: "audio/webm;codecs=opus" } ],
-  distinctiveIdentifier: "optional" as const,
-  initDataTypes: ["cenc"] as const,
-  persistentState: "optional" as const,
-  sessionTypes: ["temporary"] as const,
-  videoCapabilities: [ { contentType: "video/mp4;codecs=\"avc1.4d401e\"" },
-                       { contentType: "video/mp4;codecs=\"avc1.42e01e\"" },
-                       { contentType: "video/webm;codecs=\"vp8\"" } ],
-}];
+export const defaultKSConfig = [
+  {
+    audioCapabilities: [ { contentType: "audio/mp4;codecs=\"mp4a.40.2\"" },
+                         { contentType: "audio/webm;codecs=opus" } ],
+    distinctiveIdentifier: "optional" as const,
+    initDataTypes: ["cenc"] as const,
+    persistentState: "optional" as const,
+    sessionTypes: ["temporary"] as const,
+    videoCapabilities: [ { contentType: "video/mp4;codecs=\"avc1.4d401e\"" },
+                         { contentType: "video/mp4;codecs=\"avc1.42e01e\"" },
+                         { contentType: "video/webm;codecs=\"vp8\"" } ],
+  },
+  {
+    audioCapabilities: undefined,
+    distinctiveIdentifier: "optional" as const,
+    initDataTypes: ["cenc"] as const,
+    persistentState: "optional" as const,
+    sessionTypes: ["temporary"] as const,
+    videoCapabilities: undefined,
+  },
+];
 
 /**
  * Default "com.microsoft.playready.recommendation" MediaKeySystemAccess
  * configuration used by the RxPlayer.
  */
-export const defaultPRRecommendationKSConfig = [{
-  audioCapabilities: [ { robustness: "3000",
-                         contentType: "audio/mp4;codecs=\"mp4a.40.2\"" },
-                       { robustness: "3000",
-                         contentType: "audio/webm;codecs=opus" },
-                       { robustness: "2000",
-                         contentType: "audio/mp4;codecs=\"mp4a.40.2\"" },
-                       { robustness: "2000",
-                         contentType: "audio/webm;codecs=opus" } ],
-  distinctiveIdentifier: "optional" as const,
-  initDataTypes: ["cenc"] as const,
-  persistentState: "optional" as const,
-  sessionTypes: ["temporary"] as const,
-  videoCapabilities: [ { robustness: "3000",
-                         contentType: "video/mp4;codecs=\"avc1.4d401e\"" },
-                       { robustness: "3000",
-                         contentType: "video/mp4;codecs=\"avc1.42e01e\"" },
-                       { robustness: "3000",
-                         contentType: "video/webm;codecs=\"vp8\"" },
-                       { robustness: "2000",
-                         contentType: "video/mp4;codecs=\"avc1.4d401e\"" },
-                       { robustness: "2000",
-                         contentType: "video/mp4;codecs=\"avc1.42e01e\"" },
-                       { robustness: "2000",
-                         contentType: "video/webm;codecs=\"vp8\"" } ],
-}];
+export const defaultPRRecommendationKSConfig = [
+  {
+    audioCapabilities: [ { robustness: "3000",
+                           contentType: "audio/mp4;codecs=\"mp4a.40.2\"" },
+                         { robustness: "3000",
+                           contentType: "audio/webm;codecs=opus" },
+                         { robustness: "2000",
+                           contentType: "audio/mp4;codecs=\"mp4a.40.2\"" },
+                         { robustness: "2000",
+                           contentType: "audio/webm;codecs=opus" } ],
+    distinctiveIdentifier: "optional" as const,
+    initDataTypes: ["cenc"] as const,
+    persistentState: "optional" as const,
+    sessionTypes: ["temporary"] as const,
+    videoCapabilities: [ { robustness: "3000",
+                           contentType: "video/mp4;codecs=\"avc1.4d401e\"" },
+                         { robustness: "3000",
+                           contentType: "video/mp4;codecs=\"avc1.42e01e\"" },
+                         { robustness: "3000",
+                           contentType: "video/webm;codecs=\"vp8\"" },
+                         { robustness: "2000",
+                           contentType: "video/mp4;codecs=\"avc1.4d401e\"" },
+                         { robustness: "2000",
+                           contentType: "video/mp4;codecs=\"avc1.42e01e\"" },
+                         { robustness: "2000",
+                           contentType: "video/webm;codecs=\"vp8\"" } ],
+  },
+  {
+    audioCapabilities: undefined,
+    distinctiveIdentifier: "optional" as const,
+    initDataTypes: ["cenc"] as const,
+    persistentState: "optional" as const,
+    sessionTypes: ["temporary"] as const,
+    videoCapabilities: undefined,
+  },
+];
 
 /** Default Widevine MediaKeySystemAccess configuration used by the RxPlayer. */
 export const defaultWidevineConfig = (() => {
@@ -104,9 +124,10 @@ export const defaultWidevineConfig = (() => {
             { contentType: "audio/webm;codecs=opus",
               robustness } ];
   });
-  return defaultKSConfig.map(conf => {
-    return { ...conf,  audioCapabilities, videoCapabilities };
-  });
+  return [
+    { ...defaultKSConfig[0],  audioCapabilities, videoCapabilities },
+    defaultKSConfig[1],
+  ];
 })();
 
 /**

package/src/core/decrypt/attach_media_keys.ts

@@ -62,7 +62,7 @@ export default async function attachMediaKeys(
 
   // If this task has been cancelled while we were closing previous sessions,
   // stop now (and thus avoid setting the new media keys);
-  if (cancelSignal.isCancelled) {
+  if (cancelSignal.isCancelled()) {
     throw cancelSignal.cancellationError;
   }
 

package/src/core/decrypt/content_decryptor.ts

@@ -727,7 +727,7 @@ export default class ContentDecryptor extends EventEmitter<IContentDecryptorEven
    * formatted and sent in an "error" event.
    */
   private _onFatalError(err : unknown) : void {
-    if (this._canceller.isUsed) {
+    if (this._canceller.isUsed()) {
       return;
     }
     const formattedErr = err instanceof Error ?

package/src/core/decrypt/find_key_system.ts

@@ -156,7 +156,9 @@ function buildKeySystemConfigurations(
   if (!isNullOrUndefined(keySystem.distinctiveIdentifier)) {
     distinctiveIdentifier = keySystem.distinctiveIdentifier;
   }
-  const { EME_DEFAULT_WIDEVINE_ROBUSTNESSES,
+  const { EME_DEFAULT_AUDIO_CODECS,
+          EME_DEFAULT_VIDEO_CODECS,
+          EME_DEFAULT_WIDEVINE_ROBUSTNESSES,
           EME_DEFAULT_PLAYREADY_RECOMMENDATION_ROBUSTNESSES } = config.getCurrent();
 
   // From the W3 EME spec, we have to provide videoCapabilities and
@@ -195,7 +197,7 @@ function buildKeySystemConfigurations(
 
     const audioCodecs = audioCapabilitiesConfig?.type === "contentType" ?
       audioCapabilitiesConfig.value :
-      ["audio/mp4;codecs=\"mp4a.40.2\"", "audio/webm;codecs=opus"];
+      EME_DEFAULT_AUDIO_CODECS;
 
     audioCapabilities = flatMap(audioRobustnesses, (robustness) =>
       audioCodecs.map(contentType => {
@@ -223,9 +225,7 @@ function buildKeySystemConfigurations(
 
     const videoCodecs = videoCapabilitiesConfig?.type === "contentType" ?
       videoCapabilitiesConfig.value :
-      ["video/mp4;codecs=\"avc1.4d401e\"",
-       "video/mp4;codecs=\"avc1.42e01e\"",
-       "video/webm;codecs=\"vp8\""];
+      EME_DEFAULT_VIDEO_CODECS;
 
     videoCapabilities = flatMap(videoRobustnesses, (robustness) =>
       videoCodecs.map(contentType => {
@@ -234,12 +234,26 @@ function buildKeySystemConfigurations(
       }));
   }
 
-  return [{ initDataTypes: ["cenc"],
-            videoCapabilities,
-            audioCapabilities,
-            distinctiveIdentifier,
-            persistentState,
-            sessionTypes }];
+  const wantedMediaKeySystemConfiguration : MediaKeySystemConfiguration = {
+    initDataTypes: ["cenc"],
+    videoCapabilities,
+    audioCapabilities,
+    distinctiveIdentifier,
+    persistentState,
+    sessionTypes,
+  };
+
+  return [
+    wantedMediaKeySystemConfiguration,
+
+    // Some legacy implementations have issues with `audioCapabilities` and
+    // `videoCapabilities`, so we're including a supplementary
+    // `MediaKeySystemConfiguration` without those properties.
+    { ...wantedMediaKeySystemConfiguration,
+      audioCapabilities: undefined ,
+      videoCapabilities: undefined,
+    } as unknown as MediaKeySystemConfiguration,
+  ];
 }
 
 /**

package/src/core/decrypt/session_events_listener.ts

@@ -58,13 +58,14 @@ export default function SessionEventsListener(
   const { getLicenseConfig = {} } = keySystemOptions;
 
   /** Allows to manually cancel everything the `SessionEventsListener` is doing. */
-  const manualCanceller = new TaskCanceller({ cancelOn: cancelSignal });
+  const manualCanceller = new TaskCanceller();
+  manualCanceller.linkToSignal(cancelSignal);
 
   if (!isNullOrUndefined(session.closed)) {
     session.closed
       .then(() => manualCanceller.cancel())
       .catch((err) => { // Should never happen
-        if (cancelSignal.isCancelled) {
+        if (cancelSignal.isCancelled()) {
           return;
         }
         manualCanceller.cancel();
@@ -79,10 +80,10 @@ export default function SessionEventsListener(
 
   onKeyStatusesChange(session, () => {
     try {
-      handleKeyStatusesChangeEvent();
+      checkAndHandleCurrentKeyStatuses();
     } catch (error) {
-      if (cancelSignal.isCancelled ||
-          (manualCanceller.isUsed && error instanceof CancellationSignal))
+      if (cancelSignal.isCancelled() ||
+          (manualCanceller.isUsed() && error instanceof CancellationSignal))
       {
         return;
       }
@@ -106,17 +107,22 @@ export default function SessionEventsListener(
                             backoffOptions,
                             manualCanceller.signal)
       .then((licenseObject) => {
-        if (manualCanceller.isUsed) {
+        if (manualCanceller.isUsed()) {
           return Promise.resolve();
         }
         if (isNullOrUndefined(licenseObject)) {
           log.info("DRM: No license given, skipping session.update");
         } else {
-          return updateSessionWithMessage(session, licenseObject);
+          try {
+            return updateSessionWithMessage(session, licenseObject);
+          } catch (err) {
+            manualCanceller.cancel();
+            callbacks.onError(err);
+          }
         }
       })
       .catch((err : unknown) => {
-        if (manualCanceller.isUsed) {
+        if (manualCanceller.isUsed()) {
           return;
         }
         manualCanceller.cancel();
@@ -135,23 +141,25 @@ export default function SessionEventsListener(
       });
   }, manualCanceller.signal);
 
+  checkAndHandleCurrentKeyStatuses();
+  return;
   /**
    * Check current MediaKeyStatus for each key in the given MediaKeySession and:
    *   - throw if at least one status is a non-recoverable error
    *   - call warning callback for recoverable errors
    *   - call onKeyUpdate callback when the MediaKeyStatus of any key is updated
    */
-  function handleKeyStatusesChangeEvent() : void {
+  function checkAndHandleCurrentKeyStatuses() : void {
     log.info("DRM: keystatuseschange event received", session.sessionId);
 
-    if (manualCanceller.isUsed || session.keyStatuses.size === 0) {
+    if (manualCanceller.isUsed() || session.keyStatuses.size === 0) {
       return ;
     }
     const { warning, blacklistedKeyIds, whitelistedKeyIds } =
       checkKeyStatuses(session, keySystemOptions, keySystem);
     if (warning !== undefined) {
       callbacks.onWarning(warning);
-      if (manualCanceller.isUsed) {
+      if (manualCanceller.isUsed()) {
         return;
       }
     }
@@ -162,40 +170,38 @@ export default function SessionEventsListener(
     message : Uint8Array,
     messageType : MediaKeyMessageType
   ) : Promise<BufferSource | null> {
-    return new Promise((res, rej) => {
-      log.debug("DRM: Calling `getLicense`", messageType);
-      const getLicense = keySystemOptions.getLicense(message, messageType);
-      const getLicenseTimeout = isNullOrUndefined(getLicenseConfig.timeout) ?
-        10 * 1000 :
-        getLicenseConfig.timeout;
-
-      let timeoutId : number | undefined;
-      if (getLicenseTimeout >= 0) {
-        timeoutId = setTimeout(() => {
-          rej(new GetLicenseTimeoutError(
-            `"getLicense" timeout exceeded (${getLicenseTimeout} ms)`
-          ));
-        }, getLicenseTimeout) as unknown as number;
-      }
-
+    let timeoutId : number | undefined;
+    return new Promise<BufferSource | null>((res, rej) => {
       try {
-        Promise.resolve(getLicense).then(
-          (val) => {
-            clearTimeoutIfOne();
-            res(val);
-          },
-          (err) => {
-            clearTimeoutIfOne();
-            rej(err);
-          });
+        log.debug("DRM: Calling `getLicense`", messageType);
+        const getLicense = keySystemOptions.getLicense(message, messageType);
+        const getLicenseTimeout = isNullOrUndefined(getLicenseConfig.timeout) ?
+          10 * 1000 :
+          getLicenseConfig.timeout;
+
+        if (getLicenseTimeout >= 0) {
+          timeoutId = setTimeout(() => {
+            rej(new GetLicenseTimeoutError(
+              `"getLicense" timeout exceeded (${getLicenseTimeout} ms)`
+            ));
+          }, getLicenseTimeout) as unknown as number;
+        }
+        Promise.resolve(getLicense)
+          .then(clearTimeoutAndResolve, clearTimeoutAndReject);
       } catch (err) {
-        clearTimeoutIfOne();
-        rej(err);
+        clearTimeoutAndReject(err);
+      }
+      function clearTimeoutAndResolve(data : BufferSource | null) {
+        if (timeoutId !== undefined) {
+          clearTimeout(timeoutId);
+        }
+        res(data);
       }
-      function clearTimeoutIfOne() {
+      function clearTimeoutAndReject(err : unknown) {
         if (timeoutId !== undefined) {
           clearTimeout(timeoutId);
         }
+        rej(err);
       }
     });
   }

package/src/core/decrypt/utils/check_key_statuses.ts

@@ -18,6 +18,7 @@ import { ICustomMediaKeySession } from "../../../compat";
 /* eslint-disable-next-line max-len */
 import getUUIDKidFromKeyStatusKID from "../../../compat/eme/get_uuid_kid_from_keystatus_kid";
 import { EncryptedMediaError } from "../../../errors";
+import log from "../../../log";
 import {
   IEncryptedMediaErrorKeyStatusObject,
   IKeySystemOption,
@@ -111,6 +112,11 @@ export default function checkKeyStatuses(
                                              new Uint8Array(keyStatusKeyId));
 
     const keyStatusObj = { keyId: keyId.buffer, keyStatus };
+
+    if (log.hasLevel("DEBUG")) {
+      log.debug(`DRM: key status update (${bytesToHex(keyId)}): ${keyStatus}`);
+    }
+
     switch (keyStatus) {
       case KEY_STATUSES.EXPIRED: {
         const error = new EncryptedMediaError(

package/src/core/decrypt/utils/clean_old_loaded_sessions.ts

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+import log from "../../../log";
 import LoadedSessionsStore from "./loaded_sessions_store";
 
 /**
@@ -32,7 +33,7 @@ export default async function cleanOldLoadedSessions(
   if (limit < 0 || limit >= loadedSessionsStore.getLength()) {
     return ;
   }
-
+  log.info("DRM: LSS cache limit exceeded", limit, loadedSessionsStore.getLength());
   const proms : Array<Promise<unknown>> = [];
   const entries = loadedSessionsStore.getAll().slice(); // clone
   const toDelete = entries.length - limit;

package/src/core/decrypt/utils/loaded_sessions_store.ts

@@ -63,6 +63,7 @@ export default class LoadedSessionsStore {
     sessionType : MediaKeySessionType
   ) : IStoredSessionEntry {
     const keySessionRecord = new KeySessionRecord(initData);
+    log.debug("DRM-LSS: calling `createSession`", sessionType);
     const mediaKeySession = this._mediaKeys.createSession(sessionType);
     const entry = { mediaKeySession,
                     sessionType,
@@ -73,6 +74,8 @@ export default class LoadedSessionsStore {
     if (!isNullOrUndefined(mediaKeySession.closed)) {
       mediaKeySession.closed
         .then(() => {
+          log.info("DRM-LSS: session was closed, removing it.",
+                   mediaKeySession.sessionId);
           const index = this.getIndex(keySessionRecord);
           if (index >= 0 &&
               this._storage[index].mediaKeySession === mediaKeySession)
@@ -86,8 +89,8 @@ export default class LoadedSessionsStore {
         });
     }
 
-    log.debug("DRM-LSS: Add MediaKeySession", entry.sessionType);
     this._storage.push({ ...entry });
+    log.debug("DRM-LSS: MediaKeySession added", entry.sessionType, this._storage.length);
     return entry;
   }
 
@@ -111,6 +114,8 @@ export default class LoadedSessionsStore {
       if (stored.keySessionRecord.isCompatibleWith(initializationData)) {
         this._storage.splice(i, 1);
         this._storage.push(stored);
+        log.debug("DRM-LSS: Reusing session:",
+                  stored.mediaKeySession.sessionId, stored.sessionType);
         return { ...stored };
       }
     }
@@ -332,6 +337,8 @@ export default class LoadedSessionsStore {
     for (let i = this._storage.length - 1; i >= 0; i--) {
       const stored = this._storage[i];
       if (stored.mediaKeySession === mediaKeySession) {
+        log.debug("DRM-LSS: Removing session without closing it",
+                  mediaKeySession.sessionId);
         this._storage.splice(i, 1);
         return true;
       }

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

@@ -154,7 +154,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);
         }
       })
@@ -340,7 +340,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, {
@@ -444,7 +444,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) => {
@@ -643,7 +644,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>(
@@ -197,14 +209,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,
@@ -233,22 +238,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
@@ -373,11 +390,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;
 }