rx-player 4.0.0-dev.2023111400 → 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.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}

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.2023111400";
+        this.version = /* PLAYER_VERSION */ "4.0.0-dev.2023121900";
         this.log = log;
         this.state = "STOPPED";
         this.videoElement = videoElement;
@@ -250,7 +250,7 @@ class Player extends EventEmitter {
      * @param {Object} options
      */
     _priv_initializeContentPlayback(options) {
-        var _a, _b, _c, _d;
+        var _a, _b, _c, _d, _e, _f;
         const { autoPlay, defaultAudioTrackSwitchingMode, enableFastSwitching, initialManifest, keySystems, lowLatencyMode, minimumManifestUpdateInterval, requestConfig, onCodecSwitch, startAt, transport, checkMediaSegmentIntegrity, manifestLoader, referenceDateTime, representationFilter, segmentLoader, serverSyncInfos, __priv_manifestUpdateUrl, __priv_patchLastSegmentInSidx, url } = options;
         // Perform multiple checks on the given options
         if (this.videoElement === null) {
@@ -286,6 +286,7 @@ class Player extends EventEmitter {
             const manifestRequestSettings = { lowLatencyMode,
                 maxRetry: (_a = requestConfig.manifest) === null || _a === void 0 ? void 0 : _a.maxRetry,
                 requestTimeout: (_b = requestConfig.manifest) === null || _b === void 0 ? void 0 : _b.timeout,
+                connectionTimeout: (_c = requestConfig.manifest) === null || _c === void 0 ? void 0 : _c.connectionTimeout,
                 minimumManifestUpdateInterval,
                 initialManifest };
             const relyOnVideoVisibilityAndSize = canRelyOnVideoVisibilityAndSize();
@@ -332,8 +333,9 @@ class Player extends EventEmitter {
             const bufferOptions = objectAssign({ enableFastSwitching,
                 onCodecSwitch }, this._priv_bufferOptions);
             const segmentRequestOptions = { lowLatencyMode,
-                maxRetry: (_c = requestConfig.segment) === null || _c === void 0 ? void 0 : _c.maxRetry,
-                requestTimeout: (_d = requestConfig.segment) === null || _d === void 0 ? void 0 : _d.timeout };
+                maxRetry: (_d = requestConfig.segment) === null || _d === void 0 ? void 0 : _d.maxRetry,
+                requestTimeout: (_e = requestConfig.segment) === null || _e === void 0 ? void 0 : _e.timeout,
+                connectionTimeout: (_f = requestConfig.segment) === null || _f === void 0 ? void 0 : _f.connectionTimeout };
             initializer = new features.mediaSourceInit({
                 adaptiveOptions,
                 autoPlay,
@@ -457,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;
             }
         };
@@ -1462,6 +1464,27 @@ class Player extends EventEmitter {
         }
         return 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() {
+        if (this._priv_contentInfos === null) {
+            return null;
+        }
+        const { isDirectFile, manifest } = this._priv_contentInfos;
+        if (isDirectFile) {
+            return undefined;
+        }
+        if ((manifest === null || manifest === void 0 ? void 0 : manifest.isLive) !== true) {
+            return null;
+        }
+        return manifest.getLivePosition();
+    }
     /**
      * Get maximum seek-able position.
      * @returns {number}
@@ -1506,9 +1529,11 @@ class Player extends EventEmitter {
         }
         const segmentBufferStatus = this._priv_contentInfos
             .segmentBuffersStore.getStatus(bufferType);
-        return segmentBufferStatus.type === "initialized" ?
-            segmentBufferStatus.value.getInventory() :
-            null;
+        if (segmentBufferStatus.type === "initialized") {
+            segmentBufferStatus.value.synchronizeInventory();
+            return segmentBufferStatus.value.getInventory();
+        }
+        return null;
     }
     /**
      * /!\ For tools use only! Do not touch!
@@ -1950,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,
@@ -1962,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);
@@ -2107,5 +2132,5 @@ class Player extends EventEmitter {
         }
     }
 }
-Player.version = /* PLAYER_VERSION */ "4.0.0-dev.2023111400";
+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/fetchers/manifest/manifest_fetcher.d.ts

@@ -171,6 +171,12 @@ export interface IManifestFetcherSettings {
      * `undefined` will lead to a default, large, timeout being used.
      */
     requestTimeout: number | undefined;
+    /**
+     * Connection timeout, in milliseconds, after which the request is canceled
+     * if the responses headers has not being received.
+     * Do not set or set to "undefined" to disable it.
+     */
+    connectionTimeout: number | undefined;
     /** Limit the frequency of Manifest updates. */
     minimumManifestUpdateInterval: number;
     /**

package/dist/es2017/core/fetchers/manifest/manifest_fetcher.js

@@ -18,7 +18,6 @@ import { formatError } from "../../../errors";
 import log from "../../../log";
 import Manifest from "../../../manifest";
 import EventEmitter from "../../../utils/event_emitter";
-import isNullOrUndefined from "../../../utils/is_null_or_undefined";
 import getMonotonicTimeStamp from "../../../utils/monotonic_timestamp";
 import noop from "../../../utils/noop";
 import TaskCanceller from "../../../utils/task_canceller";
@@ -157,13 +156,22 @@ export default class ManifestFetcher extends EventEmitter {
          */
         function callLoaderWithRetries(manifestUrl) {
             const { loadManifest } = pipelines;
-            let requestTimeout = isNullOrUndefined(settings.requestTimeout) ?
+            let requestTimeout = (settings.requestTimeout === undefined) ?
                 config.getCurrent().DEFAULT_REQUEST_TIMEOUT :
                 settings.requestTimeout;
+            let connectionTimeout = (settings.connectionTimeout === undefined) ?
+                config.getCurrent().DEFAULT_CONNECTION_TIMEOUT :
+                settings.connectionTimeout;
             if (requestTimeout < 0) {
                 requestTimeout = undefined;
             }
-            const callLoader = () => loadManifest(manifestUrl, { timeout: requestTimeout }, cancelSignal);
+            if (connectionTimeout < 0) {
+                connectionTimeout = undefined;
+            }
+            const callLoader = () => loadManifest(manifestUrl, {
+                timeout: requestTimeout,
+                connectionTimeout,
+            }, cancelSignal);
             return scheduleRequestPromise(callLoader, backoffSettings, cancelSignal);
         }
     }

package/dist/es2017/core/fetchers/segment/segment_fetcher.d.ts

@@ -135,14 +135,21 @@ export interface ISegmentFetcherOptions {
      * To set to `-1` for no timeout.
      */
     requestTimeout: number;
+    /**
+     * Connection timeout, in milliseconds, after which the request is canceled
+     * if the responses headers has not being received.
+     * Do not set or set to "undefined" to disable it.
+     */
+    connectionTimeout: number | undefined;
 }
 /**
  * @param {string} bufferType
  * @param {Object}
  * @returns {Object}
  */
-export declare function getSegmentFetcherOptions({ maxRetry, lowLatencyMode, requestTimeout }: {
+export declare function getSegmentFetcherOptions({ maxRetry, lowLatencyMode, requestTimeout, connectionTimeout }: {
     maxRetry?: number | undefined;
     requestTimeout?: number | undefined;
+    connectionTimeout?: number | undefined;
     lowLatencyMode: boolean;
 }): ISegmentFetcherOptions;