rx-player 4.0.0-beta.1 → 4.0.0-beta.2

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

@@ -87,7 +87,7 @@ import getInitialTime from "./utils/get_initial_time";
 import getLoadedReference from "./utils/get_loaded_reference";
 import performInitialSeekAndPlay from "./utils/initial_seek_and_play";
 import initializeContentDecryption from "./utils/initialize_content_decryption";
-import MediaDurationUpdater from "./utils/media_duration_updater";
+import MediaSourceDurationUpdater from "./utils/media_source_duration_updater";
 import RebufferingController from "./utils/rebuffering_controller";
 import streamEventsEmitter from "./utils/stream_events_emitter";
 import listenToMediaError from "./utils/throw_on_media_error";
@@ -249,7 +249,7 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
                     if (initCanceller.isUsed()) {
                         return;
                     }
-                    triggerEvent("reloadingMediaSource", null);
+                    triggerEvent("reloadingMediaSource", reloadOrder);
                     if (initCanceller.isUsed()) {
                         return;
                     }
@@ -341,7 +341,18 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
             }
         }, { clearSignal: cancelSignal, emitCurrentValue: true });
         var streamObserver = createStreamPlaybackObserver(manifest, playbackObserver, { autoPlay: autoPlay, initialPlayPerformed: initialPlayPerformed, initialSeekPerformed: initialSeekPerformed, speed: speed, startTime: initialTime });
-        var rebufferingController = this._createRebufferingController(playbackObserver, manifest, speed, cancelSignal);
+        var rebufferingController = this._createRebufferingController(playbackObserver, manifest, segmentBuffersStore, speed, cancelSignal);
+        rebufferingController.addEventListener("needsReload", function () {
+            // NOTE couldn't both be always calculated at event destination?
+            // Maybe there are exceptions?
+            var position = initialSeekPerformed.getValue() ?
+                playbackObserver.getCurrentTime() :
+                initialTime;
+            var autoplay = initialPlayPerformed.getValue() ?
+                !playbackObserver.getIsPaused() :
+                autoPlay;
+            onReloadOrder({ position: position, autoPlay: autoplay });
+        }, cancelSignal);
         var contentTimeBoundariesObserver = this
             ._createContentTimeBoundariesObserver(manifest, mediaSource, streamObserver, segmentBuffersStore, cancelSignal);
         /**
@@ -376,7 +387,32 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
         function handleStreamOrchestratorCallbacks() {
             return {
                 needsBufferFlush: function () {
-                    return playbackObserver.setCurrentTime(mediaElement.currentTime + 0.001);
+                    var seekedTime = mediaElement.currentTime + 0.001;
+                    playbackObserver.setCurrentTime(seekedTime);
+                    // Seek again once data begins to be buffered.
+                    // This is sadly necessary on some browsers to avoid decoding
+                    // issues after a flush.
+                    //
+                    // NOTE: there's in theory a potential race condition in the following
+                    // logic as the callback could be called when media data is still
+                    // being removed by the browser - which is an asynchronous process.
+                    // The following condition checking for buffered data could thus lead
+                    // to a false positive where we're actually checking previous data.
+                    // For now, such scenario is avoided by setting the
+                    // `includeLastObservation` option to `false` and calling
+                    // `needsBufferFlush` once MSE media removal operations have been
+                    // explicitely validated by the browser, but that's a complex and easy
+                    // to break system.
+                    playbackObserver.listen(function (obs, stopListening) {
+                        if (
+                        // Data is buffered around the current position
+                        obs.currentRange !== null ||
+                            // Or, for whatever reason, playback is already advancing
+                            obs.position > seekedTime + 0.1) {
+                            stopListening();
+                            playbackObserver.setCurrentTime(obs.position + 0.001);
+                        }
+                    }, { includeLastObservation: false, clearSignal: cancelSignal });
                 },
                 streamStatusUpdate: function (value) {
                     // Announce discontinuities if found
@@ -498,9 +534,9 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
     MediaSourceContentInitializer.prototype._createContentTimeBoundariesObserver = function (manifest, mediaSource, streamObserver, segmentBuffersStore, cancelSignal) {
         var _this = this;
         /** Maintains the MediaSource's duration up-to-date with the Manifest */
