rx-player 3.30.1-dev.2023032301 → 3.30.1-dev.2023032800

package/CHANGELOG.md

@@ -1,10 +1,16 @@
 # Changelog
 
-## v3.30.1-dev.2023032301 (2023-03-23)
+## v3.30.1-dev.2023032800 (2023-03-28)
 
 ### Bug fixes
 
-  - DASH: Fix issue which could lead to infinite rebuffering when switching between multiple Periods
+  - DASH: Fix issue which could lead to infinite rebuffering when switching between multiple Periods [#1232]
+  - Return actual ending duration through the `getVideoDuration` method when playing dynamic contents whose future end is already known [#1235]
+
+### Other improvements
+
+  - adaptive: Perform various adaptive tweaks to avoid switching too much between qualities in some conditions
+
 
 ## v3.30.0 (2023-03-07)
 

package/VERSION

@@ -1 +1 @@
-3.30.1-dev.2023032301
+3.30.1-dev.2023032800

package/dist/_esm5.processed/config.d.ts

@@ -77,6 +77,8 @@ declare class ConfigHandler {
         SAMPLING_INTERVAL_MEDIASOURCE: number;
         SAMPLING_INTERVAL_LOW_LATENCY: number;
         SAMPLING_INTERVAL_NO_MEDIASOURCE: number;
+        ABR_ENTER_BUFFER_BASED_ALGO: number;
+        ABR_EXIT_BUFFER_BASED_ALGO: number;
         ABR_MINIMUM_TOTAL_BYTES: number;
         ABR_MINIMUM_CHUNK_SIZE: number;
         ABR_STARVATION_FACTOR: {

package/dist/_esm5.processed/core/adaptive/adaptive_representation_selector.js

@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import config from "../../config";
 import log from "../../log";
 import noop from "../../utils/noop";
 import { getLeftSizeOfRange } from "../../utils/ranges";
@@ -242,12 +243,13 @@ function getEstimateReference(_a, stopAllEstimates) {
                 stableRepresentation.bitrate / (lastPlaybackObservation.speed > 0 ?
                     lastPlaybackObservation.speed :
                     1);
-            if (allowBufferBasedEstimates && bufferGap <= 5) {
+            var _b = config.getCurrent(), ABR_ENTER_BUFFER_BASED_ALGO = _b.ABR_ENTER_BUFFER_BASED_ALGO, ABR_EXIT_BUFFER_BASED_ALGO = _b.ABR_EXIT_BUFFER_BASED_ALGO;
+            if (allowBufferBasedEstimates && bufferGap <= ABR_EXIT_BUFFER_BASED_ALGO) {
                 allowBufferBasedEstimates = false;
             }
             else if (!allowBufferBasedEstimates &&
                 isFinite(bufferGap) &&
-                bufferGap > 10) {
+                bufferGap >= ABR_ENTER_BUFFER_BASED_ALGO) {
                 allowBufferBasedEstimates = true;
             }
             /**

package/dist/_esm5.processed/core/adaptive/buffer_based_chooser.js

@@ -56,10 +56,10 @@ var BufferBasedChooser = /** @class */ (function () {
             return bitrates[0];
         }
         var scaledScore;
-        if (currentScore != null) {
+        if (currentScore !== undefined) {
             scaledScore = speed === 0 ? currentScore : (currentScore / speed);
         }
-        if (scaledScore != null && scaledScore > 1) {
+        if (scaledScore !== undefined && scaledScore > 1) {
             var currentBufferLevel_1 = bufferLevels[currentBitrateIndex];
             var nextIndex = (function () {
                 for (var i = currentBitrateIndex + 1; i < bufferLevels.length; i++) {
@@ -68,14 +68,14 @@ var BufferBasedChooser = /** @class */ (function () {
                     }
                 }
             })();
-            if (nextIndex != null) {
+            if (nextIndex !== undefined) {
                 var nextBufferLevel = bufferLevels[nextIndex];
                 if (bufferGap >= nextBufferLevel) {
                     return bitrates[nextIndex];
                 }
             }
         }
-        if (scaledScore == null || scaledScore < 1.15) {
+        if (scaledScore === undefined || scaledScore < 1.15) {
             var currentBufferLevel = bufferLevels[currentBitrateIndex];
             if (bufferGap < currentBufferLevel) {
                 for (var i = currentBitrateIndex - 1; i >= 0; i--) {

package/dist/_esm5.processed/core/adaptive/network_analyzer.js

@@ -126,6 +126,12 @@ function estimateStarvationModeBitrate(pendingRequests, playbackInfo, currentRep
     }
     var concernedRequest = concernedRequests[0];
     var now = performance.now();
+    var minimumRequestTime = concernedRequest.content.segment.duration * 1.5;
+    minimumRequestTime = Math.min(minimumRequestTime, 3000);
+    minimumRequestTime = Math.max(minimumRequestTime, 12000);
+    if (now - concernedRequest.requestTimestamp < minimumRequestTime) {
+        return undefined;
+    }
     var lastProgressEvent = concernedRequest.progress.length > 0 ?
         concernedRequest.progress[concernedRequest.progress.length - 1] :
         undefined;
@@ -138,7 +144,7 @@ function estimateStarvationModeBitrate(pendingRequests, playbackInfo, currentRep
             // Calculate estimated time spent rebuffering if we continue doing that request.
             var expectedRebufferingTime = remainingTime -
                 (realBufferGap / speed);
-            if (expectedRebufferingTime > 2000) {
+            if (expectedRebufferingTime > 2500) {
                 return bandwidthEstimate;
             }
         }
@@ -320,12 +326,9 @@ var NetworkAnalyzer = /** @class */ (function () {
         if (currentRepresentation === null) {
             return true;
         }
-        else if (bitrate === currentRepresentation.bitrate) {
+        else if (bitrate >= currentRepresentation.bitrate) {
             return false;
         }
-        else if (bitrate > currentRepresentation.bitrate) {
-            return !this._inStarvationMode;
-        }
         return shouldDirectlySwitchToLowBitrate(playbackInfo, currentRequests, this._lowLatencyMode);
     };
     return NetworkAnalyzer;

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

@@ -89,7 +89,7 @@ var Player = /** @class */ (function (_super) {
         // Workaround to support Firefox autoplay on FF 42.
         // See: https://bugzilla.mozilla.org/show_bug.cgi?id=1194624
         videoElement.preload = "auto";
-        _this.version = /* PLAYER_VERSION */ "3.30.1-dev.2023032301";
+        _this.version = /* PLAYER_VERSION */ "3.30.1-dev.2023032800";
         _this.log = log;
         _this.state = "STOPPED";
         _this.videoElement = videoElement;
@@ -2340,5 +2340,5 @@ var Player = /** @class */ (function (_super) {
     };
     return Player;
 }(EventEmitter));
-Player.version = /* PLAYER_VERSION */ "3.30.1-dev.2023032301";
+Player.version = /* PLAYER_VERSION */ "3.30.1-dev.2023032800";
 export default Player;

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";
@@ -501,9 +501,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;
@@ -518,7 +518,7 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
             _this.trigger("activePeriodChanged", { period: period });
         });
         contentTimeBoundariesObserver.addEventListener("durationUpdate", function (newDuration) {
-            mediaDurationUpdater.updateKnownDuration(newDuration);
+            mediaSourceDurationUpdater.updateDuration(newDuration.duration, !newDuration.isEnd);
         });
         contentTimeBoundariesObserver.addEventListener("endOfStream", function () {
             if (endOfStreamCanceller === null) {
@@ -535,6 +535,8 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
                 endOfStreamCanceller = null;
             }
         });
+        var currentDuration = contentTimeBoundariesObserver.getCurrentDuration();
+        mediaSourceDurationUpdater.updateDuration(currentDuration.duration, !currentDuration.isEnd);
         return contentTimeBoundariesObserver;
     };
     /**

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} addTimeMargin - If set to `true`, 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, addTimeMargin: 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}

@@ -20,90 +20,83 @@ 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} addTimeMargin - If set to `true`, 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, addTimeMargin) {
+        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, addTimeMargin, 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,27 +106,20 @@ export default MediaDurationUpdater;
  *   - `null` if it hasn'nt been updated
  *
  * @param {MediaSource} mediaSource
- * @param {Object} manifest
+ * @param {number} duration
+ * @param {boolean} addTimeMargin
  * @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) {
+function setMediaSourceDuration(mediaSource, duration, addTimeMargin) {
+    var newDuration = duration;
+    if (addTimeMargin) {
         // 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.
+        // 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.
         newDuration = Math.max(Math.pow(2, 32), newDuration + YEAR_IN_SECONDS);
     }
     var maxBufferedEnd = 0;
@@ -242,23 +228,23 @@ 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} addTimeMargin
  * @param {Object} cancelSignal
  */
-function recursivelyForceDurationUpdate(mediaSource, manifest, duration, cancelSignal) {
-    var res = setMediaSourceDuration(mediaSource, manifest, duration);
+function recursivelyForceDurationUpdate(mediaSource, duration, addTimeMargin, cancelSignal) {
+    var res = setMediaSourceDuration(mediaSource, duration, addTimeMargin);
     if (res === "success" /* MediaSourceDurationUpdateStatus.Success */) {
         return;
     }
     var timeoutId = setTimeout(function () {
         unregisterClear();
-        recursivelyForceDurationUpdate(mediaSource, manifest, duration, cancelSignal);
+        recursivelyForceDurationUpdate(mediaSource, duration, addTimeMargin, cancelSignal);
     }, 2000);
     var unregisterClear = cancelSignal.register(function () {
         clearTimeout(timeoutId);

package/dist/_esm5.processed/core/stream/orchestrator/stream_orchestrator.js

@@ -411,7 +411,7 @@ export default function StreamOrchestrator(content, playbackObserver, representa
                     var nextPeriod = manifest.getPeriodAfter(basePeriod);
                     if (nextPeriod !== null) {
                         // current Stream is full, create the next one if not
-                        createNextPeriodStream(nextPeriod);
+                        checkOrCreateNextPeriodStream(nextPeriod);
                     }
                 }
                 else if (nextStreamInfo !== null) {
@@ -436,12 +436,12 @@ export default function StreamOrchestrator(content, playbackObserver, representa
          * Create `PeriodStream` for the next Period, specified under `nextPeriod`.
          * @param {Object} nextPeriod
          */
-        function createNextPeriodStream(nextPeriod) {
+        function checkOrCreateNextPeriodStream(nextPeriod) {
             if (nextStreamInfo !== null) {
                 if (nextStreamInfo.period.id === nextPeriod.id) {
                     return;
                 }
-                log.warn("Stream: Creating next `PeriodStream` while it was already created.", bufferType);
+                log.warn("Stream: Creating next `PeriodStream` while one was already created.", bufferType, nextPeriod.id, nextStreamInfo.period.id);
                 consecutivePeriodStreamCb.periodStreamCleared({ type: bufferType,
                     period: nextStreamInfo.period });
                 nextStreamInfo.canceller.cancel();

package/dist/_esm5.processed/default_config.d.ts

@@ -420,6 +420,31 @@ declare const DEFAULT_CONFIG: {
      * @type {Number}
      */
     SAMPLING_INTERVAL_NO_MEDIASOURCE: number;
+    /**
+     * Amount of buffer to have ahead of the current position before we may
+     * consider buffer-based adaptive estimates, in seconds.
+     *
+     * For example setting it to `10` means that we need to have ten seconds of
+     * buffer ahead of the current position before relying on buffer-based
+     * adaptive estimates.
+     *
+     * To avoid getting in-and-out of the buffer-based logic all the time, it
+     * should be set higher than `ABR_EXIT_BUFFER_BASED_ALGO`.
+     */
+    ABR_ENTER_BUFFER_BASED_ALGO: number;
+    /**
+     * Below this amount of buffer ahead of the current position, in seconds, we
+     * will stop using buffer-based estimate in our adaptive logic to select a
+     * quality.
+     *
+     * For example setting it to `5` means that if we have less than 5 seconds of
+     * buffer ahead of the current position, we should stop relying on
+     * buffer-based estimates to choose a quality.
+     *
+     * To avoid getting in-and-out of the buffer-based logic all the time, it
+     * should be set lower than `ABR_ENTER_BUFFER_BASED_ALGO`.
+     */
+    ABR_EXIT_BUFFER_BASED_ALGO: number;
     /**
      * Minimum number of bytes sampled before we trust the estimate.
      * If we have not sampled much data, our estimate may not be accurate