rx-player 4.3.0-dev.2024112900 → 4.3.0-dev.2025012900

package/src/main_thread/decrypt/find_key_system.ts

@@ -32,7 +32,7 @@ import arrayIncludes from "../../utils/array_includes";
 import flatMap from "../../utils/flat_map";
 import isNullOrUndefined from "../../utils/is_null_or_undefined";
 import type { CancellationSignal } from "../../utils/task_canceller";
-import MediaKeysInfosStore from "./utils/media_keys_infos_store";
+import MediaKeysAttacher from "./utils/media_keys_attacher";
 
 type MediaKeysRequirement = "optional" | "required" | "not-allowed";
 
@@ -81,59 +81,81 @@ interface IKeySystemType {
    * system.
    */
   keyName: string | undefined;
-  /** keyType: keySystem type (e.g. "com.widevine.alpha") */
+  /** KeySystem type (e.g. "com.widevine.alpha") */
   keyType: string;
-  /** keySystem {Object}: the original keySystem object */
+  /** The original keySystem object */
   keySystemOptions: IKeySystemOption;
 }
 
 /**
- * @param {Object} keySystem
- * @param {Object} askedConfiguration
- * @param {MediaKeySystemAccess} currentKeySystemAccess
- * @param {Object} currentKeySystemOptions
- * @returns {null|Object}
+ * Takes a `newConfiguration` `MediaKeySystemConfiguration`, that is intended
+ * for the creation of a `MediaKeySystemAccess`, and a `prevConfiguration`
+ * `MediaKeySystemConfiguration`, that was the one used at creation of the
+ * current `MediaKeySystemAccess`.
+ *
+ * This function will then return `true` if it determined that the new
+ * configuration is conceptually compatible with the one used before, and
+ * `false` otherwise.
+ * @param {Object} newConfiguration - New wanted `MediaKeySystemConfiguration`
+ * @param {Object} prevConfiguration - The `MediaKeySystemConfiguration` that is
+ * relied on util now.
+ * @returns {boolean} - `true` if `newConfiguration` is compatible with
+ * `prevConfiguration`.
  */
