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

package/dist/es2017/core/fetchers/segment/segment_fetcher.js

@@ -56,6 +56,8 @@ export default function createSegmentFetcher(bufferType, pipeline, cdnPrioritize
     const requestOptions = {
         timeout: options.requestTimeout < 0 ? undefined :
             options.requestTimeout,
+        connectionTimeout: options.connectionTimeout === undefined ? undefined :
+            options.connectionTimeout < 0 ? undefined : options.connectionTimeout,
     };
     /**
      * Cache audio and video initialization segments.
@@ -283,13 +285,15 @@ export default function createSegmentFetcher(bufferType, pipeline, cdnPrioritize
  * @param {Object}
  * @returns {Object}
  */
-export function getSegmentFetcherOptions({ maxRetry, lowLatencyMode, requestTimeout }) {
-    const { DEFAULT_MAX_REQUESTS_RETRY_ON_ERROR, DEFAULT_REQUEST_TIMEOUT, INITIAL_BACKOFF_DELAY_BASE, MAX_BACKOFF_DELAY_BASE } = config.getCurrent();
+export function getSegmentFetcherOptions({ maxRetry, lowLatencyMode, requestTimeout, connectionTimeout }) {
+    const { DEFAULT_MAX_REQUESTS_RETRY_ON_ERROR, DEFAULT_REQUEST_TIMEOUT, DEFAULT_CONNECTION_TIMEOUT, INITIAL_BACKOFF_DELAY_BASE, MAX_BACKOFF_DELAY_BASE } = config.getCurrent();
     return { maxRetry: maxRetry !== null && maxRetry !== void 0 ? maxRetry : DEFAULT_MAX_REQUESTS_RETRY_ON_ERROR,
         baseDelay: lowLatencyMode ? INITIAL_BACKOFF_DELAY_BASE.LOW_LATENCY :
             INITIAL_BACKOFF_DELAY_BASE.REGULAR,
         maxDelay: lowLatencyMode ? MAX_BACKOFF_DELAY_BASE.LOW_LATENCY :
             MAX_BACKOFF_DELAY_BASE.REGULAR,
-        requestTimeout: isNullOrUndefined(requestTimeout) ? DEFAULT_REQUEST_TIMEOUT :
-            requestTimeout };
+        requestTimeout: (requestTimeout === undefined) ? DEFAULT_REQUEST_TIMEOUT :
+            requestTimeout,
+        connectionTimeout: (connectionTimeout === undefined) ?
+            DEFAULT_CONNECTION_TIMEOUT : connectionTimeout, };
 }

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

@@ -74,4 +74,5 @@ export interface ISegmentFetcherCreatorBackoffOptions {
      * `undefined` will lead to a default, large, timeout being used.
      */
     requestTimeout: number | undefined;
+    connectionTimeout: number | undefined;
 }

package/dist/es2017/core/fetchers/utils/schedule_request.js

@@ -287,7 +287,7 @@ export async function scheduleRequestWithCdns(cdns, cdnPrioritizer, performReque
      * attempts already done for that resource.
      *
      * Returns `undefined` if there's no Cdn left to request the resource.
-     * @param {Array.<Object>}
+     * @param {Array.<Object>} sortedCdns
      * @returns {Object|undefined}
      */
     function getPrioritaryRequestableCdnFromSortedList(sortedCdns) {

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

@@ -20,6 +20,7 @@
 import { clearElementSrc } from "../../compat";
 import log from "../../log";
 import assert from "../../utils/assert";
+import isNullOrUndefined from "../../utils/is_null_or_undefined";
 import SharedReference from "../../utils/reference";
 import TaskCanceller from "../../utils/task_canceller";
 import { ContentInitializer } from "./types";
@@ -152,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) {
@@ -174,10 +181,10 @@ export default class DirectFileContentInitializer extends ContentInitializer {
  * @returns {number}
  */
 function getDirectFileInitialTime(mediaElement, startAt) {
-    if (startAt == null) {
+    if (isNullOrUndefined(startAt)) {
         return 0;
     }
-    if (startAt.position != null) {
+    if (!isNullOrUndefined(startAt.position)) {
         return startAt.position;
     }
     else if (startAt.wallClockTime != null) {
@@ -187,15 +194,31 @@ function getDirectFileInitialTime(mediaElement, startAt) {
         return startAt.fromFirstPosition;
     }
     const duration = mediaElement.duration;
-    if (duration == null || !isFinite(duration)) {
-        log.warn("startAt.fromLastPosition set but no known duration, " +
-            "beginning at 0.");
-        return 0;
-    }
     if (typeof startAt.fromLastPosition === "number") {
+        if (isNullOrUndefined(duration) || !isFinite(duration)) {
+            log.warn("startAt.fromLastPosition set but no known duration, " +
+                "beginning at 0.");
+            return 0;
+        }
         return Math.max(0, duration + startAt.fromLastPosition);
     }
+    else if (typeof startAt.fromLivePosition === "number") {
+        const livePosition = mediaElement.seekable.length > 0 ?
+            mediaElement.seekable.end(0) :
+            duration;
+        if (isNullOrUndefined(livePosition)) {
+            log.warn("startAt.fromLivePosition set but no known live position, " +
+                "beginning at 0.");
+            return 0;
+        }
+        return Math.max(0, livePosition + startAt.fromLivePosition);
+    }
     else if (startAt.percentage != null) {
+        if (isNullOrUndefined(duration) || !isFinite(duration)) {
+            log.warn("startAt.percentage set but no known duration, " +
+                "beginning at 0.");
+            return 0;
+        }
         const { percentage } = startAt;
         if (percentage >= 100) {
             return duration;

package/dist/es2017/core/init/media_source_content_initializer.d.ts

@@ -160,6 +160,12 @@ export interface IInitializeArguments {
          * `-1` indicates no timeout.
          */
         requestTimeout: number | undefined;
+        /**
+         * Amount of time, in milliseconds, after which a request that hasn't receive
+         * the headers and status code should be aborted and optionnaly retried,
+         * depending on the maxRetry configuration.
+         */
+        connectionTimeout: number | undefined;
         /** Maximum number of time a request on error will be retried. */
         maxRetry: number | undefined;
     };

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;
@@ -359,10 +367,10 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
                         if (
                         // Data is buffered around the current position
                         obs.currentRange !== null ||
-                            // Or, for whatever reason, playback is already advancing
-                            obs.position > seekedTime + 0.1) {
+                            // Or, for whatever reason, we have no buffer but we're already advancing
+                            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) {
@@ -512,9 +526,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
         contentTimeBoundariesObserver.addEventListener("periodChange", (period) => {
             this.trigger("activePeriodChanged", { period });
         });
-        contentTimeBoundariesObserver.addEventListener("durationUpdate", (newDuration) => {
-            mediaSourceDurationUpdater.updateDuration(newDuration.duration, newDuration.isEnd);
-        });
+        contentTimeBoundariesObserver.addEventListener("endingPositionChange", (x) => mediaSourceDurationUpdater.updateDuration(x.endingPosition, x.isEnd));
         contentTimeBoundariesObserver.addEventListener("endOfStream", () => {
             if (endOfStreamCanceller === null) {
                 endOfStreamCanceller = new TaskCanceller();
@@ -530,8 +542,8 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
                 endOfStreamCanceller = null;
             }
         });
-        const currentDuration = contentTimeBoundariesObserver.getCurrentDuration();
-        mediaSourceDurationUpdater.updateDuration(currentDuration.duration, currentDuration.isEnd);
+        const endInfo = contentTimeBoundariesObserver.getCurrentEndingTime();
+        mediaSourceDurationUpdater.updateDuration(endInfo.endingPosition, endInfo.isEnd);
         return contentTimeBoundariesObserver;
     }
     /**

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

@@ -22,8 +22,8 @@ import { IStreamOrchestratorPlaybackObservation } from "../../stream";
 /**
  * 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
@@ -56,10 +56,11 @@ export default class ContentTimeBoundariesObserver extends EventEmitter<IContent
      */
     constructor(manifest: Manifest, playbackObserver: IReadOnlyPlaybackObserver<IStreamOrchestratorPlaybackObservation>, bufferTypes: IBufferType[]);
     /**
-     * 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}
      */
-    getCurrentDuration(): IDurationItem;
+    getCurrentEndingTime(): IEndingPositionInformation;
     /**
      * Method to call any time an Adaptation has been selected.
      *
@@ -126,20 +127,20 @@ export default class ContentTimeBoundariesObserver extends EventEmitter<IContent
     private _addActivelyLoadedPeriod;
     private _removeActivelyLoadedPeriod;
     private _checkCurrentPeriod;
-    private _getManifestDuration;
+    private _getManifestEndTime;
     private _lazilyCreateActiveStreamInfo;
     private _checkEndOfStream;
 }
-export interface IDurationItem {
+export interface IEndingPositionInformation {
     /**
      * The new maximum known position (note that this is the ending position
      * currently known of the current content, it might be superior to the last
      * position at which segments are available and it might also evolve over
      * time), in seconds.
      */
-    duration: number;
+    endingPosition: number;
     /**
-     * If `true`, the communicated `duration` is the actual end of the content.
+     * If `true`, the communicated `endingPosition` is the actual end of the content.
      * It may still be updated due to a track change or to add precision, but it
      * is still a (rough) estimate of the maximum position that content should
      * have.
@@ -147,7 +148,7 @@ export interface IDurationItem {
      * If `false`, this is the currently known maximum position associated to
      * the content, but the content is still evolving (typically, new media
      * segments are still being generated) and as such it can still have a
-     * longer duration in the future.
+     * longer `endingPosition` in the future.
      */
     isEnd: boolean;
 }
@@ -161,10 +162,10 @@ export interface IContentTimeBoundariesObserverEvent {
     /** Triggered when a new `Period` is currently playing. */
     periodChange: Period;
     /**
-     * Triggered when the duration of the currently-playing content became known
-     * or changed.
+     * Triggered when the ending position of the currently-playing content became
+     * known or changed.
      */
-    durationUpdate: IDurationItem;
+    endingPositionChange: IEndingPositionInformation;
     /**
      * Triggered when the last possible chronological segment for all types of
      * buffers has either been pushed or is being pushed to the corresponding

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

@@ -21,8 +21,8 @@ import TaskCanceller from "../../../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
@@ -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.");
@@ -65,7 +64,7 @@ export default class ContentTimeBoundariesObserver extends EventEmitter {
             }
         }, { includeLastObservation: true, clearSignal: cancelSignal });
         manifest.addEventListener("manifestUpdate", () => {
-            this.trigger("durationUpdate", this._getManifestDuration());
+            this.trigger("endingPositionChange", this._getManifestEndTime());
             if (cancelSignal.isCancelled()) {
                 return;
             }
@@ -73,11 +72,12 @@ export default class ContentTimeBoundariesObserver extends EventEmitter {
         }, cancelSignal);
     }
     /**
-     * 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}
      */
-    getCurrentDuration() {
-        return this._getManifestDuration();
+    getCurrentEndingTime() {
+        return this._getManifestEndTime();
     }
     /**
      * Method to call any time an Adaptation has been selected.
@@ -106,12 +106,13 @@ export default class ContentTimeBoundariesObserver extends EventEmitter {
                             .updateLastVideoAdaptation(adaptation);
                     }
                     const endingPosition = this._maximumPositionCalculator.getEndingPosition();
-                    const newDuration = endingPosition !== undefined ?
+                    const newEndingPosition = endingPosition !== undefined ?
                         { isEnd: true,
-                            duration: endingPosition } :
+                            endingPosition } :
                         { isEnd: false,
-                            duration: this._maximumPositionCalculator.getMaximumAvailablePosition() };
-                    this.trigger("durationUpdate", newDuration);
+                            endingPosition: this._maximumPositionCalculator
+                                .getMaximumAvailablePosition() };
+                    this.trigger("endingPositionChange", newEndingPosition);
                 }
             }
         }
@@ -238,13 +239,13 @@ export default class ContentTimeBoundariesObserver extends EventEmitter {
             }
         }
     }
-    _getManifestDuration() {
+    _getManifestEndTime() {
         const endingPosition = this._maximumPositionCalculator.getEndingPosition();
         return endingPosition !== undefined ?
             { isEnd: true,
-                duration: endingPosition } :
+                endingPosition } :
             { isEnd: false,
-                duration: this._maximumPositionCalculator.getMaximumAvailablePosition() };
+                endingPosition: this._maximumPositionCalculator.getMaximumAvailablePosition() };
     }
     _lazilyCreateActiveStreamInfo(bufferType) {
         let streamInfo = this._activeStreams.get(bufferType);
@@ -315,9 +316,8 @@ class MaximumPositionCalculator {
      * @returns {number}
      */
     getMaximumAvailablePosition() {
-        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/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>;

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

@@ -24,7 +24,7 @@ import TaskCanceller from "../../../utils/task_canceller";
  * @param {Object} fnCancelSignal - Abort the created PlaybackObserver.
  * @returns {Object}
  */
-export default function createStreamPlaybackObserver(srcPlaybackObserver, { autoPlay, initialPlayPerformed, initialSeekPerformed, manifest, speed, startTime }, fnCancelSignal) {
+export default function createStreamPlaybackObserver(srcPlaybackObserver, { autoPlay, initialPlayPerformed, manifest, speed }, fnCancelSignal) {
     return srcPlaybackObserver.deriveReadOnlyObserver(function transform(observationRef, parentObserverCancelSignal) {
         const canceller = new TaskCanceller();
         canceller.linkToSignal(parentObserverCancelSignal);
@@ -42,11 +42,7 @@ export default function createStreamPlaybackObserver(srcPlaybackObserver, { auto
         function constructStreamPlaybackObservation() {
             const observation = observationRef.getValue();
             const lastSpeed = speed.getValue();
-            let 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.
@@ -54,19 +50,25 @@ export default function createStreamPlaybackObserver(srcPlaybackObserver, { auto
                 // want to seek one second before the period's end (despite never
                 // doing it).
                 const lastPeriod = manifest.periods[manifest.periods.length - 1];
-                if (lastPeriod !== undefined &&
-                    lastPeriod.end !== undefined &&
-                    observation.position > lastPeriod.end) {
-                    pendingPosition = lastPeriod.end - 1;
+                if (lastPeriod !== undefined && lastPeriod.end !== undefined) {
+                    const wantedPosition = observation.position.getWanted();
+                    if (wantedPosition >= lastPeriod.start &&
+                        wantedPosition >= lastPeriod.end - 1) {
+                        // We're after the end of the last Period, check if `buffered`
+                        // indicates that the last segment is probably not loaded, in which
+                        // case act as if we want to load one second before the end.
+                        const buffered = observation.buffered;
+                        if (buffered.length === 0 ||
+                            buffered.end(buffered.length - 1) < observation.duration - 1) {
+                            observation.position.forceWantedPosition(lastPeriod.end - 1);
+                        }
+                    }
                 }
             }
             return {
                 // TODO more exact according to the current Adaptation chosen?
                 maximumPosition: manifest.getMaximumSafePosition(),
-                position: {
-                    last: observation.position,
-                    pending: pendingPosition,
-                },
+                position: observation.position,
                 duration: observation.duration,
                 paused: {
                     last: observation.paused,

package/dist/es2017/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/es2017/core/init/utils/get_initial_time.js

@@ -31,15 +31,10 @@ import getMonotonicTimeStamp from "../../../utils/monotonic_timestamp";
  * @returns {Number}
  */
 export default function getInitialTime(manifest, lowLatencyMode, startAt) {
+    var _a;
     if (!isNullOrUndefined(startAt)) {
         const min = manifest.getMinimumSafePosition();
-        let max;
-        if (manifest.isLive) {
-            max = manifest.getLivePosition();
-        }
-        if (max === undefined) {
-            max = manifest.getMaximumSafePosition();
-        }
+        const max = manifest.getMaximumSafePosition();
         if (!isNullOrUndefined(startAt.position)) {
             log.debug("Init: using startAt.minimumPosition");
             return Math.max(Math.min(startAt.position, max), min);
@@ -64,6 +59,13 @@ export default function getInitialTime(manifest, lowLatencyMode, startAt) {
             return fromLastPosition >= 0 ? max :
                 Math.max(min, max + fromLastPosition);
         }
+        else if (!isNullOrUndefined(startAt.fromLivePosition)) {
+            log.debug("Init: using startAt.fromLivePosition");
+            const livePosition = (_a = manifest.getLivePosition()) !== null && _a !== void 0 ? _a : max;
+            const { fromLivePosition } = startAt;
+            return fromLivePosition >= 0 ? livePosition :
+                Math.max(min, livePosition + fromLivePosition);
+        }
         else if (!isNullOrUndefined(startAt.percentage)) {
             log.debug("Init: using startAt.percentage");
             const { percentage } = startAt;

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