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

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

@@ -41,7 +41,6 @@ var __values = (this && this.__values) || function(o) {
     throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-var is_seeking_approximate_1 = require("../../../compat/is_seeking_approximate");
 var config_1 = require("../../../config");
 var errors_1 = require("../../../errors");
 var log_1 = require("../../../log");
@@ -87,52 +86,15 @@ var RebufferingController = /** @class */ (function (_super) {
             return;
         }
         this._isStarted = true;
-        /**
-         * On some devices (right now only seen on Tizen), seeking through the
-         * `currentTime` property can lead to the browser re-seeking once the
-         * segments have been loaded to improve seeking performances (for
-         * example, by seeking right to an intra video frame).
-         * In that case, we risk being in a conflict with that behavior: if for
-         * example we encounter a small discontinuity at the position the browser
-         * seeks to, we will seek over it, the browser would seek back and so on.
-         *
-         * This variable allows to store the last known position we were seeking to
-         * so we can detect when the browser seeked back (to avoid performing another
-         * seek after that). When browsers seek back to a position behind a
-         * discontinuity, they are usually able to skip them without our help.
-         */
-        var lastSeekingPosition;
-        /**
-         * In some conditions (see `lastSeekingPosition`), we might want to not
-         * automatically seek over discontinuities because the browser might do it
-         * itself instead.
-         * In that case, we still want to perform the seek ourselves if the browser
-         * doesn't do it after sufficient time.
-         * This variable allows to store the timestamp at which a discontinuity began
-         * to be ignored.
-         */
-        var ignoredStallTimeStamp = null;
         var playbackRateUpdater = new PlaybackRateUpdater(this._playbackObserver, this._speed);
         this._canceller.signal.register(function () {
             playbackRateUpdater.dispose();
         });
         var prevFreezingState = null;
         this._playbackObserver.listen(function (observation) {
-            var _a;
             var discontinuitiesStore = _this._discontinuitiesStore;
             var buffered = observation.buffered, position = observation.position, readyState = observation.readyState, rebuffering = observation.rebuffering, freezing = observation.freezing;
-            var _b = config_1.default.getCurrent(), BUFFER_DISCONTINUITY_THRESHOLD = _b.BUFFER_DISCONTINUITY_THRESHOLD, FORCE_DISCONTINUITY_SEEK_DELAY = _b.FORCE_DISCONTINUITY_SEEK_DELAY, FREEZING_STALLED_DELAY = _b.FREEZING_STALLED_DELAY, UNFREEZING_SEEK_DELAY = _b.UNFREEZING_SEEK_DELAY, UNFREEZING_DELTA_POSITION = _b.UNFREEZING_DELTA_POSITION;
-            if (!observation.seeking &&
-                is_seeking_approximate_1.default &&
-                ignoredStallTimeStamp === null &&
-                lastSeekingPosition !== null && observation.position < lastSeekingPosition) {
-                log_1.default.debug("Init: the device appeared to have seeked back by itself.");
-                var now = (0, monotonic_timestamp_1.default)();
-                ignoredStallTimeStamp = now;
-            }
-            lastSeekingPosition = observation.seeking ?
-                Math.max((_a = observation.pendingInternalSeek) !== null && _a !== void 0 ? _a : 0, observation.position) :
-                null;
+            var _a = config_1.default.getCurrent(), BUFFER_DISCONTINUITY_THRESHOLD = _a.BUFFER_DISCONTINUITY_THRESHOLD, FREEZING_STALLED_DELAY = _a.FREEZING_STALLED_DELAY, UNFREEZING_SEEK_DELAY = _a.UNFREEZING_SEEK_DELAY, UNFREEZING_DELTA_POSITION = _a.UNFREEZING_DELTA_POSITION;
             if (_this._checkDecipherabilityFreeze(observation)) {
                 return;
             }
@@ -141,13 +103,14 @@ var RebufferingController = /** @class */ (function (_super) {
                 var referenceTimestamp = prevFreezingState === null ?
                     freezing.timestamp :
                     prevFreezingState.attemptTimestamp;
-                if (now - referenceTimestamp > UNFREEZING_SEEK_DELAY) {
+                if (!position.isAwaitingFuturePosition() &&
+                    now - referenceTimestamp > UNFREEZING_SEEK_DELAY) {
                     log_1.default.warn("Init: trying to seek to un-freeze player");
                     _this._playbackObserver.setCurrentTime(_this._playbackObserver.getCurrentTime() + UNFREEZING_DELTA_POSITION);
                     prevFreezingState = { attemptTimestamp: now };
                 }
                 if (now - freezing.timestamp > FREEZING_STALLED_DELAY) {
-                    if (rebuffering === null || ignoredStallTimeStamp !== null) {
+                    if (rebuffering === null) {
                         playbackRateUpdater.stopRebuffering();
                     }
                     else {
@@ -166,8 +129,9 @@ var RebufferingController = /** @class */ (function (_super) {
                     // With a readyState set to 1, we should still not be able to play:
                     // Return that we're stalled
                     var reason = void 0;
-                    if (observation.seeking) {
-                        reason = observation.pendingInternalSeek !== null ? "internal-seek" :
+                    if (observation.seeking !== 0 /* SeekingState.None */) {
+                        reason = observation.seeking === 1 /* SeekingState.Internal */ ?
+                            "internal-seek" :
                             "seeking";
                     }
                     else {
@@ -182,22 +146,15 @@ var RebufferingController = /** @class */ (function (_super) {
             // We want to separate a stall situation when a seek is due to a seek done
             // internally by the player to when its due to a regular user seek.
             var stalledReason = rebuffering.reason === "seeking" &&
-                observation.pendingInternalSeek !== null ?
+                observation.seeking === 1 /* SeekingState.Internal */ ?
                 "internal-seek" :
                 rebuffering.reason;
-            if (ignoredStallTimeStamp !== null) {
-                var now = (0, monotonic_timestamp_1.default)();
-                if (now - ignoredStallTimeStamp < FORCE_DISCONTINUITY_SEEK_DELAY) {
-                    playbackRateUpdater.stopRebuffering();
-                    log_1.default.debug("Init: letting the device get out of a stall by itself");
-                    _this.trigger("stalled", stalledReason);
-                    return;
-                }
-                else {
-                    log_1.default.warn("Init: ignored stall for too long, considering it", now - ignoredStallTimeStamp);
-                }
+            if (position.isAwaitingFuturePosition()) {
+                playbackRateUpdater.stopRebuffering();
+                log_1.default.debug("Init: let rebuffering happen as we're awaiting a future position");
+                _this.trigger("stalled", stalledReason);
+                return;
             }
-            ignoredStallTimeStamp = null;
             playbackRateUpdater.startRebuffering();
             if (_this._manifest === null) {
                 _this.trigger("stalled", stalledReason);
@@ -215,14 +172,14 @@ var RebufferingController = /** @class */ (function (_super) {
                         log_1.default.info("Init: position to seek already reached, no seeking", _this._playbackObserver.getCurrentTime(), realSeekTime);
                     }
                     else {
-                        log_1.default.warn("SA: skippable discontinuity found in the stream", position, realSeekTime);
+                        log_1.default.warn("SA: skippable discontinuity found in the stream", position.getPolled(), realSeekTime);
                         _this._playbackObserver.setCurrentTime(realSeekTime);
                         _this.trigger("warning", generateDiscontinuityError(stalledPosition, realSeekTime));
                         return;
                     }
                 }
             }
-            var freezePosition = stalledPosition !== null && stalledPosition !== void 0 ? stalledPosition : position;
+            var positionBlockedAt = stalledPosition !== null && stalledPosition !== void 0 ? stalledPosition : position.getPolled();
             // Is it a very short discontinuity in buffer ? -> Seek at the beginning of the
             //                                                 next range
             //
@@ -230,14 +187,14 @@ var RebufferingController = /** @class */ (function (_super) {
             // calculate a stalled state. This is useful for some
             // implementation that might drop an injected segment, or in
             // case of small discontinuity in the content.
-            var nextBufferRangeGap = (0, ranges_1.getNextBufferedTimeRangeGap)(buffered, freezePosition);
+            var nextBufferRangeGap = (0, ranges_1.getNextBufferedTimeRangeGap)(buffered, positionBlockedAt);
             if (_this._speed.getValue() > 0 &&
                 nextBufferRangeGap < BUFFER_DISCONTINUITY_THRESHOLD) {
-                var seekTo = (freezePosition + nextBufferRangeGap + EPSILON);
+                var seekTo = (positionBlockedAt + nextBufferRangeGap + EPSILON);
                 if (_this._playbackObserver.getCurrentTime() < seekTo) {
-                    log_1.default.warn("Init: discontinuity encountered inferior to the threshold", freezePosition, seekTo, BUFFER_DISCONTINUITY_THRESHOLD);
+                    log_1.default.warn("Init: discontinuity encountered inferior to the threshold", positionBlockedAt, seekTo, BUFFER_DISCONTINUITY_THRESHOLD);
                     _this._playbackObserver.setCurrentTime(seekTo);
-                    _this.trigger("warning", generateDiscontinuityError(freezePosition, seekTo));
+                    _this.trigger("warning", generateDiscontinuityError(positionBlockedAt, seekTo));
                     return;
                 }
             }
@@ -245,13 +202,13 @@ var RebufferingController = /** @class */ (function (_super) {
             //                                                next period
             for (var i = _this._manifest.periods.length - 2; i >= 0; i--) {
                 var period = _this._manifest.periods[i];
-                if (period.end !== undefined && period.end <= freezePosition) {
-                    if (_this._manifest.periods[i + 1].start > freezePosition &&
+                if (period.end !== undefined && period.end <= positionBlockedAt) {
+                    if (_this._manifest.periods[i + 1].start > positionBlockedAt &&
                         _this._manifest.periods[i + 1].start >
                             _this._playbackObserver.getCurrentTime()) {
                         var nextPeriod = _this._manifest.periods[i + 1];
                         _this._playbackObserver.setCurrentTime(nextPeriod.start);
-                        _this.trigger("warning", generateDiscontinuityError(freezePosition, nextPeriod.start));
+                        _this.trigger("warning", generateDiscontinuityError(positionBlockedAt, nextPeriod.start));
                         return;
                     }
                     break;
@@ -293,10 +250,10 @@ var RebufferingController = /** @class */ (function (_super) {
             bufferType !== "video")) {
             return;
         }
-        var currPos = observation.position;
-        var rebufferingPos = (_a = observation.rebuffering.position) !== null && _a !== void 0 ? _a : currPos;
+        var loadedPos = observation.position.getWanted();
+        var rebufferingPos = (_a = observation.rebuffering.position) !== null && _a !== void 0 ? _a : loadedPos;
         var lockedPeriodStart = period.start;
-        if (currPos < lockedPeriodStart &&
+        if (loadedPos < lockedPeriodStart &&
             Math.abs(rebufferingPos - lockedPeriodStart) < 1) {
             log_1.default.warn("Init: rebuffering because of a future locked stream.\n" +
                 "Trying to unlock by seeking to the next Period");
@@ -331,7 +288,6 @@ var RebufferingController = /** @class */ (function (_super) {
      * right handling steps.
      */
     RebufferingController.prototype._checkDecipherabilityFreeze = function (observation) {
-        // XXX TODO allow this in in-worker configuration
         var e_1, _a, e_2, _b;
         var readyState = observation.readyState, rebuffering = observation.rebuffering, freezing = observation.freezing;
         var bufferGap = observation.bufferGap !== undefined &&
@@ -478,10 +434,11 @@ function eventContainsDiscontinuity(evt) {
  * @returns {Array.<Object>}
  */
 function updateDiscontinuitiesStore(discontinuitiesStore, evt, observation) {
+    var gcTime = Math.min(observation.position.getPolled(), observation.position.getWanted());
     // First, perform clean-up of old discontinuities
     while (discontinuitiesStore.length > 0 &&
         discontinuitiesStore[0].period.end !== undefined &&
-        discontinuitiesStore[0].period.end + 10 < observation.position) {
+        discontinuitiesStore[0].period.end + 10 < gcTime) {
         discontinuitiesStore.shift();
     }
     var period = evt.period, bufferType = evt.bufferType;

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

@@ -113,8 +113,10 @@ var StreamEventsEmitter = /** @class */ (function (_super) {
                 clearInterval(intervalId);
             });
             function constructObservation() {
-                var isSeeking = playbackObserver.getReference().getValue().seeking;
-                return { currentTime: mediaElement.currentTime, isSeeking: isSeeking };
+                var lastObservation = playbackObserver.getReference().getValue();
+                var currentTime = mediaElement.currentTime;
+                var isSeeking = lastObservation.seeking !== 0 /* SeekingState.None */;
+                return { currentTime: currentTime, isSeeking: isSeeking };
             }
         }, { emitCurrentValue: true, clearSignal: cancelSignal });
     };

package/dist/commonjs/core/segment_buffers/garbage_collector.js

@@ -78,8 +78,7 @@ function BufferGarbageCollector(_a, cancellationSignal) {
     var segmentBuffer = _a.segmentBuffer, playbackObserver = _a.playbackObserver, maxBufferBehind = _a.maxBufferBehind, maxBufferAhead = _a.maxBufferAhead;
     var lastPosition;
     playbackObserver.listen(function (o) {
-        var _a;
-        lastPosition = (_a = o.position.pending) !== null && _a !== void 0 ? _a : o.position.last;
+        lastPosition = o.position.getWanted();
         clean();
     }, { includeLastObservation: true, clearSignal: cancellationSignal });
     function clean() {

package/dist/commonjs/core/segment_buffers/implementations/audio_video/audio_video_segment_buffer.js

@@ -226,7 +226,14 @@ var AudioVideoSegmentBuffer = /** @class */ (function (_super) {
                 err :
                 new Error("An unknown error occured when doing operations " +
                     "on the SourceBuffer");
-            this._pendingTask.reject(error);
+            var task = this._pendingTask;
+            if (task.type === types_1.SegmentBufferOperation.Push &&
+                task.data.length === 0 &&
+                task.inventoryData !== null) {
+                this._segmentInventory.insertChunk(task.inventoryData, false);
+            }
+            this._pendingTask = null;
+            task.reject(error);
         }
     };
     /**
@@ -274,7 +281,7 @@ var AudioVideoSegmentBuffer = /** @class */ (function (_super) {
                 switch (task.type) {
                     case types_1.SegmentBufferOperation.Push:
                         if (task.inventoryData !== null) {
-                            this._segmentInventory.insertChunk(task.inventoryData);
+                            this._segmentInventory.insertChunk(task.inventoryData, true);
                         }
                         break;
                     case types_1.SegmentBufferOperation.EndOfSegment:

package/dist/commonjs/core/segment_buffers/implementations/text/html/html_text_segment_buffer.js

@@ -233,7 +233,7 @@ var HTMLTextSegmentBuffer = /** @class */ (function (_super) {
             return;
         }
         if (infos.inventoryInfos !== null) {
-            this._segmentInventory.insertChunk(infos.inventoryInfos);
+            this._segmentInventory.insertChunk(infos.inventoryInfos, true);
         }
         this._buffer.insert(cues, start, end);
         this._buffered.insert(start, end);

package/dist/commonjs/core/segment_buffers/implementations/text/native/native_text_segment_buffer.js

@@ -158,7 +158,7 @@ var NativeTextSegmentBuffer = /** @class */ (function (_super) {
             }
             this._buffered.insert(start, end);
             if (infos.inventoryInfos !== null) {
-                this._segmentInventory.insertChunk(infos.inventoryInfos);
+                this._segmentInventory.insertChunk(infos.inventoryInfos, true);
             }
         }
         catch (err) {

package/dist/commonjs/core/segment_buffers/index.d.ts

@@ -15,7 +15,7 @@
  */
 import BufferGarbageCollector from "./garbage_collector";
 import { IBufferType, IEndOfSegmentInfos, IEndOfSegmentOperation, IPushChunkInfos, IPushedChunkData, IPushOperation, IRemoveOperation, ISBOperation, SegmentBuffer, SegmentBufferOperation } from "./implementations";
-import { IBufferedChunk, IChunkContext, IInsertedChunkInfos, getFirstSegmentAfterPeriod, getLastSegmentBeforePeriod } from "./inventory";
+import { ChunkStatus, IBufferedChunk, IChunkContext, IInsertedChunkInfos, getFirstSegmentAfterPeriod, getLastSegmentBeforePeriod } from "./inventory";
 import SegmentBuffersStore, { ISegmentBufferOptions, ITextTrackSegmentBufferOptions } from "./segment_buffers_store";
 export default SegmentBuffersStore;
-export { BufferGarbageCollector, ISegmentBufferOptions, ITextTrackSegmentBufferOptions, SegmentBuffer, IBufferType, IBufferedChunk, IChunkContext, IInsertedChunkInfos, IPushChunkInfos, IPushedChunkData, IEndOfSegmentInfos, SegmentBufferOperation, ISBOperation, IEndOfSegmentOperation, IPushOperation, IRemoveOperation, getFirstSegmentAfterPeriod, getLastSegmentBeforePeriod, };
+export { BufferGarbageCollector, ChunkStatus, ISegmentBufferOptions, ITextTrackSegmentBufferOptions, SegmentBuffer, IBufferType, IBufferedChunk, IChunkContext, IInsertedChunkInfos, IPushChunkInfos, IPushedChunkData, IEndOfSegmentInfos, SegmentBufferOperation, ISBOperation, IEndOfSegmentOperation, IPushOperation, IRemoveOperation, getFirstSegmentAfterPeriod, getLastSegmentBeforePeriod, };

package/dist/commonjs/core/segment_buffers/inventory/index.d.ts

@@ -13,9 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import SegmentInventory, { IBufferedChunk, IInsertedChunkInfos } from "./segment_inventory";
+import SegmentInventory, { ChunkStatus, IBufferedChunk, IInsertedChunkInfos } from "./segment_inventory";
 export default SegmentInventory;
-export { IBufferedChunk, IInsertedChunkInfos, };
+export { ChunkStatus, IBufferedChunk, IInsertedChunkInfos, };
 export { IBufferedHistoryEntry } from "./buffered_history";
 export { IChunkContext } from "./types";
 export { getFirstSegmentAfterPeriod, getLastSegmentBeforePeriod, } from "./utils";

package/dist/commonjs/core/segment_buffers/inventory/segment_inventory.d.ts

@@ -16,6 +16,27 @@
 import { Adaptation, ISegment, Period, Representation } from "../../../manifest";
 import { IBufferedHistoryEntry } from "./buffered_history";
 import { IChunkContext } from "./types";
+/** Categorization of a given chunk in the `SegmentInventory`. */
+export declare const enum ChunkStatus {
+    /**
+     * This chunk is only a part of a partially-pushed segment for now, meaning
+     * that it is only a sub-part of a requested segment that was not yet
+     * fully-loaded and pushed.
+     *
+     * Once and if the corresponding segment is fully-pushed, its `ChunkStatus`
+     * switches to `Complete`.
+     */
+    PartiallyPushed = 0,
+    /** This chunk corresponds to a fully-loaded segment. */
+    Complete = 1,
+    /**
+     * This chunk's push operation failed, in this scenario there is no certitude
+     * about the presence of that chunk in the buffer: it may not be present,
+     * partially-present, or fully-present depending on why that push operation
+     * failed, which is generally only known by the lower-level code.
+     */
+    Failed = 2
+}
 /** Information stored on a single chunk by the SegmentInventory. */
 export interface IBufferedChunk {
     /**
@@ -69,14 +90,10 @@ export interface IBufferedChunk {
     /** Information on what that chunk actually contains. */
     infos: IChunkContext;
     /**
-     * If `true`, this chunk is only a partial chunk of a whole segment.
-     *
-     * Inversely, if `false`, this chunk is a whole segment whose inner chunks
-     * have all been fully pushed.
-     * In that condition, the `start` and `end` properties refer to that fully
-     * pushed segment.
+     * Status of this chunk.
+     * @see ChunkStatus
      */
-    partiallyPushed: boolean;
+    status: ChunkStatus;
     /**
      * If `true`, the segment as a whole is divided into multiple parts in the
      * buffer, with other segment(s) between them.
@@ -169,7 +186,7 @@ export default class SegmentInventory {
      * segment have been inserted, you should call the `completeSegment` method.
      * @param {Object} chunkInformation
      */
-    insertChunk({ period, adaptation, representation, segment, chunkSize, start, end }: IInsertedChunkInfos): void;
+    insertChunk({ period, adaptation, representation, segment, chunkSize, start, end }: IInsertedChunkInfos, succeed: boolean): void;
     /**
      * Indicate that inserted chunks can now be considered as a complete segment.
      * Take in argument the same content than what was given to `insertChunk` for

package/dist/commonjs/core/segment_buffers/inventory/segment_inventory.js

@@ -112,7 +112,9 @@ var SegmentInventory = /** @class */ (function () {
                 try {
                     for (var removed_1 = (e_1 = void 0, __values(removed)), removed_1_1 = removed_1.next(); !removed_1_1.done; removed_1_1 = removed_1.next()) {
                         var seg = removed_1_1.value;
-                        if (seg.bufferedStart === undefined && seg.bufferedEnd === undefined) {
+                        if (seg.bufferedStart === undefined &&
+                            seg.bufferedEnd === undefined &&
+                            seg.status !== 2 /* ChunkStatus.Failed */) {
                             this._bufferedHistory.addBufferedSegment(seg.infos, null);
                         }
                     }
@@ -180,7 +182,9 @@ var SegmentInventory = /** @class */ (function () {
             try {
                 for (var removed_2 = __values(removed), removed_2_1 = removed_2.next(); !removed_2_1.done; removed_2_1 = removed_2.next()) {
                     var seg = removed_2_1.value;
-                    if (seg.bufferedStart === undefined && seg.bufferedEnd === undefined) {
+                    if (seg.bufferedStart === undefined &&
+                        seg.bufferedEnd === undefined &&
+                        seg.status !== 2 /* ChunkStatus.Failed */) {
                         this._bufferedHistory.addBufferedSegment(seg.infos, null);
                     }
                 }
@@ -205,7 +209,7 @@ var SegmentInventory = /** @class */ (function () {
      * segment have been inserted, you should call the `completeSegment` method.
      * @param {Object} chunkInformation
      */
-    SegmentInventory.prototype.insertChunk = function (_a) {
+    SegmentInventory.prototype.insertChunk = function (_a, succeed) {
         var period = _a.period, adaptation = _a.adaptation, representation = _a.representation, segment = _a.segment, chunkSize = _a.chunkSize, start = _a.start, end = _a.end;
         if (segment.isInit) {
             return;
@@ -216,7 +220,8 @@ var SegmentInventory = /** @class */ (function () {
             return;
         }
         var inventory = this._inventory;
-        var newSegment = { partiallyPushed: true, chunkSize: chunkSize, splitted: false, start: start, end: end, precizeStart: false,
+        var newSegment = { status: succeed ? 0 /* ChunkStatus.PartiallyPushed */ :
+                2 /* ChunkStatus.Failed */, chunkSize: chunkSize, splitted: false, start: start, end: end, precizeStart: false,
             precizeEnd: false,
             bufferedStart: undefined,
             bufferedEnd: undefined,
@@ -409,7 +414,7 @@ var SegmentInventory = /** @class */ (function () {
                             //  newSegment   :    |====|
                             //  ===>         : |--|====|-|
                             log_1.default.warn("SI: Segment pushed is contained in a previous one", bufferType, start, end, segmentI.start, segmentI.end);
-                            var nextSegment = { partiallyPushed: segmentI.partiallyPushed,
+                            var nextSegment = { status: segmentI.status,
                                 /**
                                  * Note: this sadly means we're doing as if
                                  * that chunk is present two times.
@@ -568,7 +573,9 @@ var SegmentInventory = /** @class */ (function () {
                     this._inventory.splice(firstI + 1, length_1);
                     i -= length_1;
                 }
-                this._inventory[firstI].partiallyPushed = false;
+                if (this._inventory[firstI].status === 0 /* ChunkStatus.PartiallyPushed */) {
+                    this._inventory[firstI].status = 1 /* ChunkStatus.Complete */;
+                }
                 this._inventory[firstI].chunkSize = segmentSize;
                 this._inventory[firstI].end = lastEnd;
                 this._inventory[firstI].bufferedEnd = lastBufferedEnd;
@@ -585,8 +592,10 @@ var SegmentInventory = /** @class */ (function () {
                 for (var resSegments_1 = __values(resSegments), resSegments_1_1 = resSegments_1.next(); !resSegments_1_1.done; resSegments_1_1 = resSegments_1.next()) {
                     var seg = resSegments_1_1.value;
                     if (seg.bufferedStart !== undefined && seg.bufferedEnd !== undefined) {
-                        this._bufferedHistory.addBufferedSegment(seg.infos, { start: seg.bufferedStart,
-                            end: seg.bufferedEnd });
+                        if (seg.status !== 2 /* ChunkStatus.Failed */) {
+                            this._bufferedHistory.addBufferedSegment(seg.infos, { start: seg.bufferedStart,
+                                end: seg.bufferedEnd });
+                        }
                     }
                     else {
                         log_1.default.debug("SI: buffered range not known after sync. Skipping history.", seg.start, seg.end);
@@ -639,7 +648,7 @@ exports.default = SegmentInventory;
  */
 function bufferedStartLooksCoherent(thisSegment) {
     if (thisSegment.bufferedStart === undefined ||
-        thisSegment.partiallyPushed) {
+        thisSegment.status !== 1 /* ChunkStatus.Complete */) {
         return false;
     }
     var start = thisSegment.start, end = thisSegment.end;
@@ -660,7 +669,7 @@ function bufferedStartLooksCoherent(thisSegment) {
  */
 function bufferedEndLooksCoherent(thisSegment) {
     if (thisSegment.bufferedEnd === undefined ||
-        thisSegment.partiallyPushed) {
+        thisSegment.status !== 1 /* ChunkStatus.Complete */) {
         return false;
     }
     var start = thisSegment.start, end = thisSegment.end;

package/dist/commonjs/core/stream/adaptation/get_representations_switch_strategy.d.ts

@@ -16,8 +16,8 @@
 import { Adaptation, Period } from "../../../manifest";
 import { IReadOnlyPlaybackObserver } from "../../api";
 import { SegmentBuffer } from "../../segment_buffers";
-import { IRepresentationsChoice } from "../representation";
-export default function getRepresentationsSwitchingStrategy(period: Period, adaptation: Adaptation, settings: IRepresentationsChoice, segmentBuffer: SegmentBuffer, playbackObserver: IReadOnlyPlaybackObserver<unknown>): IRepresentationSwitchStrategy;
+import { IRepresentationStreamPlaybackObservation, IRepresentationsChoice } from "../representation";
+export default function getRepresentationsSwitchingStrategy(period: Period, adaptation: Adaptation, settings: IRepresentationsChoice, segmentBuffer: SegmentBuffer, playbackObserver: IReadOnlyPlaybackObserver<IRepresentationStreamPlaybackObservation>): IRepresentationSwitchStrategy;
 export type IRepresentationSwitchStrategy = {
     type: "continue";
     value: undefined;

package/dist/commonjs/core/stream/adaptation/get_representations_switch_strategy.js

@@ -47,16 +47,22 @@ function getRepresentationsSwitchingStrategy(period, adaptation, settings, segme
     if (unwantedRange.length === 0) {
         return { type: "continue", value: undefined };
     }
-    var currentTime = playbackObserver.getCurrentTime();
     var readyState = playbackObserver.getReadyState();
-    if (settings.switchingMode === "reload" &&
-        // We're playing the current Period
-        (0, ranges_1.isTimeInRange)({ start: start, end: end }, currentTime) &&
-        // There is data for the current position
-        readyState > 1 &&
-        // We're not playing the current wanted video Adaptation
-        !(0, ranges_1.isTimeInRanges)(rangesWithReps, currentTime)) {
-        return { type: "needs-reload", value: undefined };
+    if (settings.switchingMode === "reload" && readyState > 1) {
+        var lastObservation = playbackObserver.getReference().getValue();
+        if (lastObservation.position.isAwaitingFuturePosition()) {
+            // We are not at the position we want to reach (e.g. initial seek, tizen
+            // seek-back...), just reload as checks here would be too complex
+            return { type: "needs-reload", value: undefined };
+        }
+        else {
+            var currentTime = playbackObserver.getCurrentTime();
+            if ((0, ranges_1.isTimeInRange)({ start: start, end: end }, currentTime) &&
+                // We're not playing the current wanted video Adaptation
+                !(0, ranges_1.isTimeInRanges)(rangesWithReps, currentTime)) {
+                return { type: "needs-reload", value: undefined };
+            }
+        }
     }
     // From here, clean-up data from the previous Adaptation, if one
     var shouldFlush = settings.switchingMode === "direct";
@@ -87,6 +93,7 @@ function getRepresentationsSwitchingStrategy(period, adaptation, settings, segme
         if (paddingAfter == null) {
             paddingAfter = 0;
         }
+        var currentTime = playbackObserver.getCurrentTime();
         rangesToExclude.push({ start: currentTime - paddingBefore,
             end: currentTime + paddingAfter });
     }

package/dist/commonjs/core/stream/orchestrator/stream_orchestrator.js

@@ -155,23 +155,22 @@ function StreamOrchestrator(content, playbackObserver, representationEstimator,
     var e_1, _a;
     var manifest = content.manifest, initialPeriod = content.initialPeriod;
     var maxBufferAhead = options.maxBufferAhead, maxBufferBehind = options.maxBufferBehind, wantedBufferAhead = options.wantedBufferAhead, maxVideoBufferSize = options.maxVideoBufferSize;
-    var _b = config_1.default.getCurrent(), MAXIMUM_MAX_BUFFER_AHEAD = _b.MAXIMUM_MAX_BUFFER_AHEAD, MAXIMUM_MAX_BUFFER_BEHIND = _b.MAXIMUM_MAX_BUFFER_BEHIND;
+    var _b = config_1.default.getCurrent(), MINIMUM_MAX_BUFFER_AHEAD = _b.MINIMUM_MAX_BUFFER_AHEAD, MAXIMUM_MAX_BUFFER_AHEAD = _b.MAXIMUM_MAX_BUFFER_AHEAD, MAXIMUM_MAX_BUFFER_BEHIND = _b.MAXIMUM_MAX_BUFFER_BEHIND;
     // Keep track of a unique BufferGarbageCollector created per
     // SegmentBuffer.
     var garbageCollectors = new weak_map_memory_1.default(function (segmentBuffer) {
+        var _a, _b;
         var bufferType = segmentBuffer.bufferType;
-        var defaultMaxBehind = MAXIMUM_MAX_BUFFER_BEHIND[bufferType] != null ?
-            MAXIMUM_MAX_BUFFER_BEHIND[bufferType] :
-            Infinity;
-        var defaultMaxAhead = MAXIMUM_MAX_BUFFER_AHEAD[bufferType] != null ?
-            MAXIMUM_MAX_BUFFER_AHEAD[bufferType] :
-            Infinity;
+        var defaultMaxBehind = (_a = MAXIMUM_MAX_BUFFER_BEHIND[bufferType]) !== null && _a !== void 0 ? _a : Infinity;
+        var maxAheadHigherBound = (_b = MAXIMUM_MAX_BUFFER_AHEAD[bufferType]) !== null && _b !== void 0 ? _b : Infinity;
         return function (gcCancelSignal) {
             (0, segment_buffers_1.BufferGarbageCollector)({ segmentBuffer: segmentBuffer, playbackObserver: playbackObserver, maxBufferBehind: (0, reference_1.createMappedReference)(maxBufferBehind, function (val) {
                     return Math.min(val, defaultMaxBehind);
                 }, gcCancelSignal),
                 maxBufferAhead: (0, reference_1.createMappedReference)(maxBufferAhead, function (val) {
-                    return Math.min(val, defaultMaxAhead);
+                    var _a;
+                    var lowerBound = Math.max(val, (_a = MINIMUM_MAX_BUFFER_AHEAD[bufferType]) !== null && _a !== void 0 ? _a : 0);
+                    return Math.min(lowerBound, maxAheadHigherBound);
                 }, gcCancelSignal) }, gcCancelSignal);
         };
     });
@@ -215,9 +214,9 @@ function StreamOrchestrator(content, playbackObserver, representationEstimator,
         // Restart the current Stream when the wanted time is in another period
         // than the ones already considered
         playbackObserver.listen(function (_a) {
-            var _b, _c;
+            var _b;
             var position = _a.position;
-            var time = (_b = position.pending) !== null && _b !== void 0 ? _b : position.last;
+            var time = position.getWanted();
             if (!enableOutOfBoundsCheck || !isOutOfPeriodList(time)) {
                 return;
             }
@@ -231,7 +230,7 @@ function StreamOrchestrator(content, playbackObserver, representationEstimator,
             currentCanceller.cancel();
             currentCanceller = new task_canceller_1.default();
             currentCanceller.linkToSignal(orchestratorCancelSignal);
-            var nextPeriod = (_c = manifest.getPeriodForTime(time)) !== null && _c !== void 0 ? _c : manifest.getNextPeriod(time);
+            var nextPeriod = (_b = manifest.getPeriodForTime(time)) !== null && _b !== void 0 ? _b : manifest.getNextPeriod(time);
             if (nextPeriod === undefined) {
                 log_1.default.warn("Stream: The wanted position is not found in the Manifest.");
                 return;
@@ -382,7 +381,6 @@ function StreamOrchestrator(content, playbackObserver, representationEstimator,
                             // to reduce the risk of race conditions where the next observation
                             // was going to be emitted synchronously.
                             (0, queue_microtask_1.default)(function () {
-                                var _a;
                                 if (orchestratorCancelSignal.isCancelled()) {
                                     return;
                                 }
@@ -400,7 +398,7 @@ function StreamOrchestrator(content, playbackObserver, representationEstimator,
                                         return;
                                     }
                                 }
-                                var lastPosition = (_a = observation.position.pending) !== null && _a !== void 0 ? _a : observation.position.last;
+                                var lastPosition = observation.position.getWanted();
                                 var newInitialPeriod = manifest.getPeriodForTime(lastPosition);
                                 if (newInitialPeriod == null) {
                                     callbacks.error(new errors_1.MediaError("MEDIA_TIME_NOT_FOUND", "The wanted position is not found in the Manifest."));
@@ -458,11 +456,9 @@ function StreamOrchestrator(content, playbackObserver, representationEstimator,
         // Stop current PeriodStream when the current position goes over the end of
         // that Period.
         playbackObserver.listen(function (_a, stopListeningObservations) {
-            var _b, _c;
             var position = _a.position;
-            if (basePeriod.end !== undefined &&
-                ((_b = position.pending) !== null && _b !== void 0 ? _b : position.last) >= basePeriod.end) {
-                log_1.default.info("Stream: Destroying PeriodStream as the current playhead moved above it", bufferType, basePeriod.start, (_c = position.pending) !== null && _c !== void 0 ? _c : position.last, basePeriod.end);
+            if (basePeriod.end !== undefined && position.getWanted() >= basePeriod.end) {
+                log_1.default.info("Stream: Destroying PeriodStream as the current playhead moved above it", bufferType, basePeriod.start, position.getWanted(), basePeriod.end);
                 stopListeningObservations();
                 consecutivePeriodStreamCb.periodStreamCleared({ type: bufferType, manifest: manifest, period: basePeriod });
                 currentStreamCanceller.cancel();
@@ -591,7 +587,7 @@ function needsFlushingAfterClean(observation, cleanedRanges) {
     if (cleanedRanges.length === 0) {
         return false;
     }
-    var curPos = observation.position.last;
+    var curPos = observation.position.getPolled();
     // Based on the playback direction, we just check whether we may encounter
     // the corresponding ranges, without seeking or re-switching playback
     // direction which is expected to lead to a low-level flush anyway.