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

package/src/core/adaptive/__tests__/buffer_based_chooser.test.ts

@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 
+import { ScoreConfidenceLevel } from "../utils/representation_score_calculator";
+
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
 /* eslint-disable @typescript-eslint/no-var-requires */
@@ -47,12 +49,25 @@ describe("BufferBasedChooser", () => {
       bufferGap: 0,
       speed: 1,
       currentBitrate: undefined,
-      currentScore: 4,
+      currentScore: { score: 4, confidenceLevel: ScoreConfidenceLevel.LOW },
+    })).toEqual(1);
+    expect(new BufferBasedChooser([1, 2, 3]).getEstimate({
+      bufferGap: 0,
+      speed: 1,
+      currentBitrate: undefined,
+      currentScore: { score: 4, confidenceLevel: ScoreConfidenceLevel.HIGH },
+    })).toEqual(1);
+    expect(new BufferBasedChooser([1, 2, 3]).getEstimate({
+      bufferGap: 0,
+      speed: 1,
+      currentBitrate: undefined,
+      currentScore: { score: 1, confidenceLevel: ScoreConfidenceLevel.LOW },
     })).toEqual(1);
     expect(new BufferBasedChooser([1, 2, 3]).getEstimate({
       bufferGap: 0,
       speed: 1,
-      currentScore: 1,
+      currentBitrate: undefined,
+      currentScore: { score: 1, confidenceLevel: ScoreConfidenceLevel.HIGH },
     })).toEqual(1);
   });
 
@@ -76,7 +91,7 @@ describe("BufferBasedChooser", () => {
   });
 
   /* eslint-disable max-len */
-  it("should go to the next bitrate if the current one is maintainable and we have more buffer than the next level", () => {
+  it("should not go to the next bitrate if we don't have a high enough maintainability score", () => {
   /* eslint-enable max-len */
     const logger = { debug: jest.fn() };
     jest.mock("../../../log", () => ({ __esModule: true as const,
@@ -86,82 +101,82 @@ describe("BufferBasedChooser", () => {
       bufferGap: 16,
       speed: 1,
       currentBitrate: 10,
-      currentScore: 1.01,
-    })).toEqual(20);
+      currentScore: { score: 1.15, confidenceLevel: ScoreConfidenceLevel.LOW },
+    })).toEqual(10);
     expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
       bufferGap: 30,
       speed: 1,
       currentBitrate: 20,
-      currentScore: 1.01,
-    })).toEqual(40);
+      currentScore: { score: 1.15, confidenceLevel: ScoreConfidenceLevel.LOW },
+    })).toEqual(20);
     expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
       bufferGap: 30,
       speed: 1,
       currentBitrate: 20,
-      currentScore: 100,
-    })).toEqual(40);
+      currentScore: { score: 100, confidenceLevel: ScoreConfidenceLevel.LOW },
+    })).toEqual(20);
     expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
       bufferGap: 30,
       speed: 2,
       currentBitrate: 20,
-      currentScore: 2.1,
-    })).toEqual(40);
+      currentScore: { score: 2.30, confidenceLevel: ScoreConfidenceLevel.LOW },
+    })).toEqual(20);
     expect(new BufferBasedChooser([10, 20, 20, 40]).getEstimate({
       bufferGap: 30,
       speed: 2,
       currentBitrate: 20,
-      currentScore: 2.1,
-    })).toEqual(40);
+      currentScore: { score: 2.30, confidenceLevel: ScoreConfidenceLevel.LOW },
+    })).toEqual(20);
     expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
       bufferGap: 30,
       speed: 0, // 0 is a special case
       currentBitrate: 20,
-      currentScore: 100,
-    })).toEqual(40);
+      currentScore: { score: 100, confidenceLevel: ScoreConfidenceLevel.LOW },
+    })).toEqual(20);
   });
 
   /* eslint-disable max-len */
-  it("should go to the next bitrate if the current one is maintainable and we have the buffer corresponding to the next level", () => {
+  it("should go to the next bitrate if the current one is maintainable and we have more buffer than the next level", () => {
   /* eslint-enable max-len */
     const logger = { debug: jest.fn() };
     jest.mock("../../../log", () => ({ __esModule: true as const,
                                        default: logger }));
     const BufferBasedChooser = jest.requireActual("../buffer_based_chooser").default;
     expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
-      bufferGap: 15,
+      bufferGap: 16,
       speed: 1,
       currentBitrate: 10,
-      currentScore: 1.01,
+      currentScore: { score: 1.15, confidenceLevel: ScoreConfidenceLevel.HIGH },
     })).toEqual(20);
     expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
-      bufferGap: 20,
+      bufferGap: 30,
       speed: 1,
       currentBitrate: 20,
-      currentScore: 1.01,
+      currentScore: { score: 1.15, confidenceLevel: ScoreConfidenceLevel.HIGH },
     })).toEqual(40);
     expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
