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

package/CHANGELOG.md

@@ -1,11 +1,21 @@
 # Changelog
 
-## v3.27.1-dev.2022040500 (2022-04-05)
+## v3.27.1-dev.2022051100 (2022-06-03)
 
 ### 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/DRM: Fix potential infinite rebuffering when a KID is not anounced in the MPD [#1113]
+  - DASH: Avoid infinite loop due to rounding errors while parsing multi-Periods MPDs [#1111, #1110]
+  - TTML: Add support for percent based thickness for textOutline in TTML Subtitles
+  - If seeking after the last potential position, load last segments before ending [#1097]
+  - DASH: Fix possibility of wrong segments being requested when a SegmentTimeline in a given Period (whose Period@end is set) had an S@r set to `-1` at its end [#1098]
+  - DASH: Don't include presentationTimeOffset for the default initial time of the first `<S>` element if its S@t is not set.
 
+### Other improvements
+
+  - The duration set on the media element is now only relative to the current chosen tracks (it was previously relative to all potential track). This allows to seek later when switching e.g. to a longer video track [#1102]
+  - Errors coming from an HTMLMediaElement now have the browser's error message if it exists [#1112]
 
 ## v3.27.0 (2022-03-31)
 

package/README.md

@@ -1,5 +1,6 @@
 <p align="center">
-  <img src="./doc/static/img/logo.png" />
+  <img src="./doc/static/img/logo.png#gh-light-mode-only" alt="RxPlayer's logo"/>
+  <img src="./doc/static/img/logo-white.png#gh-dark-mode-only" alt="RxPlayer's logo"/>
   <br /><br />
   <a href="https://developers.canal-plus.com/rx-player/doc/api/Overview.html">📖 <b>API documentation</b></a>
   -

package/VERSION

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

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.2022060300";
         _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.2022060300";
 export default Player;

package/dist/_esm5.processed/core/decrypt/content_decryptor.js

@@ -668,16 +668,18 @@ function updateDecipherability(manifest, whitelistedKeyIds, blacklistedKeyIDs) {
             return representation.decipherable;
         }
         var contentKIDs = representation.contentProtections.keyIds;
-        for (var i = 0; i < contentKIDs.length; i++) {
-            var elt = contentKIDs[i];
-            for (var j = 0; j < blacklistedKeyIDs.length; j++) {
-                if (areKeyIdsEqual(blacklistedKeyIDs[j], elt.keyId)) {
-                    return false;
+        if (contentKIDs !== undefined) {
+            for (var i = 0; i < contentKIDs.length; i++) {
+                var elt = contentKIDs[i];
+                for (var j = 0; j < blacklistedKeyIDs.length; j++) {
+                    if (areKeyIdsEqual(blacklistedKeyIDs[j], elt.keyId)) {
+                        return false;
+                    }
                 }
-            }
-            for (var j = 0; j < whitelistedKeyIds.length; j++) {
-                if (areKeyIdsEqual(whitelistedKeyIds[j], elt.keyId)) {
-                    return true;
+                for (var j = 0; j < whitelistedKeyIds.length; j++) {
+                    if (areKeyIdsEqual(whitelistedKeyIds[j], elt.keyId)) {
+                        return true;
+                    }
                 }
             }
         }
@@ -862,7 +864,7 @@ function addKeyIdsFromPeriod(set, period) {
         for (var _b = 0, _c = adaptation.representations; _b < _c.length; _b++) {
             var representation = _c[_b];
             if (representation.contentProtections !== undefined &&
-                representation.contentProtections.keyIds.length >= -1) {
+                representation.contentProtections.keyIds !== undefined) {
                 for (var _d = 0, _e = representation.contentProtections.keyIds; _d < _e.length; _d++) {
                     var kidInf = _e[_d];
                     set.add(kidInf.keyId);

package/dist/_esm5.processed/core/decrypt/utils/key_session_record.js

@@ -129,7 +129,7 @@ var KeySessionRecord = /** @class */ (function () {
      */
     KeySessionRecord.prototype.isCompatibleWith = function (initializationData) {
         var keyIds = initializationData.keyIds;
-        if (keyIds !== undefined) {
+        if (keyIds !== undefined && keyIds.length > 0) {
             if (this._keyIds !== null && areAllKeyIdsContainedIn(keyIds, this._keyIds)) {
                 return true;
             }
@@ -141,6 +141,7 @@ var KeySessionRecord = /** @class */ (function () {
     };
     KeySessionRecord.prototype._checkInitializationDataCompatibility = function (initializationData) {
         if (initializationData.keyIds !== undefined &&
+            initializationData.keyIds.length > 0 &&
             this._initializationData.keyIds !== undefined) {
             return areAllKeyIdsContainedIn(initializationData.keyIds, this._initializationData.keyIds);
         }

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,
             };
         }));
     });