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

package/FILES.md

@@ -1,44 +1,14 @@
-# File architecture ############################################################
+# File architecture
 
 This page describes how the player files are organized. Each chapter go through
 a single directory or subdirectory, in alphabetical order.
 
 
-## Table of Contents ###########################################################
-
-- [demo/: Demos of rx-player implementations](#demo)
-- [dist/: Player builds](#dist)
-- [doc/: Player documentation](#doc)
-- [scripts/: Tools and scripts](#scripts)
-- [src/: the source code](#src)
-  - [src/compat/: The compatibility files](#src-compat)
-  - [src/core/: The core files](#src-core)
-  - [src/errors/: Error definitions](#src-errors)
-  - [src/experimental/: Experimental features](#src-experimental)
-  - [src/features/: Feature switching](#src-features)
-  - [src/manifest/: The Manifest class](#src-manifest)
-  - [src/transports/: The transport protocols](#src-transports)
-  - [src/parsers/: The parsing files](#src-parsers)
-  - [src/typings/: Typescript typings](#src-typings)
-  - [src/utils/: The utils](#src-utils)
-- [src/core/: The core directory](#core)
-  - [src/core/adaptive/: The adaptive bitrate code](#core-abr)
-  - [src/core/api/: The API definition](#core-api)
-  - [src/core/stream/: Load the right segments](#core-stream)
-  - [src/core/decrypt/: Decryption management](#core-decrypt)
-  - [src/core/fetchers/: The fetchers](#core-fetchers)
-  - [src/core/segment_buffers/: The Media buffers](#core-sb)
-  - [src/core/init/: Media streaming logic](#core-init)
-- [src/**/__tests__: the unit tests directories](#src-tests)
-- [tests/: the player's tests](#tests)
-
-
-<a name="demo"></a>
-## The demo/ directory: Demos of rx-player implementations #####################
-
-Demonstration of functional codebases implementing the rx-player.
-
-At the time of writing, there are two demos:
+## `demo/`: Demo applications
+
+The `demo/` directory contains demos of application using the RxPlayer.
+
+At the time of writing, there are two distinct demos:
 
   - _full_: Demo with a graphic interface, written with the React library, to
     showcase what the player can do
@@ -48,36 +18,35 @@ At the time of writing, there are two demos:
     the displayed page.
 
 
-<a name="dist"></a>
-## The dist/ directory: Player builds ##########################################
+## `dist/`: Builds
 
-Store the player builds of the last version released.
+The `demo/` directory stores the player builds of the last version released.
 
-Contains two files: the minified (``rx-player.min.js``) and the non-minified
-files (``rx-player.js``). Both are automatically generated with scripts at every
-new release.
+Contains the minified (``rx-player.min.js``) and the non-minified files
+(``rx-player.js``). Both are automatically generated with scripts at every new
+release.
 
 Two directories, namely ``_esm5.raw`` and ``_esm5.processed`` can also be
 generated in here if the right scripts are called.
 These allow to publish more modular codebases to npm.
 
 
-<a name="doc"></a>
-## The doc/ directory: Player documentation ####################################
+## `doc/`: Documentation
 
-Documentation, mostly in markdown, of various subjects related to the rx-player:
+The `doc/` directory contains the RxPlayer's documentation, mostly written in
+markdown, on various subjects related to the rx-player:
   - API documentation
   - tutorials
   - list of deprecated APIs...
   - how to transition between RxPlayer versions
+  - how to contribute
   - etc.
 
 
-<a name="scripts"></a>
-## The scripts/ directory: scripts #####################################
+## `scripts/`: Project-managing scripts
 
-Contains various scripts used to help the test and the management of the player
-code.
+The `scripts/` directory contains various scripts used to help the test and the
+management of the player code.
 
 For example:
   - generating one of the demo and starting the server to run it
@@ -86,16 +55,14 @@ For example:
   - generating the rx-player build before publishing on npm
 
 
-<a name="src"></a>
-## The src/ directory: the source code #########################################
+## `src/`: The source code
 
-The src contains the entire source code of the rx-player.
+The `src` directory contains the entire source code of the rx-player.
 
 It is subdivized into subdirectories which are defined here.
 
 
-<a name="src-compat"></a>
-### src/compat/: The compatibility files #######################################
+### `src/compat/`: Compatibility files
 
 ``src/compat`` contains functions allowing to use browser APIs in a
 cross-browser manner.
@@ -110,8 +77,7 @@ Every functions needed in the rest of the code are exported in
 ``import { whatINeed } from "../compat";``)
 
 
-<a name="src-core"></a>
-### src/core/: The core files ##################################################
+### `src/core/`: Core logic
 
 Defines the logic and behavior of the player, regardless of the browser and of
 the streaming technology used.
@@ -126,22 +92,19 @@ This directory contains other subdirectories which are listed in the next
 chapter.
 
 
-<a name="src-errors"></a>
-### src/errors/: Error definitions #############################################
+### `src/errors/`: Error definitions
 
 Contains the definition of the error classes used in the rx-player and
 accessible through the API.
 
 
-<a name="src-experimental"></a>
-### src/experimental/: Experimental features ###################################
+### `src/experimental/`: Experimental features
 
 You will find here experimental features. Those are tested features who might
 completely change their API in new player versions.
 
 
-<a name="src-features"></a>
-### src/features/: Feature switching ###########################################
+### `src/features/`: Feature switching
 
 This manage activated or deactivated features (e.g. DASH, TTML subtitles
 parsing).
@@ -150,16 +113,14 @@ It exports an object defining the different activated features and provide utils
 to initialize and update them.
 
 
-<a name="src-manifest"></a>
-### src/manifest/: The Manifest class ##########################################
+### `src/manifest/`: Manifest Object definition
 
 Defines a common `Manifest` class, regardless of the streaming technology (DASH,
 HSS...). This class is then used by the rest of the RxPlayer, to allow
 interaction with it without considering the underlying technology used.
 
 
-<a name="src-transports"></a>
-### src/transports/: The transport protocols ###################################
+### `src/transports/`: Streaming protocols implementation
 
 Defines a common interface for multiple streaming technologies (DASH, HSS).
 
@@ -174,8 +135,7 @@ As in most of the code of the rx-player, everything used in the other parts of
 the code is exported in the index.js file at the root of this directory.
 
 
-<a name="src-parsers"></a>
-### src/parsers/: The parsers ##################################################
+### `src/parsers/`: The parsers
 
 Functions to parse various formats into the same interface.
 
@@ -186,22 +146,19 @@ The parsed data being either:
   - image containers: BIF
 
 
-<a name="src-typings"></a>
-### src/typings/: Typescript typings ###########################################
+### `src/typings/`: Typescript typings
 
 This directory contains only declaration files for TypeScript. It is
 automatically added as a `typeRoots` when the TypeScript code is transpiled.
 
 
-<a name="src-utils"></a>
-### src/utils/: The utils ######################################################
+### `src/utils/`: Util functions
 
 This directory contains general helpers which are used in different parts of the
 rx-player code.
 
 
-<a name="core"></a>
-## The src/core/ directory #####################################################
+## Inside `src/core/`
 
 As written in the previous chapter, this is the "core" of the player, where the
 logic is defined.
@@ -209,8 +166,7 @@ logic is defined.
 As this directory is versatile and complicated, it also deserves its own chapter.
 
 
-<a name="core-abr"></a>
-### src/core/adaptive/: The adaptive bitrate code ##############################
+### `src/core/adaptive/`: Adaptive BitRate logic
 
 Defines functions which manages the adaptive streaming part of the player.
 
@@ -225,29 +181,25 @@ This allows to isolate this complex part and facilitate future refactoring and
 improvements.
 
 
-<a name="core-api"></a>
-### src/core/api/: The API definition ##########################################
+### `src/core/api/`: API definition
 
 Defines the rx-player API. This is the part the library user will directly
 interact with.
 
 
-<a name="core-stream"></a>
-### src/core/stream/: Load the right segments ##################################
+### `src/core/stream/`: Segment-picking logic
 
 The code there calculate which segments should be downloaded, ask for their
 download and push the segments into the `SegmentBuffers`.
 
 
-<a name="core-decrypt"></a>
-### src/core/decrypt/: Decryption management ###################################
+### `src/core/decrypt/`: Decryption handling
 
 Defines functions allowing to handle encrypted contents through the EME browser
 APIs.
 
 
-<a name="core-fetchers"></a>
-### src/core/fetchers/: The fetchers ###########################################
+### `src/core/fetchers/`: Load resources
 
 Handle the segments and Manifest downloading pipelines (load and parse) as
 defined in the ``src/transports/`` directory.
@@ -257,8 +209,7 @@ It facilitates the role of loading the Manifest and new segments for the rest of
 the core.
 
 
-<a name="core-sb"></a>
-### src/core/segment_buffers/: The media buffers ###############################
+### `src/core/segment_buffers/`: Media buffers
 
 Code allowing to interact with the media buffers called `SegmentBuffers`.
 
@@ -271,8 +222,7 @@ for other type of contents (like subtitles), we rely on completely custom media
 buffers implementations.
 
 
-<a name="core-init"></a>
-### src/core/init/: Content initialization #####################################
+### `src/core/init/`: Content initialization and orchestration
 
 This is the central part which download manifests, initialize MSE and EME APIs,
 instanciate the central `StreamOrchestrator` (which will allow to download and
@@ -280,8 +230,7 @@ push segments so the content can play) and link together many subparts of the
 player.
 
 
-<a name="src-tests"></a>
-## src/**/__tests__: the unit tests directories ################################
+## `src/**/__tests__`: Unit tests
 
 You will find multiple directories named `__tests__` in the RxPlayer.
 Those contain unit tests and are put in the same directory than the code it
@@ -303,8 +252,7 @@ Their filename don't follow the same convention than single-source unit tests
 but should still be suffixed by `.test.ts`.
 
 
-<a name="tests"></a>
-## The tests/ directory: the player's tests ####################################
+## `tests/`: The RxPlayer's general tests
 
 This directory contains most testing code for the RxPlayer.
 

package/VERSION

@@ -1 +1 @@
-4.0.0-beta.1
+4.0.0-beta.2

package/dist/_esm5.processed/compat/browser_detection.d.ts

@@ -37,4 +37,6 @@ declare let isWebOs2021: boolean;
 declare let isWebOs2022: boolean;
 /** `true` for Panasonic devices. */
 declare let isPanasonic: boolean;
-export { isEdgeChromium, isIE11, isIEOrEdge, isFirefox, isPanasonic, isSafariDesktop, isSafariMobile, isSamsungBrowser, isTizen, isWebOs, isWebOs2021, isWebOs2022, };
+/** `true` for the PlayStation 5 game console. */
+declare let isPlayStation5: boolean;
+export { isEdgeChromium, isIE11, isIEOrEdge, isFirefox, isPanasonic, isPlayStation5, isSafariDesktop, isSafariMobile, isSamsungBrowser, isTizen, isWebOs, isWebOs2021, isWebOs2022, };

package/dist/_esm5.processed/compat/browser_detection.js

@@ -38,6 +38,8 @@ var isWebOs2021 = false;
 var isWebOs2022 = false;
 /** `true` for Panasonic devices. */
 var isPanasonic = false;
+/** `true` for the PlayStation 5 game console. */
+var isPlayStation5 = false;
 ((function findCurrentBrowser() {
     var _a, _b;
     if (isNode) {
@@ -74,7 +76,10 @@ var isPanasonic = false;
     if (/SamsungBrowser/.test(navigator.userAgent)) {
         isSamsungBrowser = true;
     }
-    if (/Tizen/.test(navigator.userAgent)) {
+    if (navigator.userAgent.indexOf("PlayStation 5") !== -1) {
+        isPlayStation5 = true;
+    }
+    else if (/Tizen/.test(navigator.userAgent)) {
         isTizen = true;
         // Inspired form: http://webostv.developer.lge.com/discover/specifications/web-engine/
         // Note: even that page doesn't correspond to what we've actually seen in the
@@ -95,4 +100,4 @@ var isPanasonic = false;
         isPanasonic = true;
     }
 })());
-export { isEdgeChromium, isIE11, isIEOrEdge, isFirefox, isPanasonic, isSafariDesktop, isSafariMobile, isSamsungBrowser, isTizen, isWebOs, isWebOs2021, isWebOs2022, };
+export { isEdgeChromium, isIE11, isIEOrEdge, isFirefox, isPanasonic, isPlayStation5, isSafariDesktop, isSafariMobile, isSamsungBrowser, isTizen, isWebOs, isWebOs2021, isWebOs2022, };

package/dist/_esm5.processed/compat/eme/load_session.js

@@ -70,7 +70,7 @@ export default function loadSession(session, sessionId) {
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
-                    log.info("Compat/DRM: Load persisted session", sessionId);
+                    log.info("DRM: Load persisted session", sessionId);
                     return [4 /*yield*/, session.load(sessionId)];
                 case 1:
                     isLoaded = _a.sent();

package/dist/_esm5.processed/compat/has_issues_with_high_media_source_duration.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Some platforms have issues when the `MediaSource`'s `duration` property
+ * is set to a very high value (playback freezes) but not when setting it
+ * to `Infinity`, which is what the HTML spec as of now (2023-05-15) recommends
+ * for live contents.
+ *
+ * However setting the `MediaSource`'s `duration` property to `Infinity` seems
+ * more risky, considering all platforms we now support, than setting it at a
+ * relatively high ~2**32 value which is what we do generally.
+ *
+ * Moreover, setting it to `Infinity` require us to use another MSE API,
+ * `setLiveSeekableRange` to properly allow seeking. We're used to MSE issues so
+ * I'm not too confident of using another MSE API for all platforms directly.
+ *
+ * So this methods just return `true` based on a whitelist of platform for which
+ * it has been detected that high `duration` values cause issues but setting it
+ * to Infinity AND playing with `setLiveSeekableRange` does not.
+ *
+ * @returns {boolean}
+ */
+export default function hasIssuesWithHighMediaSourceDuration(): boolean;

package/dist/_esm5.processed/compat/has_issues_with_high_media_source_duration.js

@@ -0,0 +1,26 @@
+import { isPlayStation5 } from "./browser_detection";
+/**
+ * Some platforms have issues when the `MediaSource`'s `duration` property
+ * is set to a very high value (playback freezes) but not when setting it
+ * to `Infinity`, which is what the HTML spec as of now (2023-05-15) recommends
+ * for live contents.
+ *
+ * However setting the `MediaSource`'s `duration` property to `Infinity` seems
+ * more risky, considering all platforms we now support, than setting it at a
+ * relatively high ~2**32 value which is what we do generally.
+ *
+ * Moreover, setting it to `Infinity` require us to use another MSE API,
+ * `setLiveSeekableRange` to properly allow seeking. We're used to MSE issues so
+ * I'm not too confident of using another MSE API for all platforms directly.
+ *
+ * So this methods just return `true` based on a whitelist of platform for which
+ * it has been detected that high `duration` values cause issues but setting it
+ * to Infinity AND playing with `setLiveSeekableRange` does not.
+ *
+ * @returns {boolean}
+ */
+export default function hasIssuesWithHighMediaSourceDuration() {
+    // For now only seen on the Webkit present in the PlayStation 5, for which the
+    // alternative is known to work.
+    return isPlayStation5;
+}

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

@@ -65,6 +65,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";
@@ -177,8 +178,7 @@ function getEstimateReference(_a, stopAllEstimates) {
             var timeRanges = val.buffered;
             var bufferGap = getLeftSizeOfRange(timeRanges, position.last);
             var representation = val.content.representation;
-            var scoreData = scoreCalculator.getEstimate(representation);
-            var currentScore = scoreData === null || scoreData === void 0 ? void 0 : scoreData[0];
+            var currentScore = scoreCalculator.getEstimate(representation);
             var currentBitrate = representation.bitrate;
             var observation = { bufferGap: bufferGap, currentBitrate: currentBitrate, currentScore: currentScore, speed: speed };
             currentBufferBasedEstimate = bufferBasedChooser.getEstimate(observation);
@@ -209,12 +209,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.d.ts

@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { IRepresentationMaintainabilityScore } from "./utils/representation_score_calculator";
 /**
  * Choose a bitrate based on the currently available buffer.
  *
@@ -24,11 +25,27 @@
  * "maintanable" or not.
  * If so, we may switch to a better quality, or conversely to a worse quality.
  *
+ * It also rely on mechanisms to avoid fluctuating too much between qualities.
+ *
  * @class BufferBasedChooser
  */
 export default class BufferBasedChooser {
     private _levelsMap;
     private _bitrates;
+    /**
+     * Laast timestamp, in terms of `performance.now`, at which the current
+     * quality was seen as too high by this algorithm.
+     * Begins at `undefined`.
+     */
+    private _lastUnsuitableQualityTimestamp;
+    /**
+     * After lowering in quality, we forbid raising during a set amount of time.
+     * This amount is adaptive may continue to raise if it seems that quality
+     * is switching too much between low and high qualities.
+     *
+     * `_blockRaiseDelay` represents this time in milliseconds.
+     */
+    private _blockRaiseDelay;
     /**
      * @param {Array.<number>} bitrates
      */
@@ -50,7 +67,7 @@ export interface IBufferBasedChooserPlaybackObservation {
     /** The bitrate of the currently downloaded segments, in bps. */
     currentBitrate?: number | undefined;
     /** The "maintainability score" of the currently downloaded segments. */
-    currentScore?: number | undefined;
+    currentScore?: IRepresentationMaintainabilityScore | undefined;
     /** Playback rate wanted (e.g. `1` is regular playback, `2` is double speed etc.). */
     speed: number;
 }

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

@@ -16,6 +16,45 @@
 import log from "../../log";
 import arrayFindIndex from "../../utils/array_find_index";
 import getBufferLevels from "./utils/get_buffer_levels";
+/**
+ * Minimum amount of time, in milliseconds, during which we are blocked from
+ * raising in quality after it had been considered as too high.
+ */
+var MINIMUM_BLOCK_RAISE_DELAY = 6000;
+/**
+ * Maximum amount of time, in milliseconds, during which we are blocked from
+ * raising in quality after it had been considered as too high.
+ */
+var MAXIMUM_BLOCK_RAISE_DELAY = 15000;
+/**
+ * Amount of time, in milliseconds, with which the blocking time in raising
+ * the quality will be incremented if the current quality estimate is seen
+ * as too unstable.
+ */
+var RAISE_BLOCKING_DELAY_INCREMENT = 3000;
+/**
+ * Amount of time, in milliseconds, with which the blocking time in raising
+ * the quality will be dcremented if the current quality estimate is seen
+ * as relatively stable, until `MINIMUM_BLOCK_RAISE_DELAY` is reached.
+ */
+var RAISE_BLOCKING_DELAY_DECREMENT = 1000;
+/**
+ * Amount of time, in milliseconds, after the "raise blocking delay" currently
+ * in place (during which it is forbidden to raise up in quality), during which
+ * we might want to raise the "raise blocking delay" if the last chosen quality
+ * seems unsuitable.
+ *
+ * For example, let's consider that the current raise blocking delay is at
+ * `4000`, or 4 seconds, and that this `STABILITY_CHECK_DELAY` is at `5000`, or
+ * 5 seconds.
+ * Here it means that if the estimated quality is found to be unsuitable less
+ * than 4+5 = 9 seconds after it last was, we will increment the raise blocking
+ * delay by `RAISE_BLOCKING_DELAY_INCREMENT` (unless `MAXIMUM_BLOCK_RAISE_DELAY`
+ * is reached).
+ * Else, if takes more than 9 seconds, the raise blocking delay might be
+ * decremented.
+ */
+var STABILITY_CHECK_DELAY = 9000;
 /**
  * Choose a bitrate based on the currently available buffer.
  *
@@ -27,6 +66,8 @@ import getBufferLevels from "./utils/get_buffer_levels";
  * "maintanable" or not.
  * If so, we may switch to a better quality, or conversely to a worse quality.
  *
+ * It also rely on mechanisms to avoid fluctuating too much between qualities.
+ *
  * @class BufferBasedChooser
  */
 var BufferBasedChooser = /** @class */ (function () {
@@ -34,8 +75,13 @@ var BufferBasedChooser = /** @class */ (function () {
      * @param {Array.<number>} bitrates
      */
     function BufferBasedChooser(bitrates) {
-        this._levelsMap = getBufferLevels(bitrates);
+        this._levelsMap = getBufferLevels(bitrates).map(function (bl) {
+            return bl + 4; // Add some buffer security as it will be used conjointly with
+            // other algorithms anyway
+        });
         this._bitrates = bitrates;
+        this._lastUnsuitableQualityTimestamp = undefined;
+        this._blockRaiseDelay = MINIMUM_BLOCK_RAISE_DELAY;
         log.debug("ABR: Steps for buffer based chooser.", this._levelsMap.map(function (l, i) { return "bufferLevel: ".concat(l, ", bitrate: ").concat(bitrates[i]); })
             .join(" ,"));
     }
@@ -50,40 +96,75 @@ var BufferBasedChooser = /** @class */ (function () {
         if (currentBitrate == null) {
             return bitrates[0];
         }
-        var currentBitrateIndex = arrayFindIndex(bitrates, function (b) { return b === currentBitrate; });
+        var currentBitrateIndex = -1;
+        for (var i = 0; i < bitrates.length; i++) {
+            // There could be bitrate duplicates. Only take the last one to simplify
+            var bitrate = bitrates[i];
+            if (bitrate === currentBitrate) {
+                currentBitrateIndex = i;
+            }
+            else if (bitrate > currentBitrate) {
+                break;
+            }
+        }
         if (currentBitrateIndex < 0 || bitrates.length !== bufferLevels.length) {
             log.error("ABR: Current Bitrate not found in the calculated levels");
             return bitrates[0];
         }
         var scaledScore;
-        if (currentScore != null) {
-            scaledScore = speed === 0 ? currentScore : (currentScore / speed);
+        if (currentScore !== undefined) {
+            scaledScore = speed === 0 ? currentScore.score : (currentScore.score / speed);
         }
-        if (scaledScore != null && scaledScore > 1) {
-            var currentBufferLevel_1 = bufferLevels[currentBitrateIndex];
-            var nextIndex = (function () {
-                for (var i = currentBitrateIndex + 1; i < bufferLevels.length; i++) {
-                    if (bufferLevels[i] > currentBufferLevel_1) {
-                        return i;
-                    }
-                }
-            })();
-            if (nextIndex != null) {
-                var nextBufferLevel = bufferLevels[nextIndex];
-                if (bufferGap >= nextBufferLevel) {
-                    return bitrates[nextIndex];
+        var actualBufferGap = isFinite(bufferGap) ?
+            bufferGap :
+            0;
+        var now = performance.now();
+        if (actualBufferGap < bufferLevels[currentBitrateIndex] ||
+            (scaledScore !== undefined && scaledScore < 1 &&
+                (currentScore === null || currentScore === void 0 ? void 0 : currentScore.confidenceLevel) === 1 /* ScoreConfidenceLevel.HIGH */)) {
+            var timeSincePrev = this._lastUnsuitableQualityTimestamp === undefined ?
+                -1 :
+                now - this._lastUnsuitableQualityTimestamp;
+            if (timeSincePrev < this._blockRaiseDelay + STABILITY_CHECK_DELAY) {
+                var newDelay = this._blockRaiseDelay + RAISE_BLOCKING_DELAY_INCREMENT;
+                this._blockRaiseDelay = Math.min(newDelay, MAXIMUM_BLOCK_RAISE_DELAY);
+                log.debug("ABR: Incrementing blocking raise in BufferBasedChooser due " +
+                    "to unstable quality", this._blockRaiseDelay);
+            }
+            else {
+                var newDelay = this._blockRaiseDelay - RAISE_BLOCKING_DELAY_DECREMENT;
+                this._blockRaiseDelay = Math.max(MINIMUM_BLOCK_RAISE_DELAY, newDelay);
+                log.debug("ABR: Lowering quality in BufferBasedChooser", this._blockRaiseDelay);
+            }
+            this._lastUnsuitableQualityTimestamp = now;
+            // Security if multiple bitrates are equal, we now take the first one
+            var baseIndex = arrayFindIndex(bitrates, function (b) { return b === currentBitrate; });
+            for (var i = baseIndex - 1; i >= 0; i--) {
+                if (actualBufferGap >= bufferLevels[i]) {
+                    return bitrates[i];
                 }
             }
+            return bitrates[0];
         }
-        if (scaledScore == null || scaledScore < 1.15) {
-            var currentBufferLevel = bufferLevels[currentBitrateIndex];
-            if (bufferGap < currentBufferLevel) {
-                for (var i = currentBitrateIndex - 1; i >= 0; i--) {
-                    if (bitrates[i] < currentBitrate) {
-                        return bitrates[i];
-                    }
+        if ((this._lastUnsuitableQualityTimestamp !== undefined &&
+            now - this._lastUnsuitableQualityTimestamp < this._blockRaiseDelay) ||
+            scaledScore === undefined || scaledScore < 1.15 ||
+            (currentScore === null || currentScore === void 0 ? void 0 : currentScore.confidenceLevel) !== 1 /* ScoreConfidenceLevel.HIGH */) {
+            return currentBitrate;
+        }
+        var currentBufferLevel = bufferLevels[currentBitrateIndex];
+        var nextIndex = (function () {
+            for (var i = currentBitrateIndex + 1; i < bufferLevels.length; i++) {
+                if (bufferLevels[i] > currentBufferLevel) {
+                    return i;
                 }
-                return currentBitrate;
+            }
+        })();
+        if (nextIndex !== undefined) {
+            var nextBufferLevel = bufferLevels[nextIndex];
+            if (bufferGap >= nextBufferLevel) {
+                log.debug("ABR: Raising quality in BufferBasedChooser", bitrates[nextIndex]);
+                return bitrates[nextIndex];
             }
         }
         return currentBitrate;