rx-player 3.28.0-dev.2022063000 → 3.28.1-dev.2022083000

package/jest.config.js

@@ -6,6 +6,11 @@ module.exports = {
   roots: ["<rootDir>/src"],
   preset: "ts-jest",
   testEnvironment: "jsdom",
+    // Without this, Jest just fails when importing rxjs, for some arcane
+    // ESM-vs-CommonJS reasons linked to how it works internally.
+    moduleNameMapper: {
+      '^rxjs$': require.resolve('rxjs'),
+  },
   testMatch: ["**/?(*.)+(spec|test).[jt]s?(x)"],
   collectCoverageFrom: [
     "src/**/*.ts",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "rx-player",
   "author": "Canal+",
-  "version": "3.28.0-dev.2022063000",
+  "version": "3.28.1-dev.2022083000",
   "description": "Canal+ HTML5 Video Player",
   "main": "./dist/rx-player.js",
   "keywords": [
@@ -48,7 +48,7 @@
     "doc": "rm -rf doc/generated; node ./scripts/doc-generator/index.js doc/ doc/generated \"$(cat VERSION)\"",
     "lint": "eslint src -c .eslintrc.js",
     "lint:demo": "eslint demo/full/scripts",
-    "lint:tests": "eslint tests/**/*.js",
+    "lint:tests": "eslint tests/**/*.js --ignore-pattern '/tests/performance/bundle*'",
     "list": "node scripts/list-npm-scripts.js",
     "prepublishOnly": "npm run build:modular",
     "standalone": "node ./scripts/run_standalone_demo.js",
@@ -81,34 +81,35 @@
     "rxjs": "7.4.0"
   },
   "devDependencies": {
-    "@babel/core": "7.18.5",
-    "@babel/plugin-transform-runtime": "7.18.5",
-    "@babel/preset-env": "7.18.2",
-    "@babel/preset-react": "7.17.12",
-    "@types/chai": "4.3.1",
-    "@types/jest": "27.5.1",
+    "@babel/core": "7.18.13",
+    "@babel/plugin-transform-runtime": "7.18.10",
+    "@babel/preset-env": "7.18.10",
+    "@babel/preset-react": "7.18.6",
+    "@types/chai": "4.3.3",
+    "@types/jest": "28.1.8",
     "@types/mocha": "9.1.1",
-    "@types/node": "17.0.42",
-    "@types/sinon": "10.0.11",
-    "@typescript-eslint/eslint-plugin": "5.27.1",
-    "@typescript-eslint/eslint-plugin-tslint": "5.27.1",
-    "@typescript-eslint/parser": "5.27.1",
+    "@types/node": "18.7.13",
+    "@types/sinon": "10.0.13",
+    "@typescript-eslint/eslint-plugin": "5.35.1",
+    "@typescript-eslint/eslint-plugin-tslint": "5.35.1",
+    "@typescript-eslint/parser": "5.35.1",
     "arraybuffer-loader": "1.0.8",
     "babel-loader": "8.2.5",
     "chai": "4.3.6",
-    "cheerio": "1.0.0-rc.11",
-    "core-js": "3.22.8",
-    "esbuild": "0.14.43",
-    "eslint": "8.17.0",
+    "cheerio": "1.0.0-rc.12",
+    "core-js": "3.25.0",
+    "esbuild": "0.15.5",
+    "eslint": "8.23.0",
     "eslint-plugin-import": "2.26.0",
-    "eslint-plugin-jsdoc": "39.3.2",
-    "eslint-plugin-react": "7.30.0",
+    "eslint-plugin-jsdoc": "39.3.6",
+    "eslint-plugin-react": "7.31.1",
     "esm": "3.2.25",
     "express": "4.18.1",
-    "highlight.js": "11.5.1",
+    "highlight.js": "11.6.0",
     "html-entities": "2.3.3",
-    "jest": "27.5.1",
-    "karma": "6.3.20",
+    "jest": "28.1.3",
+    "jest-environment-jsdom": "28.1.3",
+    "karma": "6.4.0",
     "karma-chrome-launcher": "3.1.1",
     "karma-firefox-launcher": "2.1.2",
     "karma-mocha": "2.0.1",
@@ -117,19 +118,19 @@
     "mocha": "10.0.0",
     "mocha-loader": "5.1.5",
     "raw-loader": "4.0.2",
-    "react": "18.1.0",
-    "react-dom": "18.1.0",
+    "react": "18.2.0",
+    "react-dom": "18.2.0",
     "regenerator-runtime": "0.13.9",
     "rimraf": "3.0.2",
     "semver": "7.3.7",
     "sinon": "14.0.0",
-    "terser-webpack-plugin": "5.3.3",
-    "ts-jest": "27.1.5",
-    "ts-loader": "9.3.0",
+    "terser-webpack-plugin": "5.3.5",
+    "ts-jest": "28.0.8",
+    "ts-loader": "9.3.1",
     "tslint": "6.1.3",
-    "typescript": "4.7.3",
-    "webpack": "5.73.0",
-    "webpack-bundle-analyzer": "4.5.0",
+    "typescript": "4.8.2",
+    "webpack": "5.74.0",
+    "webpack-bundle-analyzer": "4.6.1",
     "webpack-cli": "4.10.0"
   },
   "scripts-list": {

package/sonar-project.properties

@@ -1,7 +1,7 @@
 sonar.projectKey=rx-player
 sonar.organization=rx-player
 sonar.projectName=rx-player
-sonar.projectVersion=3.28.0-dev.2022063000
+sonar.projectVersion=3.28.1-dev.2022083000
 sonar.sources=./src,./demo,./tests
 sonar.exclusions=demo/full/bundle.js,demo/standalone/lib.js,demo/bundle.js
 sonar.host.url=https://sonarcloud.io

package/src/compat/eme/load_session.ts

@@ -23,15 +23,14 @@ const EME_WAITING_DELAY_LOADED_SESSION_EMPTY_KEYSTATUSES = 100;
  * Load a persistent session, based on its `sessionId`, on the given
  * MediaKeySession.
  *
- * Returns an Observable which emits:
- *   - true if the persistent MediaKeySession was found and loaded
- *   - false if no persistent MediaKeySession was found with that `sessionId`.
- * Then completes.
+ * Returns a Promise which resolves with:
+ *   - `true` if the persistent MediaKeySession was found and loaded
+ *   - `false` if no persistent MediaKeySession was found with that `sessionId`.
  *
- * The Observable throws if anything goes wrong in the process.
+ * The Promise rejects if anything goes wrong in the process.
  * @param {MediaKeySession} session
  * @param {string} sessionId
- * @returns {Observable}
+ * @returns {Promise.<boolean>}
  */
 export default async function loadSession(
   session : MediaKeySession | ICustomMediaKeySession,

package/src/compat/event_listeners.ts

@@ -205,11 +205,13 @@ function getPageActivityRef(
   const ref = createSharedReference(true);
   stopListening.register(() => {
     clearTimeout(currentTimeout);
+    currentTimeout = undefined;
     ref.finish();
   });
 
   isDocVisibleRef.onUpdate(function onDocVisibilityChange(isVisible : boolean) : void {
     clearTimeout(currentTimeout); // clear potential previous timeout
+    currentTimeout = undefined;
     if (!isVisible) {
       const { INACTIVITY_DELAY } = config.getCurrent();
       currentTimeout = window.setTimeout(() => {
@@ -313,6 +315,7 @@ function getVideoVisibilityRef(
   const ref = createSharedReference(true);
   stopListening.register(() => {
     clearTimeout(currentTimeout);
+    currentTimeout = undefined;
     ref.finish();
   });
 
@@ -324,6 +327,8 @@ function getVideoVisibilityRef(
   return ref;
 
   function checkCurrentVisibility() : void {
+    clearTimeout(currentTimeout);
+    currentTimeout = undefined;
     if (pipStatus.getValue().isEnabled || isDocVisibleRef.getValue()) {
       ref.setValueIfChanged(true);
     } else {

package/src/core/api/media_element_track_choice_manager.ts

@@ -102,7 +102,7 @@ function createAudioTracks(
     const track = { language: audioTrack.language,
                     id,
                     normalized: normalizeLanguage(audioTrack.language),
-                    audioDescription: false,
+                    audioDescription: audioTrack.kind === "descriptions",
                     representations: [] as Representation[] };
     newAudioTracks.push({ track,
                           nativeTrack: audioTrack });

package/src/core/api/public_api.ts

@@ -432,7 +432,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     // See: https://bugzilla.mozilla.org/show_bug.cgi?id=1194624
     videoElement.preload = "auto";
 
-    this.version = /* PLAYER_VERSION */"3.28.0-dev.2022063000";
+    this.version = /* PLAYER_VERSION */"3.28.1-dev.2022083000";
     this.log = log;
     this.state = "STOPPED";
     this.videoElement = videoElement;
@@ -2943,7 +2943,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     return activeRepresentations[currentPeriod.id];
   }
 }
-Player.version = /* PLAYER_VERSION */"3.28.0-dev.2022063000";
+Player.version = /* PLAYER_VERSION */"3.28.1-dev.2022083000";
 
 /** Every events sent by the RxPlayer's public API. */
 interface IPublicAPIEvent {

package/src/core/decrypt/create_session.ts

@@ -117,8 +117,18 @@ async function createAndTryToRetrievePersistentSession(
     if (!hasLoadedSession) {
       log.warn("DRM: No data stored for the loaded session");
       persistentSessionsStore.delete(storedEntry.sessionId);
+
+      // The EME specification is kind of implicit about it but it seems from my
+      // understanding (Paul B.) that a MediaKeySession on wich a `load` attempt
+      // did not succeed due to the loaded session not being found by the
+      // browser/CDM, should neither be used anymore nor closed.
+      // Thus, we're creating another `"persistent-license"` `MediaKeySession`
+      // in that specific case.
+      loadedSessionsStore.removeSessionWithoutClosingIt(entry.mediaKeySession);
+      const newEntry = loadedSessionsStore.createSession(initData,
+                                                         "persistent-license");
       return { type: MediaKeySessionLoadingType.Created,
-               value: entry };
+               value: newEntry };
     }
 
     if (hasLoadedSession && isSessionUsable(entry.mediaKeySession)) {
@@ -153,7 +163,23 @@ async function createAndTryToRetrievePersistentSession(
       persistentSessionsStore.delete(persistentEntry.sessionId);
     }
 
-    await loadedSessionsStore.closeSession(entry.mediaKeySession);
+    try {
+      await loadedSessionsStore.closeSession(entry.mediaKeySession);
+    } catch (err) {
+      // From reading the EME specification in details, it seems that a
+      // `MediaKeySession`'s ability to be closed is tightly linked to its
+      // possession of a "sanitized session ID" set as `sessionId`.
+      // This is never clearly stated however and I'm (Paul B.) always afraid of
+      // breaking compatibility when it comes to EME code.
+      // So we still try to close the `MediaKeySession` in any case, only, if it
+      // fails and it didn't had any `sessionId` set, we just ignore the error.
+      // Note that trying to close the `MediaKeySession` might incur some delays
+      // in those rare cases.
+      if (entry.mediaKeySession.sessionId !== "") {
+        throw err;
+      }
+      loadedSessionsStore.removeSessionWithoutClosingIt(entry.mediaKeySession);
+    }
     if (cancelSignal.cancellationError !== null) {
       throw cancelSignal.cancellationError;
     }

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

@@ -22,6 +22,7 @@ import {
   loadSession,
 } from "../../../compat";
 import log from "../../../log";
+import assert from "../../../utils/assert";
 import isNullOrUndefined from "../../../utils/is_null_or_undefined";
 import { IProcessedProtectionData } from "../types";
 import KeySessionRecord from "./key_session_record";
@@ -310,6 +311,34 @@ export default class LoadedSessionsStore {
     await Promise.all(closingProms);
   }
 
+  /**
+   * Find the given `MediaKeySession` in the `LoadedSessionsStore` and removes
+   * any reference to it without actually closing it.
+   *
+   * Returns `true` if the given `mediaKeySession` has been found and removed,
+   * `false` otherwise.
+   *
+   * Note that this may create a `MediaKeySession` leakage in the wrong
+   * conditions, cases where this method should be called should be very
+   * carefully evaluated.
+   * @param {MediaKeySession} mediaKeySession
+   * @returns {boolean}
+   */
+  public removeSessionWithoutClosingIt(
+    mediaKeySession : MediaKeySession | ICustomMediaKeySession
+  ) : boolean {
+    assert(mediaKeySession.sessionId === "",
+           "Initialized `MediaKeySession`s should always be properly closed");
+    for (let i = this._storage.length - 1; i >= 0; i--) {
+      const stored = this._storage[i];
+      if (stored.mediaKeySession === mediaKeySession) {
+        this._storage.splice(i, 1);
+        return true;
+      }
+    }
+    return false;
+  }
+
   /**
    * Get the index of a stored MediaKeySession entry based on its
    * `KeySessionRecord`.

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

@@ -61,7 +61,7 @@ const generateRequestID = idGenerator();
  * `options` argument, which may retry a segment request when it fails.
  *
  * @param {string} bufferType
- * @param {Object} transport
+ * @param {Object} pipeline
  * @param {Object} callbacks
  * @param {Object} options
  * @returns {Function}

package/src/core/init/content_time_boundaries_observer.ts

@@ -31,6 +31,7 @@ import Manifest, {
 } from "../../manifest";
 import { fromEvent } from "../../utils/event_emitter";
 import filterMap from "../../utils/filter_map";
+import isNullOrUndefined from "../../utils/is_null_or_undefined";
 import createSharedReference from "../../utils/reference";
 import { IReadOnlyPlaybackObserver } from "../api";
 import {
@@ -86,7 +87,7 @@ export default function ContentTimeBoundariesObserver(
                                        "earliest time announced in the Manifest.");
         return EVENTS.warning(warning);
       } else if (
-        wantedPosition > maximumPositionCalculator.getCurrentMaximumPosition()
+        wantedPosition > maximumPositionCalculator.getMaximumAvailablePosition()
       ) {
         const warning = new MediaError("MEDIA_TIME_AFTER_MANIFEST",
                                        "The current position is after the latest " +
@@ -106,13 +107,10 @@ export default function ContentTimeBoundariesObserver(
   const updateDurationOnManifestUpdate$ = fromEvent(manifest, "manifestUpdate").pipe(
     startWith(null),
     tap(() => {
-      if (!manifest.isDynamic) {
-        const maxPos = maximumPositionCalculator.getCurrentMaximumPosition();
-        contentDuration.setValue(maxPos);
-      } else {
-        // TODO handle finished dynamic contents?
-        contentDuration.setValue(undefined);
-      }
+      const duration = manifest.isDynamic ?
+        maximumPositionCalculator.getEndingPosition() :
+        maximumPositionCalculator.getMaximumAvailablePosition();
+      contentDuration.setValue(duration);
     }),
     ignoreElements()
   );
@@ -120,24 +118,23 @@ export default function ContentTimeBoundariesObserver(
   const updateDurationAndTimeBoundsOnTrackChange$ = streams.pipe(
     tap((message) => { // Update Manifest's bounds and duration if necessary
       if (message.type === "adaptationChange") {
+        if (!manifest.isLastPeriodKnown) {
+          return;
+        }
         const lastPeriod = manifest.periods[manifest.periods.length - 1];
         if (message.value.period.id === lastPeriod?.id) {
-          if (message.value.type === "audio") {
-            maximumPositionCalculator
-              .updateLastAudioAdaptation(message.value.adaptation);
-            if (!manifest.isDynamic) {
-              contentDuration.setValue(
-                maximumPositionCalculator.getCurrentMaximumPosition()
-              );
-            }
-          } else if (message.value.type === "video") {
-            maximumPositionCalculator
-              .updateLastVideoAdaptation(message.value.adaptation);
-            if (!manifest.isDynamic) {
-              contentDuration.setValue(
-                maximumPositionCalculator.getCurrentMaximumPosition()
-              );
+          if (message.value.type === "audio" || message.value.type === "video") {
+            if (message.value.type === "audio") {
+              maximumPositionCalculator
+                .updateLastAudioAdaptation(message.value.adaptation);
+            } else {
+              maximumPositionCalculator
+                .updateLastVideoAdaptation(message.value.adaptation);
             }
+            const newDuration = manifest.isDynamic ?
+              maximumPositionCalculator.getMaximumAvailablePosition() :
+              maximumPositionCalculator.getEndingPosition();
+            contentDuration.setValue(newDuration);
           }
         }
       }
@@ -182,7 +179,7 @@ class MaximumPositionCalculator {
    * If no Adaptation has been set, it should be set to `null`.
    *
    * Allows to calculate the maximum position more precizely in
-   * `getCurrentMaximumPosition`.
+   * `getMaximumAvailablePosition` and `getEndingPosition`.
    * @param {Object|null} adaptation
    */
   public updateLastAudioAdaptation(adaptation : Adaptation | null) : void {
@@ -194,7 +191,7 @@ class MaximumPositionCalculator {
    * If no Adaptation has been set, it should be set to `null`.
    *
    * Allows to calculate the maximum position more precizely in
-   * `getCurrentMaximumPosition`.
+   * `getMaximumAvailablePosition` and `getEndingPosition`.
    * @param {Object|null} adaptation
    */
   public updateLastVideoAdaptation(adaptation : Adaptation | null) : void {
@@ -202,11 +199,11 @@ class MaximumPositionCalculator {
   }
 
 /**
- * Returns an estimate of the maximum position reachable under the current
- * circumstances.
+ * Returns an estimate of the maximum position currently reachable (i.e.
+ * segments are available) under the current circumstances.
  * @returns {number}
  */
-  public getCurrentMaximumPosition() : number {
+  public getMaximumAvailablePosition() : number {
     if (this._manifest.isDynamic) {
       return this._manifest.getLivePosition() ??
              this._manifest.getMaximumSafePosition();
@@ -220,7 +217,7 @@ class MaximumPositionCalculator {
         return this._manifest.getMaximumSafePosition();
       } else {
         const lastVideoPosition =
-          getLastPositionFromAdaptation(this._lastVideoAdaptation);
+          getLastAvailablePositionFromAdaptation(this._lastVideoAdaptation);
         if (typeof lastVideoPosition !== "number") {
           return this._manifest.getMaximumSafePosition();
         }
@@ -228,16 +225,16 @@ class MaximumPositionCalculator {
       }
     } else if (this._lastVideoAdaptation === null) {
       const lastAudioPosition =
-        getLastPositionFromAdaptation(this._lastAudioAdaptation);
+        getLastAvailablePositionFromAdaptation(this._lastAudioAdaptation);
       if (typeof lastAudioPosition !== "number") {
         return this._manifest.getMaximumSafePosition();
       }
       return lastAudioPosition;
     } else {
-      const lastAudioPosition = getLastPositionFromAdaptation(
+      const lastAudioPosition = getLastAvailablePositionFromAdaptation(
         this._lastAudioAdaptation
       );
-      const lastVideoPosition = getLastPositionFromAdaptation(
+      const lastVideoPosition = getLastAvailablePositionFromAdaptation(
         this._lastVideoAdaptation
       );
       if (typeof lastAudioPosition !== "number" ||
@@ -249,20 +246,59 @@ class MaximumPositionCalculator {
       }
     }
   }
+
+/**
+ * Returns an estimate of the actual ending position once
+ * the full content is available.
+ * Returns `undefined` if that could not be determined, for various reasons.
+ * @returns {number|undefined}
+ */
+  public getEndingPosition() : number | undefined {
+    if (!this._manifest.isDynamic) {
+      return this.getMaximumAvailablePosition();
+    }
+    if (this._lastVideoAdaptation === undefined ||
+        this._lastAudioAdaptation === undefined)
+    {
+      return undefined;
+    } else if (this._lastAudioAdaptation === null) {
+      if (this._lastVideoAdaptation === null) {
+        return undefined;
+      } else {
+        return getEndingPositionFromAdaptation(this._lastVideoAdaptation) ??
+               undefined;
+      }
+    } else if (this._lastVideoAdaptation === null) {
+      return getEndingPositionFromAdaptation(this._lastAudioAdaptation) ??
+             undefined;
+    } else {
+      const lastAudioPosition =
+        getEndingPositionFromAdaptation(this._lastAudioAdaptation);
+      const lastVideoPosition =
+        getEndingPositionFromAdaptation(this._lastVideoAdaptation);
+      if (typeof lastAudioPosition !== "number" ||
+          typeof lastVideoPosition !== "number")
+      {
+        return undefined;
+      } else {
+        return Math.min(lastAudioPosition, lastVideoPosition);
+      }
+    }
+  }
 }
 
 /**
- * Returns "last time of reference" from the adaptation given.
+ * Returns last currently available position from the Adaptation given.
  * `undefined` if a time could not be found.
- * Null if the Adaptation has no segments (it could be that it didn't started or
+ * `null` if the Adaptation has no segments (it could be that it didn't started or
  * that it already finished for example).
  *
- * We consider the earliest last time from every representations in the given
- * adaptation.
+ * We consider the earliest last available position from every Representation
+ * in the given Adaptation.
  * @param {Object} adaptation
  * @returns {Number|undefined|null}
  */
-function getLastPositionFromAdaptation(
+function getLastAvailablePositionFromAdaptation(
   adaptation: Adaptation
 ) : number | undefined | null {
   const { representations } = adaptation;
@@ -278,18 +314,56 @@ function getLastPositionFromAdaptation(
   for (let i = 0; i < representations.length; i++) {
     if (representations[i].index !== lastIndex) {
       lastIndex = representations[i].index;
-      const lastPosition = representations[i].index.getLastPosition();
+      const lastPosition = representations[i].index.getLastAvailablePosition();
       if (lastPosition === undefined) { // we cannot tell
         return undefined;
       }
       if (lastPosition !== null) {
-        min = min == null ? lastPosition :
-                            Math.min(min, lastPosition);
+        min = isNullOrUndefined(min) ? lastPosition :
+                                       Math.min(min, lastPosition);
       }
     }
   }
-  if (min === null) { // It means that all positions were null === no segments (yet?)
-    return null;
+  return min;
+}
+
+/**
+ * Returns ending time from the Adaptation given, once all its segments are
+ * available.
+ * `undefined` if a time could not be found.
+ * `null` if the Adaptation has no segments (it could be that it already
+ * finished for example).
+ *
+ * We consider the earliest ending time from every Representation in the given
+ * Adaptation.
+ * @param {Object} adaptation
+ * @returns {Number|undefined|null}
+ */
+function getEndingPositionFromAdaptation(
+  adaptation: Adaptation
+) : number | undefined | null {
+  const { representations } = adaptation;
+  let min : null | number = null;
+
+  /**
+   * Some Manifest parsers use the exact same `IRepresentationIndex` reference
+   * for each Representation of a given Adaptation, because in the actual source
+   * Manifest file, indexing data is often defined at Adaptation-level.
+   * This variable allows to optimize the logic here when this is the case.
+   */
+  let lastIndex : IRepresentationIndex | undefined;
+  for (let i = 0; i < representations.length; i++) {
+    if (representations[i].index !== lastIndex) {
+      lastIndex = representations[i].index;
+      const lastPosition = representations[i].index.getEnd();
+      if (lastPosition === undefined) { // we cannot tell
+        return undefined;
+      }
+      if (lastPosition !== null) {
+        min = isNullOrUndefined(min) ? lastPosition :
+                                       Math.min(min, lastPosition);
+      }
+    }
   }
   return min;
 }

package/src/core/stream/representation/check_for_discontinuity.ts

@@ -102,10 +102,17 @@ export default function checkForDiscontinuity(
     (nextSegmentStart === null ||
      nextBufferedSegment.infos.segment.end <= nextSegmentStart)
   ) {
+    const discontinuityEnd = nextBufferedSegment.bufferedStart;
+    if (!hasFinishedLoading &&
+        representation.index.awaitSegmentBetween(checkedRange.start,
+                                                 discontinuityEnd) !== false)
+    {
+      return null;
+    }
     log.debug("RS: current discontinuity encountered",
               adaptation.type, nextBufferedSegment.bufferedStart);
     return { start: undefined,
-             end: nextBufferedSegment.bufferedStart };
+             end: discontinuityEnd };
   }
 
   // Check if there's a discontinuity BETWEEN segments of the current range
@@ -116,16 +123,27 @@ export default function checkForDiscontinuity(
 
   // If there was a hole between two consecutives segments, and if this hole
   // comes before the next segment to load, there is a discontinuity (that hole!)
-  if (nextHoleIdx !== null &&
-      (nextSegmentStart === null ||
-       bufferedSegments[nextHoleIdx].infos.segment.end <= nextSegmentStart))
-  {
-    const start = bufferedSegments[nextHoleIdx - 1].bufferedEnd as number;
-    const end = bufferedSegments[nextHoleIdx].bufferedStart as number;
-    log.debug("RS: future discontinuity encountered", adaptation.type, start, end);
-    return { start, end };
+  if (nextHoleIdx !== null) {
+    const segmentInfoBeforeHole = bufferedSegments[nextHoleIdx - 1];
+    const segmentInfoAfterHole = bufferedSegments[nextHoleIdx];
+
+    if (nextSegmentStart === null ||
+        segmentInfoAfterHole.infos.segment.end <= nextSegmentStart)
+    {
+      if (!hasFinishedLoading && representation.index
+        .awaitSegmentBetween(segmentInfoBeforeHole.infos.segment.end,
+                             segmentInfoAfterHole.infos.segment.time) !== false)
+      {
+        return null;
+      }
+      const start = segmentInfoBeforeHole.bufferedEnd as number;
+      const end = segmentInfoAfterHole.bufferedStart as number;
+      log.debug("RS: future discontinuity encountered", adaptation.type, start, end);
+      return { start, end };
+    }
+  }
 
-  } else if (nextSegmentStart === null) {
+  if (nextSegmentStart === null) {
     // If no hole between segments and no segment to load, check for a
     // discontinuity at the end of the Period