-function checkCachedMediaKeySystemAccess(
-  keySystem: IKeySystemOption,
-  askedConfiguration: MediaKeySystemConfiguration,
-  currentKeySystemAccess: MediaKeySystemAccess | ICustomMediaKeySystemAccess,
-  currentKeySystemOptions: IKeySystemOption,
-): null | {
-  keySystemOptions: IKeySystemOption;
-  askedConfiguration: MediaKeySystemConfiguration;
-  keySystemAccess: MediaKeySystemAccess | ICustomMediaKeySystemAccess;
-} {
-  const mksConfiguration = currentKeySystemAccess.getConfiguration();
-  if (shouldRenewMediaKeySystemAccess() || isNullOrUndefined(mksConfiguration)) {
-    return null;
+function isNewMediaKeySystemConfigurationCompatibleWithPreviousOne(
+  newConfiguration: MediaKeySystemConfiguration,
+  prevConfiguration: MediaKeySystemConfiguration,
+): boolean {
+  if (newConfiguration.label !== prevConfiguration.label) {
+    return false;
   }
 
-  // TODO Do it with MediaKeySystemAccess.prototype.keySystem instead
-  if (keySystem.type !== currentKeySystemOptions.type) {
-    return null;
+  const prevDistinctiveIdentifier = prevConfiguration.distinctiveIdentifier ?? "optional";
+  const newDistinctiveIdentifier = newConfiguration.distinctiveIdentifier ?? "optional";
+  if (prevDistinctiveIdentifier !== newDistinctiveIdentifier) {
+    return false;
   }
 
-  if (
-    (!isNullOrUndefined(keySystem.persistentLicenseConfig) ||
-      keySystem.persistentState === "required") &&
-    mksConfiguration.persistentState !== "required"
-  ) {
-    return null;
+  const prevPersistentState = prevConfiguration.persistentState ?? "optional";
+  const newPersistentState = newConfiguration.persistentState ?? "optional";
+  if (prevPersistentState !== newPersistentState) {
+    return false;
   }
 
-  if (
-    keySystem.distinctiveIdentifier === "required" &&
-    mksConfiguration.distinctiveIdentifier !== "required"
-  ) {
-    return null;
+  const prevInitDataTypes = prevConfiguration.initDataTypes ?? [];
+  const newInitDataTypes = newConfiguration.initDataTypes ?? [];
+  if (!isArraySubsetOf(newInitDataTypes, prevInitDataTypes)) {
+    return false;
   }
 
-  return {
-    keySystemOptions: keySystem,
-    keySystemAccess: currentKeySystemAccess,
-    askedConfiguration,
-  };
+  const prevSessionTypes = prevConfiguration.sessionTypes ?? [];
+  const newSessionTypes = newConfiguration.sessionTypes ?? [];
+  if (!isArraySubsetOf(newSessionTypes, prevSessionTypes)) {
+    return false;
+  }
+
+  for (const prop of ["audioCapabilities", "videoCapabilities"] as const) {
+    const newCapabilities = newConfiguration[prop] ?? [];
+    const prevCapabilities = prevConfiguration[prop] ?? [];
+    const wasFound = newCapabilities.every((n) => {
+      for (let i = 0; i < prevCapabilities.length; i++) {
+        const prevCap = prevCapabilities[i];
+        if (
+          (prevCap.robustness ?? "") === (n.robustness ?? "") ||
+          (prevCap.encryptionScheme ?? null) === (n.encryptionScheme ?? null) ||
+          (prevCap.robustness ?? "") === (n.robustness ?? "")
+        ) {
+          return true;
+        }
+      }
+      return false;
+    });
+    if (!wasFound) {
+      return false;
+    }
+  }
+
+  return true;
 }
 
 /**
@@ -162,13 +184,23 @@ function buildKeySystemConfigurations(
   keySystemTypeInfo: IKeySystemType,
 ): MediaKeySystemConfiguration[] {
   const { keyName, keyType, keySystemOptions: keySystem } = keySystemTypeInfo;
-  const sessionTypes = ["temporary"];
+  let sessionTypes: string[];
   let persistentState: MediaKeysRequirement = "optional";
   let distinctiveIdentifier: MediaKeysRequirement = "optional";
 
-  if (!isNullOrUndefined(keySystem.persistentLicenseConfig)) {
+  if (Array.isArray(keySystem.wantedSessionTypes)) {
+    sessionTypes = keySystem.wantedSessionTypes;
+    if (
+      arrayIncludes(keySystem.wantedSessionTypes, "persistent-license") &&
+      !isNullOrUndefined(keySystem.persistentLicenseConfig)
+    ) {
+      persistentState = "required";
+    }
+  } else if (!isNullOrUndefined(keySystem.persistentLicenseConfig)) {
     persistentState = "required";
-    sessionTypes.push("persistent-license");
+    sessionTypes = ["persistent-license"];
+  } else {
+    sessionTypes = ["temporary"];
   }
 
   if (!isNullOrUndefined(keySystem.persistentState)) {
@@ -384,14 +416,7 @@ export default function getMediaKeySystemAccess(
   cancelSignal: CancellationSignal,
 ): Promise<IFoundMediaKeySystemAccessEvent> {
   log.info("DRM: Searching for compatible MediaKeySystemAccess");
-  /**
-   * Array of set keySystems for this content.
-   * Each item of this array is an object containing the following keys:
-   *   - keyName {string}: keySystem canonical name (e.g. "widevine")
-   *   - keyType {string}: keySystem type (e.g. "com.widevine.alpha")
-   *   - keySystem {Object}: the original keySystem object
-   * @type {Array.<Object>}
-   */
+  /** Array of set keySystems for this content. */
   const keySystemsType: IKeySystemType[] = keySystemsConfigs.reduce(
     (arr: IKeySystemType[], keySystemOptions) => {
       const { EME_KEY_SYSTEMS } = config.getCurrent();
@@ -444,36 +469,6 @@ export default function getMediaKeySystemAccess(
     }
 
     const chosenType = keySystemsType[index];
-
-    const currentState = MediaKeysInfosStore.getState(mediaElement);
-    if (currentState !== null) {
-      if (eme.implementation === currentState.emeImplementation.implementation) {
-        // Fast way to find a compatible keySystem if the currently loaded
-        // one as exactly the same compatibility options.
-        const cachedKeySystemAccess = checkCachedMediaKeySystemAccess(
-          chosenType.keySystemOptions,
-          currentState.askedConfiguration,
-          currentState.mediaKeySystemAccess,
-          currentState.keySystemOptions,
-        );
-        if (cachedKeySystemAccess !== null) {
-          log.info("DRM: Found cached compatible keySystem");
-          return Promise.resolve({
-            type: "reuse-media-key-system-access" as const,
-            value: {
-              mediaKeySystemAccess: cachedKeySystemAccess.keySystemAccess,
-              askedConfiguration: cachedKeySystemAccess.askedConfiguration,
-              options: cachedKeySystemAccess.keySystemOptions,
-              codecSupport: extractCodecSupportListFromConfiguration(
-                cachedKeySystemAccess.askedConfiguration,
-                cachedKeySystemAccess.keySystemAccess.getConfiguration(),
-              ),
-            },
-          });
-        }
-      }
-    }
-
     const { keyType, keySystemOptions } = chosenType;
 
     const keySystemConfigurations = buildKeySystemConfigurations(chosenType);
@@ -484,8 +479,37 @@ export default function getMediaKeySystemAccess(
     );
 
     let keySystemAccess;
+    const currentState = await MediaKeysAttacher.getAttachedMediaKeysState(mediaElement);
     for (let configIdx = 0; configIdx < keySystemConfigurations.length; configIdx++) {
       const keySystemConfiguration = keySystemConfigurations[configIdx];
+
+      // Check if the current `MediaKeySystemAccess` created cannot be reused here
+      if (
+        currentState !== null &&
+        !shouldRenewMediaKeySystemAccess() &&
+        // TODO: Do it with MediaKeySystemAccess.prototype.keySystem instead?
+        keyType === currentState.mediaKeySystemAccess.keySystem &&
+        eme.implementation === currentState.emeImplementation.implementation &&
+        isNewMediaKeySystemConfigurationCompatibleWithPreviousOne(
+          keySystemConfiguration,
+          currentState.askedConfiguration,
+        )
+      ) {
+        log.info("DRM: Found cached compatible keySystem");
+        return Promise.resolve({
+          type: "reuse-media-key-system-access" as const,
+          value: {
+            mediaKeySystemAccess: currentState.mediaKeySystemAccess,
+            askedConfiguration: currentState.askedConfiguration,
+            options: keySystemOptions,
+            codecSupport: extractCodecSupportListFromConfiguration(
+              currentState.askedConfiguration,
+              currentState.mediaKeySystemAccess.getConfiguration(),
+            ),
+          },
+        });
+      }
+
       try {
         keySystemAccess = await testKeySystem(keyType, [keySystemConfiguration]);
         log.info("DRM: Found compatible keysystem", keyType, index + 1);
@@ -544,3 +568,18 @@ export async function testKeySystem(
   }
   return keySystemAccess;
 }
+
+/**
+ * Returns `true` if `arr1`'s values are entirely contained in `arr2`.
+ * @param {string} arr1
+ * @param {string} arr2
+ * @return {boolean}
+ */
+function isArraySubsetOf(arr1: string[], arr2: string[]): boolean {
+  for (let i = 0; i < arr1.length; i++) {
+    if (!arrayIncludes(arr2, arr1[i])) {
+      return false;
+    }
+  }
+  return true;
+}

package/src/main_thread/decrypt/get_key_system_configuration.ts

@@ -15,7 +15,7 @@
  */
 
 import type { IMediaElement } from "../../compat/browser_compatibility_types";
-import MediaKeysInfosStore from "./utils/media_keys_infos_store";
+import MediaKeysAttacher from "./utils/media_keys_attacher";
 
 /**
  * Returns the name of the current key system used as well as its configuration,
@@ -26,7 +26,7 @@ import MediaKeysInfosStore from "./utils/media_keys_infos_store";
 export default function getKeySystemConfiguration(
   mediaElement: IMediaElement,
 ): [string, MediaKeySystemConfiguration] | null {
-  const currentState = MediaKeysInfosStore.getState(mediaElement);
+  const currentState = MediaKeysAttacher.getAwaitedState(mediaElement);
   if (currentState === null) {
     return null;
   }

package/src/main_thread/decrypt/get_media_keys.ts

@@ -26,7 +26,7 @@ import getMediaKeySystemAccess from "./find_key_system";
 import type { ICodecSupportList } from "./find_key_system";
 import type { IMediaKeySessionStores } from "./types";
 import LoadedSessionsStore from "./utils/loaded_sessions_store";
-import MediaKeysInfosStore from "./utils/media_keys_infos_store";
+import MediaKeysAttacher from "./utils/media_keys_attacher";
 import PersistentSessionsStore from "./utils/persistent_sessions_store";
 import ServerCertificateStore from "./utils/server_certificate_store";
 
@@ -94,7 +94,7 @@ export default async function getMediaKeysInfos(
   }
 
   const { options, mediaKeySystemAccess, askedConfiguration, codecSupport } = evt.value;
-  const currentState = MediaKeysInfosStore.getState(mediaElement);
+  const currentState = await MediaKeysAttacher.getAttachedMediaKeysState(mediaElement);
   const persistentSessionsStore = createPersistentSessionsStorage(options);
 
   if (

package/src/main_thread/decrypt/init_media_keys.ts

@@ -18,9 +18,9 @@ import type { IMediaElement } from "../../compat/browser_compatibility_types";
 import log from "../../log";
 import type { IKeySystemOption } from "../../public_types";
 import type { CancellationSignal } from "../../utils/task_canceller";
-import { disableMediaKeys } from "./attach_media_keys";
 import type { IMediaKeysInfos } from "./get_media_keys";
 import getMediaKeysInfos from "./get_media_keys";
+import MediaKeysAttacher from "./utils/media_keys_attacher";
 
 /**
  * Get media keys infos from key system configs then attach media keys to media element.
@@ -48,7 +48,7 @@ export default async function initMediaKeys(
 
   if (shouldDisableOldMediaKeys) {
     log.debug("DRM: Disabling old MediaKeys");
-    await disableMediaKeys(mediaElement);
+    await MediaKeysAttacher.clearMediaKeys(mediaElement);
   }
   return mediaKeysInfo;
 }

package/src/main_thread/decrypt/utils/media_keys_attacher.ts

@@ -0,0 +1,284 @@
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type { IMediaElement } from "../../../compat/browser_compatibility_types";
+import type {
+  ICustomMediaKeys,
+  ICustomMediaKeySystemAccess,
+  IEmeApiImplementation,
+} from "../../../compat/eme";
+import { setMediaKeys } from "../../../compat/eme/set_media_keys";
+import { EncryptedMediaError } from "../../../errors";
+import log from "../../../log";
+import type { IKeySystemOption } from "../../../public_types";
+import isNullOrUndefined from "../../../utils/is_null_or_undefined";
+import type LoadedSessionsStore from "./loaded_sessions_store";
+
+/** DRM-related state that can be associated to a single HTMLMediaElement. */
+export interface IMediaElementMediaKeysInfos {
+  emeImplementation: IEmeApiImplementation;
+
+  /** Last keySystemOptions used with that HTMLMediaElement. */
+  keySystemOptions: IKeySystemOption;
+
+  /**
+   * The actual MediaKeySystemConfiguration asked to the
+   * `requestMediaKeySystemAccess` API.
+   */
+  askedConfiguration: MediaKeySystemConfiguration;
+
+  /**
+   * Last MediaKeySystemAccess used to create a MediaKeys bound to that
+   * HTMLMediaElement.
+   */
+  mediaKeySystemAccess: ICustomMediaKeySystemAccess | MediaKeySystemAccess;
+
+  /** Last MediaKeys instance bound to that HTMLMediaElement. */
+  mediaKeys: MediaKeys | ICustomMediaKeys;
+
+  /**
+   * Store containing information about every MediaKeySession active on the
+   * MediaKeys instance bound to that HTMLMediaElement.
+   */
+  loadedSessionsStore: LoadedSessionsStore;
+}
+
+// Store the MediaKeys infos attached to a media element.
+const currentMediaState = new WeakMap<IMediaElement, IMediaKeysAttacherItem>();
+
+interface IMediaKeysAttacherItem {
+  /**
+   * Information on `MediaKeys` which has been attached or is being attached
+   * to the `HTMLMediaElement`.
+   *
+   * `null` either if no `MediaKeys` is attached or if the last attachment
+   * task failed.
+   */
+  mediaKeysState: IMediaElementMediaKeysInfos | null;
+
+  /**
+   * Property set to a Promise **only** when the `MediaKeys` attachment is
+   * pending.
+   *
+   * This promise resolves once `mediaKeys` is attached to that
+   * `HTMLMediaElement`, and rejects if it failed to do so.
+   *
+   * `null` if no `MediaKeys` attachment is pending (it is already attached
+   * or it already failed to do so).
+   */
+  pendingTask: Promise<void> | null;
+}
+
+export default {
+  /**
+   * Attach new MediaKeys infos set on a HMTLMediaElement.
+   * @param {HTMLMediaElement} mediaElement
+   * @param {Object} mediaKeysInfo
+   * @returns {Promise}
+   */
+  async attach(
+    mediaElement: IMediaElement,
+    mediaKeysInfo: IMediaElementMediaKeysInfos,
+  ): Promise<void> {
+    const previousState = currentMediaState.get(mediaElement);
+    const pendingTask = attachMediaKeys(mediaElement, previousState, mediaKeysInfo).then(
+      () => {
+        currentMediaState.set(mediaElement, {
+          pendingTask: null,
+          mediaKeysState: mediaKeysInfo,
+        });
+      },
+      () => {
+        currentMediaState.set(mediaElement, {
+          pendingTask: null,
+          mediaKeysState: null,
+        });
+      },
+    );
+    currentMediaState.set(mediaElement, {
+      pendingTask,
+      mediaKeysState: mediaKeysInfo,
+    });
+    return pendingTask;
+  },
+
+  /**
+   * Get MediaKeys information expected to be linked to the given
+   * `HTMLMediaElement`.
+   *
+   * Unlike `getAttachedMediaKeysState`, this method is synchronous and will
+   * also return the expected state when `MediaKeys` attachment is still
+   * pending and thus when that state is not truly applied (and where it
+   * might fail before being applied).
+   *
+   * As such, only call this method if you want the currently expected state,
+   * not the actual one.
+   * @param {HTMLMediaElement} mediaElement
+   * @returns {Array}
+   */
+  getAwaitedState(mediaElement: IMediaElement): IMediaElementMediaKeysInfos | null {
+    const currentState = currentMediaState.get(mediaElement);
+    return currentState?.mediaKeysState ?? null;
+  },
+
+  /**
+   * Get MediaKeys information set on a HMTLMediaElement.
+   *
+   * This method is asynchronous because that state may still be in a process
+   * of being attached to the `HTMLMediaElement` (and the state we're
+   * currently setting may not work out).
+   * @param {HTMLMediaElement} mediaElement
+   * @returns {Object|null}
+   */
+  async getAttachedMediaKeysState(
+    mediaElement: IMediaElement,
+  ): Promise<IMediaElementMediaKeysInfos | null> {
+    const currentState = currentMediaState.get(mediaElement);
+    if (currentState === undefined) {
+      return null;
+    }
+    if (currentState.pendingTask !== null) {
+      await currentState.pendingTask;
+      return this.getAttachedMediaKeysState(mediaElement);
+    }
+    return currentState.mediaKeysState;
+  },
+
+  /**
+   * Remove MediaKeys currently set on a HMTLMediaElement and update state
+   * accordingly.
+   * @param {HTMLMediaElement} mediaElement
+   * @returns {Promise}
+   */
+  clearMediaKeys(mediaElement: IMediaElement): Promise<void> {
+    const previousState = currentMediaState.get(mediaElement);
+    const pendingTask = clearMediaKeys(mediaElement, previousState).then(
+      () => {
+        currentMediaState.set(mediaElement, {
+          pendingTask: null,
+          mediaKeysState: null,
+        });
+      },
+      () => {
+        currentMediaState.set(mediaElement, {
+          pendingTask: null,
+          mediaKeysState: null,
+        });
+      },
+    );
+    currentMediaState.set(mediaElement, {
+      pendingTask,
+      mediaKeysState: null,
+    });
+    return pendingTask;
+  },
+};
+
+/**
+ * Ensure that the last `MediaKeys` set on the given HTMLMediaElement is
+ * attached.
+ *
+ * The returned Promise never rejects, it will just log an error if the
+ * previous attachment failed.
+ *
+ * @param {Object} previousState
+ * @returns {Promise.<undefined>}
+ */
+async function awaitMediaKeysAttachment(
+  previousState: IMediaKeysAttacherItem,
+): Promise<void> {
+  const promise = previousState.pendingTask;
+  if (isNullOrUndefined(promise)) {
+    return;
+  }
+  log.info("DRM: Awaiting previous MediaKeys attachment operation");
+  try {
+    await previousState.pendingTask;
+  } catch (err) {
+    log.info(
+      "DRM: previous MediaKeys attachment operation failed",
+      err instanceof Error ? err : "Unknown error",
+    );
+  }
+}
+
+async function attachMediaKeys(
+  mediaElement: IMediaElement,
+  previousState: IMediaKeysAttacherItem | undefined,
+  mediaKeysInfo: IMediaElementMediaKeysInfos,
+): Promise<void> {
+  if (previousState !== undefined) {
+    if (previousState.pendingTask !== null) {
+      // Ensure the `MediaKeys` has been fully attached to the HTMLMediaElement before
+      // resetting things, to avoid browser errors due to an invalid state.
+      await awaitMediaKeysAttachment(previousState);
+    }
+
+    const closeAllSessions =
+      !isNullOrUndefined(previousState.mediaKeysState) &&
+      previousState.mediaKeysState.loadedSessionsStore !==
+        mediaKeysInfo.loadedSessionsStore
+        ? previousState.mediaKeysState.loadedSessionsStore.closeAllSessions()
+        : Promise.resolve();
+
+    await closeAllSessions;
+
+    if (mediaElement.mediaKeys === mediaKeysInfo.mediaKeys) {
+      log.debug("DRM: Right MediaKeys already set");
+      return;
+    }
+  }
+
+  log.info("DRM: Attaching MediaKeys to the media element");
+  try {
+    await setMediaKeys(
+      mediaKeysInfo.emeImplementation,
+      mediaElement,
+      mediaKeysInfo.mediaKeys,
+    );
+    log.info("DRM: MediaKeys attached with success");
+  } catch (err) {
+    const errMessage = err instanceof Error ? err.toString() : "Unknown Error";
+    throw new EncryptedMediaError(
+      "MEDIA_KEYS_ATTACHMENT_ERROR",
+      "Could not attach the MediaKeys to the media element: " + errMessage,
+    );
+  }
+}
+
+async function clearMediaKeys(
+  mediaElement: IMediaElement,
+  previousState: IMediaKeysAttacherItem | undefined,
+): Promise<unknown> {
+  if (previousState === undefined) {
+    return;
+  }
+
+  if (previousState.pendingTask !== null) {
+    // Ensure the `MediaKeys` has been fully attached to the HTMLMediaElement before
+    // resetting things, to avoid browser errors due to an invalid state.
+    await awaitMediaKeysAttachment(previousState);
+  }
+
+  if (previousState.mediaKeysState === null) {
+    return;
+  }
+
+  log.info("DRM: Disposing of the current MediaKeys");
+  const { loadedSessionsStore } = previousState.mediaKeysState;
+  await loadedSessionsStore.closeAllSessions();
+  return setMediaKeys(previousState.mediaKeysState.emeImplementation, mediaElement, null);
+}

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

@@ -171,15 +171,16 @@ export default class RebufferingController extends EventEmitter<IRebufferingCont
         if (position.isAwaitingFuturePosition()) {
           playbackRateUpdater.stopRebuffering();
           log.debug("Init: let rebuffering happen as we're awaiting a future position");
-          this.trigger("stalled", stalledReason);
-          return;
+        } else {
+          playbackRateUpdater.startRebuffering();
         }
 
-        playbackRateUpdater.startRebuffering();
-
         if (
           this._manifest === null ||
           (isSeekingApproximate &&
+            // Don't handle discontinuities on devices with broken seeks before
+            // enough time have passed because seeking brings more risks to
+            // lead to a lengthy rebuffering-exiting process
             getMonotonicTimeStamp() - rebuffering.timestamp <= 1000)
         ) {
           this.trigger("stalled", stalledReason);
@@ -189,6 +190,16 @@ export default class RebufferingController extends EventEmitter<IRebufferingCont
         /** Position at which data is awaited. */
         const { position: stalledPosition } = rebuffering;
 
+        /**
+         * We may still be in the process of waiting for a position to be seeked
+         * to. When calculating a potential position to e.g. skip over
+         * discontinuities, we should compare it to that "target" position if
+         * one, not the one we're currently playing.
+         */
+        const targetTime = observation.position.isAwaitingFuturePosition()
+          ? observation.position.getWanted()
+          : this._playbackObserver.getCurrentTime();
+
         if (
           stalledPosition !== null &&
           stalledPosition !== undefined &&
@@ -201,10 +212,10 @@ export default class RebufferingController extends EventEmitter<IRebufferingCont
           );
           if (skippableDiscontinuity !== null) {
             const realSeekTime = skippableDiscontinuity + 0.001;
-            if (realSeekTime <= this._playbackObserver.getCurrentTime()) {
+            if (realSeekTime <= targetTime) {
               log.info(
                 "Init: position to seek already reached, no seeking",
-                this._playbackObserver.getCurrentTime(),
+                targetTime,
                 realSeekTime,
               );
             } else {
@@ -243,7 +254,7 @@ export default class RebufferingController extends EventEmitter<IRebufferingCont
           nextBufferRangeGap < BUFFER_DISCONTINUITY_THRESHOLD
         ) {
           const seekTo = positionBlockedAt + nextBufferRangeGap + EPSILON;
-          if (this._playbackObserver.getCurrentTime() < seekTo) {
+          if (targetTime < seekTo) {
             log.warn(
               "Init: discontinuity encountered inferior to the threshold",
               positionBlockedAt,
@@ -266,8 +277,7 @@ export default class RebufferingController extends EventEmitter<IRebufferingCont
           if (period.end !== undefined && period.end <= positionBlockedAt) {
             if (
               this._manifest.periods[i + 1].start > positionBlockedAt &&
-              this._manifest.periods[i + 1].start >
-                this._playbackObserver.getCurrentTime()
+              this._manifest.periods[i + 1].start > targetTime
             ) {
               const nextPeriod = this._manifest.periods[i + 1];
               this._playbackObserver.setCurrentTime(nextPeriod.start);
@@ -315,7 +325,7 @@ export default class RebufferingController extends EventEmitter<IRebufferingCont
     }
     const observation = this._playbackObserver.getReference().getValue();
     if (
-      !observation.rebuffering ||
+      observation.rebuffering === null ||
       observation.paused ||
       this._speed.getValue() <= 0 ||
       (bufferType !== "audio" && bufferType !== "video")