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

package/dist/es2017/core/api/playback_observer.js

@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import isSeekingApproximate from "../../compat/is_seeking_approximate";
 import config from "../../config";
 import log from "../../log";
 import getMonotonicTimeStamp from "../../utils/monotonic_timestamp";
@@ -65,6 +66,19 @@ export default class PlaybackObserver {
         this._lowLatencyMode = options.lowLatencyMode;
         this._canceller = new TaskCanceller();
         this._observationRef = this._createSharedReference();
+        this._expectedSeekingPosition = null;
+        this._pendingSeek = null;
+        const onLoadedMetadata = () => {
+            if (this._pendingSeek !== null) {
+                const positionToSeekTo = this._pendingSeek;
+                this._pendingSeek = null;
+                this._actuallySetCurrentTime(positionToSeekTo);
+            }
+        };
+        mediaElement.addEventListener("loadedmetadata", onLoadedMetadata);
+        this._canceller.signal.register(() => {
+            mediaElement.removeEventListener("loadedmetadata", onLoadedMetadata);
+        });
     }
     /**
      * Stop the `PlaybackObserver` from emitting playback observations and free all
@@ -114,9 +128,14 @@ export default class PlaybackObserver {
      * @param {number} time
      */
     setCurrentTime(time) {
-        this._internalSeeksIncoming.push(time);
-        log.info("API: Seeking internally", time);
-        this._mediaElement.currentTime = time;
+        if (this._mediaElement.readyState >= 1) {
+            this._actuallySetCurrentTime(time);
+        }
+        else {
+            this._internalSeeksIncoming = [];
+            this._pendingSeek = time;
+            this._generateObservationForEvent("manual");
+        }
     }
     /**
      * Update the playback rate of the `HTMLMediaElement`.
@@ -181,6 +200,11 @@ export default class PlaybackObserver {
     deriveReadOnlyObserver(transform) {
         return generateReadOnlyObserver(this, transform, this._canceller.signal);
     }
+    _actuallySetCurrentTime(time) {
+        log.info("API: Seeking internally", time);
+        this._internalSeeksIncoming.push(time);
+        this._mediaElement.currentTime = time;
+    }
     /**
      * Creates the `IReadOnlySharedReference` that will generate playback
      * observations.
@@ -190,57 +214,21 @@ export default class PlaybackObserver {
         if (this._observationRef !== undefined) {
             return this._observationRef;
         }
-        let lastObservation;
         const { SAMPLING_INTERVAL_MEDIASOURCE, SAMPLING_INTERVAL_LOW_LATENCY, SAMPLING_INTERVAL_NO_MEDIASOURCE } = config.getCurrent();
-        const getCurrentObservation = (event) => {
-            let tmpEvt = event;
-            let startedInternalSeekTime;
-            if (tmpEvt === "seeking" && this._internalSeeksIncoming.length > 0) {
-                tmpEvt = "internal-seeking";
-                startedInternalSeekTime = this._internalSeeksIncoming.shift();
-            }
-            const _lastObservation = lastObservation !== null && lastObservation !== void 0 ? lastObservation : this._generateInitialObservation();
-            const mediaTimings = getMediaInfos(this._mediaElement, tmpEvt, this._withMediaSource);
-            let pendingInternalSeek = null;
-            if (mediaTimings.seeking) {
-                if (typeof startedInternalSeekTime === "number") {
-                    pendingInternalSeek = startedInternalSeekTime;
-                }
-                else if (_lastObservation.pendingInternalSeek !== null && event !== "seeking") {
-                    pendingInternalSeek = _lastObservation.pendingInternalSeek;
-                }
-            }
-            const rebufferingStatus = getRebufferingStatus(_lastObservation, mediaTimings, { lowLatencyMode: this._lowLatencyMode,
-                withMediaSource: this._withMediaSource });
-            const freezingStatus = getFreezingStatus(_lastObservation, mediaTimings);
-            const timings = objectAssign({}, { rebuffering: rebufferingStatus,
-                freezing: freezingStatus,
-                pendingInternalSeek }, mediaTimings);
-            if (log.hasLevel("DEBUG")) {
-                log.debug("API: current media element state tick", "event", timings.event, "position", timings.position, "seeking", timings.seeking, "internalSeek", timings.pendingInternalSeek, "rebuffering", timings.rebuffering !== null, "freezing", timings.freezing !== null, "ended", timings.ended, "paused", timings.paused, "playbackRate", timings.playbackRate, "readyState", timings.readyState);
-            }
-            return timings;
-        };
-        const returnedSharedReference = new SharedReference(getCurrentObservation("init"), this._canceller.signal);
-        const generateObservationForEvent = (event) => {
-            const newObservation = getCurrentObservation(event);
-            if (log.hasLevel("DEBUG")) {
-                log.debug("API: current playback timeline:\n" +
-                    prettyPrintBuffered(newObservation.buffered, newObservation.position), `\n${event}`);
-            }
-            lastObservation = newObservation;
-            returnedSharedReference.setValue(newObservation);
-        };
+        const returnedSharedReference = new SharedReference(this._getCurrentObservation("init"), this._canceller.signal);
         const interval = this._lowLatencyMode ? SAMPLING_INTERVAL_LOW_LATENCY :
             this._withMediaSource ? SAMPLING_INTERVAL_MEDIASOURCE :
                 SAMPLING_INTERVAL_NO_MEDIASOURCE;
+        const onInterval = () => {
+            this._generateObservationForEvent("timeupdate");
+        };
         let intervalId = setInterval(onInterval, interval);
         const removeEventListeners = SCANNED_MEDIA_ELEMENTS_EVENTS.map((eventName) => {
-            this._mediaElement.addEventListener(eventName, onMediaEvent);
-            function onMediaEvent() {
+            const onMediaEvent = () => {
                 restartInterval();
-                generateObservationForEvent(eventName);
-            }
+                this._generateObservationForEvent(eventName);
+            };
+            this._mediaElement.addEventListener(eventName, onMediaEvent);
             return () => {
                 this._mediaElement.removeEventListener(eventName, onMediaEvent);
             };
@@ -251,18 +239,165 @@ export default class PlaybackObserver {
             returnedSharedReference.finish();
         });
         return returnedSharedReference;
-        function onInterval() {
-            generateObservationForEvent("timeupdate");
-        }
         function restartInterval() {
             clearInterval(intervalId);
             intervalId = setInterval(onInterval, interval);
         }
     }
-    _generateInitialObservation() {
-        return objectAssign(getMediaInfos(this._mediaElement, "init", this._withMediaSource), { rebuffering: null,
-            freezing: null,
-            pendingInternalSeek: null });
+    _getCurrentObservation(event) {
+        var _a;
+        /** Actual event emitted through an observation. */
+        let tmpEvt = event;
+        // NOTE: `this._observationRef` may be `undefined` because we might here be
+        // called in the constructor when that property is not yet set.
+        const previousObservation = this._observationRef === undefined ?
+            getInitialObservation(this._mediaElement, this._withMediaSource) :
+            this._observationRef.getValue();
+        /**
+         * If `true`, there is a seek operation ongoing but it was done from the
+         * `PlaybackObserver`'s `setCurrentTime` method, not from external code.
+         */
+        let isInternalSeeking = false;
+        /** If set, the position for which we plan to seek to as soon as possible. */
+        let pendingPosition = this._pendingSeek;
+        /** Initially-polled playback observation, before adjustments. */
+        const mediaTimings = getMediaInfos(this._mediaElement, this._withMediaSource);
+        if (tmpEvt === "seeking") {
+            // We just began seeking.
+            // Let's find out if the seek is internal or external and handle approximate
+            // seeking
+            if (this._internalSeeksIncoming.length > 0) {
+                isInternalSeeking = true;
+                tmpEvt = "internal-seeking";
+                const startedInternalSeekTime = this._internalSeeksIncoming.shift();
+                this._expectedSeekingPosition = isSeekingApproximate ?
+                    Math.max(mediaTimings.position, startedInternalSeekTime !== null && startedInternalSeekTime !== void 0 ? startedInternalSeekTime : 0) :
+                    mediaTimings.position;
+            }
+            else {
+                this._expectedSeekingPosition = mediaTimings.position;
+            }
+        }
+        else if (mediaTimings.seeking) {
+            // we're still seeking, this time without a "seeking" event so it's an
+            // already handled one, keep track of the last wanted position we wanted
+            // to seek to, to work-around devices re-seeking silently.
+            this._expectedSeekingPosition = Math.max(mediaTimings.position, (_a = this._expectedSeekingPosition) !== null && _a !== void 0 ? _a : 0);
+        }
+        else if (isSeekingApproximate &&
+            this._expectedSeekingPosition !== null &&
+            mediaTimings.position < this._expectedSeekingPosition) {
+            // We're on a target with aproximate seeking, we're not seeking anymore, but
+            // we're not yet at the expected seeking position.
+            // Signal to the rest of the application that the intented position is not
+            // the current position but the one contained in `this._expectedSeekingPosition`
+            pendingPosition = this._expectedSeekingPosition;
+        }
+        else {
+            this._expectedSeekingPosition = null;
+        }
+        if (mediaTimings.seeking &&
+            previousObservation.seeking === 1 /* SeekingState.Internal */ &&
+            event !== "seeking") {
+            isInternalSeeking = true;
+        }
+        const rebufferingStatus = getRebufferingStatus(previousObservation, mediaTimings, tmpEvt, { lowLatencyMode: this._lowLatencyMode,
+            withMediaSource: this._withMediaSource });
+        const freezingStatus = getFreezingStatus(previousObservation, mediaTimings, tmpEvt);
+        const seeking = isInternalSeeking ? 1 /* SeekingState.Internal */ :
+            mediaTimings.seeking ? 2 /* SeekingState.External */ :
+                0 /* SeekingState.None */;
+        const timings = objectAssign({}, mediaTimings, { position: new ObservationPosition(mediaTimings.position, pendingPosition),
+            event: tmpEvt,
+            seeking,
+            rebuffering: rebufferingStatus,
+            freezing: freezingStatus });
+        if (log.hasLevel("DEBUG")) {
+            log.debug("API: current media element state tick", "event", timings.event, "position", timings.position.getPolled(), "seeking", timings.seeking, "internalSeek", isInternalSeeking, "rebuffering", timings.rebuffering !== null, "freezing", timings.freezing !== null, "ended", timings.ended, "paused", timings.paused, "playbackRate", timings.playbackRate, "readyState", timings.readyState);
+        }
+        return timings;
+    }
+    _generateObservationForEvent(event) {
+        const newObservation = this._getCurrentObservation(event);
+        if (log.hasLevel("DEBUG")) {
+            log.debug("API: current playback timeline:\n" +
+                prettyPrintBuffered(newObservation.buffered, newObservation.position.getPolled()), `\n${event}`);
+        }
+        this._observationRef.setValue(newObservation);
+    }
+}
+class ObservationPosition {
+    constructor(last, wanted) {
+        this._last = last;
+        this._wanted = wanted;
+    }
+    /**
+     * Returns the playback position actually observed on the media element at
+     * the time the playback observation was made.
+     *
+     * Note that it may be different than the position for which media data is
+     * wanted in rare scenarios where the goal position is not yet set on the
+     * media element.
+     *
+     * You should use this value when you want to obtain the actual position set
+     * on the media element for browser compatibility purposes. Note that this
+     * position was calculated at observation time, it might thus not be
+     * up-to-date if what you want is milliseconds-accuracy.
+     *
+     * If what you want is the actual position which the player is intended to
+     * play, you should rely on `getWanted` instead`.
+     * @returns {number}
+     */
+    getPolled() {
+        return this._last;
+    }
+    /**
+     * Returns the position which the player should consider to load media data
+     * at the time the observation was made.
+     *
+     * It can be different than the value returned by `getPolled` in rare
+     * scenarios:
+     *
+     *   - When the initial position has not been set yet.
+     *
+     *   - When the current device do not let the RxPlayer peform precize seeks,
+     *     usually for perfomance reasons by seeking to a previous IDR frame
+     *     instead (for now only Tizen may be like this), in which case we
+     *     prefer to generally rely on the position wanted by the player (this
+     *     e.g. prevents issues where the RxPlayer logic and the device are
+     *     seeking back and forth in a loop).
+     *
+     *   - When a wanted position has been "forced" (@see forceWantedPosition).
+     * @returns {number}
+     */
+    getWanted() {
+        var _a;
+        return (_a = this._wanted) !== null && _a !== void 0 ? _a : this._last;
+    }
+    /**
+     * Method to call if you want to overwrite the currently wanted position.
+     * @param {number} pos
+     */
+    forceWantedPosition(pos) {
+        this._wanted = pos;
+    }
+    /**
+     * Returns `true` when the position wanted returned by `getWanted` and the
+     * actual position returned by `getPolled` may be different, meaning that
+     * we're currently not at the position we want to reach.
+     *
+     * This is a relatively rare situation which only happens when either the
+     * initial seek has not yet been performed. on specific targets where the
+     * seeking behavior is a little broken (@see getWanted) or when the wanted
+     * position has been forced (@see forceWantedPosition).
+     *
+     * In those situations, you might temporarily refrain from acting upon the
+     * actual current media position, as it may change soon.
+     *
+     * @returns {boolean}
+     */
+    isAwaitingFuturePosition() {
+        return this._wanted !== null;
     }
 }
 /**
@@ -311,10 +446,9 @@ function hasLoadedUntilTheEnd(currentTime, currentRange, ended, duration, lowLat
 /**
  * Get basic playback information.
  * @param {HTMLMediaElement} mediaElement
- * @param {string} event
  * @returns {Object}
  */
