rx-player 4.0.0-dev.2023111400 → 4.0.0-dev.2023121900

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

@@ -36,12 +36,8 @@ export interface IStreamPlaybackObserverArguments {
   manifest : Manifest;
   /** Becomes `true` after the initial play has been taken care of. */
   initialPlayPerformed : IReadOnlySharedReference<boolean>;
-  /** Becomes `true` after the initial seek has been taken care of. */
-  initialSeekPerformed : IReadOnlySharedReference<boolean>;
   /** The last speed requested by the user. */
   speed : IReadOnlySharedReference<number>;
-  /** The time the player will seek when `initialSeekPerformed` becomes `true`. */
-  startTime : number;
 }
 
 /**
@@ -57,10 +53,8 @@ export default function createStreamPlaybackObserver(
   srcPlaybackObserver : PlaybackObserver,
   { autoPlay,
     initialPlayPerformed,
-    initialSeekPerformed,
     manifest,
-    speed,
-    startTime } : IStreamPlaybackObserverArguments,
+    speed } : IStreamPlaybackObserverArguments,
   fnCancelSignal : CancellationSignal
 ) : IReadOnlyPlaybackObserver<IStreamOrchestratorPlaybackObservation> {
   return srcPlaybackObserver.deriveReadOnlyObserver(function transform(
@@ -87,10 +81,8 @@ export default function createStreamPlaybackObserver(
     function constructStreamPlaybackObservation() {
       const observation = observationRef.getValue();
       const lastSpeed = speed.getValue();
-      let pendingPosition : number | undefined;
-      if (!initialSeekPerformed.getValue()) {
-        pendingPosition = startTime;
-      } else if (!manifest.isDynamic || manifest.isLastPeriodKnown) {
+
+      if (!manifest.isDynamic || manifest.isLastPeriodKnown) {
         // HACK: When the position is actually further than the maximum
         // position for a finished content, we actually want to be loading
         // the last segment before ending.
@@ -98,21 +90,28 @@ export default function createStreamPlaybackObserver(
         // want to seek one second before the period's end (despite never
         // doing it).
         const lastPeriod = manifest.periods[manifest.periods.length - 1];
-        if (lastPeriod !== undefined &&
-            lastPeriod.end !== undefined &&
-            observation.position > lastPeriod.end)
-        {
-          pendingPosition = lastPeriod.end - 1;
+        if (lastPeriod !== undefined && lastPeriod.end !== undefined) {
+          const wantedPosition = observation.position.getWanted();
+          if (wantedPosition >= lastPeriod.start &&
+              wantedPosition >= lastPeriod.end - 1)
+          {
+            // We're after the end of the last Period, check if `buffered`
+            // indicates that the last segment is probably not loaded, in which
+            // case act as if we want to load one second before the end.
+            const buffered = observation.buffered;
+            if (buffered.length === 0 ||
+                buffered.end(buffered.length - 1) < observation.duration - 1)
+            {
+              observation.position.forceWantedPosition(lastPeriod.end - 1);
+            }
+          }
         }
       }
 
       return {
         // TODO more exact according to the current Adaptation chosen?
         maximumPosition: manifest.getMaximumSafePosition(),
-        position: {
-          last: observation.position,
-          pending: pendingPosition,
-        },
+        position: observation.position,
         duration: observation.duration,
         paused: {
           last: observation.paused,

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

@@ -43,11 +43,25 @@ export interface IInitialTimeOptions {
    */
   fromFirstPosition? : number | null | undefined;
   /**
-   * If set, we should begin at this position relative to the content's end,
-   * in seconds.
+   * If set, we should begin at this position relative to the content's maximum
+   * seekable position, in seconds.
+   *
+   * It should consequently in most cases be a negative value.
    */
   fromLastPosition? : number | null | undefined;
