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

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

@@ -49,8 +49,8 @@ var task_canceller_1 = require("../../../utils/task_canceller");
 /**
  * Observes what's being played and take care of media events relating to time
  * boundaries:
- *   - Emits a `durationUpdate` when the duration of the current content is
- *     known and every time it changes.
+ *   - Emits a `endingPositionChange` when the known maximum playable position
+ *     of the current content is known and every time it changes.
  *   - Emits `endOfStream` API once segments have been pushed until the end and
  *     `resumeStream` if downloads starts back.
  *   - Emits a `periodChange` event when the currently-playing Period seemed to
@@ -80,9 +80,8 @@ var ContentTimeBoundariesObserver = /** @class */ (function (_super) {
         _this._maximumPositionCalculator = maximumPositionCalculator;
         var cancelSignal = _this._canceller.signal;
         playbackObserver.listen(function (_a) {
-            var _b;
             var position = _a.position;
-            var wantedPosition = (_b = position.pending) !== null && _b !== void 0 ? _b : position.last;
+            var wantedPosition = position.getWanted();
             if (wantedPosition < manifest.getMinimumSafePosition()) {
                 var warning = new errors_1.MediaError("MEDIA_TIME_BEFORE_MANIFEST", "The current position is behind the " +
                     "earliest time announced in the Manifest.");
@@ -95,7 +94,7 @@ var ContentTimeBoundariesObserver = /** @class */ (function (_super) {
             }
         }, { includeLastObservation: true, clearSignal: cancelSignal });
         manifest.addEventListener("manifestUpdate", function () {
-            _this.trigger("durationUpdate", _this._getManifestDuration());
+            _this.trigger("endingPositionChange", _this._getManifestEndTime());
             if (cancelSignal.isCancelled()) {
                 return;
             }
@@ -104,11 +103,12 @@ var ContentTimeBoundariesObserver = /** @class */ (function (_super) {
         return _this;
     }
     /**
-     * Returns an estimate of the current duration of the content.
+     * Returns an estimate of the current last position which may be played in
+     * the content at the moment.
      * @returns {Object}
      */
-    ContentTimeBoundariesObserver.prototype.getCurrentDuration = function () {
-        return this._getManifestDuration();
+    ContentTimeBoundariesObserver.prototype.getCurrentEndingTime = function () {
+        return this._getManifestEndTime();
     };
     /**
      * Method to call any time an Adaptation has been selected.
@@ -137,12 +137,12 @@ var ContentTimeBoundariesObserver = /** @class */ (function (_super) {
                             .updateLastVideoAdaptation(adaptation);
                     }
                     var endingPosition = this._maximumPositionCalculator.getEndingPosition();
-                    var newDuration = endingPosition !== undefined ?
-                        { isEnd: true,
-                            duration: endingPosition } :
+                    var newEndingPosition = endingPosition !== undefined ?
+                        { isEnd: true, endingPosition: endingPosition } :
                         { isEnd: false,
-                            duration: this._maximumPositionCalculator.getMaximumAvailablePosition() };
-                    this.trigger("durationUpdate", newDuration);
+                            endingPosition: this._maximumPositionCalculator
+                                .getMaximumAvailablePosition() };
+                    this.trigger("endingPositionChange", newEndingPosition);
                 }
             }
         }
@@ -286,13 +286,12 @@ var ContentTimeBoundariesObserver = /** @class */ (function (_super) {
             finally { if (e_1) throw e_1.error; }
         }
     };
-    ContentTimeBoundariesObserver.prototype._getManifestDuration = function () {
+    ContentTimeBoundariesObserver.prototype._getManifestEndTime = function () {
         var endingPosition = this._maximumPositionCalculator.getEndingPosition();
         return endingPosition !== undefined ?
-            { isEnd: true,
-                duration: endingPosition } :
+            { isEnd: true, endingPosition: endingPosition } :
             { isEnd: false,
-                duration: this._maximumPositionCalculator.getMaximumAvailablePosition() };
+                endingPosition: this._maximumPositionCalculator.getMaximumAvailablePosition() };
     };
     ContentTimeBoundariesObserver.prototype._lazilyCreateActiveStreamInfo = function (bufferType) {
         var streamInfo = this._activeStreams.get(bufferType);
@@ -366,9 +365,8 @@ var MaximumPositionCalculator = /** @class */ (function () {
      * @returns {number}
      */
     MaximumPositionCalculator.prototype.getMaximumAvailablePosition = function () {
-        var _a;
         if (this._manifest.isDynamic) {
-            return (_a = this._manifest.getLivePosition()) !== null && _a !== void 0 ? _a : this._manifest.getMaximumSafePosition();
+            return this._manifest.getMaximumSafePosition();
         }
         if (this._lastVideoAdaptation === undefined ||
             this._lastAudioAdaptation === undefined) {

package/dist/commonjs/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>;

package/dist/commonjs/core/init/utils/create_stream_playback_observer.js

@@ -27,7 +27,7 @@ var task_canceller_1 = require("../../../utils/task_canceller");
  * @returns {Object}
  */
 function createStreamPlaybackObserver(srcPlaybackObserver, _a, fnCancelSignal) {
-    var autoPlay = _a.autoPlay, initialPlayPerformed = _a.initialPlayPerformed, initialSeekPerformed = _a.initialSeekPerformed, manifest = _a.manifest, speed = _a.speed, startTime = _a.startTime;
+    var autoPlay = _a.autoPlay, initialPlayPerformed = _a.initialPlayPerformed, manifest = _a.manifest, speed = _a.speed;
     return srcPlaybackObserver.deriveReadOnlyObserver(function transform(observationRef, parentObserverCancelSignal) {
         var canceller = new task_canceller_1.default();
         canceller.linkToSignal(parentObserverCancelSignal);
@@ -45,11 +45,7 @@ function createStreamPlaybackObserver(srcPlaybackObserver, _a, fnCancelSignal) {
         function constructStreamPlaybackObservation() {
             var observation = observationRef.getValue();
             var lastSpeed = speed.getValue();
-            var pendingPosition;
-            if (!initialSeekPerformed.getValue()) {
-                pendingPosition = startTime;
-            }
-            else if (!manifest.isDynamic || manifest.isLastPeriodKnown) {
+            if (!manifest.isDynamic || manifest.isLastPeriodKnown) {
                 // HACK: When the position is actually further than the maximum
                 // position for a finished content, we actually want to be loading
                 // the last segment before ending.
@@ -57,19 +53,25 @@ function createStreamPlaybackObserver(srcPlaybackObserver, _a, fnCancelSignal) {
                 // want to seek one second before the period's end (despite never
                 // doing it).
                 var lastPeriod = manifest.periods[manifest.periods.length - 1];
-                if (lastPeriod !== undefined &&
-                    lastPeriod.end !== undefined &&
-                    observation.position > lastPeriod.end) {
-                    pendingPosition = lastPeriod.end - 1;
+                if (lastPeriod !== undefined && lastPeriod.end !== undefined) {
+                    var wantedPosition = observation.position.getWanted();
+                    if (wantedPosition >= lastPeriod.start &&
+                        wantedPosition >= lastPeriod.end - 1) {
+                        // We're after the end of the last Period, check if `buffered`
+                        // indicates that the last segment is probably not loaded, in which
+                        // case act as if we want to load one second before the end.
+                        var buffered = observation.buffered;
+                        if (buffered.length === 0 ||
+                            buffered.end(buffered.length - 1) < observation.duration - 1) {
+                            observation.position.forceWantedPosition(lastPeriod.end - 1);
+                        }
+                    }
                 }
             }
             return {
                 // TODO more exact according to the current Adaptation chosen?
                 maximumPosition: manifest.getMaximumSafePosition(),
-                position: {
-                    last: observation.position,
-                    pending: pendingPosition,
-                },
+                position: observation.position,
                 duration: observation.duration,
                 paused: {
                     last: observation.paused,

package/dist/commonjs/core/init/utils/get_initial_time.d.ts

@@ -37,11 +37,25 @@ export interface IInitialTimeOptions {
      */
     fromFirstPosition?: number | null | undefined;
     /**
-     * If set, we should begin at this position relative to the content's end,
-     * in seconds.
+     * If set, we should begin at this position relative to the content's maximum
+     * seekable position, in seconds.
+     *
+     * It should consequently in most cases be a negative value.
      */
     fromLastPosition?: number | null | undefined;
-    /** If set, we should begin at this position relative to the whole duration of
+    /**
+     * If set, we should begin at this position relative to the content's live
+     * edge if it makes sense, in seconds.
+     *
+     * It should consequently in most cases be a negative value.
+     *
+     * If the live edge is unknown or if it does not make sense for the current
+     * content, that position is relative to the content's maximum position
+     * instead.
+     */
+    fromLivePosition?: number | null | undefined;
+    /**
+     * If set, we should begin at this position relative to the whole duration of
      * the content, in percentage.
      */
     percentage?: number | null | undefined;

package/dist/commonjs/core/init/utils/get_initial_time.js

@@ -33,15 +33,10 @@ var monotonic_timestamp_1 = require("../../../utils/monotonic_timestamp");
  * @returns {Number}
  */
 function getInitialTime(manifest, lowLatencyMode, startAt) {
+    var _a;
     if (!(0, is_null_or_undefined_1.default)(startAt)) {
         var min = manifest.getMinimumSafePosition();
-        var max = void 0;
-        if (manifest.isLive) {
-            max = manifest.getLivePosition();
-        }
-        if (max === undefined) {
-            max = manifest.getMaximumSafePosition();
-        }
+        var max = manifest.getMaximumSafePosition();
         if (!(0, is_null_or_undefined_1.default)(startAt.position)) {
             log_1.default.debug("Init: using startAt.minimumPosition");
             return Math.max(Math.min(startAt.position, max), min);
@@ -66,6 +61,13 @@ function getInitialTime(manifest, lowLatencyMode, startAt) {
             return fromLastPosition >= 0 ? max :
                 Math.max(min, max + fromLastPosition);
         }
+        else if (!(0, is_null_or_undefined_1.default)(startAt.fromLivePosition)) {
+            log_1.default.debug("Init: using startAt.fromLivePosition");
+            var livePosition = (_a = manifest.getLivePosition()) !== null && _a !== void 0 ? _a : max;
+            var fromLivePosition = startAt.fromLivePosition;
+            return fromLivePosition >= 0 ? livePosition :
+                Math.max(min, livePosition + fromLivePosition);
+        }
         else if (!(0, is_null_or_undefined_1.default)(startAt.percentage)) {
             log_1.default.debug("Init: using startAt.percentage");
             var percentage = startAt.percentage;

package/dist/commonjs/core/init/utils/initial_seek_and_play.d.ts

@@ -38,11 +38,6 @@ export type IInitialPlayEvent =
 export interface IInitialSeekAndPlayObject {
     /** Emit the result of the auto-play operation, once performed. */
     autoPlayResult: Promise<IInitialPlayEvent>;
-    /**
-     * Shared reference whose value becomes `true` once the initial seek has
-     * been considered / has been done by `performInitialSeekAndPlay`.
-     */
-    initialSeekPerformed: IReadOnlySharedReference<boolean>;
     /**
      * Shared reference whose value becomes `true` once the initial play has
      * been considered / has been done by `performInitialSeekAndPlay`.
@@ -52,12 +47,15 @@ export interface IInitialSeekAndPlayObject {
 /**
  * Seek as soon as possible at the initially wanted position and play if
  * autoPlay is wanted.
- * @param {HTMLMediaElement} mediaElement
- * @param {Object} playbackObserver
- * @param {number|Function} startTime
- * @param {boolean} mustAutoPlay
- * @param {Function} onWarning
+ * @param {Object} args
  * @param {Object} cancelSignal
  * @returns {Object}
  */
-export default function performInitialSeekAndPlay(mediaElement: HTMLMediaElement, playbackObserver: PlaybackObserver, startTime: number | (() => number), mustAutoPlay: boolean, onWarning: (err: IPlayerError) => void, cancelSignal: CancellationSignal): IInitialSeekAndPlayObject;
+export default function performInitialSeekAndPlay({ mediaElement, playbackObserver, startTime, mustAutoPlay, isDirectfile, onWarning }: {
+    mediaElement: HTMLMediaElement;
+    playbackObserver: PlaybackObserver;
+    startTime: number | (() => number);
+    mustAutoPlay: boolean;
+    isDirectfile: boolean;
+    onWarning: (err: IPlayerError) => void;
+}, cancelSignal: CancellationSignal): IInitialSeekAndPlayObject;

package/dist/commonjs/core/init/utils/initial_seek_and_play.js

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