-      bufferGap: 20,
+      bufferGap: 30,
       speed: 1,
       currentBitrate: 20,
-      currentScore: 100,
+      currentScore: { score: 100, confidenceLevel: ScoreConfidenceLevel.HIGH },
     })).toEqual(40);
     expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
-      bufferGap: 20,
+      bufferGap: 30,
       speed: 2,
       currentBitrate: 20,
-      currentScore: 2.1,
+      currentScore: { score: 2.30, confidenceLevel: ScoreConfidenceLevel.HIGH },
     })).toEqual(40);
     expect(new BufferBasedChooser([10, 20, 20, 40]).getEstimate({
-      bufferGap: 20,
+      bufferGap: 30,
       speed: 2,
       currentBitrate: 20,
-      currentScore: 2.1,
+      currentScore: { score: 2.30, confidenceLevel: ScoreConfidenceLevel.HIGH },
     })).toEqual(40);
     expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
-      bufferGap: 20,
+      bufferGap: 30,
       speed: 0, // 0 is a special case
       currentBitrate: 20,
-      currentScore: 100,
+      currentScore: { score: 100, confidenceLevel: ScoreConfidenceLevel.HIGH },
     })).toEqual(40);
   });
 
@@ -176,31 +191,31 @@ describe("BufferBasedChooser", () => {
       bufferGap: 6,
       speed: 1,
       currentBitrate: 10,
-      currentScore: 1.01,
+      currentScore: { score: 1.15, confidenceLevel: ScoreConfidenceLevel.HIGH },
     })).toEqual(10);
     expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
-      bufferGap: 10,
+      bufferGap: 13,
       speed: 1,
       currentBitrate: 20,
-      currentScore: 1.01,
+      currentScore: { score: 1.15, confidenceLevel: ScoreConfidenceLevel.HIGH },
     })).toEqual(20);
     expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
-      bufferGap: 10,
+      bufferGap: 13,
       speed: 1,
       currentBitrate: 20,
-      currentScore: 100,
+      currentScore: { score: 100, confidenceLevel: ScoreConfidenceLevel.HIGH },
     })).toEqual(20);
     expect(new BufferBasedChooser([10, 20, 20, 40]).getEstimate({
-      bufferGap: 10,
+      bufferGap: 13,
       speed: 1,
       currentBitrate: 20,
-      currentScore: 100,
+      currentScore: { score: 100, confidenceLevel: ScoreConfidenceLevel.HIGH },
     })).toEqual(20);
     expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
-      bufferGap: 10,
+      bufferGap: 13,
       speed: 2,
       currentBitrate: 20,
-      currentScore: 2.1,
+      currentScore: { score: 2.30, confidenceLevel: ScoreConfidenceLevel.HIGH },
     })).toEqual(20);
   });
 
@@ -216,13 +231,13 @@ describe("BufferBasedChooser", () => {
       bufferGap: 100000000000,
       speed: 1,
       currentBitrate: 40,
-      currentScore: 1000000,
+      currentScore: { score: 1000000, confidenceLevel: ScoreConfidenceLevel.HIGH },
     })).toEqual(40);
     expect(new BufferBasedChooser([10, 20, 40, 40]).getEstimate({
       bufferGap: 100000000000,
       speed: 1,
       currentBitrate: 40,
-      currentScore: 1000000,
+      currentScore: { score: 1000000, confidenceLevel: ScoreConfidenceLevel.HIGH },
     })).toEqual(40);
   });
 
@@ -237,31 +252,115 @@ describe("BufferBasedChooser", () => {
       bufferGap: 15,
       speed: 2,
       currentBitrate: 10,
-      currentScore: 1.01,
+      currentScore: { score: 2, confidenceLevel: ScoreConfidenceLevel.HIGH },
     })).toEqual(10);
     expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
-      bufferGap: 20,
+      bufferGap: 22,
       speed: 2,
       currentBitrate: 20,
-      currentScore: 1.01,
+      currentScore: { score: 2, confidenceLevel: ScoreConfidenceLevel.HIGH },
     })).toEqual(20);
     expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
