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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "rx-player",
   "author": "Canal+",
-  "version": "3.30.1-dev.2023032301",
+  "version": "3.30.1-dev.2023032800",
   "description": "Canal+ HTML5 Video Player",
   "main": "./dist/rx-player.js",
   "keywords": [

package/sonar-project.properties

@@ -1,7 +1,7 @@
 sonar.projectKey=rx-player
 sonar.organization=rx-player
 sonar.projectName=rx-player
-sonar.projectVersion=3.30.1-dev.2023032301
+sonar.projectVersion=3.30.1-dev.2023032800
 sonar.sources=./src,./demo,./tests
 sonar.exclusions=demo/full/bundle.js,demo/standalone/lib.js,demo/bundle.js
 sonar.host.url=https://sonarcloud.io

package/src/core/adaptive/adaptive_representation_selector.ts

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+import config from "../../config";
 import log from "../../log";
 import Manifest, {
   Adaptation,
@@ -362,11 +363,14 @@ function getEstimateReference(
                                           lastPlaybackObservation.speed :
                                           1);
 
-      if (allowBufferBasedEstimates && bufferGap <= 5) {
+      const { ABR_ENTER_BUFFER_BASED_ALGO,
+              ABR_EXIT_BUFFER_BASED_ALGO } = config.getCurrent();
+
+      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/src/core/adaptive/buffer_based_chooser.ts

@@ -66,11 +66,11 @@ export default class BufferBasedChooser {
     }
 
     let scaledScore : number|undefined;
-    if (currentScore != null) {
+    if (currentScore !== undefined) {
       scaledScore = speed === 0 ? currentScore : (currentScore / speed);
     }
 
-    if (scaledScore != null && scaledScore > 1) {
+    if (scaledScore !== undefined && scaledScore > 1) {
       const currentBufferLevel = bufferLevels[currentBitrateIndex];
       const nextIndex = (() => {
         for (let i = currentBitrateIndex + 1; i < bufferLevels.length; i++) {
@@ -79,7 +79,7 @@ export default class BufferBasedChooser {
           }
         }
       })();
-      if (nextIndex != null) {
+      if (nextIndex !== undefined) {
         const nextBufferLevel = bufferLevels[nextIndex];
         if (bufferGap >= nextBufferLevel) {
           return bitrates[nextIndex];
@@ -87,7 +87,7 @@ export default class BufferBasedChooser {
       }
     }
 
-    if (scaledScore == null || scaledScore < 1.15) {
+    if (scaledScore === undefined || scaledScore < 1.15) {
       const currentBufferLevel = bufferLevels[currentBitrateIndex];
       if (bufferGap < currentBufferLevel) {
         for (let i = currentBitrateIndex - 1; i >= 0; i--) {

package/src/core/adaptive/network_analyzer.ts

@@ -162,6 +162,13 @@ function estimateStarvationModeBitrate(
 
   const concernedRequest = concernedRequests[0];
   const now = performance.now();
+
+  let minimumRequestTime = concernedRequest.content.segment.duration * 1.5;
+  minimumRequestTime = Math.min(minimumRequestTime, 3000);
+  minimumRequestTime = Math.max(minimumRequestTime, 12000);
+  if (now - concernedRequest.requestTimestamp < minimumRequestTime) {
+    return undefined;
+  }
   const lastProgressEvent = concernedRequest.progress.length > 0 ?
     concernedRequest.progress[concernedRequest.progress.length - 1] :
     undefined;
@@ -178,7 +185,7 @@ function estimateStarvationModeBitrate(
       // Calculate estimated time spent rebuffering if we continue doing that request.
       const expectedRebufferingTime = remainingTime -
         (realBufferGap / speed);
-      if (expectedRebufferingTime > 2000) {
+      if (expectedRebufferingTime > 2500) {
         return bandwidthEstimate;
       }
     }
@@ -402,10 +409,8 @@ export default class NetworkAnalyzer {
   ) : boolean {
     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,

package/src/core/api/public_api.ts

@@ -364,7 +364,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     // 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;
@@ -2986,7 +2986,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     return mediaElementTrackChoiceManager;
   }
 }
-Player.version = /* PLAYER_VERSION */"3.30.1-dev.2023032301";
+Player.version = /* PLAYER_VERSION */"3.30.1-dev.2023032800";
 
 /** Every events sent by the RxPlayer's public API. */
 interface IPublicAPIEvent {

package/src/core/init/media_source_content_initializer.ts

@@ -68,7 +68,7 @@ import getInitialTime, {
 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";
@@ -644,9 +644,9 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
     cancelSignal : CancellationSignal
   ) : ContentTimeBoundariesObserver {
     /** Maintains the MediaSource's duration up-to-date with the Manifest */
-    const mediaDurationUpdater = new MediaDurationUpdater(manifest, mediaSource);
+    const mediaSourceDurationUpdater = new MediaSourceDurationUpdater(mediaSource);
     cancelSignal.register(() => {
-      mediaDurationUpdater.stop();
+      mediaSourceDurationUpdater.stopUpdating();
     });
     /** Allows to cancel a pending `end-of-stream` operation. */
     let endOfStreamCanceller : TaskCanceller | null = null;
@@ -664,7 +664,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
       this.trigger("activePeriodChanged", { period });
     });
     contentTimeBoundariesObserver.addEventListener("durationUpdate", (newDuration) => {
-      mediaDurationUpdater.updateKnownDuration(newDuration);
+      mediaSourceDurationUpdater.updateDuration(newDuration.duration, !newDuration.isEnd);
     });
     contentTimeBoundariesObserver.addEventListener("endOfStream", () => {
       if (endOfStreamCanceller === null) {
@@ -681,6 +681,9 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
         endOfStreamCanceller = null;
       }
     });
+    const currentDuration = contentTimeBoundariesObserver.getCurrentDuration();
+    mediaSourceDurationUpdater.updateDuration(currentDuration.duration,
+                                              !currentDuration.isEnd);
     return contentTimeBoundariesObserver;
   }
 

package/src/core/init/utils/content_time_boundaries_observer.ts

@@ -111,18 +111,20 @@ export default class ContentTimeBoundariesObserver
     }, { includeLastObservation: true, clearSignal: cancelSignal });
 
     manifest.addEventListener("manifestUpdate", () => {
-      this.trigger("durationUpdate", getManifestDuration());
+      this.trigger("durationUpdate", this._getManifestDuration());
       if (cancelSignal.isCancelled()) {
         return;
       }
       this._checkEndOfStream();
     }, cancelSignal);
+  }
 
-    function getManifestDuration() : number | undefined {
-      return manifest.isDynamic ?
-        maximumPositionCalculator.getMaximumAvailablePosition() :
-        maximumPositionCalculator.getEndingPosition();
-    }
+  /**
+   * Returns an estimate of the current duration of the content.
+   * @returns {Object}
+   */
+  public getCurrentDuration() : IDurationItem  {
+    return this._getManifestDuration();
   }
 
   /**
@@ -154,9 +156,12 @@ export default class ContentTimeBoundariesObserver
             this._maximumPositionCalculator
               .updateLastVideoAdaptation(adaptation);
           }
-          const newDuration = this._manifest.isDynamic ?
-            this._maximumPositionCalculator.getMaximumAvailablePosition() :
-            this._maximumPositionCalculator.getEndingPosition();
+          const endingPosition = this._maximumPositionCalculator.getEndingPosition();
+          const newDuration = endingPosition !== undefined ?
+            { isEnd: true,
+              duration: endingPosition } :
+            { isEnd: false,
+              duration: this._maximumPositionCalculator.getMaximumAvailablePosition() };
           this.trigger("durationUpdate", newDuration);
         }
       }
@@ -306,6 +311,15 @@ export default class ContentTimeBoundariesObserver
     }
   }
 
+  private _getManifestDuration() : IDurationItem {
+    const endingPosition = this._maximumPositionCalculator.getEndingPosition();
+    return endingPosition !== undefined ?
+      { isEnd: true,
+        duration: endingPosition } :
+      { isEnd: false,
+        duration: this._maximumPositionCalculator.getMaximumAvailablePosition() };
+  }
+
   private _lazilyCreateActiveStreamInfo(bufferType : IBufferType) : IActiveStreamsInfo {
     let streamInfo = this._activeStreams.get(bufferType);
     if (streamInfo === undefined) {
@@ -334,6 +348,28 @@ export default class ContentTimeBoundariesObserver
   }
 }
 
+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.
@@ -347,7 +383,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/src/core/init/utils/{media_duration_updater.ts → media_source_duration_updater.ts}

@@ -20,10 +20,8 @@ import {
   onSourceClose,
 } from "../../../compat/event_listeners";
 import log from "../../../log";
-import Manifest from "../../../manifest";
 import createSharedReference, {
   IReadOnlySharedReference,
-  ISharedReference,
 } from "../../../utils/reference";
 import TaskCanceller, {
   CancellationSignal,
@@ -33,124 +31,108 @@ import TaskCanceller, {
 const 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
  */
-export default class MediaDurationUpdater {
-  private _canceller : TaskCanceller;
+export default class MediaSourceDurationUpdater {
+  /**
+   * `MediaSource` on which we're going to update the `duration` attribute.
+   */
+  private _mediaSource : MediaSource;
 
   /**
-   * The last known audio Adaptation (i.e. track) chosen for the last Period.
-   * Useful to determinate the duration of the current content.
-   * `undefined` if the audio track for the last Period has never been known yet.
-   * `null` if there are no chosen audio Adaptation.
+   * Abort the current duration-setting logic.
+   * `null` if no such logic is pending.
    */
-  private _currentKnownDuration : ISharedReference<number | undefined>;
+  private _currentMediaSourceDurationUpdateCanceller : TaskCanceller | null;
 
   /**
-   * 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.
    */
-  constructor(manifest : Manifest, mediaSource : MediaSource) {
-    const canceller = new TaskCanceller();
-    const currentKnownDuration = createSharedReference(undefined, canceller.signal);
+  constructor(mediaSource : MediaSource) {
+    this._mediaSource = mediaSource;
+    this._currentMediaSourceDurationUpdateCanceller = null;
+  }
 
-    this._canceller = canceller;
-    this._currentKnownDuration = currentKnownDuration;
+  /**
+   * 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).
+   */
+  public updateDuration(
+    newDuration : number,
+    addTimeMargin : boolean
+  ) : void {
+    if (this._currentMediaSourceDurationUpdateCanceller !== null) {
+      this._currentMediaSourceDurationUpdateCanceller.cancel();
+    }
+    this._currentMediaSourceDurationUpdateCanceller = new TaskCanceller();
 
+    const mediaSource = this._mediaSource;
+    const currentSignal = this._currentMediaSourceDurationUpdateCanceller.signal;
     const isMediaSourceOpened = createMediaSourceOpenReference(mediaSource,
-                                                               this._canceller.signal);
-
-    /** TaskCanceller triggered each time the MediaSource open status changes. */
-    let msUpdateCanceller = new TaskCanceller();
-    msUpdateCanceller.linkToSignal(this._canceller.signal);
+                                                               currentSignal);
 
+    /** TaskCanceller triggered each time the MediaSource switches to and from "open". */
+    let 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 */
-      let durationChangeCanceller = new TaskCanceller();
-      durationChangeCanceller.linkToSignal(msUpdateCanceller.signal);
-
-      const reSetDuration = () => {
-        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 : CancellationSignal) {
+      msOpenStatusCanceller = new TaskCanceller();
+      msOpenStatusCanceller.linkToSignal(currentSignal);
       const areSourceBuffersUpdating = createSourceBuffersUpdatingReference(
         mediaSource.sourceBuffers,
-        cancelSignal
+        msOpenStatusCanceller.signal
       );
-
       /** TaskCanceller triggered each time SourceBuffers' updating status changes */
       let sourceBuffersUpdatingCanceller = new TaskCanceller();
-      sourceBuffersUpdatingCanceller.linkToSignal(cancelSignal);
+      sourceBuffersUpdatingCanceller.linkToSignal(msOpenStatusCanceller.signal);
+
       return areSourceBuffersUpdating.onUpdate((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 });
+                                       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
-   */
-  public updateKnownDuration(
-    newDuration : number | undefined
-  ) : void {
-    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.
    */
-  public stop() {
-    this._canceller.cancel();
+  public stopUpdating() {
+    if (this._currentMediaSourceDurationUpdateCanceller !== null) {
+      this._currentMediaSourceDurationUpdateCanceller.cancel();
+      this._currentMediaSourceDurationUpdateCanceller = null;
+    }
   }
 }
 
@@ -163,33 +145,27 @@ export default class 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: MediaSource,
-  manifest: Manifest,
-  knownDuration : number | undefined
+  duration : number,
+  addTimeMargin : boolean
 ) : MediaSourceDurationUpdateStatus {
-  let newDuration  = knownDuration;
-
-  if (newDuration === undefined) {
-    if (manifest.isDynamic) {
-      newDuration = manifest.getLivePosition() ??
-                    manifest.getMaximumSafePosition();
-    } else {
-      newDuration = manifest.getMaximumSafePosition();
-    }
-  }
+  let newDuration = duration;
 
-  if (manifest.isDynamic) {
+  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.
-    newDuration =  Math.max(Math.pow(2, 32), newDuration + YEAR_IN_SECONDS);
+    // 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);
   }
 
   let maxBufferedEnd : number = 0;
@@ -328,28 +304,28 @@ function createMediaSourceOpenReference(
 
 /**
  * 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 : MediaSource,
-  manifest : Manifest,
-  duration : number | undefined,
+  duration : number,
+  addTimeMargin : boolean,
   cancelSignal : CancellationSignal
 ) : void {
-  const res = setMediaSourceDuration(mediaSource, manifest, duration);
+  const res = setMediaSourceDuration(mediaSource, duration, addTimeMargin);
   if (res === MediaSourceDurationUpdateStatus.Success) {
     return ;
   }
   const timeoutId = setTimeout(() => {
     unregisterClear();
-    recursivelyForceDurationUpdate(mediaSource, manifest, duration, cancelSignal);
+    recursivelyForceDurationUpdate(mediaSource, duration, addTimeMargin, cancelSignal);
   }, 2000);
   const unregisterClear = cancelSignal.register(() => {
     clearTimeout(timeoutId);

package/src/core/stream/orchestrator/stream_orchestrator.ts

@@ -466,7 +466,7 @@ export default function StreamOrchestrator(
           const 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
@@ -495,13 +495,13 @@ export default function StreamOrchestrator(
      * Create `PeriodStream` for the next Period, specified under `nextPeriod`.
      * @param {Object} nextPeriod
      */
-    function createNextPeriodStream(nextPeriod : Period) : void {
+    function checkOrCreateNextPeriodStream(nextPeriod : Period) : void {
       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/src/default_config.ts

@@ -487,6 +487,33 @@ const DEFAULT_CONFIG = {
      */
   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
@@ -525,8 +552,8 @@ const DEFAULT_CONFIG = {
      * @type {Object}
      */
   ABR_REGULAR_FACTOR: {
-    DEFAULT: 0.8,
-    LOW_LATENCY: 0.8,
+    DEFAULT: 0.72,
+    LOW_LATENCY: 0.72,
   },
 
     /**

package/src/utils/is_null_or_undefined.ts

@@ -20,7 +20,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 : unknown) : x is null | undefined | void {
   return x === null || x === undefined;