-        var mediaDurationUpdater = new MediaDurationUpdater(manifest, mediaSource);
+        var mediaSourceDurationUpdater = new MediaSourceDurationUpdater(mediaSource);
         cancelSignal.register(function () {
-            mediaDurationUpdater.stop();
+            mediaSourceDurationUpdater.stopUpdating();
         });
         /** Allows to cancel a pending `end-of-stream` operation. */
         var endOfStreamCanceller = null;
@@ -515,8 +551,7 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
             _this.trigger("activePeriodChanged", { period: period });
         });
         contentTimeBoundariesObserver.addEventListener("durationUpdate", function (newDuration) {
-            log.debug("Init: Duration has to be updated.", newDuration);
-            mediaDurationUpdater.updateKnownDuration(newDuration);
+            mediaSourceDurationUpdater.updateDuration(newDuration.duration, newDuration.isEnd);
         });
         contentTimeBoundariesObserver.addEventListener("endOfStream", function () {
             if (endOfStreamCanceller === null) {
@@ -533,6 +568,8 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
                 endOfStreamCanceller = null;
             }
         });
+        var currentDuration = contentTimeBoundariesObserver.getCurrentDuration();
+        mediaSourceDurationUpdater.updateDuration(currentDuration.duration, currentDuration.isEnd);
         return contentTimeBoundariesObserver;
     };
     /**
@@ -553,9 +590,9 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
      * @param {Object} cancelSignal
      * @returns {Object}
      */
-    MediaSourceContentInitializer.prototype._createRebufferingController = function (playbackObserver, manifest, speed, cancelSignal) {
+    MediaSourceContentInitializer.prototype._createRebufferingController = function (playbackObserver, manifest, segmentBuffersStore, speed, cancelSignal) {
         var _this = this;
-        var rebufferingController = new RebufferingController(playbackObserver, manifest, speed);
+        var rebufferingController = new RebufferingController(playbackObserver, manifest, segmentBuffersStore, speed);
         // Bubble-up events
         rebufferingController.addEventListener("stalled", function (evt) { return _this.trigger("stalled", evt); });
         rebufferingController.addEventListener("unstalled", function () { return _this.trigger("unstalled", null); });

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

@@ -95,7 +95,15 @@ export interface IContentInitializerEvents {
      * Event sent when we're starting attach a new MediaSource to the media element
      * (after removing the previous one).
      */
-    reloadingMediaSource: null;
+    reloadingMediaSource: {
+        /** The position we're reloading at, in seconds. */
+        position: number;
+        /**
+         * If `true`, we'll play directly after finishing the reloading operation.
+         * If `false`, we'll be paused after it.
+         */
+        autoPlay: boolean;
+    };
     /** Event sent after the player stalled. */
     stalled: IStallingSituation;
     /** Event sent when the player goes out of a stalling situation. */

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

@@ -55,6 +55,11 @@ export default class ContentTimeBoundariesObserver extends EventEmitter<IContent
      * @param {Object} playbackObserver
      */
     constructor(manifest: Manifest, playbackObserver: IReadOnlyPlaybackObserver<IStreamOrchestratorPlaybackObservation>, bufferTypes: IBufferType[]);
+    /**
+     * Returns an estimate of the current duration of the content.
+     * @returns {Object}
+     */
+    getCurrentDuration(): IDurationItem;
     /**
      * Method to call any time an Adaptation has been selected.
      *
@@ -121,9 +126,31 @@ export default class ContentTimeBoundariesObserver extends EventEmitter<IContent
     private _addActivelyLoadedPeriod;
     private _removeActivelyLoadedPeriod;
     private _checkCurrentPeriod;
+    private _getManifestDuration;
     private _lazilyCreateActiveStreamInfo;
     private _checkEndOfStream;
 }
+export interface IDurationItem {
+    /**
+     * The new maximum known position (note that this is the ending position
+     * currently known of the current content, it might be superior to the last
+     * position at which segments are available and it might also evolve over
+     * time), in seconds.
+     */
+    duration: number;
+    /**
+     * If `true`, the communicated `duration` is the actual end of the content.
+     * It may still be updated due to a track change or to add precision, but it
+     * is still a (rough) estimate of the maximum position that content should
+     * have.
+     *
+     * If `false`, this is the currently known maximum position associated to
+     * the content, but the content is still evolving (typically, new media
+     * segments are still being generated) and as such it can still have a
+     * longer duration in the future.
+     */
+    isEnd: boolean;
+}
 /**
  * Events triggered by a `ContentTimeBoundariesObserver` where the keys are the
  * event names and the value is the payload of those events.
@@ -137,7 +164,7 @@ export interface IContentTimeBoundariesObserverEvent {
      * Triggered when the duration of the currently-playing content became known
      * or changed.
      */
-    durationUpdate: number | undefined;
+    durationUpdate: IDurationItem;
     /**
      * Triggered when the last possible chronological segment for all types of
      * buffers has either been pushed or is being pushed to the corresponding

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

@@ -82,19 +82,21 @@ var ContentTimeBoundariesObserver = /** @class */ (function (_super) {
             }
         }, { includeLastObservation: true, clearSignal: cancelSignal });
         manifest.addEventListener("manifestUpdate", function () {
-            _this.trigger("durationUpdate", getManifestDuration());
+            _this.trigger("durationUpdate", _this._getManifestDuration());
             if (cancelSignal.isCancelled()) {
                 return;
             }
             _this._checkEndOfStream();
         }, cancelSignal);
-        function getManifestDuration() {
-            return manifest.isDynamic ?
-                maximumPositionCalculator.getMaximumAvailablePosition() :
-                maximumPositionCalculator.getEndingPosition();
-        }
         return _this;
     }