-      bufferGap: 20,
+      bufferGap: 22,
       speed: 100,
       currentBitrate: 20,
-      currentScore: 100,
+      currentScore: { score: 100, confidenceLevel: ScoreConfidenceLevel.HIGH },
     })).toEqual(20);
     expect(new BufferBasedChooser([10, 20, 20, 40]).getEstimate({
-      bufferGap: 20,
+      bufferGap: 22,
       speed: 100,
       currentBitrate: 20,
-      currentScore: 100,
+      currentScore: { score: 100, confidenceLevel: ScoreConfidenceLevel.HIGH },
     })).toEqual(20);
     expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
-      bufferGap: 20,
+      bufferGap: 22,
+      speed: 3,
+      currentBitrate: 20,
+      currentScore: { score: 3, confidenceLevel: ScoreConfidenceLevel.HIGH },
+    })).toEqual(20);
+  });
+
+  /* eslint-disable max-len */
+  it("should lower bitrate if the current one is not maintainable due to the speed", () => {
+  /* eslint-enable max-len */
+    const logger = { debug: jest.fn() };
+    jest.mock("../../../log", () => ({ __esModule: true as const,
+                                       default: logger }));
+    const BufferBasedChooser = jest.requireActual("../buffer_based_chooser").default;
+    expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
+      bufferGap: 15,
+      speed: 2,
+      currentBitrate: 10,
+      currentScore: { score: 1.9, confidenceLevel: ScoreConfidenceLevel.HIGH },
+    })).toEqual(10);
+    expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
+      bufferGap: 22,
+      speed: 2,
+      currentBitrate: 20,
+      currentScore: { score: 1.9, confidenceLevel: ScoreConfidenceLevel.HIGH },
+    })).toEqual(10);
+    expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
+      bufferGap: 22,
+      speed: 100,
+      currentBitrate: 20,
+      currentScore: { score: 99, confidenceLevel: ScoreConfidenceLevel.HIGH },
+    })).toEqual(10);
+    expect(new BufferBasedChooser([10, 20, 20, 40]).getEstimate({
+      bufferGap: 22,
+      speed: 100,
+      currentBitrate: 20,
+      currentScore: { score: 99, confidenceLevel: ScoreConfidenceLevel.HIGH },
+    })).toEqual(10);
+    expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
+      bufferGap: 22,
+      speed: 3,
+      currentBitrate: 20,
+      currentScore: { score: 2.5, confidenceLevel: ScoreConfidenceLevel.HIGH },
+    })).toEqual(10);
+  });
+
+  /* eslint-disable max-len */
+  it("should not lower bitrate if the current one is not maintainable due to the speed but confidence on the score is low", () => {
+  /* eslint-enable max-len */
+    const logger = { debug: jest.fn() };
+    jest.mock("../../../log", () => ({ __esModule: true as const,
+                                       default: logger }));
+    const BufferBasedChooser = jest.requireActual("../buffer_based_chooser").default;
+    expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
+      bufferGap: 15,
+      speed: 2,
+      currentBitrate: 10,
+      currentScore: { score: 1.9, confidenceLevel: ScoreConfidenceLevel.LOW },
+    })).toEqual(10);
+    expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
+      bufferGap: 22,
+      speed: 2,
+      currentBitrate: 20,
+      currentScore: undefined,
+    })).toEqual(20);
+    expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
+      bufferGap: 22,
+      speed: 2,
+      currentBitrate: 20,
+      currentScore: { score: 1.9, confidenceLevel: ScoreConfidenceLevel.LOW },
+    })).toEqual(20);
+    expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
+      bufferGap: 22,
+      speed: 100,
+      currentBitrate: 20,
+      currentScore: { score: 99, confidenceLevel: ScoreConfidenceLevel.LOW },
+    })).toEqual(20);
+    expect(new BufferBasedChooser([10, 20, 20, 40]).getEstimate({
+      bufferGap: 22,
+      speed: 100,
+      currentBitrate: 20,
+      currentScore: { score: 99, confidenceLevel: ScoreConfidenceLevel.LOW },
+    })).toEqual(20);
+    expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
+      bufferGap: 22,
       speed: 3,
       currentBitrate: 20,
