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

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

package/dist/_esm5.processed/default_config.js

@@ -444,6 +444,31 @@ var DEFAULT_CONFIG = {
      * @type {Number}
      */
     SAMPLING_INTERVAL_NO_MEDIASOURCE: 500,
+    /**
+     * 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: 10,
+    /**
+     * 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: 5,
     /**
      * Minimum number of bytes sampled before we trust the estimate.
      * If we have not sampled much data, our estimate may not be accurate
@@ -479,8 +504,8 @@ var DEFAULT_CONFIG = {
      * @type {Object}
      */
     ABR_REGULAR_FACTOR: {
-        DEFAULT: 0.8,
-        LOW_LATENCY: 0.8,
+        DEFAULT: 0.72,
+        LOW_LATENCY: 0.72,
     },
     /**
      * If a media buffer has less than ABR_STARVATION_GAP in seconds ahead of the

package/dist/_esm5.processed/utils/is_null_or_undefined.d.ts

@@ -19,6 +19,6 @@
  * not always understood by newcomers to the code, and which can be overused when
  * only one of the possibility can arise.
  * @param {*} x
- * @returns {*}
+ * @returns {boolean}
  */
 export default function isNullOrUndefined(x: unknown): x is null | undefined | void;

package/dist/_esm5.processed/utils/is_null_or_undefined.js

@@ -19,7 +19,7 @@
  * not always understood by newcomers to the code, and which can be overused when
  * only one of the possibility can arise.
  * @param {*} x
- * @returns {*}
+ * @returns {boolean}
  */
 export default function isNullOrUndefined(x) {
     return x === null || x === undefined;