-function getMediaInfos(mediaElement, event, withMediaSource) {
+function getMediaInfos(mediaElement, withMediaSource) {
     const { buffered, currentTime, duration, ended, paused, playbackRate, readyState, seeking } = mediaElement;
     let currentRange;
     let bufferGap;
@@ -342,8 +476,7 @@ function getMediaInfos(mediaElement, event, withMediaSource) {
         paused,
         playbackRate,
         readyState,
-        seeking,
-        event };
+        seeking };
 }
 /**
  * Infer rebuffering status of the media based on:
@@ -354,12 +487,13 @@ function getMediaInfos(mediaElement, event, withMediaSource) {
  * @param {Object} currentInfo - Current set of basic information on the
  * `HTMLMediaElement`. This does not need every single property from a regular
  * playback observation.
+ * @param {string} currentEvt
  * @param {Object} options
  * @returns {Object|null}
  */
-function getRebufferingStatus(prevObservation, currentInfo, { withMediaSource, lowLatencyMode }) {
+function getRebufferingStatus(prevObservation, currentInfo, currentEvt, { withMediaSource, lowLatencyMode }) {
     const { REBUFFERING_GAP } = config.getCurrent();
-    const { event: currentEvt, position: currentTime, bufferGap, currentRange, duration, paused, readyState, ended } = currentInfo;
+    const { position: currentTime, bufferGap, currentRange, duration, paused, readyState, ended } = currentInfo;
     const { rebuffering: prevRebuffering, event: prevEvt, position: prevTime } = prevObservation;
     const fullyLoaded = hasLoadedUntilTheEnd(currentTime, currentRange, ended, duration, lowLatencyMode);
     const canSwitchToRebuffering = (readyState >= 1 &&
@@ -414,12 +548,12 @@ function getRebufferingStatus(prevObservation, currentInfo, { withMediaSource, l
         if (canSwitchToRebuffering &&
             ((!paused &&
                 currentEvt === "timeupdate" && prevEvt === "timeupdate" &&
-                currentTime === prevTime) ||
+                currentTime === prevTime.getPolled()) ||
                 (currentEvt === "seeking" && (bufferGap === Infinity || (bufferGap === undefined && readyState < 3))))) {
             shouldRebuffer = true;
         }
         else if (prevRebuffering !== null &&
-            ((currentEvt !== "seeking" && currentTime !== prevTime) ||
+            ((currentEvt !== "seeking" && currentTime !== prevTime.getPolled()) ||
                 currentEvt === "canplay" ||
                 (bufferGap === undefined && readyState >= 3) ||
                 (bufferGap !== undefined && bufferGap < Infinity &&
@@ -465,28 +599,29 @@ function getRebufferingStatus(prevObservation, currentInfo, { withMediaSource, l
  * `null` if not.
  * @param {Object} prevObservation
  * @param {Object} currentInfo
+ * @param {string} currentEvt
  * @returns {Object|null}
  */
-function getFreezingStatus(prevObservation, currentInfo) {
+function getFreezingStatus(prevObservation, currentInfo, currentEvt) {
     const { MINIMUM_BUFFER_AMOUNT_BEFORE_FREEZING } = config.getCurrent();
     if (prevObservation.freezing) {
         if (currentInfo.ended ||
             currentInfo.paused ||
             currentInfo.readyState === 0 ||
             currentInfo.playbackRate === 0 ||
-            prevObservation.position !== currentInfo.position) {
+            prevObservation.position.getPolled() !== currentInfo.position) {
             return null; // Quit freezing status
         }
         return prevObservation.freezing; // Stay in it
     }
-    return currentInfo.event === "timeupdate" &&
+    return currentEvt === "timeupdate" &&
         currentInfo.bufferGap !== undefined &&
         currentInfo.bufferGap > MINIMUM_BUFFER_AMOUNT_BEFORE_FREEZING &&
         !currentInfo.ended &&
         !currentInfo.paused &&
         currentInfo.readyState >= 1 &&
         currentInfo.playbackRate !== 0 &&
-        currentInfo.position === prevObservation.position ?
+        currentInfo.position === prevObservation.position.getPolled() ?
         { timestamp: getMonotonicTimeStamp() } :
         null;
 }
@@ -589,3 +724,19 @@ function generateReadOnlyObserver(src, transform, cancellationSignal) {
         },
     };
 }
+/**
+ * Generate the initial playback observation for when no event has yet been
+ * emitted to lead to one.
+ * @param {HTMLMediaElement} mediaElement
+ * @param {boolean} withMediaSource
+ * @returns {Object}
+ */
+function getInitialObservation(mediaElement, withMediaSource) {
+    const mediaTimings = getMediaInfos(mediaElement, withMediaSource);
+    return objectAssign(mediaTimings, { rebuffering: null,
+        event: "init",
+        seeking: 0 /* SeekingState.None */,
+        position: { last: mediaTimings.position,
+            pending: undefined },
+        freezing: null });
+}

package/dist/es2017/core/api/public_api.js

@@ -91,7 +91,7 @@ class Player extends EventEmitter {
         // Workaround to support Firefox autoplay on FF 42.
         // See: https://bugzilla.mozilla.org/show_bug.cgi?id=1194624
         videoElement.preload = "auto";
-        this.version = /* PLAYER_VERSION */ "4.0.0-dev.2023120600";
+        this.version = /* PLAYER_VERSION */ "4.0.0-dev.2023121900";
         this.log = log;
         this.state = "STOPPED";
         this.videoElement = videoElement;
@@ -459,12 +459,12 @@ class Player extends EventEmitter {
                 case "ENDED":
                     this._priv_reloadingMetadata.reloadInPause = true;
                     this._priv_reloadingMetadata.reloadPosition =
-                        playbackObserver.getReference().getValue().position;
+                        playbackObserver.getReference().getValue().position.getPolled();
                     break;
                 default:
                     const o = playbackObserver.getReference().getValue();
                     this._priv_reloadingMetadata.reloadInPause = o.paused;
-                    this._priv_reloadingMetadata.reloadPosition = o.position;
+                    this._priv_reloadingMetadata.reloadPosition = o.position.getWanted();
                     break;
             }
         };
@@ -1975,7 +1975,7 @@ class Player extends EventEmitter {
         const maximumPosition = manifest !== null ? manifest.getMaximumSafePosition() :
             undefined;
         const positionData = {
-            position: observation.position,
+            position: observation.position.getPolled(),
             duration: observation.duration,
             playbackRate: observation.playbackRate,
             maximumPosition,
@@ -1987,18 +1987,18 @@ class Player extends EventEmitter {
         };
         if (manifest !== null &&
             manifest.isLive &&
-            observation.position > 0) {
+            observation.position.getPolled() > 0) {
             const ast = (_b = manifest.availabilityStartTime) !== null && _b !== void 0 ? _b : 0;
-            positionData.wallClockTime = observation.position + ast;
+            positionData.wallClockTime = observation.position.getPolled() + ast;
             const livePosition = manifest.getLivePosition();
             if (livePosition !== undefined) {
-                positionData.liveGap = livePosition - observation.position;
+                positionData.liveGap = livePosition - observation.position.getPolled();
             }
         }
         else if (isDirectFile && this.videoElement !== null) {
             const startDate = getStartDate(this.videoElement);
             if (startDate !== undefined) {
-                positionData.wallClockTime = startDate + observation.position;
+                positionData.wallClockTime = startDate + observation.position.getPolled();
             }
         }
         this.trigger("positionUpdate", positionData);
@@ -2132,5 +2132,5 @@ class Player extends EventEmitter {
         }
     }
 }
-Player.version = /* PLAYER_VERSION */ "4.0.0-dev.2023120600";
+Player.version = /* PLAYER_VERSION */ "4.0.0-dev.2023121900";
 export default Player;

package/dist/es2017/core/api/utils.js

@@ -31,7 +31,7 @@ export function emitSeekEvents(mediaElement, playbackObserver, onSeeking, onSeek
     if (cancelSignal.isCancelled() || mediaElement === null) {
         return;
     }
-    let wasSeeking = playbackObserver.getReference().getValue().seeking;
+    let wasSeeking = playbackObserver.getReference().getValue().seeking === 2 /* SeekingState.External */;
     if (wasSeeking) {
         onSeeking();
         if (cancelSignal.isCancelled()) {

package/dist/es2017/core/decrypt/get_media_keys.js

@@ -28,13 +28,9 @@ import ServerCertificateStore from "./utils/server_certificate_store";
  * @returns {Object|null}
  */
 function createPersistentSessionsStorage(keySystemOptions) {
-    if (isNullOrUndefined(keySystemOptions.persistentLicenseConfig)) {
-        return null;
-    }
     const { persistentLicenseConfig } = keySystemOptions;
-    if (persistentLicenseConfig == null) {
-        throw new EncryptedMediaError("INVALID_KEY_SYSTEM", "No `persistentLicenseConfig` found for " +
-            "persistent license.");
+    if (isNullOrUndefined(persistentLicenseConfig)) {
+        return null;
     }
     log.debug("DRM: Set the given license storage");
     return new PersistentSessionsStore(persistentLicenseConfig);

package/dist/es2017/core/init/directfile_content_initializer.js

@@ -153,7 +153,13 @@ export default class DirectFileContentInitializer extends ContentInitializer {
             log.debug("Init: Initial time calculated:", initTime);
             return initTime;
         };
-        performInitialSeekAndPlay(mediaElement, playbackObserver, initialTime, autoPlay, (err) => this.trigger("warning", err), cancelSignal).autoPlayResult
+        performInitialSeekAndPlay({ mediaElement,
+            playbackObserver,
+            startTime: initialTime,
+            mustAutoPlay: autoPlay,
+            onWarning: (err) => this.trigger("warning", err),
+            isDirectfile: true }, cancelSignal)
+            .autoPlayResult
             .then(() => getLoadedReference(playbackObserver, mediaElement, true, cancelSignal)
             .onUpdate((isLoaded, stopListening) => {
             if (isLoaded) {

package/dist/es2017/core/init/media_source_content_initializer.js

@@ -267,7 +267,12 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
         cancelSignal.register(() => {
             segmentBuffersStore.disposeAll();
         });
-        const { autoPlayResult, initialPlayPerformed, initialSeekPerformed } = performInitialSeekAndPlay(mediaElement, playbackObserver, initialTime, autoPlay, (err) => this.trigger("warning", err), cancelSignal);
+        const { autoPlayResult, initialPlayPerformed } = performInitialSeekAndPlay({ mediaElement,
+            playbackObserver,
+            startTime: initialTime,
+            mustAutoPlay: autoPlay,
+            onWarning: (err) => { this.trigger("warning", err); },
+            isDirectfile: false }, cancelSignal);
         if (cancelSignal.isCancelled()) {
             return;
         }
@@ -290,16 +295,19 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
         const streamObserver = createStreamPlaybackObserver(playbackObserver, { autoPlay,
             manifest,
             initialPlayPerformed,
-            initialSeekPerformed,
-            speed,
-            startTime: initialTime }, cancelSignal);
+            speed }, cancelSignal);
         const rebufferingController = this._createRebufferingController(playbackObserver, manifest, segmentBuffersStore, speed, cancelSignal);
         rebufferingController.addEventListener("needsReload", () => {
+            let position;
+            const lastObservation = playbackObserver.getReference().getValue();
+            if (lastObservation.position.isAwaitingFuturePosition()) {
+                position = lastObservation.position.getWanted();
+            }
+            else {
+                position = playbackObserver.getCurrentTime();
+            }
             // NOTE couldn't both be always calculated at event destination?
             // Maybe there are exceptions?
-            const position = initialSeekPerformed.getValue() ?
-                playbackObserver.getCurrentTime() :
-                initialTime;
             const autoplay = initialPlayPerformed.getValue() ?
                 !playbackObserver.getIsPaused() :
                 autoPlay;
@@ -360,9 +368,9 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
                         // Data is buffered around the current position
                         obs.currentRange !== null ||
                             // Or, for whatever reason, we have no buffer but we're already advancing
-                            obs.position > seekedTime + 0.1) {
+                            obs.position.getPolled() > seekedTime + 0.1) {
                             stopListening();
-                            playbackObserver.setCurrentTime(obs.position + 0.001);
+                            playbackObserver.setCurrentTime(obs.position.getWanted() + 0.001);
                         }
                     }, { includeLastObservation: false, clearSignal: cancelSignal });
                 },
@@ -434,10 +442,12 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
                 },
                 bitrateEstimateChange: (value) => self.trigger("bitrateEstimateChange", value),
                 needsMediaSourceReload: (payload) => {
-                    var _a, _b;
+                    var _a;
                     const lastObservation = streamObserver.getReference().getValue();
-                    const currentPosition = (_a = lastObservation.position.pending) !== null && _a !== void 0 ? _a : streamObserver.getCurrentTime();
-                    const isPaused = (_b = lastObservation.paused.pending) !== null && _b !== void 0 ? _b : streamObserver.getIsPaused();
+                    const currentPosition = lastObservation.position.isAwaitingFuturePosition() ?
+                        lastObservation.position.getWanted() :
+                        streamObserver.getCurrentTime();
+                    const isPaused = (_a = lastObservation.paused.pending) !== null && _a !== void 0 ? _a : streamObserver.getIsPaused();
                     let position = currentPosition + payload.timeOffset;
                     if (payload.minimumPosition !== undefined) {
                         position = Math.max(payload.minimumPosition, position);
@@ -448,17 +458,21 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
                     onReloadOrder({ position, autoPlay: !isPaused });
                 },
                 needsDecipherabilityFlush() {
-                    var _a, _b, _c;
+                    var _a;
                     const keySystem = getKeySystemConfiguration(mediaElement);
                     if (shouldReloadMediaSourceOnDecipherabilityUpdate(keySystem === null || keySystem === void 0 ? void 0 : keySystem[0])) {
                         const lastObservation = streamObserver.getReference().getValue();
-                        const position = (_a = lastObservation.position.pending) !== null && _a !== void 0 ? _a : streamObserver.getCurrentTime();
-                        const isPaused = (_b = lastObservation.paused.pending) !== null && _b !== void 0 ? _b : streamObserver.getIsPaused();
+                        const position = lastObservation.position.isAwaitingFuturePosition() ?
+                            lastObservation.position.getWanted() :
+                            streamObserver.getCurrentTime();
+                        const isPaused = (_a = lastObservation.paused.pending) !== null && _a !== void 0 ? _a : streamObserver.getIsPaused();
                         onReloadOrder({ position, autoPlay: !isPaused });
                     }
                     else {
                         const lastObservation = streamObserver.getReference().getValue();
-                        const position = (_c = lastObservation.position.pending) !== null && _c !== void 0 ? _c : streamObserver.getCurrentTime();
+                        const position = lastObservation.position.isAwaitingFuturePosition() ?
+                            lastObservation.position.getWanted() :
+                            streamObserver.getCurrentTime();
                         // simple seek close to the current position
                         // to flush the buffers
                         if (position + 0.001 < lastObservation.duration) {

package/dist/es2017/core/init/utils/content_time_boundaries_observer.js

@@ -51,8 +51,7 @@ export default class ContentTimeBoundariesObserver extends EventEmitter {
         this._maximumPositionCalculator = maximumPositionCalculator;
         const cancelSignal = this._canceller.signal;
         playbackObserver.listen(({ position }) => {
-            var _a;
-            const wantedPosition = (_a = position.pending) !== null && _a !== void 0 ? _a : position.last;
+            const wantedPosition = position.getWanted();
             if (wantedPosition < manifest.getMinimumSafePosition()) {
                 const warning = new MediaError("MEDIA_TIME_BEFORE_MANIFEST", "The current position is behind the " +
                     "earliest time announced in the Manifest.");

package/dist/es2017/core/init/utils/create_stream_playback_observer.d.ts

@@ -26,12 +26,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;
 }
 /**
  * Create PlaybackObserver for the `Stream` part of the code.
@@ -42,4 +38,4 @@ export interface IStreamPlaybackObserverArguments {
  * @param {Object} fnCancelSignal - Abort the created PlaybackObserver.
  * @returns {Object}
  */
-export default function createStreamPlaybackObserver(srcPlaybackObserver: PlaybackObserver, { autoPlay, initialPlayPerformed, initialSeekPerformed, manifest, speed, startTime }: IStreamPlaybackObserverArguments, fnCancelSignal: CancellationSignal): IReadOnlyPlaybackObserver<IStreamOrchestratorPlaybackObservation>;
+export default function createStreamPlaybackObserver(srcPlaybackObserver: PlaybackObserver, { autoPlay, initialPlayPerformed, manifest, speed }: IStreamPlaybackObserverArguments, fnCancelSignal: CancellationSignal): IReadOnlyPlaybackObserver<IStreamOrchestratorPlaybackObservation>;