-      currentScore: 2.1,
+      currentScore: { score: 2.5, confidenceLevel: ScoreConfidenceLevel.LOW },
     })).toEqual(20);
   });
 

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,
@@ -189,7 +190,8 @@ function getEstimateReference(
    * This TaskCanceller is used both for restarting estimates with a new
    * configuration and to cancel them altogether.
    */
-  let currentEstimatesCanceller = new TaskCanceller({ cancelOn: stopAllEstimates });
+  let currentEstimatesCanceller = new TaskCanceller();
+  currentEstimatesCanceller.linkToSignal(stopAllEstimates);
 
   // Create `ISharedReference` on which estimates will be emitted.
   const estimateRef = createEstimateReference(representationsRef.getValue(),
@@ -259,8 +261,7 @@ function getEstimateReference(
       const timeRanges = val.buffered;
       const bufferGap = getLeftSizeOfRange(timeRanges, position.last);
       const { representation } = val.content;
-      const scoreData = scoreCalculator.getEstimate(representation);
-      const currentScore = scoreData?.[0];
+      const currentScore = scoreCalculator.getEstimate(representation);
       const currentBitrate = representation.bitrate;
       const observation = { bufferGap, currentBitrate, currentScore, speed };
       currentBufferBasedEstimate = bufferBasedChooser.getEstimate(observation);
@@ -306,11 +307,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;
       }
@@ -428,7 +432,8 @@ function getEstimateReference(
   function restartEstimatesProductionFromCurrentConditions() : void {
     const representations = representationsRef.getValue();
     currentEstimatesCanceller.cancel();
-    currentEstimatesCanceller = new TaskCanceller({ cancelOn: stopAllEstimates });
+    currentEstimatesCanceller = new TaskCanceller();
+    currentEstimatesCanceller.linkToSignal(stopAllEstimates);
     const newRef = createEstimateReference(representations,
                                            currentEstimatesCanceller.signal);
 

package/src/core/adaptive/buffer_based_chooser.ts

@@ -17,6 +17,54 @@
 import log from "../../log";
 import arrayFindIndex from "../../utils/array_find_index";
 import getBufferLevels from "./utils/get_buffer_levels";
+import {
+  IRepresentationMaintainabilityScore,
+  ScoreConfidenceLevel,
+} from "./utils/representation_score_calculator";
+
+/**
+ * Minimum amount of time, in milliseconds, during which we are blocked from
+ * raising in quality after it had been considered as too high.
+ */
+const 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.
+ */
+const 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.
+ */
+const 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.
+ */
+const 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.
+ */
+const STABILITY_CHECK_DELAY = 9000;
 
 /**
  * Choose a bitrate based on the currently available buffer.
@@ -29,18 +77,41 @@ 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
  */
 export default class BufferBasedChooser {
   private _levelsMap : number[];
   private _bitrates : number[];
 
+  /**
+   * 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: number | undefined;
+
+  /**
+   * 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: number;
+
   /**
    * @param {Array.<number>} bitrates
    */
   constructor(bitrates : number[]) {
-    this._levelsMap = getBufferLevels(bitrates);
+    this._levelsMap = getBufferLevels(bitrates).map(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((l, i) => `bufferLevel: ${l}, bitrate: ${bitrates[i]}`)
                 .join(" ,"));
@@ -59,43 +130,90 @@ export default class BufferBasedChooser {
     if (currentBitrate == null) {
       return bitrates[0];
     }
-    const currentBitrateIndex = arrayFindIndex(bitrates, b => b === currentBitrate);
+
+    let currentBitrateIndex = -1;
+    for (let i = 0; i < bitrates.length; i++) {
+      // There could be bitrate duplicates. Only take the last one to simplify
+      const 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];
     }
 
     let scaledScore : number|undefined;
-    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) {
-      const currentBufferLevel = bufferLevels[currentBitrateIndex];
-      const nextIndex = (() => {
-        for (let i = currentBitrateIndex + 1; i < bufferLevels.length; i++) {
-          if (bufferLevels[i] > currentBufferLevel) {
-            return i;
-          }
-        }
-      })();
-      if (nextIndex != null) {
-        const nextBufferLevel = bufferLevels[nextIndex];
-        if (bufferGap >= nextBufferLevel) {
-          return bitrates[nextIndex];
+    const actualBufferGap = isFinite(bufferGap) ?
+      bufferGap :
+      0;
+
+    const now = performance.now();
+
+    if (
+      actualBufferGap < bufferLevels[currentBitrateIndex] ||
+      (
+        scaledScore !== undefined && scaledScore < 1 &&
+        currentScore?.confidenceLevel === ScoreConfidenceLevel.HIGH
+      )
+    ) {
+      const timeSincePrev = this._lastUnsuitableQualityTimestamp === undefined ?
+        -1 :
+        now - this._lastUnsuitableQualityTimestamp;
+      if (timeSincePrev < this._blockRaiseDelay + STABILITY_CHECK_DELAY) {
+        const 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 {
+        const 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
+      const baseIndex = arrayFindIndex(bitrates, (b) => b === currentBitrate);
+      for (let i = baseIndex - 1; i >= 0; i--) {
+        if (actualBufferGap >= bufferLevels[i]) {
+          return bitrates[i];
         }
       }
+      return bitrates[0];
+    }
+
+    if (
+      (
+        this._lastUnsuitableQualityTimestamp !== undefined &&
+        now - this._lastUnsuitableQualityTimestamp < this._blockRaiseDelay
+      ) ||
+      scaledScore === undefined || scaledScore < 1.15 ||
+      currentScore?.confidenceLevel !== ScoreConfidenceLevel.HIGH
+    ) {
+      return currentBitrate;
     }
 
-    if (scaledScore == null || scaledScore < 1.15) {
-      const currentBufferLevel = bufferLevels[currentBitrateIndex];
-      if (bufferGap < currentBufferLevel) {
-        for (let i = currentBitrateIndex - 1; i >= 0; i--) {
-          if (bitrates[i] < currentBitrate) {
-            return bitrates[i];
-          }
+    const currentBufferLevel = bufferLevels[currentBitrateIndex];
+    const nextIndex = (() => {
+      for (let i = currentBitrateIndex + 1; i < bufferLevels.length; i++) {
+        if (bufferLevels[i] > currentBufferLevel) {
+          return i;
         }
-        return currentBitrate;
+      }
+    })();
+    if (nextIndex !== undefined) {
+      const nextBufferLevel = bufferLevels[nextIndex];
+      if (bufferGap >= nextBufferLevel) {
+        log.debug("ABR: Raising quality in BufferBasedChooser", bitrates[nextIndex]);
+        return bitrates[nextIndex];
       }
     }
     return currentBitrate;
@@ -113,7 +231,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/src/core/adaptive/guess_based_chooser.ts

@@ -23,6 +23,7 @@ import LastEstimateStorage, {
 } from "./utils/last_estimate_storage";
 import { IRequestInfo } from "./utils/pending_requests_store";
 import RepresentationScoreCalculator, {
+  IRepresentationMaintainabilityScore,
   ScoreConfidenceLevel,
 } from "./utils/representation_score_calculator";
 
@@ -178,11 +179,11 @@ export default class GuessBasedChooser {
   private _canGuessHigher(
     bufferGap : number,
     speed : number,
-    [score, scoreConfidenceLevel] : [number, ScoreConfidenceLevel]
+    { score, confidenceLevel } : IRepresentationMaintainabilityScore
   ) : boolean {
     return isFinite(bufferGap) && bufferGap >= 2.5 &&
            performance.now() > this._blockGuessesUntil &&
-           scoreConfidenceLevel === ScoreConfidenceLevel.HIGH &&
+           confidenceLevel === ScoreConfidenceLevel.HIGH &&
            score / speed > 1.01;
   }
 
@@ -197,13 +198,13 @@ export default class GuessBasedChooser {
    */
   private _shouldStopGuess(
     lastGuess : Representation,
-    scoreData : [number, ScoreConfidenceLevel] | undefined,
+    scoreData : IRepresentationMaintainabilityScore | undefined,
     bufferGap : number,
     requests : IRequestInfo[]
   ) : boolean {
-    if (scoreData !== undefined && scoreData[0] < 1.01) {
+    if (scoreData !== undefined && scoreData.score < 1.01) {
       return true;
-    } else if ((scoreData === undefined || scoreData[0] < 1.2) && bufferGap < 0.6) {
+    } else if ((scoreData === undefined || scoreData.score < 1.2) && bufferGap < 0.6) {
       return true;
     }
 
@@ -233,11 +234,11 @@ export default class GuessBasedChooser {
   private _isLastGuessValidated(
     lastGuess : Representation,
     incomingBestBitrate : number,
-    scoreData : [number, ScoreConfidenceLevel] | undefined
+    scoreData : IRepresentationMaintainabilityScore | undefined
   ) : boolean {
     if (scoreData !== undefined &&
-        scoreData[1] === ScoreConfidenceLevel.HIGH &&
-        scoreData[0] > 1.5)
+        scoreData.confidenceLevel === ScoreConfidenceLevel.HIGH &&
+        scoreData.score > 1.5)
     {
       return true;
     }