rx-player 3.27.1-dev.2022040500 → 3.27.1-dev.2022041500

package/CHANGELOG.md

@@ -1,11 +1,16 @@
 # Changelog
 
-## v3.27.1-dev.2022040500 (2022-04-05)
+## v3.27.1-dev.2022041500 (2022-04-15)
 
 ### Bug fixes
 
- - When creating SourceBuffers, use the first _supported_ codec of the chosen `Adaptation`, not the lowest-bitrate one [#1094]
+  - Use the first compatible codec of the current AdaptationSet when creating a SourceBuffer [#1094]
+  - DASH: fix wrong segment estimates on some SegmentTimeline-based contents where the last segment has a negative `S@d` attribute set in the MPD [#1098]
 
+### Other improvements
+
+  - Update duration of a content based on the last chosen tracks [#1102]
+  - If seeking after the last potential position, load last segments before ending [#1097]
 
 ## v3.27.0 (2022-03-31)
 

package/VERSION

@@ -1 +1 @@
-3.27.1-dev.2022040500
+3.27.1-dev.2022041500

package/dist/_esm5.processed/core/abr/abr_manager.d.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 import { Observable } from "rxjs";
-import { Representation } from "../../manifest";
+import Manifest, { Adaptation, Period, Representation } from "../../manifest";
 import { ISharedReference } from "../../utils/reference";
 import { IBufferType } from "../segment_buffers";
 import { IABREstimate, IABRStreamEvents, IRepresentationEstimatorPlaybackObservation } from "./representation_estimator";
@@ -59,13 +59,17 @@ export default class ABRManager {
      * Take type and an array of the available representations, spit out an
      * observable emitting the best representation (given the network/buffer
      * state).
-     * @param {string} type
+     * @param {Object} context
      * @param {Array.<Representation>} representations
      * @param {Observable<Object>} observation$
      * @param {Observable<Object>} streamEvents$
      * @returns {Observable}
      */
-    get$(type: IBufferType, representations: Representation[], observation$: Observable<IABRManagerPlaybackObservation>, streamEvents$: Observable<IABRStreamEvents>): Observable<IABREstimate>;
+    get$(context: {
+        manifest: Manifest;
+        period: Period;
+        adaptation: Adaptation;
+    }, representations: Representation[], observation$: Observable<IABRManagerPlaybackObservation>, streamEvents$: Observable<IABRStreamEvents>): Observable<IABREstimate>;
     /**
      * @param {string} bufferType
      * @returns {Object}

package/dist/_esm5.processed/core/abr/abr_manager.js

@@ -52,21 +52,22 @@ var ABRManager = /** @class */ (function () {
      * Take type and an array of the available representations, spit out an
      * observable emitting the best representation (given the network/buffer
      * state).
-     * @param {string} type
+     * @param {Object} context
      * @param {Array.<Representation>} representations
      * @param {Observable<Object>} observation$
      * @param {Observable<Object>} streamEvents$
      * @returns {Observable}
      */
-    ABRManager.prototype.get$ = function (type, representations, observation$, streamEvents$) {
+    ABRManager.prototype.get$ = function (context, representations, observation$, streamEvents$) {
         var _a, _b, _c;
+        var type = context.adaptation.type;
         var bandwidthEstimator = this._getBandwidthEstimator(type);
         var manualBitrate$ = takeFirstSet((_a = this._manualBitrates[type]) === null || _a === void 0 ? void 0 : _a.asObservable(), observableOf(-1));
         var minAutoBitrate$ = takeFirstSet((_b = this._minAutoBitrates[type]) === null || _b === void 0 ? void 0 : _b.asObservable(), observableOf(0));
         var maxAutoBitrate$ = takeFirstSet((_c = this._maxAutoBitrates[type]) === null || _c === void 0 ? void 0 : _c.asObservable(), observableOf(Infinity));
         var initialBitrate = takeFirstSet(this._initialBitrates[type], 0);
         var filters$ = createFilters(this._throttlers.limitWidth[type], this._throttlers.throttleBitrate[type], this._throttlers.throttle[type]);
-        return RepresentationEstimator({ bandwidthEstimator: bandwidthEstimator, streamEvents$: streamEvents$, observation$: observation$, filters$: filters$, initialBitrate: initialBitrate, manualBitrate$: manualBitrate$, minAutoBitrate$: minAutoBitrate$, maxAutoBitrate$: maxAutoBitrate$, representations: representations, lowLatencyMode: this._lowLatencyMode });
+        return RepresentationEstimator({ bandwidthEstimator: bandwidthEstimator, context: context, streamEvents$: streamEvents$, observation$: observation$, filters$: filters$, initialBitrate: initialBitrate, manualBitrate$: manualBitrate$, minAutoBitrate$: minAutoBitrate$, maxAutoBitrate$: maxAutoBitrate$, representations: representations, lowLatencyMode: this._lowLatencyMode });
     };
     /**
      * @param {string} bufferType

package/dist/_esm5.processed/core/abr/representation_estimator.d.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 import { Observable } from "rxjs";
-import { Adaptation, ISegment, Representation } from "../../manifest";
+import Manifest, { Adaptation, ISegment, Period, Representation } from "../../manifest";
 import BandwidthEstimator from "./bandwidth_estimator";
 import { IPendingRequestStoreBegin, IPendingRequestStoreProgress } from "./pending_requests_store";
 /**
@@ -100,12 +100,8 @@ export interface IRepresentationEstimatorPlaybackObservation {
     speed: number;
     /** `duration` property of the HTMLMediaElement on which the content plays. */
     duration: number;
-    /**
-     * For live contents only, difference between the maximum playable position
-     * and the current position.
-     * `undefined` for non-live contents.
-     */
-    liveGap: number | undefined;
+    /** Theoretical maximum position on the content that can currently be played. */
+    maximumPosition: number;
 }
 /** Content of the `IABRMetricsEvent` event's payload. */
 export interface IABRMetricsEventValue {
@@ -304,6 +300,15 @@ export interface IRepresentationEstimatorArguments {
     maxAutoBitrate$: Observable<number>;
     /** The list of Representations the `RepresentationEstimator` can choose from. */
     representations: Representation[];
+    /** Context for the list of Representations to choose. */
+    context: {
+        /** In which Manifest the Representations are. */
+        manifest: Manifest;
+        /** In which Period the Representations are. */
+        period: Period;
+        /** In which Adaptation the Representations are. */
+        adaptation: Adaptation;
+    };
 }
 /**
  * Estimate regularly the current network bandwidth and the best Representation
@@ -317,4 +322,4 @@ export interface IRepresentationEstimatorArguments {
  * @param {Object} args
  * @returns {Observable}
  */
-export default function RepresentationEstimator({ bandwidthEstimator, observation$, filters$, initialBitrate, lowLatencyMode, manualBitrate$, minAutoBitrate$, maxAutoBitrate$, representations, streamEvents$, }: IRepresentationEstimatorArguments): Observable<IABREstimate>;
+export default function RepresentationEstimator({ bandwidthEstimator, context, observation$, filters$, initialBitrate, lowLatencyMode, manualBitrate$, minAutoBitrate$, maxAutoBitrate$, representations, streamEvents$, }: IRepresentationEstimatorArguments): Observable<IABREstimate>;

package/dist/_esm5.processed/core/abr/representation_estimator.js

@@ -54,7 +54,7 @@ function getFilteredRepresentations(representations, filters) {
  * @returns {Observable}
  */
 export default function RepresentationEstimator(_a) {
-    var bandwidthEstimator = _a.bandwidthEstimator, observation$ = _a.observation$, filters$ = _a.filters$, initialBitrate = _a.initialBitrate, lowLatencyMode = _a.lowLatencyMode, manualBitrate$ = _a.manualBitrate$, minAutoBitrate$ = _a.minAutoBitrate$, maxAutoBitrate$ = _a.maxAutoBitrate$, representations = _a.representations, streamEvents$ = _a.streamEvents$;
+    var bandwidthEstimator = _a.bandwidthEstimator, context = _a.context, observation$ = _a.observation$, filters$ = _a.filters$, initialBitrate = _a.initialBitrate, lowLatencyMode = _a.lowLatencyMode, manualBitrate$ = _a.manualBitrate$, minAutoBitrate$ = _a.minAutoBitrate$, maxAutoBitrate$ = _a.maxAutoBitrate$, representations = _a.representations, streamEvents$ = _a.streamEvents$;
     var scoreCalculator = new RepresentationScoreCalculator();
     var networkAnalyzer = new NetworkAnalyzer(initialBitrate == null ? 0 :
         initialBitrate, lowLatencyMode);
@@ -145,7 +145,7 @@ export default function RepresentationEstimator(_a) {
                 filters$,
                 bufferBasedEstimation$]).pipe(withLatestFrom(currentRepresentation$), map(function (_a) {
                 var _b = _a[0], observation = _b[0], minAutoBitrate = _b[1], maxAutoBitrate = _b[2], filters = _b[3], bufferBasedBitrate = _b[4], currentRepresentation = _a[1];
-                var bufferGap = observation.bufferGap, liveGap = observation.liveGap;
+                var bufferGap = observation.bufferGap, position = observation.position, maximumPosition = observation.maximumPosition;
                 var filteredReps = getFilteredRepresentations(representations, filters);
                 var requests = requestsStore.getRequests();
                 var _c = networkAnalyzer
@@ -206,8 +206,8 @@ export default function RepresentationEstimator(_a) {
                 var chosenRepFromGuessMode = null;
                 if (lowLatencyMode &&
                     currentRepresentation !== null &&
-                    liveGap !== undefined &&
-                    liveGap < 40) {
+                    context.manifest.isDynamic &&
+                    maximumPosition - position < 40) {
                     chosenRepFromGuessMode = guessBasedChooser.getGuess(representations, observation, currentRepresentation, currentBestBitrate, requests);
                 }
                 if (chosenRepFromGuessMode !== null &&

package/dist/_esm5.processed/core/api/public_api.js

@@ -87,7 +87,7 @@ var Player = /** @class */ (function (_super) {
         // 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 */ "3.27.1-dev.2022040500";
+        _this.version = /* PLAYER_VERSION */ "3.27.1-dev.2022041500";
         _this.log = log;
         _this.state = "STOPPED";
         _this.videoElement = videoElement;
@@ -1102,13 +1102,7 @@ var Player = /** @class */ (function (_super) {
         if (positionWanted === undefined) {
             throw new Error("invalid time given");
         }
-        var seekAt = positionWanted;
-        if (manifest !== null && !manifest.isLive) {
-            var maximumTime = manifest.getMaximumPosition();
-            seekAt = maximumTime !== undefined ? Math.min(positionWanted, maximumTime - 0.001) :
-                positionWanted;
-        }
-        this.videoElement.currentTime = seekAt;
+        this.videoElement.currentTime = positionWanted;
         return positionWanted;
     };
     /**
@@ -1691,7 +1685,7 @@ var Player = /** @class */ (function (_super) {
         }
         var manifest = this._priv_contentInfos.manifest;
         if (manifest !== null) {
-            return manifest.getMinimumPosition();
+            return manifest.getMinimumSafePosition();
         }
         return null;
     };
@@ -1711,7 +1705,10 @@ var Player = /** @class */ (function (_super) {
             return this.videoElement.duration;
         }
         if (manifest !== null) {
-            return manifest.getMaximumPosition();
+            if (!manifest.isDynamic && this.videoElement !== null) {
+                return this.videoElement.duration;
+            }
+            return manifest.getMaximumSafePosition();
         }
         return null;
     };
@@ -2236,7 +2233,7 @@ var Player = /** @class */ (function (_super) {
             return;
         }
         this._priv_lastContentPlaybackInfos.lastPlaybackPosition = observation.position;
-        var maximumPosition = manifest !== null ? manifest.getMaximumPosition() :
+        var maximumPosition = manifest !== null ? manifest.getMaximumSafePosition() :
             undefined;
         var positionData = {
             position: observation.position,
@@ -2248,12 +2245,14 @@ var Player = /** @class */ (function (_super) {
                 0,
         };
         if (manifest !== null &&
-            maximumPosition !== undefined &&
             manifest.isLive &&
             observation.position > 0) {
             var ast = (_a = manifest.availabilityStartTime) !== null && _a !== void 0 ? _a : 0;
             positionData.wallClockTime = observation.position + ast;
-            positionData.liveGap = maximumPosition - observation.position;
+            var livePosition = manifest.getLivePosition();
+            if (livePosition !== undefined) {
+                positionData.liveGap = livePosition - observation.position;
+            }
         }
         else if (isDirectFile && this.videoElement !== null) {
             var startDate = getStartDate(this.videoElement);
@@ -2302,5 +2301,5 @@ var Player = /** @class */ (function (_super) {
     };
     return Player;
 }(EventEmitter));
-Player.version = /* PLAYER_VERSION */ "3.27.1-dev.2022040500";
+Player.version = /* PLAYER_VERSION */ "3.27.1-dev.2022041500";
 export default Player;

package/dist/_esm5.processed/core/init/content_time_boundaries_observer.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Observable } from "rxjs";
+import Manifest from "../../manifest";
+import { IReadOnlyPlaybackObserver } from "../api";
+import { IStreamOrchestratorEvent } from "../stream";
+import { IWarningEvent } from "./types";
+/**
+ * Observes the position and Adaptations being played and deduce various events
+ * related to the available time boundaries:
+ *  - Emit when the theoretical duration of the content becomes known or when it
+ *    changes.
+ *  - Emit warnings when the duration goes out of what is currently
+ *    theoretically playable.
+ *
+ * @param {Object} manifest
+ * @param {Observable} streams
+ * @param {Object} playbackObserver
+ * @returns {Observable}
+ */
+export default function ContentTimeBoundariesObserver(manifest: Manifest, streams: Observable<IStreamOrchestratorEvent>, playbackObserver: IReadOnlyPlaybackObserver<IContentTimeObserverPlaybackObservation>): Observable<IContentDurationUpdateEvent | IWarningEvent>;
+/**
+ * Emitted when the duration of the full content (== the last playable position)
+ * has changed.
+ */
+export interface IContentDurationUpdateEvent {
+    type: "contentDurationUpdate";
+    /** The new theoretical duration, `undefined` if unknown, */
+    value: number | undefined;
+}
+export interface IContentTimeObserverPlaybackObservation {
+    /** The position we are in the video in seconds at the time of the observation. */
+    position: number;
+    /**
+     * Offset, in seconds to add to `position` to obtain the starting position at
+     * which we actually want to download segments for.
+     */
+    wantedTimeOffset: number;
+}

package/dist/_esm5.processed/core/init/content_time_boundaries_observer.js

@@ -0,0 +1,223 @@
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { distinctUntilChanged, ignoreElements, map, merge as observableMerge, skipWhile, startWith, tap, } from "rxjs";
+import { MediaError } from "../../errors";
+import { fromEvent } from "../../utils/event_emitter";
+import filterMap from "../../utils/filter_map";
+import createSharedReference from "../../utils/reference";
+import EVENTS from "./events_generators";
+// NOTE As of now (RxJS 7.4.0), RxJS defines `ignoreElements` default
+// first type parameter as `any` instead of the perfectly fine `unknown`,
+// leading to linter issues, as it forbids the usage of `any`.
+// This is why we're disabling the eslint rule.
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+/**
+ * Observes the position and Adaptations being played and deduce various events
+ * related to the available time boundaries:
+ *  - Emit when the theoretical duration of the content becomes known or when it
+ *    changes.
+ *  - Emit warnings when the duration goes out of what is currently
+ *    theoretically playable.
+ *
+ * @param {Object} manifest
+ * @param {Observable} streams
+ * @param {Object} playbackObserver
+ * @returns {Observable}
+ */
+export default function ContentTimeBoundariesObserver(manifest, streams, playbackObserver) {
+    /**
+     * Allows to calculate the minimum and maximum playable position on the
+     * whole content.
+     */
+    var maximumPositionCalculator = new MaximumPositionCalculator(manifest);
+    // trigger warnings when the wanted time is before or after the manifest's
+    // segments
+    var outOfManifest$ = playbackObserver.observe(true).pipe(filterMap(function (_a) {
+        var position = _a.position, wantedTimeOffset = _a.wantedTimeOffset;
+        var offsetedPosition = wantedTimeOffset + position;
+        if (offsetedPosition < manifest.getMinimumSafePosition()) {
+            var warning = new MediaError("MEDIA_TIME_BEFORE_MANIFEST", "The current position is behind the " +
+                "earliest time announced in the Manifest.");
+            return EVENTS.warning(warning);
+        }
+        else if (offsetedPosition > maximumPositionCalculator.getCurrentMaximumPosition()) {
+            var warning = new MediaError("MEDIA_TIME_AFTER_MANIFEST", "The current position is after the latest " +
+                "time announced in the Manifest.");
+            return EVENTS.warning(warning);
+        }
+        return null;
+    }, null));
+    /**
+     * Contains the content duration according to the last audio and video
+     * Adaptation chosen for the last Period.
+     * `undefined` if unknown yet.
+     */
+    var contentDuration = createSharedReference(undefined);
+    var updateDurationOnManifestUpdate$ = fromEvent(manifest, "manifestUpdate").pipe(startWith(null), tap(function () {
+        if (!manifest.isDynamic) {
+            var maxPos = maximumPositionCalculator.getCurrentMaximumPosition();
+            contentDuration.setValue(maxPos);
+        }
+        else {
+            // TODO handle finished dynamic contents?
+            contentDuration.setValue(undefined);
+        }
+    }), ignoreElements());
+    var updateDurationAndTimeBoundsOnTrackChange$ = streams.pipe(tap(function (message) {
+        if (message.type === "adaptationChange") {
+            var lastPeriod = manifest.periods[manifest.periods.length - 1];
+            if (message.value.period.id === (lastPeriod === null || lastPeriod === void 0 ? void 0 : lastPeriod.id)) {
+                if (message.value.type === "audio") {
+                    maximumPositionCalculator
+                        .updateLastAudioAdaptation(message.value.adaptation);
+                    if (!manifest.isDynamic) {
+                        contentDuration.setValue(maximumPositionCalculator.getCurrentMaximumPosition());
+                    }
+                }
+                else if (message.value.type === "video") {
+                    maximumPositionCalculator
+                        .updateLastVideoAdaptation(message.value.adaptation);
+                    if (!manifest.isDynamic) {
+                        contentDuration.setValue(maximumPositionCalculator.getCurrentMaximumPosition());
+                    }
+                }
+            }
+        }
+    }), ignoreElements());
+    return observableMerge(updateDurationOnManifestUpdate$, updateDurationAndTimeBoundsOnTrackChange$, outOfManifest$, contentDuration.asObservable().pipe(skipWhile(function (val) { return val === undefined; }), distinctUntilChanged(), map(function (value) { return ({ type: "contentDurationUpdate", value: value }); })));
+}
+/**
+ * Calculate the last position from the last chosen audio and video Adaptations
+ * for the last Period (or a default one, if no Adaptations has been chosen).
+ * @class MaximumPositionCalculator
+ */
+var MaximumPositionCalculator = /** @class */ (function () {
+    /**
+     * @param {Object} manifest
+     */
+    function MaximumPositionCalculator(manifest) {
+        this._manifest = manifest;
+        this._lastAudioAdaptation = undefined;
+        this._lastVideoAdaptation = undefined;
+    }
+    /**
+     * Update the last known audio Adaptation for the last Period.
+     * If no Adaptation has been set, it should be set to `null`.
+     *
+     * Allows to calculate the maximum position more precizely in
+     * `getCurrentMaximumPosition`.
+     * @param {Object|null} adaptation
+     */
+    MaximumPositionCalculator.prototype.updateLastAudioAdaptation = function (adaptation) {
+        this._lastAudioAdaptation = adaptation;
+    };
+    /**
+     * Update the last known video Adaptation for the last Period.
+     * If no Adaptation has been set, it should be set to `null`.
+     *
+     * Allows to calculate the maximum position more precizely in
+     * `getCurrentMaximumPosition`.
+     * @param {Object|null} adaptation
+     */
+    MaximumPositionCalculator.prototype.updateLastVideoAdaptation = function (adaptation) {
+        this._lastVideoAdaptation = adaptation;
+    };
+    /**
+     * Returns an estimate of the maximum position reachable under the current
+     * circumstances.
+     * @returns {number}
+     */
+    MaximumPositionCalculator.prototype.getCurrentMaximumPosition = function () {
+        var _a;
+        if (this._manifest.isDynamic) {
+            return (_a = this._manifest.getLivePosition()) !== null && _a !== void 0 ? _a : this._manifest.getMaximumSafePosition();
+        }
+        if (this._lastVideoAdaptation === undefined ||
+            this._lastAudioAdaptation === undefined) {
+            return this._manifest.getMaximumSafePosition();
+        }
+        else if (this._lastAudioAdaptation === null) {
+            if (this._lastVideoAdaptation === null) {
+                return this._manifest.getMaximumSafePosition();
+            }
+            else {
+                var lastVideoPosition = getLastPositionFromAdaptation(this._lastVideoAdaptation);
+                if (typeof lastVideoPosition !== "number") {
+                    return this._manifest.getMaximumSafePosition();
+                }
+                return lastVideoPosition;
+            }
+        }
+        else if (this._lastVideoAdaptation === null) {
+            var lastAudioPosition = getLastPositionFromAdaptation(this._lastAudioAdaptation);
+            if (typeof lastAudioPosition !== "number") {
+                return this._manifest.getMaximumSafePosition();
+            }
+            return lastAudioPosition;
+        }
+        else {
+            var lastAudioPosition = getLastPositionFromAdaptation(this._lastAudioAdaptation);
+            var lastVideoPosition = getLastPositionFromAdaptation(this._lastVideoAdaptation);
+            if (typeof lastAudioPosition !== "number" ||
+                typeof lastVideoPosition !== "number") {
+                return this._manifest.getMaximumSafePosition();
+            }
+            else {
+                return Math.min(lastAudioPosition, lastVideoPosition);
+            }
+        }
+    };
+    return MaximumPositionCalculator;
+}());
+/**
+ * Returns "last time of reference" from the adaptation given.
+ * `undefined` if a time could not be found.
+ * Null if the Adaptation has no segments (it could be that it didn't started or
+ * that it already finished for example).
+ *
+ * We consider the earliest last time from every representations in the given
+ * adaptation.
+ * @param {Object} adaptation
+ * @returns {Number|undefined|null}
+ */
+function getLastPositionFromAdaptation(adaptation) {
+    var representations = adaptation.representations;
+    var min = null;
+    /**
+     * Some Manifest parsers use the exact same `IRepresentationIndex` reference
+     * for each Representation of a given Adaptation, because in the actual source
+     * Manifest file, indexing data is often defined at Adaptation-level.
+     * This variable allows to optimize the logic here when this is the case.
+     */
+    var lastIndex;
+    for (var i = 0; i < representations.length; i++) {
+        if (representations[i].index !== lastIndex) {
+            lastIndex = representations[i].index;
+            var lastPosition = representations[i].index.getLastPosition();
+            if (lastPosition === undefined) { // we cannot tell
+                return undefined;
+            }
+            if (lastPosition !== null) {
+                min = min == null ? lastPosition :
+                    Math.min(min, lastPosition);
+            }
+        }
+    }
+    if (min === null) { // It means that all positions were null === no segments (yet?)
+        return null;
+    }
+    return min;
+}

package/dist/_esm5.processed/core/init/create_stream_playback_observer.js

@@ -25,10 +25,23 @@ export default function createStreamPlaybackObserver(manifest, playbackObserver,
     return playbackObserver.deriveReadOnlyObserver(function mapObservable(observation$) {
         return observableCombineLatest([observation$, speed.asObservable()]).pipe(map(function (_a) {
             var observation = _a[0], lastSpeed = _a[1];
+            var wantedTimeOffset = 0;
+            if (!initialSeekPerformed.getValue()) {
+                wantedTimeOffset = startTime - observation.position;
+            }
+            else if (!manifest.isDynamic || manifest.isLastPeriodKnown) {
+                var lastPeriod = manifest.periods[manifest.periods.length - 1];
+                if (lastPeriod !== undefined &&
+                    lastPeriod.end !== undefined &&
+                    observation.position > lastPeriod.end) {
+                    wantedTimeOffset = lastPeriod.end -
+                        observation.position -
+                        1;
+                }
+            }
             return {
-                liveGap: manifest.isLive ?
-                    manifest.getMaximumPosition() - observation.position :
-                    undefined,
+                // TODO more exact according to the current Adaptation chosen?
+                maximumPosition: manifest.getMaximumSafePosition(),
                 position: observation.position,
                 duration: observation.duration,
                 isPaused: initialPlayPerformed.getValue() ? observation.paused :
@@ -41,9 +54,7 @@ export default function createStreamPlaybackObserver(manifest, playbackObserver,
                 // initial position, the currentTime will most probably be 0 where the
                 // effective starting position will be _startTime_.
                 // Thus we initially set a wantedTimeOffset equal to startTime.
-                wantedTimeOffset: initialSeekPerformed.getValue() ?
-                    0 :
-                    startTime - observation.position,
+                wantedTimeOffset: wantedTimeOffset,
             };
         }));
     });

package/dist/_esm5.processed/core/init/get_initial_time.d.ts

@@ -14,12 +14,37 @@
  * limitations under the License.
  */
 import Manifest from "../../manifest";
+/**
+ * All possible initial time options that can be set.
+ *
+ * Written this way (with many type possibilities) on purpose to avoid issues
+ * if the application using the RxPlayer gives undocumented values such as
+ * `null`.
+ *
+ * TODO we shouldn't be that robust, at least not outside the API code, because
+ * if we begin to be that liberal here, where should we end?
+ * We may instead either want to progressively remove tolerance on the wrong
+ * type being given or be better to enforce type-compliancy in the API code.
+ */
 export interface IInitialTimeOptions {
-    position?: number;
-    wallClockTime?: number;
-    fromFirstPosition?: number;
-    fromLastPosition?: number;
-    percentage?: number;
+    /** If set, we should begin at this position, in seconds. */
+    position?: number | null | undefined;
+    /** If set, we should begin at this unix timestamp, in seconds. */
+    wallClockTime?: number | null | undefined;
+    /**
+     * If set, we should begin at this position relative to the content's start,
+     * in seconds.
+     */
+    fromFirstPosition?: number | null | undefined;
+    /**
+     * If set, we should begin at this position relative to the content's end,
+     * in seconds.
+     */
+    fromLastPosition?: 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;
 }
 /**
  * Returns the calculated initial time for the content described by the given