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

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

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

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

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

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

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

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

@@ -13,7 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import isSeekingApproximate from "../../../compat/is_seeking_approximate";
 import config from "../../../config";
 import { MediaError } from "../../../errors";
 import log from "../../../log";
@@ -56,52 +55,15 @@ export default class RebufferingController extends EventEmitter {
             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.
-         */
-        let 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.
-         */
-        let ignoredStallTimeStamp = null;
         const playbackRateUpdater = new PlaybackRateUpdater(this._playbackObserver, this._speed);
         this._canceller.signal.register(() => {
             playbackRateUpdater.dispose();
         });
         let prevFreezingState = null;
         this._playbackObserver.listen((observation) => {
-            var _a;
             const discontinuitiesStore = this._discontinuitiesStore;
             const { buffered, position, readyState, rebuffering, freezing } = observation;
-            const { BUFFER_DISCONTINUITY_THRESHOLD, FORCE_DISCONTINUITY_SEEK_DELAY, FREEZING_STALLED_DELAY, UNFREEZING_SEEK_DELAY, UNFREEZING_DELTA_POSITION } = config.getCurrent();
-            if (!observation.seeking &&
-                isSeekingApproximate &&
-                ignoredStallTimeStamp === null &&
-                lastSeekingPosition !== null && observation.position < lastSeekingPosition) {
-                log.debug("Init: the device appeared to have seeked back by itself.");
-                const now = getMonotonicTimeStamp();
-                ignoredStallTimeStamp = now;
-            }
-            lastSeekingPosition = observation.seeking ?
-                Math.max((_a = observation.pendingInternalSeek) !== null && _a !== void 0 ? _a : 0, observation.position) :
-                null;
+            const { BUFFER_DISCONTINUITY_THRESHOLD, FREEZING_STALLED_DELAY, UNFREEZING_SEEK_DELAY, UNFREEZING_DELTA_POSITION } = config.getCurrent();
             if (this._checkDecipherabilityFreeze(observation)) {
                 return;
             }
@@ -110,13 +72,14 @@ export default class RebufferingController extends EventEmitter {
                 const referenceTimestamp = prevFreezingState === null ?
                     freezing.timestamp :
                     prevFreezingState.attemptTimestamp;
-                if (now - referenceTimestamp > UNFREEZING_SEEK_DELAY) {
+                if (!position.isAwaitingFuturePosition() &&
+                    now - referenceTimestamp > UNFREEZING_SEEK_DELAY) {
                     log.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 {
@@ -135,8 +98,9 @@ export default class RebufferingController extends EventEmitter {
                     // With a readyState set to 1, we should still not be able to play:
                     // Return that we're stalled
                     let reason;
-                    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 {
@@ -151,22 +115,15 @@ export default class RebufferingController extends EventEmitter {
             // 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.
             const stalledReason = rebuffering.reason === "seeking" &&
-                observation.pendingInternalSeek !== null ?
+                observation.seeking === 1 /* SeekingState.Internal */ ?
                 "internal-seek" :
                 rebuffering.reason;
-            if (ignoredStallTimeStamp !== null) {
-                const now = getMonotonicTimeStamp();
-                if (now - ignoredStallTimeStamp < FORCE_DISCONTINUITY_SEEK_DELAY) {
-                    playbackRateUpdater.stopRebuffering();
-                    log.debug("Init: letting the device get out of a stall by itself");
-                    this.trigger("stalled", stalledReason);
-                    return;
-                }
-                else {
-                    log.warn("Init: ignored stall for too long, considering it", now - ignoredStallTimeStamp);
-                }
+            if (position.isAwaitingFuturePosition()) {
+                playbackRateUpdater.stopRebuffering();
+                log.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);
@@ -184,14 +141,14 @@ export default class RebufferingController extends EventEmitter {
                         log.info("Init: position to seek already reached, no seeking", this._playbackObserver.getCurrentTime(), realSeekTime);
                     }
                     else {
-                        log.warn("SA: skippable discontinuity found in the stream", position, realSeekTime);
+                        log.warn("SA: skippable discontinuity found in the stream", position.getPolled(), realSeekTime);
                         this._playbackObserver.setCurrentTime(realSeekTime);
                         this.trigger("warning", generateDiscontinuityError(stalledPosition, realSeekTime));
                         return;
                     }
                 }
             }
-            const freezePosition = stalledPosition !== null && stalledPosition !== void 0 ? stalledPosition : position;
+            const 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
             //
@@ -199,14 +156,14 @@ export default class RebufferingController extends EventEmitter {
             // 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.
-            const nextBufferRangeGap = getNextBufferedTimeRangeGap(buffered, freezePosition);
+            const nextBufferRangeGap = getNextBufferedTimeRangeGap(buffered, positionBlockedAt);
             if (this._speed.getValue() > 0 &&
                 nextBufferRangeGap < BUFFER_DISCONTINUITY_THRESHOLD) {
-                const seekTo = (freezePosition + nextBufferRangeGap + EPSILON);
+                const seekTo = (positionBlockedAt + nextBufferRangeGap + EPSILON);
                 if (this._playbackObserver.getCurrentTime() < seekTo) {
-                    log.warn("Init: discontinuity encountered inferior to the threshold", freezePosition, seekTo, BUFFER_DISCONTINUITY_THRESHOLD);
+                    log.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;
                 }
             }
@@ -214,13 +171,13 @@ export default class RebufferingController extends EventEmitter {
             //                                                next period
             for (let i = this._manifest.periods.length - 2; i >= 0; i--) {
                 const 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()) {
                         const 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;
@@ -262,10 +219,10 @@ export default class RebufferingController extends EventEmitter {
             bufferType !== "video")) {
             return;
         }
-        const currPos = observation.position;
-        const rebufferingPos = (_a = observation.rebuffering.position) !== null && _a !== void 0 ? _a : currPos;
+        const loadedPos = observation.position.getWanted();
+        const rebufferingPos = (_a = observation.rebuffering.position) !== null && _a !== void 0 ? _a : loadedPos;
         const lockedPeriodStart = period.start;
-        if (currPos < lockedPeriodStart &&
+        if (loadedPos < lockedPeriodStart &&
             Math.abs(rebufferingPos - lockedPeriodStart) < 1) {
             log.warn("Init: rebuffering because of a future locked stream.\n" +
                 "Trying to unlock by seeking to the next Period");
@@ -300,7 +257,6 @@ export default class RebufferingController extends EventEmitter {
      * right handling steps.
      */
     _checkDecipherabilityFreeze(observation) {
-        // XXX TODO allow this in in-worker configuration
         const { readyState, rebuffering, freezing } = observation;
         const bufferGap = observation.bufferGap !== undefined &&
             isFinite(observation.bufferGap) ? observation.bufferGap :
@@ -424,10 +380,11 @@ function eventContainsDiscontinuity(evt) {
  * @returns {Array.<Object>}
  */
 function updateDiscontinuitiesStore(discontinuitiesStore, evt, observation) {
+    const 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();
     }
     const { period, bufferType } = evt;

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

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

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

@@ -28,8 +28,7 @@ import { getInnerAndOuterRangesFromBufferedTimeRanges } from "../../utils/ranges
 export default function BufferGarbageCollector({ segmentBuffer, playbackObserver, maxBufferBehind, maxBufferAhead }, cancellationSignal) {
     let lastPosition;
     playbackObserver.listen((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/es2017/core/segment_buffers/implementations/audio_video/audio_video_segment_buffer.js

@@ -207,7 +207,14 @@ export default class AudioVideoSegmentBuffer extends SegmentBuffer {
                 err :
                 new Error("An unknown error occured when doing operations " +
                     "on the SourceBuffer");
-            this._pendingTask.reject(error);
+            const task = this._pendingTask;
+            if (task.type === SegmentBufferOperation.Push &&
+                task.data.length === 0 &&
+                task.inventoryData !== null) {
+                this._segmentInventory.insertChunk(task.inventoryData, false);
+            }
+            this._pendingTask = null;
+            task.reject(error);
         }
     }
     /**
@@ -254,7 +261,7 @@ export default class AudioVideoSegmentBuffer extends SegmentBuffer {
                 switch (task.type) {
                     case SegmentBufferOperation.Push:
                         if (task.inventoryData !== null) {
-                            this._segmentInventory.insertChunk(task.inventoryData);
+                            this._segmentInventory.insertChunk(task.inventoryData, true);
                         }
                         break;
                     case SegmentBufferOperation.EndOfSegment:

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

@@ -213,7 +213,7 @@ export default class HTMLTextSegmentBuffer extends SegmentBuffer {
             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/es2017/core/segment_buffers/implementations/text/native/native_text_segment_buffer.js

@@ -138,7 +138,7 @@ export default class NativeTextSegmentBuffer extends SegmentBuffer {
             }
             this._buffered.insert(start, end);
             if (infos.inventoryInfos !== null) {
-                this._segmentInventory.insertChunk(infos.inventoryInfos);
+                this._segmentInventory.insertChunk(infos.inventoryInfos, true);
             }
         }
         catch (err) {

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