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

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;

package/dist/rx-player.js

@@ -2326,6 +2326,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
@@ -2361,8 +2386,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
@@ -34911,7 +34936,7 @@ function isNonEmptyString(x) {
  * 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}
  */
 function isNullOrUndefined(x) {
   return x === null || x === undefined;
@@ -38648,10 +38673,10 @@ var BufferBasedChooser = /*#__PURE__*/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 = bufferLevels[currentBitrateIndex];
       var nextIndex = function () {
         for (var i = currentBitrateIndex + 1; i < bufferLevels.length; i++) {
@@ -38660,14 +38685,14 @@ var BufferBasedChooser = /*#__PURE__*/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--) {
@@ -38870,6 +38895,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;
   // first, try to do a quick estimate from progress events
   var bandwidthEstimate = estimateRequestBandwidth(concernedRequest);
@@ -38879,7 +38910,7 @@ function estimateStarvationModeBitrate(pendingRequests, playbackInfo, currentRep
     if ((now - lastProgressEvent.timestamp) / 1000 <= remainingTime) {
       // Calculate estimated time spent rebuffering if we continue doing that request.
       var expectedRebufferingTime = remainingTime - realBufferGap / speed;
-      if (expectedRebufferingTime > 2000) {
+      if (expectedRebufferingTime > 2500) {
         return bandwidthEstimate;
       }
     }
@@ -39054,10 +39085,8 @@ var NetworkAnalyzer = /*#__PURE__*/function () {
   _proto.isUrgent = function isUrgent(bitrate, currentRepresentation, currentRequests, playbackInfo) {
     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);
   };
@@ -39783,6 +39812,7 @@ function selectOptimalRepresentation(representations, optimalBitrate, minBitrate
 
 
 
+
 // Create default shared references
 var manualBitrateDefaultRef = (0,reference/* default */.ZP)(-1);
 manualBitrateDefaultRef.finish();
@@ -40055,9 +40085,12 @@ function getEstimateReference(_ref, stopAllEstimates) {
         bitrateChosen = _networkAnalyzer$getB.bitrateChosen;
       var stableRepresentation = scoreCalculator.getLastStableRepresentation();
       var knownStableBitrate = stableRepresentation === null ? undefined : stableRepresentation.bitrate / (lastPlaybackObservation.speed > 0 ? lastPlaybackObservation.speed : 1);
-      if (allowBufferBasedEstimates && bufferGap <= 5) {
+      var _config$getCurrent = config/* default.getCurrent */.Z.getCurrent(),
+        ABR_ENTER_BUFFER_BASED_ALGO = _config$getCurrent.ABR_ENTER_BUFFER_BASED_ALGO,
+        ABR_EXIT_BUFFER_BASED_ALGO = _config$getCurrent.ABR_EXIT_BUFFER_BASED_ALGO;
+      if (allowBufferBasedEstimates && bufferGap <= ABR_EXIT_BUFFER_BASED_ALGO) {
         allowBufferBasedEstimates = false;
-      } else if (!allowBufferBasedEstimates && isFinite(bufferGap) && bufferGap > 10) {
+      } else if (!allowBufferBasedEstimates && isFinite(bufferGap) && bufferGap >= ABR_ENTER_BUFFER_BASED_ALGO) {
         allowBufferBasedEstimates = true;
       }
       /**
@@ -47525,7 +47558,7 @@ function StreamOrchestrator(content, playbackObserver, representationEstimator,
           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) {
           // current Stream is active, destroy next Stream if created
@@ -47553,12 +47586,12 @@ function StreamOrchestrator(content, playbackObserver, representationEstimator,
      * 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/* default.warn */.Z.warn("Stream: Creating next `PeriodStream` while it was already created.", bufferType);
+        log/* default.warn */.Z.warn("Stream: Creating next `PeriodStream` while one was already created.", bufferType, nextPeriod.id, nextStreamInfo.period.id);
         consecutivePeriodStreamCb.periodStreamCleared({
           type: bufferType,
           period: nextStreamInfo.period
@@ -47707,17 +47740,22 @@ var ContentTimeBoundariesObserver = /*#__PURE__*/function (_EventEmitter) {
       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}
+   */
+  var _proto = ContentTimeBoundariesObserver.prototype;
+  _proto.getCurrentDuration = function getCurrentDuration() {
+    return this._getManifestDuration();
+  }
   /**
    * Method to call any time an Adaptation has been selected.
    *
@@ -47730,8 +47768,7 @@ var ContentTimeBoundariesObserver = /*#__PURE__*/function (_EventEmitter) {
    * @param {Object|null} adaptation - The Adaptation selected. `null` if the
    * absence of `Adaptation` has been explicitely selected for this Period and
    * buffer type (e.g. no video).
-   */
-  var _proto = ContentTimeBoundariesObserver.prototype;
+   */;
   _proto.onAdaptationChange = function onAdaptationChange(bufferType, period, adaptation) {
     if (this._manifest.isLastPeriodKnown) {
       var lastPeriod = this._manifest.periods[this._manifest.periods.length - 1];
@@ -47742,7 +47779,14 @@ var ContentTimeBoundariesObserver = /*#__PURE__*/function (_EventEmitter) {
           } else {
             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);
         }
       }
@@ -47882,6 +47926,16 @@ var ContentTimeBoundariesObserver = /*#__PURE__*/function (_EventEmitter) {
       if (typeof _ret === "object") return _ret.v;
     }
   };
+  _proto._getManifestDuration = function _getManifestDuration() {
+    var endingPosition = this._maximumPositionCalculator.getEndingPosition();
+    return endingPosition !== undefined ? {
+      isEnd: true,
+      duration: endingPosition
+    } : {
+      isEnd: false,
+      duration: this._maximumPositionCalculator.getMaximumAvailablePosition()
+    };
+  };
   _proto._lazilyCreateActiveStreamInfo = function _lazilyCreateActiveStreamInfo(bufferType) {
     var streamInfo = this._activeStreams.get(bufferType);
     if (streamInfo === undefined) {
@@ -48483,7 +48537,7 @@ var get_loaded_reference = __webpack_require__(1757);
 var initial_seek_and_play = __webpack_require__(8833);
 // EXTERNAL MODULE: ./src/core/init/utils/initialize_content_decryption.ts + 1 modules
 var initialize_content_decryption = __webpack_require__(8799);
-;// CONCATENATED MODULE: ./src/core/init/utils/media_duration_updater.ts
+;// CONCATENATED MODULE: ./src/core/init/utils/media_source_duration_updater.ts
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -48506,96 +48560,87 @@ var initialize_content_decryption = __webpack_require__(8799);
 /** 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 = /*#__PURE__*/function () {
+var MediaSourceDurationUpdater = /*#__PURE__*/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 task_canceller/* default */.ZP();
-    var currentKnownDuration = (0,reference/* default */.ZP)(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 task_canceller/* default */.ZP();
-    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).
+   */
+  var _proto = MediaSourceDurationUpdater.prototype;
+  _proto.updateDuration = function updateDuration(newDuration, addTimeMargin) {
+    if (this._currentMediaSourceDurationUpdateCanceller !== null) {
+      this._currentMediaSourceDurationUpdateCanceller.cancel();
+    }
+    this._currentMediaSourceDurationUpdateCanceller = new task_canceller/* default */.ZP();
+    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 task_canceller/* default */.ZP();
+    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 task_canceller/* default */.ZP();
-      msUpdateCanceller.linkToSignal(canceller.signal);
-      /** TaskCanceller triggered each time the content's duration may have changed */
-      var durationChangeCanceller = new task_canceller/* default */.ZP();
-      durationChangeCanceller.linkToSignal(msUpdateCanceller.signal);
-      var reSetDuration = function reSetDuration() {
-        durationChangeCanceller.cancel();
-        durationChangeCanceller = new task_canceller/* default */.ZP();
-        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 task_canceller/* default */.ZP();
+      msOpenStatusCanceller.linkToSignal(currentSignal);
+      var areSourceBuffersUpdating = createSourceBuffersUpdatingReference(mediaSource.sourceBuffers, msOpenStatusCanceller.signal);
       /** TaskCanceller triggered each time SourceBuffers' updating status changes */
       var sourceBuffersUpdatingCanceller = new task_canceller/* default */.ZP();
-      sourceBuffersUpdatingCanceller.linkToSignal(cancelSignal);
+      sourceBuffersUpdatingCanceller.linkToSignal(msOpenStatusCanceller.signal);
       return areSourceBuffersUpdating.onUpdate(function (areUpdating) {
         sourceBuffersUpdatingCanceller.cancel();
         sourceBuffersUpdatingCanceller = new task_canceller/* default */.ZP();
-        sourceBuffersUpdatingCanceller.linkToSignal(cancelSignal);
+        sourceBuffersUpdatingCanceller.linkToSignal(msOpenStatusCanceller.signal);
         if (areUpdating) {
           return;
         }
-        recursivelyForceDurationUpdate(mediaSource, manifest, currentKnownDuration.getValue(), cancelSignal);
+        recursivelyForceDurationUpdate(mediaSource, newDuration, addTimeMargin, sourceBuffersUpdatingCanceller.signal);
       }, {
-        clearSignal: cancelSignal,
+        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
-   */
-  var _proto = MediaDurationUpdater.prototype;
-  _proto.updateKnownDuration = function updateKnownDuration(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.
    */;
-  _proto.stop = function stop() {
-    this._canceller.cancel();
+  _proto.stopUpdating = function stopUpdating() {
+    if (this._currentMediaSourceDurationUpdateCanceller !== null) {
+      this._currentMediaSourceDurationUpdateCanceller.cancel();
+      this._currentMediaSourceDurationUpdateCanceller = null;
+    }
   };
-  return MediaDurationUpdater;
+  return MediaSourceDurationUpdater;
 }();
 /**
  * Checks that duration can be updated on the MediaSource, and then
@@ -48606,27 +48651,21 @@ var MediaDurationUpdater = /*#__PURE__*/function () {
  *   - `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;
@@ -48733,23 +48772,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);
@@ -49601,9 +49640,9 @@ var MediaSourceContentInitializer = /*#__PURE__*/function (_ContentInitializer)
   _proto._createContentTimeBoundariesObserver = function _createContentTimeBoundariesObserver(manifest, mediaSource, streamObserver, segmentBuffersStore, cancelSignal) {
     var _this7 = 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;
@@ -49620,7 +49659,7 @@ var MediaSourceContentInitializer = /*#__PURE__*/function (_ContentInitializer)
       });
     });
     contentTimeBoundariesObserver.addEventListener("durationUpdate", function (newDuration) {
-      mediaDurationUpdater.updateKnownDuration(newDuration);
+      mediaSourceDurationUpdater.updateDuration(newDuration.duration, !newDuration.isEnd);
     });
     contentTimeBoundariesObserver.addEventListener("endOfStream", function () {
       if (endOfStreamCanceller === null) {
@@ -49637,6 +49676,8 @@ var MediaSourceContentInitializer = /*#__PURE__*/function (_ContentInitializer)
         endOfStreamCanceller = null;
       }
     });
+    var currentDuration = contentTimeBoundariesObserver.getCurrentDuration();
+    mediaSourceDurationUpdater.updateDuration(currentDuration.duration, !currentDuration.isEnd);
     return contentTimeBoundariesObserver;
   }
   /**
@@ -52026,7 +52067,7 @@ var Player = /*#__PURE__*/function (_EventEmitter) {
     // 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/* default */.Z;
     _this.state = "STOPPED";
     _this.videoElement = videoElement;
@@ -54342,7 +54383,7 @@ var Player = /*#__PURE__*/function (_EventEmitter) {
   }]);
   return Player;
 }(event_emitter/* default */.Z);
-Player.version = /* PLAYER_VERSION */"3.30.1-dev.2023032301";
+Player.version = /* PLAYER_VERSION */"3.30.1-dev.2023032800";
 /* harmony default export */ var public_api = (Player);
 ;// CONCATENATED MODULE: ./src/core/api/index.ts
 /**