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

package/dist/commonjs/core/api/playback_observer.d.ts

@@ -39,6 +39,13 @@ export default class PlaybackObserver {
      * influence on some chosen interval values here.
      */
     private _lowLatencyMode;
+    /**
+     * If set, position which could not yet be seeked to as the HTMLMediaElement
+     * had a readyState of `0`.
+     * This position should be seeked to as soon as the HTMLMediaElement is able
+     * to handle it.
+     */
+    private _pendingSeek;
     /**
      * The RxPlayer usually wants to differientate when a seek was sourced from
      * the RxPlayer's internal logic vs when it was sourced from an outside
@@ -64,6 +71,21 @@ export default class PlaybackObserver {
      * observations.
      */
     private _canceller;
+    /**
+     * 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 maximum 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.
+     */
+    private _expectedSeekingPosition;
     /**
      * Create a new `PlaybackObserver`, which allows to produce new "playback
      * observations" on various media events and intervals.
@@ -164,18 +186,22 @@ export default class PlaybackObserver {
      * @returns {Object}
      */
     deriveReadOnlyObserver<TDest>(transform: (observationRef: IReadOnlySharedReference<IPlaybackObservation>, cancellationSignal: CancellationSignal) => IReadOnlySharedReference<TDest>): IReadOnlyPlaybackObserver<TDest>;
+    private _actuallySetCurrentTime;
     /**
      * Creates the `IReadOnlySharedReference` that will generate playback
      * observations.
      * @returns {Object}
      */
     private _createSharedReference;
-    private _generateInitialObservation;
+    private _getCurrentObservation;
+    private _generateObservationForEvent;
 }
 /** "Event" that triggered the playback observation. */
 export type IPlaybackObserverEventType = 
 /** First playback observation automatically emitted. */
-"init" | // set once on first emit
+"init" | 
+/** Observation manually forced by the PlaybackObserver. */
+"manual" | 
 /** Regularly emitted playback observation when no event happened in a long time. */
 "timeupdate" | 
 /** On the HTML5 event with the same name */
@@ -236,8 +262,18 @@ interface IMediaInfos {
     readyState: number;
     /** Current `seeking` value on the mediaElement. */
     seeking: boolean;
-    /** Event that triggered this playback observation. */
-    event: IPlaybackObserverEventType;
+}
+/** Categorize a pending seek operation. */
+export declare const enum SeekingState {
+    /** We're not currently seeking. */
+    None = 0,
+    /**
+     * We're currently seeking due to an internal logic of the RxPlayer (e.g.
+     * discontinuity skipping).
+     */
+    Internal = 1,
+    /** We're currently seeking due to a regular seek wanted by the application. */
+    External = 2
 }
 /**
  * Describes when the player is "rebuffering" and what event started that
@@ -277,7 +313,16 @@ export interface IFreezingStatus {
     timestamp: number;
 }
 /** Information emitted on each playback observation. */