+    /**
+     * Returns an estimate of the current duration of the content.
+     * @returns {Object}
+     */
+    ContentTimeBoundariesObserver.prototype.getCurrentDuration = function () {
+        return this._getManifestDuration();
+    };
     /**
      * Method to call any time an Adaptation has been selected.
      *
@@ -121,9 +123,12 @@ var ContentTimeBoundariesObserver = /** @class */ (function (_super) {
                         this._maximumPositionCalculator
                             .updateLastVideoAdaptation(adaptation);
                     }
-                    var newDuration = this._manifest.isDynamic ?
-                        this._maximumPositionCalculator.getMaximumAvailablePosition() :
-                        this._maximumPositionCalculator.getEndingPosition();
+                    var endingPosition = this._maximumPositionCalculator.getEndingPosition();
+                    var newDuration = endingPosition !== undefined ?
+                        { isEnd: true,
+                            duration: endingPosition } :
+                        { isEnd: false,
+                            duration: this._maximumPositionCalculator.getMaximumAvailablePosition() };
                     this.trigger("durationUpdate", newDuration);
                 }
             }
@@ -258,6 +263,14 @@ var ContentTimeBoundariesObserver = /** @class */ (function (_super) {
                 return state_1.value;
         }
     };
+    ContentTimeBoundariesObserver.prototype._getManifestDuration = function () {
+        var endingPosition = this._maximumPositionCalculator.getEndingPosition();
+        return endingPosition !== undefined ?
+            { isEnd: true,
+                duration: endingPosition } :
+            { isEnd: false,
+                duration: this._maximumPositionCalculator.getMaximumAvailablePosition() };
+    };
     ContentTimeBoundariesObserver.prototype._lazilyCreateActiveStreamInfo = function (bufferType) {
         var streamInfo = this._activeStreams.get(bufferType);
         if (streamInfo === undefined) {

package/dist/_esm5.processed/core/init/utils/media_source_duration_updater.d.ts

@@ -0,0 +1,58 @@
+/**
+ * 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.
+ */
+/**
+ * Keep the MediaSource's `duration` attribute up-to-date with the duration of
+ * the content played on it.
+ * @class MediaSourceDurationUpdater
+ */
+export default class MediaSourceDurationUpdater {
+    /**
+     * `MediaSource` on which we're going to update the `duration` attribute.
+     */
+    private _mediaSource;
+    /**
+     * Abort the current duration-setting logic.
+     * `null` if no such logic is pending.
+     */
+    private _currentMediaSourceDurationUpdateCanceller;
+    /**
+     * Create a new `MediaSourceDurationUpdater`,
+     * @param {MediaSource} mediaSource - The MediaSource on which the content is
+     * played.
+     */
+    constructor(mediaSource: MediaSource);
+    /**
+     * Indicate to the `MediaSourceDurationUpdater` the currently known duration
+     * of the content.
+     *
+     * The `MediaSourceDurationUpdater` will then use that value to determine
+     * which `duration` attribute should be set on the `MediaSource` associated
+     *
+     * @param {number} newDuration
+     * @param {boolean} isRealEndKnown - If set to `false`, the current content is
+     * a dynamic content (it might evolve in the future) and the `newDuration`
+     * communicated might be greater still. In effect the
+     * `MediaSourceDurationUpdater` will actually set a much higher value to the
+     * `MediaSource`'s duration to prevent being annoyed by the HTML-related
+     * side-effects of having a too low duration (such as the impossibility to
+     * seek over that value).
+     */
+    updateDuration(newDuration: number, isRealEndKnown: boolean): void;
+    /**
+     * Abort the last duration-setting operation and free its resources.
+     */
+    stopUpdating(): void;
+}

package/dist/_esm5.processed/core/init/utils/{media_duration_updater.js → media_source_duration_updater.js}

@@ -14,96 +14,91 @@
  * limitations under the License.
  */
 import { onSourceOpen, onSourceEnded, onSourceClose, } from "../../../compat/event_listeners";
+/* eslint-disable-next-line max-len */
+import hasIssuesWithHighMediaSourceDuration from "../../../compat/has_issues_with_high_media_source_duration";
 import log from "../../../log";
 import createSharedReference from "../../../utils/reference";
 import TaskCanceller from "../../../utils/task_canceller";
 /** Number of seconds in a regular year. */
 var YEAR_IN_SECONDS = 365 * 24 * 3600;
 /**
- * Keep the MediaSource's duration up-to-date with what is being played.
- * @class MediaDurationUpdater
+ * Keep the MediaSource's `duration` attribute up-to-date with the duration of
+ * the content played on it.
+ * @class MediaSourceDurationUpdater
  */
-var MediaDurationUpdater = /** @class */ (function () {
+var MediaSourceDurationUpdater = /** @class */ (function () {
     /**
-     * Create a new `MediaDurationUpdater` that will keep the given MediaSource's
-     * duration as soon as possible.
-     * This duration will be updated until the `stop` method is called.
-     * @param {Object} manifest - The Manifest currently played.
-     * For another content, you will have to create another `MediaDurationUpdater`.
+     * Create a new `MediaSourceDurationUpdater`,
      * @param {MediaSource} mediaSource - The MediaSource on which the content is
-     * pushed.
+     * played.
      */
-    function MediaDurationUpdater(manifest, mediaSource) {
-        var canceller = new TaskCanceller();
-        var currentKnownDuration = createSharedReference(undefined, canceller.signal);
-        this._canceller = canceller;
-        this._currentKnownDuration = currentKnownDuration;
-        var isMediaSourceOpened = createMediaSourceOpenReference(mediaSource, this._canceller.signal);
-        /** TaskCanceller triggered each time the MediaSource open status changes. */
-        var msUpdateCanceller = new TaskCanceller();
-        msUpdateCanceller.linkToSignal(this._canceller.signal);
+    function MediaSourceDurationUpdater(mediaSource) {
+        this._mediaSource = mediaSource;
+        this._currentMediaSourceDurationUpdateCanceller = null;
+    }
+    /**
+     * Indicate to the `MediaSourceDurationUpdater` the currently known duration
+     * of the content.
+     *
+     * The `MediaSourceDurationUpdater` will then use that value to determine
+     * which `duration` attribute should be set on the `MediaSource` associated
+     *
+     * @param {number} newDuration
+     * @param {boolean} isRealEndKnown - If set to `false`, the current content is
+     * a dynamic content (it might evolve in the future) and the `newDuration`
+     * communicated might be greater still. In effect the
+     * `MediaSourceDurationUpdater` will actually set a much higher value to the
+     * `MediaSource`'s duration to prevent being annoyed by the HTML-related
+     * side-effects of having a too low duration (such as the impossibility to
+     * seek over that value).
+     */
+    MediaSourceDurationUpdater.prototype.updateDuration = function (newDuration, isRealEndKnown) {
+        if (this._currentMediaSourceDurationUpdateCanceller !== null) {
+            this._currentMediaSourceDurationUpdateCanceller.cancel();
+        }
+        this._currentMediaSourceDurationUpdateCanceller = new TaskCanceller();
+        var mediaSource = this._mediaSource;
+        var currentSignal = this._currentMediaSourceDurationUpdateCanceller.signal;
+        var isMediaSourceOpened = createMediaSourceOpenReference(mediaSource, currentSignal);
+        /** TaskCanceller triggered each time the MediaSource switches to and from "open". */
+        var msOpenStatusCanceller = new TaskCanceller();
+        msOpenStatusCanceller.linkToSignal(currentSignal);
         isMediaSourceOpened.onUpdate(onMediaSourceOpenedStatusChanged, { emitCurrentValue: true,
-            clearSignal: this._canceller.signal });
+            clearSignal: currentSignal });
         function onMediaSourceOpenedStatusChanged() {
-            msUpdateCanceller.cancel();
+            msOpenStatusCanceller.cancel();
             if (!isMediaSourceOpened.getValue()) {
                 return;
             }
-            msUpdateCanceller = new TaskCanceller();
-            msUpdateCanceller.linkToSignal(canceller.signal);
-            /** TaskCanceller triggered each time the content's duration may have changed */
-            var durationChangeCanceller = new TaskCanceller();
-            durationChangeCanceller.linkToSignal(msUpdateCanceller.signal);
-            var reSetDuration = function () {
-                durationChangeCanceller.cancel();
-                durationChangeCanceller = new TaskCanceller();
-                durationChangeCanceller.linkToSignal(msUpdateCanceller.signal);
-                onDurationMayHaveChanged(durationChangeCanceller.signal);
-            };
-            currentKnownDuration.onUpdate(reSetDuration, { emitCurrentValue: false,
-                clearSignal: msUpdateCanceller.signal });
-            manifest.addEventListener("manifestUpdate", reSetDuration, msUpdateCanceller.signal);
-            onDurationMayHaveChanged(durationChangeCanceller.signal);
-        }
-        function onDurationMayHaveChanged(cancelSignal) {
-            var areSourceBuffersUpdating = createSourceBuffersUpdatingReference(mediaSource.sourceBuffers, cancelSignal);
+            msOpenStatusCanceller = new TaskCanceller();
+            msOpenStatusCanceller.linkToSignal(currentSignal);
+            var areSourceBuffersUpdating = createSourceBuffersUpdatingReference(mediaSource.sourceBuffers, msOpenStatusCanceller.signal);
             /** TaskCanceller triggered each time SourceBuffers' updating status changes */
             var sourceBuffersUpdatingCanceller = new TaskCanceller();
-            sourceBuffersUpdatingCanceller.linkToSignal(cancelSignal);
+            sourceBuffersUpdatingCanceller.linkToSignal(msOpenStatusCanceller.signal);
             return areSourceBuffersUpdating.onUpdate(function (areUpdating) {
                 sourceBuffersUpdatingCanceller.cancel();
                 sourceBuffersUpdatingCanceller = new TaskCanceller();
-                sourceBuffersUpdatingCanceller.linkToSignal(cancelSignal);
+                sourceBuffersUpdatingCanceller.linkToSignal(msOpenStatusCanceller.signal);
                 if (areUpdating) {
                     return;
                 }
-                recursivelyForceDurationUpdate(mediaSource, manifest, currentKnownDuration.getValue(), cancelSignal);
-            }, { clearSignal: cancelSignal, emitCurrentValue: true });
+                recursivelyForceDurationUpdate(mediaSource, newDuration, isRealEndKnown, sourceBuffersUpdatingCanceller.signal);
+            }, { clearSignal: msOpenStatusCanceller.signal, emitCurrentValue: true });
         }
-    }
-    /**
-     * By default, the `MediaDurationUpdater` only set a safe estimate for the
-     * MediaSource's duration.
-     * A more precize duration can be set by communicating to it a more precize
-     * media duration through `updateKnownDuration`.
-     * If the duration becomes unknown, `undefined` can be given to it so the
-     * `MediaDurationUpdater` goes back to a safe estimate.
-     * @param {number | undefined} newDuration
-     */
-    MediaDurationUpdater.prototype.updateKnownDuration = function (newDuration) {
-        this._currentKnownDuration.setValueIfChanged(newDuration);
     };
     /**
-     * Stop the `MediaDurationUpdater` from updating and free its resources.
-     * Once stopped, it is not possible to start it again, beside creating another
-     * `MediaDurationUpdater`.
+     * Abort the last duration-setting operation and free its resources.
      */
-    MediaDurationUpdater.prototype.stop = function () {
-        this._canceller.cancel();
+    MediaSourceDurationUpdater.prototype.stopUpdating = function () {
+        if (this._currentMediaSourceDurationUpdateCanceller !== null) {
+            this._currentMediaSourceDurationUpdateCanceller.cancel();
+            this._currentMediaSourceDurationUpdateCanceller = null;
+        }
     };
-    return MediaDurationUpdater;
+    return MediaSourceDurationUpdater;
 }());
-export default MediaDurationUpdater;
+export default MediaSourceDurationUpdater;
 /**
  * Checks that duration can be updated on the MediaSource, and then
  * sets it.
@@ -113,28 +108,16 @@ export default MediaDurationUpdater;
  *   - `null` if it hasn'nt been updated
  *
  * @param {MediaSource} mediaSource
- * @param {Object} manifest
+ * @param {number} duration
+ * @param {boolean} isRealEndKnown
  * @returns {string}
  */
-function setMediaSourceDuration(mediaSource, manifest, knownDuration) {
-    var _a;
-    var newDuration = knownDuration;
-    if (newDuration === undefined) {
-        if (manifest.isDynamic) {
-            newDuration = (_a = manifest.getLivePosition()) !== null && _a !== void 0 ? _a : manifest.getMaximumSafePosition();
-        }
-        else {
-            newDuration = manifest.getMaximumSafePosition();
-        }
-    }
-    if (manifest.isDynamic) {
-        // Some targets poorly support setting a very high number for durations.
-        // Yet, in dynamic contents, we would prefer setting a value as high as possible
-        // to still be able to seek anywhere we want to (even ahead of the Manifest if
-        // we want to). As such, we put it at a safe default value of 2^32 excepted
-        // when the maximum position is already relatively close to that value, where
-        // we authorize exceptionally going over it.
-        newDuration = Math.max(Math.pow(2, 32), newDuration + YEAR_IN_SECONDS);
+function setMediaSourceDuration(mediaSource, duration, isRealEndKnown) {
+    var newDuration = duration;
+    if (!isRealEndKnown) {
+        newDuration = hasIssuesWithHighMediaSourceDuration() ?
+            Infinity :
+            getMaximumLiveSeekablePosition(duration);
     }
     var maxBufferedEnd = 0;
     for (var i = 0; i < mediaSource.sourceBuffers.length; i++) {
@@ -167,6 +150,9 @@ function setMediaSourceDuration(mediaSource, manifest, knownDuration) {
         try {
             log.info("Init: Updating duration", newDuration);
             mediaSource.duration = newDuration;
+            if (mediaSource.readyState === "open" && !isFinite(newDuration)) {
+                mediaSource.setLiveSeekableRange(0, getMaximumLiveSeekablePosition(duration));
+            }
         }
         catch (err) {
             log.warn("Duration Updater: Can't update duration on the MediaSource.", err instanceof Error ? err : "");
@@ -242,25 +228,36 @@ function createMediaSourceOpenReference(mediaSource, cancelSignal) {
 }
 /**
  * Immediately tries to set the MediaSource's duration to the most appropriate
- * one according to the Manifest and duration given.
+ * one.
  *
  * If it fails, wait 2 seconds and retries.
  *
  * @param {MediaSource} mediaSource
- * @param {Object} manifest
- * @param {number|undefined} duration
+ * @param {number} duration
+ * @param {boolean} isRealEndKnown
  * @param {Object} cancelSignal
  */
-function recursivelyForceDurationUpdate(mediaSource, manifest, duration, cancelSignal) {
-    var res = setMediaSourceDuration(mediaSource, manifest, duration);
+function recursivelyForceDurationUpdate(mediaSource, duration, isRealEndKnown, cancelSignal) {
+    var res = setMediaSourceDuration(mediaSource, duration, isRealEndKnown);
     if (res === "success" /* MediaSourceDurationUpdateStatus.Success */) {
         return;
     }
     var timeoutId = setTimeout(function () {
         unregisterClear();
-        recursivelyForceDurationUpdate(mediaSource, manifest, duration, cancelSignal);
+        recursivelyForceDurationUpdate(mediaSource, duration, isRealEndKnown, cancelSignal);
     }, 2000);
     var unregisterClear = cancelSignal.register(function () {
         clearTimeout(timeoutId);
     });
 }
+function getMaximumLiveSeekablePosition(contentLastPosition) {
+    // Some targets poorly support setting a very high number for seekable
+    // ranges.
+    // Yet, in contents whose end is not yet known (e.g. live contents), we
+    // would prefer setting a value as high as possible to still be able to
+    // seek anywhere we want to (even ahead of the Manifest if we want to).
+    // As such, we put it at a safe default value of 2^32 excepted when the
+    // maximum position is already relatively close to that value, where we
+    // authorize exceptionally going over it.
+    return Math.max(Math.pow(2, 32), contentLastPosition + YEAR_IN_SECONDS);
+}

package/dist/_esm5.processed/core/init/utils/rebuffering_controller.d.ts

@@ -18,7 +18,7 @@ import { IPlayerError } from "../../../public_types";
 import EventEmitter from "../../../utils/event_emitter";
 import { IReadOnlySharedReference } from "../../../utils/reference";
 import { PlaybackObserver } from "../../api";
-import { IBufferType } from "../../segment_buffers";
+import SegmentBuffersStore, { IBufferType } from "../../segment_buffers";
 import { IStallingSituation } from "../types";
 /**
  * Monitor playback, trying to avoid stalling situation.
@@ -32,6 +32,7 @@ export default class RebufferingController extends EventEmitter<IRebufferingCont
     /** Emit the current playback conditions */
     private _playbackObserver;
     private _manifest;
+    private _segmentBuffersStore;
     private _speed;
     private _isStarted;
     /**
@@ -40,12 +41,23 @@ export default class RebufferingController extends EventEmitter<IRebufferingCont
      */
     private _discontinuitiesStore;
     private _canceller;
+    /**
+     * If set to something else than `null`, this is the DOMHighResTimestamp as
+     * outputed by `performance.now()` when playback begin to seem to not start
+     * despite having decipherable data in the buffer(s).
+     *
+     * If enough time in that condition is spent, special considerations are
+     * taken at which point `_currentFreezeTimestamp` is reset to `null`.
+     *
+     * It is also reset to `null` when and if there is no such issue anymore.
+     */
+    private _currentFreezeTimestamp;
     /**
      * @param {object} playbackObserver - emit the current playback conditions.
      * @param {Object} manifest - The Manifest of the currently-played content.
      * @param {Object} speed - The last speed set by the user
      */
-    constructor(playbackObserver: PlaybackObserver, manifest: Manifest | null, speed: IReadOnlySharedReference<number>);
+    constructor(playbackObserver: PlaybackObserver, manifest: Manifest | null, segmentBuffersStore: SegmentBuffersStore | null, speed: IReadOnlySharedReference<number>);
     start(): void;
     /**
      * Update information on an upcoming discontinuity for a given buffer type and
@@ -68,10 +80,32 @@ export default class RebufferingController extends EventEmitter<IRebufferingCont
      * forever.
      */
     destroy(): void;
+    /**
+     * Support of contents with DRM on all the platforms out there is a pain in
+     * the *ss considering all the DRM-related bugs there are.
+     *
+     * We found out a frequent issue which is to be unable to play despite having
+     * all the decryption keys to play what is currently buffered.
+     * When this happens, re-creating the buffers from scratch, with a reload, is
+     * usually sufficient to unlock the situation.
+     *
+     * Although we prefer providing more targeted fixes or telling to platform
+     * developpers to fix their implementation, it's not always possible.
+     * We thus resorted to developping an heuristic which detects such situation
+     * and reload in that case.
+     *
+     * @param {Object} observation - The last playback observation produced, it
+     * has to be recent (just triggered for example).
+     * @returns {boolean} - Returns `true` if it seems to be such kind of
+     * decipherability freeze, in which case this method already performed the
+     * right handling steps.
+     */
+    private _checkDecipherabilityFreeze;
 }
 export interface IRebufferingControllerEvent {
     stalled: IStallingSituation;
     unstalled: null;
+    needsReload: null;
     warning: IPlayerError;
 }
 /**