-  /** If set, we should begin at this position relative to the whole duration of
+  /**
+   * If set, we should begin at this position relative to the content's live
+   * edge if it makes sense, in seconds.
+   *
+   * It should consequently in most cases be a negative value.
+   *
+   * If the live edge is unknown or if it does not make sense for the current
+   * content, that position is relative to the content's maximum position
+   * instead.
+   */
+  fromLivePosition? : number | null | undefined;
+  /**
+   * If set, we should begin at this position relative to the whole duration of
    * the content, in percentage.
    */
   percentage? : number | null | undefined;
@@ -73,13 +87,7 @@ export default function getInitialTime(
 ) : number {
   if (!isNullOrUndefined(startAt)) {
     const min = manifest.getMinimumSafePosition();
-    let max;
-    if (manifest.isLive) {
-      max = manifest.getLivePosition();
-    }
-    if (max === undefined) {
-      max = manifest.getMaximumSafePosition();
-    }
+    const max = manifest.getMaximumSafePosition();
     if (!isNullOrUndefined(startAt.position)) {
       log.debug("Init: using startAt.minimumPosition");
       return Math.max(Math.min(startAt.position, max), min);
@@ -97,12 +105,17 @@ export default function getInitialTime(
       const { fromFirstPosition } = startAt;
       return fromFirstPosition <= 0 ? min :
                                       Math.min(max, min + fromFirstPosition);
-    }
-    else if (!isNullOrUndefined(startAt.fromLastPosition)) {
+    } else if (!isNullOrUndefined(startAt.fromLastPosition)) {
       log.debug("Init: using startAt.fromLastPosition");
       const { fromLastPosition } = startAt;
       return fromLastPosition >= 0 ? max :
                                      Math.max(min, max + fromLastPosition);
+    } else if (!isNullOrUndefined(startAt.fromLivePosition)) {
+      log.debug("Init: using startAt.fromLivePosition");
+      const livePosition = manifest.getLivePosition() ?? max;
+      const { fromLivePosition } = startAt;
+      return fromLivePosition >= 0 ? livePosition :
+                                     Math.max(min, livePosition + fromLivePosition);
     } else if (!isNullOrUndefined(startAt.percentage)) {
       log.debug("Init: using startAt.percentage");
       const { percentage } = startAt;

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

@@ -15,7 +15,6 @@
  */
 
 import { shouldValidateMetadata } from "../../../compat";
-import { READY_STATES } from "../../../compat/browser_compatibility_types";
 import { MediaError } from "../../../errors";
 import log from "../../../log";
 import { IPlayerError } from "../../../public_types";
@@ -24,6 +23,7 @@ import SharedReference, {
 } from "../../../utils/reference";
 import { CancellationError, CancellationSignal } from "../../../utils/task_canceller";
 import { PlaybackObserver } from "../../api";
+import { SeekingState } from "../../api/playback_observer";
 
 /** Event emitted when trying to perform the initial `play`. */
 export type IInitialPlayEvent =
@@ -42,12 +42,6 @@ export interface IInitialSeekAndPlayObject {
   /** Emit the result of the auto-play operation, once performed. */
   autoPlayResult : Promise<IInitialPlayEvent>;
 
-  /**
-   * Shared reference whose value becomes `true` once the initial seek has
-   * been considered / has been done by `performInitialSeekAndPlay`.
-   */
-  initialSeekPerformed : IReadOnlySharedReference<boolean>;
-
   /**
    * Shared reference whose value becomes `true` once the initial play has
    * been considered / has been done by `performInitialSeekAndPlay`.
@@ -58,126 +52,164 @@ export interface IInitialSeekAndPlayObject {
 /**
  * Seek as soon as possible at the initially wanted position and play if
  * autoPlay is wanted.
- * @param {HTMLMediaElement} mediaElement
- * @param {Object} playbackObserver
- * @param {number|Function} startTime
- * @param {boolean} mustAutoPlay
- * @param {Function} onWarning
+ * @param {Object} args
  * @param {Object} cancelSignal
  * @returns {Object}
  */
 export default function performInitialSeekAndPlay(
-  mediaElement : HTMLMediaElement,
-  playbackObserver : PlaybackObserver,
-  startTime : number|(() => number),
-  mustAutoPlay : boolean,
-  onWarning : (err : IPlayerError) => void,
+  { mediaElement,
+    playbackObserver,
+    startTime,
+    mustAutoPlay,
+    isDirectfile,
+    onWarning }: { mediaElement : HTMLMediaElement;
+                   playbackObserver : PlaybackObserver;
+                   startTime : number|(() => number);
+                   mustAutoPlay : boolean;
+                   isDirectfile: boolean;
+                   onWarning : (err : IPlayerError) => void; },
   cancelSignal : CancellationSignal
 ) : IInitialSeekAndPlayObject {
-  let resolveAutoPlay : (x : IInitialPlayEvent) => void;
-  let rejectAutoPlay : (x : unknown) => void;
-  const autoPlayResult = new Promise<IInitialPlayEvent>((res, rej) => {
-    resolveAutoPlay = res;
-    rejectAutoPlay = rej;
-  });
-
-  const initialSeekPerformed = new SharedReference(false, cancelSignal);
   const initialPlayPerformed = new SharedReference(false, cancelSignal);
-
-  mediaElement.addEventListener("loadedmetadata", onLoadedMetadata);
-
-  const deregisterCancellation = cancelSignal.register((err : CancellationError) => {
-    mediaElement.removeEventListener("loadedmetadata", onLoadedMetadata);
-    rejectAutoPlay(err);
-  });
-
-  if (mediaElement.readyState >= READY_STATES.HAVE_METADATA) {
-    onLoadedMetadata();
-  }
-
-  return { autoPlayResult, initialPlayPerformed, initialSeekPerformed };
-
-  function onLoadedMetadata() {
-    mediaElement.removeEventListener("loadedmetadata", onLoadedMetadata);
-    const initialTime = typeof startTime === "function" ? startTime() :
-                                                          startTime;
-    log.info("Init: Set initial time", initialTime);
-    playbackObserver.setCurrentTime(initialTime);
-    initialSeekPerformed.setValue(true);
-    initialSeekPerformed.finish();
-
-    if (shouldValidateMetadata() && mediaElement.duration === 0) {
-      const error = new MediaError("MEDIA_ERR_NOT_LOADED_METADATA",
-                                   "Cannot load automatically: your browser " +
-                                   "falsely announced having loaded the content.");
-      onWarning(error);
-    }
-    if (cancelSignal.isCancelled()) {
-      return ;
+  const autoPlayResult = new Promise<IInitialPlayEvent>((
+    resolveAutoPlay,
+    rejectAutoPlay
+  ) => {
+    // `startTime` defined as a function might depend on metadata to make its
+    // choice, such as the content duration, minimum and/or maximum position.
+    //
+    // The RxPlayer might already know those through the Manifest file for
+    // non-Directfile contents, yet only through the `HTMLMediaElement` once a
+    // a sufficient `readyState` has been reached for directfile contents.
+    // So let's divide the two possibilities here.
+    if (!isDirectfile || typeof startTime === "number") {
+      playbackObserver.setCurrentTime(
+        typeof startTime === "number" ? startTime : startTime()
+      );
+      waitForSeekable();
+    } else {
+      playbackObserver.listen((obs, stopListening) => {
+        if (obs.readyState >= 1) {
+          stopListening();
+          playbackObserver.setCurrentTime(
+            typeof startTime === "number" ? startTime : startTime()
+          );
+          waitForSeekable();
+        }
+      }, { includeLastObservation: true, clearSignal: cancelSignal });
     }
 
-    playbackObserver.listen((observation, stopListening) => {
-      if (!observation.seeking &&
-          observation.rebuffering === null &&
-          observation.readyState >= 1)
-      {
+    const deregisterCancellation = cancelSignal.register((err : CancellationError) => {
+      rejectAutoPlay(err);
+    });
+
+    /**
+     * Logic that should be run once the initial seek has been asked to the
+     * PlaybackObserver.
+     *
+     * Actually wait until the seek has been performed, wait for the right moment
+     * to perform autoplay, resolve the promise once everything has been done and
+     * potentially send warning if a minor issue is detected.
+     */
+    function waitForSeekable() {
+      playbackObserver.listen((obs, stopListening) => {
+        if (obs.seeking === SeekingState.None || obs.readyState === 0) {
+          return;
+        }
         stopListening();
-        onPlayable();
-      }
-    }, { includeLastObservation: true, clearSignal: cancelSignal });
-  }
-
-  function onPlayable() {
-    log.info("Init: Can begin to play content");
-    if (!mustAutoPlay) {
-      if (mediaElement.autoplay) {
-        log.warn("Init: autoplay is enabled on HTML media element. " +
-                 "Media will play as soon as possible.");
-      }
-      initialPlayPerformed.setValue(true);
-      initialPlayPerformed.finish();
-      deregisterCancellation();
-      return resolveAutoPlay({ type: "skipped" as const });
+        if (shouldValidateMetadata() && mediaElement.duration === 0) {
+          const error = new MediaError("MEDIA_ERR_NOT_LOADED_METADATA",
+                                       "Cannot load automatically: your browser " +
+                                       "falsely announced having loaded the content.");
+          onWarning(error);
+        }
+        if (cancelSignal.isCancelled()) {
+          return ;
+        }
+        waitForPlayable();
+      }, { includeLastObservation: true, clearSignal: cancelSignal });
     }
 
-    let playResult : Promise<unknown>;
-    try {
-      playResult = mediaElement.play() ?? Promise.resolve();
-    } catch (playError) {
-      deregisterCancellation();
-      return rejectAutoPlay(playError);
+    /**
+     * Logic that should be run once the initial seek has been properly performed.
+     *
+     * Wait for the media being playable before performing the autoplay operation
+     * if asked. Potentially send warning if a minor issue has been detected while
+     * doing so.
+     */
+    function waitForPlayable() {
+      playbackObserver.listen((observation, stopListening) => {
+        if (observation.seeking === SeekingState.None &&
+            observation.rebuffering === null &&
+            observation.readyState >= 1)
+        {
+          stopListening();
+          onPlayable();
+        }
+      }, { includeLastObservation: true, clearSignal: cancelSignal });
     }
-    playResult
-      .then(() => {
-        if (cancelSignal.isCancelled()) {
-          return;
+
+    /**
+     * Callback called once the content is considered "playable".
+     *
+     * Perform the autoplay if needed, handling potential issues and resolve the
+     * Promise when done.
+     * Might also send warnings if minor issues arise.
+     */
+    function onPlayable() {
+      log.info("Init: Can begin to play content");
+      if (!mustAutoPlay) {
+        if (mediaElement.autoplay) {
+          log.warn("Init: autoplay is enabled on HTML media element. " +
+                   "Media will play as soon as possible.");
         }
         initialPlayPerformed.setValue(true);
         initialPlayPerformed.finish();
         deregisterCancellation();
-        return resolveAutoPlay({ type: "autoplay" as const });
-      })
-      .catch((playError : unknown) => {
-        deregisterCancellation();
-        if (cancelSignal.isCancelled()) {
-          return;
-        }
-        if (playError instanceof Error && playError.name === "NotAllowedError") {
-          // auto-play was probably prevented.
-          log.warn("Init: Media element can't play." +
-                   " It may be due to browser auto-play policies.");
+        return resolveAutoPlay({ type: "skipped" as const });
+      }
 
-          const error = new MediaError("MEDIA_ERR_BLOCKED_AUTOPLAY",
-                                       "Cannot trigger auto-play automatically: " +
-                                       "your browser does not allow it.");
-          onWarning(error);
+      let playResult : Promise<unknown>;
+      try {
+        playResult = mediaElement.play() ?? Promise.resolve();
+      } catch (playError) {
+        deregisterCancellation();
+        return rejectAutoPlay(playError);
+      }
+      playResult
+        .then(() => {
           if (cancelSignal.isCancelled()) {
             return;
           }
-          return resolveAutoPlay({ type: "autoplay-blocked" as const });
-        } else {
-          rejectAutoPlay(playError);
-        }
-      });
-  }
+          initialPlayPerformed.setValue(true);
+          initialPlayPerformed.finish();
+          deregisterCancellation();
+          return resolveAutoPlay({ type: "autoplay" as const });
+        })
+        .catch((playError : unknown) => {
+          deregisterCancellation();
+          if (cancelSignal.isCancelled()) {
+            return;
+          }
+          if (playError instanceof Error && playError.name === "NotAllowedError") {
+            // auto-play was probably prevented.
+            log.warn("Init: Media element can't play." +
+                     " It may be due to browser auto-play policies.");
+
+            const error = new MediaError("MEDIA_ERR_BLOCKED_AUTOPLAY",
+                                         "Cannot trigger auto-play automatically: " +
+                                         "your browser does not allow it.");
+            onWarning(error);
+            if (cancelSignal.isCancelled()) {
+              return;
+            }
+            return resolveAutoPlay({ type: "autoplay-blocked" as const });
+          } else {
+            rejectAutoPlay(playError);
+          }
+        });
+    }
+  });
+
+  return { autoPlayResult, initialPlayPerformed };
 }

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

@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-import isSeekingApproximate from "../../../compat/is_seeking_approximate";
 import config from "../../../config";
 import { MediaError } from "../../../errors";
 import log from "../../../log";
@@ -31,6 +30,7 @@ import {
   IPlaybackObservation,
   PlaybackObserver,
 } from "../../api";
+import { SeekingState } from "../../api/playback_observer";
 import SegmentBuffersStore, { IBufferType } from "../../segment_buffers";
 import { IStallingSituation } from "../types";
 
@@ -107,33 +107,6 @@ export default class RebufferingController
     }
     this._isStarted = true;
 
-    /**
-     * On some devices (right now only seen on Tizen), seeking through the
-     * `currentTime` property can lead to the browser re-seeking once the
-     * segments have been loaded to improve seeking performances (for
-     * example, by seeking right to an intra video frame).
-     * In that case, we risk being in a conflict with that behavior: if for
-     * example we encounter a small discontinuity at the position the browser
-     * seeks to, we will seek over it, the browser would seek back and so on.
-     *
-     * This variable allows to store the last known position we were seeking to
-     * so we can detect when the browser seeked back (to avoid performing another
-     * seek after that). When browsers seek back to a position behind a
-     * discontinuity, they are usually able to skip them without our help.
-     */
-    let lastSeekingPosition : number | null;
-
-    /**
-     * In some conditions (see `lastSeekingPosition`), we might want to not
-     * automatically seek over discontinuities because the browser might do it
-     * itself instead.
-     * In that case, we still want to perform the seek ourselves if the browser
-     * doesn't do it after sufficient time.
-     * This variable allows to store the timestamp at which a discontinuity began
-     * to be ignored.
-     */
-    let ignoredStallTimeStamp : number | null = null;
-
     const playbackRateUpdater = new PlaybackRateUpdater(this._playbackObserver,
                                                         this._speed);
     this._canceller.signal.register(() => {
@@ -151,26 +124,10 @@ export default class RebufferingController
               freezing } = observation;
 
       const { BUFFER_DISCONTINUITY_THRESHOLD,
-              FORCE_DISCONTINUITY_SEEK_DELAY,
               FREEZING_STALLED_DELAY,
               UNFREEZING_SEEK_DELAY,
               UNFREEZING_DELTA_POSITION } = config.getCurrent();
 
-      if (
-        !observation.seeking &&
-        isSeekingApproximate &&
-        ignoredStallTimeStamp === null &&
-        lastSeekingPosition !== null && observation.position < lastSeekingPosition)
-      {
-        log.debug("Init: the device appeared to have seeked back by itself.");
-        const now = getMonotonicTimeStamp();
-        ignoredStallTimeStamp = now;
-      }
-
-      lastSeekingPosition = observation.seeking ?
-        Math.max(observation.pendingInternalSeek ?? 0, observation.position) :
-        null;
-
       if (this._checkDecipherabilityFreeze(observation)) {
         return ;
       }
@@ -182,7 +139,10 @@ export default class RebufferingController
           freezing.timestamp :
           prevFreezingState.attemptTimestamp;
 
-        if (now - referenceTimestamp > UNFREEZING_SEEK_DELAY) {
+        if (
+          !position.isAwaitingFuturePosition() &&
+          now - referenceTimestamp > UNFREEZING_SEEK_DELAY
+        ) {
           log.warn("Init: trying to seek to un-freeze player");
           this._playbackObserver.setCurrentTime(
             this._playbackObserver.getCurrentTime() + UNFREEZING_DELTA_POSITION);
@@ -190,7 +150,7 @@ export default class RebufferingController
         }
 
         if (now - freezing.timestamp > FREEZING_STALLED_DELAY) {
-          if (rebuffering === null || ignoredStallTimeStamp !== null) {
+          if (rebuffering === null) {
             playbackRateUpdater.stopRebuffering();
           } else {
             playbackRateUpdater.startRebuffering();
@@ -208,9 +168,10 @@ export default class RebufferingController
           // With a readyState set to 1, we should still not be able to play:
           // Return that we're stalled
           let reason : IStallingSituation;
-          if (observation.seeking) {
-            reason = observation.pendingInternalSeek !== null ? "internal-seek" :
-                                                                "seeking";
+          if (observation.seeking !== SeekingState.None) {
+            reason = observation.seeking === SeekingState.Internal ?
+              "internal-seek" :
+              "seeking";
           } else {
             reason = "not-ready";
           }
@@ -224,24 +185,17 @@ export default class RebufferingController
       // We want to separate a stall situation when a seek is due to a seek done
       // internally by the player to when its due to a regular user seek.
       const stalledReason = rebuffering.reason === "seeking" &&
-                            observation.pendingInternalSeek !== null ?
+                            observation.seeking === SeekingState.Internal ?
         "internal-seek" as const :
         rebuffering.reason;
 
-      if (ignoredStallTimeStamp !== null) {
-        const now = getMonotonicTimeStamp();
-        if (now - ignoredStallTimeStamp < FORCE_DISCONTINUITY_SEEK_DELAY) {
-          playbackRateUpdater.stopRebuffering();
-          log.debug("Init: letting the device get out of a stall by itself");
-          this.trigger("stalled", stalledReason);
-          return ;
-        } else {
-          log.warn("Init: ignored stall for too long, considering it",
-                   now - ignoredStallTimeStamp);
-        }
+      if (position.isAwaitingFuturePosition()) {
+        playbackRateUpdater.stopRebuffering();
+        log.debug("Init: let rebuffering happen as we're awaiting a future position");
+        this.trigger("stalled", stalledReason);
+        return ;
       }
 
-      ignoredStallTimeStamp = null;
       playbackRateUpdater.startRebuffering();
 
       if (this._manifest === null) {
@@ -266,7 +220,7 @@ export default class RebufferingController
                      this._playbackObserver.getCurrentTime(), realSeekTime);
           } else {
             log.warn("SA: skippable discontinuity found in the stream",
-                     position, realSeekTime);
+                     position.getPolled(), realSeekTime);
             this._playbackObserver.setCurrentTime(realSeekTime);
             this.trigger("warning", generateDiscontinuityError(stalledPosition,
                                                                realSeekTime));
@@ -275,7 +229,7 @@ export default class RebufferingController
         }
       }
 
-      const freezePosition = stalledPosition ?? position;
+      const positionBlockedAt = stalledPosition ?? position.getPolled();
 
       // Is it a very short discontinuity in buffer ? -> Seek at the beginning of the
       //                                                 next range
@@ -284,17 +238,17 @@ export default class RebufferingController
       // calculate a stalled state. This is useful for some
       // implementation that might drop an injected segment, or in
       // case of small discontinuity in the content.
-      const nextBufferRangeGap = getNextBufferedTimeRangeGap(buffered, freezePosition);
+      const nextBufferRangeGap = getNextBufferedTimeRangeGap(buffered, positionBlockedAt);
       if (
         this._speed.getValue() > 0 &&
         nextBufferRangeGap < BUFFER_DISCONTINUITY_THRESHOLD
       ) {
-        const seekTo = (freezePosition + nextBufferRangeGap + EPSILON);
+        const seekTo = (positionBlockedAt + nextBufferRangeGap + EPSILON);
         if (this._playbackObserver.getCurrentTime() < seekTo) {
           log.warn("Init: discontinuity encountered inferior to the threshold",
-                   freezePosition, seekTo, BUFFER_DISCONTINUITY_THRESHOLD);
+                   positionBlockedAt, seekTo, BUFFER_DISCONTINUITY_THRESHOLD);
           this._playbackObserver.setCurrentTime(seekTo);
-          this.trigger("warning", generateDiscontinuityError(freezePosition, seekTo));
+          this.trigger("warning", generateDiscontinuityError(positionBlockedAt, seekTo));
           return;
         }
       }
@@ -303,14 +257,14 @@ export default class RebufferingController
       //                                                next period
       for (let i = this._manifest.periods.length - 2; i >= 0; i--) {
         const period = this._manifest.periods[i];
-        if (period.end !== undefined && period.end <= freezePosition) {
-          if (this._manifest.periods[i + 1].start > freezePosition &&
+        if (period.end !== undefined && period.end <= positionBlockedAt) {
+          if (this._manifest.periods[i + 1].start > positionBlockedAt &&
               this._manifest.periods[i + 1].start >
                 this._playbackObserver.getCurrentTime())
           {
             const nextPeriod = this._manifest.periods[i + 1];
             this._playbackObserver.setCurrentTime(nextPeriod.start);
-            this.trigger("warning", generateDiscontinuityError(freezePosition,
+            this.trigger("warning", generateDiscontinuityError(positionBlockedAt,
                                                                nextPeriod.start));
             return;
 
@@ -360,10 +314,10 @@ export default class RebufferingController
     ) {
       return;
     }
-    const currPos = observation.position;
-    const rebufferingPos = observation.rebuffering.position ?? currPos;
+    const loadedPos = observation.position.getWanted();
+    const rebufferingPos = observation.rebuffering.position ?? loadedPos;
     const lockedPeriodStart = period.start;
-    if (currPos < lockedPeriodStart &&
+    if (loadedPos < lockedPeriodStart &&
         Math.abs(rebufferingPos - lockedPeriodStart) < 1)
     {
       log.warn("Init: rebuffering because of a future locked stream.\n" +
@@ -403,8 +357,6 @@ export default class RebufferingController
   private _checkDecipherabilityFreeze(
     observation : IPlaybackObservation
   ): boolean {
-    // XXX TODO allow this in in-worker configuration
-
     const { readyState,
             rebuffering,
             freezing } = observation;
@@ -555,10 +507,13 @@ function updateDiscontinuitiesStore(
   evt : IDiscontinuityEvent,
   observation : IPlaybackObservation
 ) : void {
+  const gcTime = Math.min(observation.position.getPolled(),
+                          observation.position.getWanted());
+
   // First, perform clean-up of old discontinuities
   while (discontinuitiesStore.length > 0 &&
          discontinuitiesStore[0].period.end !== undefined &&
-         discontinuitiesStore[0].period.end + 10 < observation.position)
+         discontinuitiesStore[0].period.end + 10 < gcTime)
   {
     discontinuitiesStore.shift();
   }