-export interface IPlaybackObservation extends IMediaInfos {
+export interface IPlaybackObservation extends Omit<IMediaInfos, "position" | "seeking"> {
+    /** Event that triggered this playback observation. */
+    event: IPlaybackObserverEventType;
+    /** Current seeking state. */
+    seeking: SeekingState;
+    /**
+     * Information on the current position being played, the position for which
+     * media is wanted etc.
+     */
+    position: IObservationPosition;
     /**
      * Set if the player is short on audio and/or video media data and is a such,
      * rebuffering.
@@ -292,11 +337,86 @@ export interface IPlaybackObservation extends IMediaInfos {
      * `null` if the player is not frozen.
      */
     freezing: IFreezingStatus | null;
+}
+export type IObservationPosition = ObservationPosition;
+declare class ObservationPosition {
+    /**
+     * Known position at the time the Observation was emitted, in seconds.
+     *
+     * Note that it might have changed since. If you want truly precize
+     * information, you should recuperate it from the HTMLMediaElement directly
+     * through another mean.
+     */
+    private _last;
+    /**
+     * Actually wanted position in seconds that is not yet reached.
+     *
+     * This might for example be set to the initial position when the content is
+     * loading (and thus potentially at a `0` position) but which will be seeked
+     * to a given position once possible. It may also be the position of a seek
+     * that has not been properly accounted for by the current device.
+     */
+    private _wanted;
+    constructor(last: number, wanted: number | null);
+    /**
+     * 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(): number;
+    /**
+     * 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(): number;
+    /**
+     * Method to call if you want to overwrite the currently wanted position.
+     * @param {number} pos
+     */
+    forceWantedPosition(pos: number): void;
     /**
-     * If `true`, an "internal seek" (a seeking operation triggered by the
-     * RxPlayer code) is currently pending.
+     * 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}
      */
-    pendingInternalSeek: number | null;
+    isAwaitingFuturePosition(): boolean;
 }
 /**
  * Interface providing a generic and read-only version of a `PlaybackObserver`.

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

@@ -15,6 +15,7 @@
  * limitations under the License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+var is_seeking_approximate_1 = require("../../compat/is_seeking_approximate");
 var config_1 = require("../../config");
 var log_1 = require("../../log");
 var monotonic_timestamp_1 = require("../../utils/monotonic_timestamp");
@@ -61,12 +62,26 @@ var PlaybackObserver = /** @class */ (function () {
      * @param {Object} options
      */
     function PlaybackObserver(mediaElement, options) {
+        var _this = this;
         this._internalSeeksIncoming = [];
         this._mediaElement = mediaElement;
         this._withMediaSource = options.withMediaSource;
         this._lowLatencyMode = options.lowLatencyMode;
         this._canceller = new task_canceller_1.default();
         this._observationRef = this._createSharedReference();
+        this._expectedSeekingPosition = null;
+        this._pendingSeek = null;
+        var onLoadedMetadata = function () {
+            if (_this._pendingSeek !== null) {
+                var positionToSeekTo = _this._pendingSeek;
+                _this._pendingSeek = null;
+                _this._actuallySetCurrentTime(positionToSeekTo);
+            }
+        };
+        mediaElement.addEventListener("loadedmetadata", onLoadedMetadata);
+        this._canceller.signal.register(function () {
+            mediaElement.removeEventListener("loadedmetadata", onLoadedMetadata);
+        });
     }
     /**
      * Stop the `PlaybackObserver` from emitting playback observations and free all
@@ -116,9 +131,14 @@ var PlaybackObserver = /** @class */ (function () {
      * @param {number} time
      */
     PlaybackObserver.prototype.setCurrentTime = function (time) {
-        this._internalSeeksIncoming.push(time);
-        log_1.default.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`.
@@ -183,6 +203,11 @@ var PlaybackObserver = /** @class */ (function () {
     PlaybackObserver.prototype.deriveReadOnlyObserver = function (transform) {
         return generateReadOnlyObserver(this, transform, this._canceller.signal);
     };
+    PlaybackObserver.prototype._actuallySetCurrentTime = function (time) {
+        log_1.default.info("API: Seeking internally", time);
+        this._internalSeeksIncoming.push(time);
+        this._mediaElement.currentTime = time;
+    };
     /**
      * Creates the `IReadOnlySharedReference` that will generate playback
      * observations.
@@ -193,56 +218,21 @@ var PlaybackObserver = /** @class */ (function () {
         if (this._observationRef !== undefined) {
             return this._observationRef;
         }
-        var lastObservation;
         var _a = config_1.default.getCurrent(), SAMPLING_INTERVAL_MEDIASOURCE = _a.SAMPLING_INTERVAL_MEDIASOURCE, SAMPLING_INTERVAL_LOW_LATENCY = _a.SAMPLING_INTERVAL_LOW_LATENCY, SAMPLING_INTERVAL_NO_MEDIASOURCE = _a.SAMPLING_INTERVAL_NO_MEDIASOURCE;
-        var getCurrentObservation = function (event) {
-            var tmpEvt = event;
-            var startedInternalSeekTime;
-            if (tmpEvt === "seeking" && _this._internalSeeksIncoming.length > 0) {
-                tmpEvt = "internal-seeking";
-                startedInternalSeekTime = _this._internalSeeksIncoming.shift();
-            }
-            var _lastObservation = lastObservation !== null && lastObservation !== void 0 ? lastObservation : _this._generateInitialObservation();
-            var mediaTimings = getMediaInfos(_this._mediaElement, tmpEvt, _this._withMediaSource);
-            var pendingInternalSeek = null;
-            if (mediaTimings.seeking) {
-                if (typeof startedInternalSeekTime === "number") {
-                    pendingInternalSeek = startedInternalSeekTime;
-                }
-                else if (_lastObservation.pendingInternalSeek !== null && event !== "seeking") {
-                    pendingInternalSeek = _lastObservation.pendingInternalSeek;
-                }
-            }
-            var rebufferingStatus = getRebufferingStatus(_lastObservation, mediaTimings, { lowLatencyMode: _this._lowLatencyMode,
-                withMediaSource: _this._withMediaSource });
-            var freezingStatus = getFreezingStatus(_lastObservation, mediaTimings);
-            var timings = (0, object_assign_1.default)({}, { rebuffering: rebufferingStatus,
-                freezing: freezingStatus, pendingInternalSeek: pendingInternalSeek }, mediaTimings);
-            if (log_1.default.hasLevel("DEBUG")) {
-                log_1.default.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;
-        };
-        var returnedSharedReference = new reference_1.default(getCurrentObservation("init"), this._canceller.signal);
-        var generateObservationForEvent = function (event) {
-            var newObservation = getCurrentObservation(event);
-            if (log_1.default.hasLevel("DEBUG")) {
-                log_1.default.debug("API: current playback timeline:\n" +
-                    prettyPrintBuffered(newObservation.buffered, newObservation.position), "\n".concat(event));
-            }
-            lastObservation = newObservation;
-            returnedSharedReference.setValue(newObservation);
-        };
+        var returnedSharedReference = new reference_1.default(this._getCurrentObservation("init"), this._canceller.signal);
         var interval = this._lowLatencyMode ? SAMPLING_INTERVAL_LOW_LATENCY :
             this._withMediaSource ? SAMPLING_INTERVAL_MEDIASOURCE :
                 SAMPLING_INTERVAL_NO_MEDIASOURCE;
+        var onInterval = function () {
+            _this._generateObservationForEvent("timeupdate");
+        };
         var intervalId = setInterval(onInterval, interval);
         var removeEventListeners = SCANNED_MEDIA_ELEMENTS_EVENTS.map(function (eventName) {
-            _this._mediaElement.addEventListener(eventName, onMediaEvent);
-            function onMediaEvent() {
+            var onMediaEvent = function () {
                 restartInterval();
-                generateObservationForEvent(eventName);
-            }
+                _this._generateObservationForEvent(eventName);
+            };
+            _this._mediaElement.addEventListener(eventName, onMediaEvent);
             return function () {
                 _this._mediaElement.removeEventListener(eventName, onMediaEvent);
             };
@@ -253,22 +243,168 @@ var PlaybackObserver = /** @class */ (function () {
             returnedSharedReference.finish();
         });
         return returnedSharedReference;
-        function onInterval() {
-            generateObservationForEvent("timeupdate");
-        }
         function restartInterval() {
             clearInterval(intervalId);
             intervalId = setInterval(onInterval, interval);
         }
     };
-    PlaybackObserver.prototype._generateInitialObservation = function () {
-        return (0, object_assign_1.default)(getMediaInfos(this._mediaElement, "init", this._withMediaSource), { rebuffering: null,
-            freezing: null,
-            pendingInternalSeek: null });
+    PlaybackObserver.prototype._getCurrentObservation = function (event) {
+        var _a;
+        /** Actual event emitted through an observation. */
+        var tmpEvt = event;
+        // NOTE: `this._observationRef` may be `undefined` because we might here be
+        // called in the constructor when that property is not yet set.
+        var 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.
+         */
+        var isInternalSeeking = false;
+        /** If set, the position for which we plan to seek to as soon as possible. */
+        var pendingPosition = this._pendingSeek;
+        /** Initially-polled playback observation, before adjustments. */
+        var 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";
+                var startedInternalSeekTime = this._internalSeeksIncoming.shift();
+                this._expectedSeekingPosition = is_seeking_approximate_1.default ?
+                    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 (is_seeking_approximate_1.default &&
+            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;
+        }
+        var rebufferingStatus = getRebufferingStatus(previousObservation, mediaTimings, tmpEvt, { lowLatencyMode: this._lowLatencyMode,
+            withMediaSource: this._withMediaSource });
+        var freezingStatus = getFreezingStatus(previousObservation, mediaTimings, tmpEvt);
+        var seeking = isInternalSeeking ? 1 /* SeekingState.Internal */ :
+            mediaTimings.seeking ? 2 /* SeekingState.External */ :
+                0 /* SeekingState.None */;
+        var timings = (0, object_assign_1.default)({}, mediaTimings, { position: new ObservationPosition(mediaTimings.position, pendingPosition),
+            event: tmpEvt, seeking: seeking, rebuffering: rebufferingStatus,
+            freezing: freezingStatus });
+        if (log_1.default.hasLevel("DEBUG")) {
+            log_1.default.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;
+    };
+    PlaybackObserver.prototype._generateObservationForEvent = function (event) {
+        var newObservation = this._getCurrentObservation(event);
+        if (log_1.default.hasLevel("DEBUG")) {
+            log_1.default.debug("API: current playback timeline:\n" +
+                prettyPrintBuffered(newObservation.buffered, newObservation.position.getPolled()), "\n".concat(event));
+        }
+        this._observationRef.setValue(newObservation);
     };
     return PlaybackObserver;
 }());
 exports.default = PlaybackObserver;
+var ObservationPosition = /** @class */ (function () {
+    function ObservationPosition(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}
+     */
+    ObservationPosition.prototype.getPolled = function () {
+        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}
+     */
+    ObservationPosition.prototype.getWanted = function () {
+        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
+     */
+    ObservationPosition.prototype.forceWantedPosition = function (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}
+     */
+    ObservationPosition.prototype.isAwaitingFuturePosition = function () {
+        return this._wanted !== null;
+    };
+    return ObservationPosition;
+}());
 /**
  * Returns the amount of time in seconds the buffer should have ahead of the
  * current position before resuming playback. Based on the infos of the
@@ -315,10 +451,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) {
     var buffered = mediaElement.buffered, currentTime = mediaElement.currentTime, duration = mediaElement.duration, ended = mediaElement.ended, paused = mediaElement.paused, playbackRate = mediaElement.playbackRate, readyState = mediaElement.readyState, seeking = mediaElement.seeking;
     var currentRange;
     var bufferGap;
@@ -337,7 +472,7 @@ function getMediaInfos(mediaElement, event, withMediaSource) {
             // more appropriate
             Infinity;
     }
-    return { bufferGap: bufferGap, buffered: buffered, currentRange: currentRange, position: currentTime, duration: duration, ended: ended, paused: paused, playbackRate: playbackRate, readyState: readyState, seeking: seeking, event: event };
+    return { bufferGap: bufferGap, buffered: buffered, currentRange: currentRange, position: currentTime, duration: duration, ended: ended, paused: paused, playbackRate: playbackRate, readyState: readyState, seeking: seeking };
 }
 /**
  * Infer rebuffering status of the media based on:
@@ -348,13 +483,14 @@ 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, _a) {
+function getRebufferingStatus(prevObservation, currentInfo, currentEvt, _a) {
     var withMediaSource = _a.withMediaSource, lowLatencyMode = _a.lowLatencyMode;
     var REBUFFERING_GAP = config_1.default.getCurrent().REBUFFERING_GAP;
-    var currentEvt = currentInfo.event, currentTime = currentInfo.position, bufferGap = currentInfo.bufferGap, currentRange = currentInfo.currentRange, duration = currentInfo.duration, paused = currentInfo.paused, readyState = currentInfo.readyState, ended = currentInfo.ended;
+    var currentTime = currentInfo.position, bufferGap = currentInfo.bufferGap, currentRange = currentInfo.currentRange, duration = currentInfo.duration, paused = currentInfo.paused, readyState = currentInfo.readyState, ended = currentInfo.ended;
     var prevRebuffering = prevObservation.rebuffering, prevEvt = prevObservation.event, prevTime = prevObservation.position;
     var fullyLoaded = hasLoadedUntilTheEnd(currentTime, currentRange, ended, duration, lowLatencyMode);
     var canSwitchToRebuffering = (readyState >= 1 &&
@@ -409,12 +545,12 @@ function getRebufferingStatus(prevObservation, currentInfo, _a) {
         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 &&
@@ -459,28 +595,29 @@ function getRebufferingStatus(prevObservation, currentInfo, _a) {
  * `null` if not.
  * @param {Object} prevObservation
  * @param {Object} currentInfo
+ * @param {string} currentEvt
  * @returns {Object|null}
  */
-function getFreezingStatus(prevObservation, currentInfo) {
+function getFreezingStatus(prevObservation, currentInfo, currentEvt) {
     var MINIMUM_BUFFER_AMOUNT_BEFORE_FREEZING = config_1.default.getCurrent().MINIMUM_BUFFER_AMOUNT_BEFORE_FREEZING;
     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: (0, monotonic_timestamp_1.default)() } :
         null;
 }
@@ -583,3 +720,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) {
+    var mediaTimings = getMediaInfos(mediaElement, withMediaSource);
+    return (0, object_assign_1.default)(mediaTimings, { rebuffering: null,
+        event: "init",
+        seeking: 0 /* SeekingState.None */,
+        position: { last: mediaTimings.position,
+            pending: undefined },
+        freezing: null });
+}

package/dist/commonjs/core/api/public_api.d.ts

@@ -557,6 +557,15 @@ declare class Player extends EventEmitter<IPublicAPIEvent> {
      * @returns {number}
      */
     getMinimumPosition(): number | null;
+    /**
+     * Returns the current position for live contents.
+     *
+     * Returns `null` if no content is loaded or if the current loaded content is
+     * not considered as a live content.
+     * Returns `undefined` if that live position is currently unknown.
+     * @returns {number}
+     */
+    getLivePosition(): number | undefined | null;
     /**
      * Get maximum seek-able position.
      * @returns {number}