rx-player 3.26.2 → 3.27.0-dev.20220317

package/src/core/README.md

@@ -16,7 +16,7 @@ Those modules are:
     Initialize playback and connects different modules between one another.
 
 
-  - __the `EMEManager` (./eme)__
+  - __the `ContentDecryptor` (./decrypt)__
 
     Negotiate content decryption.
     Only used for contents with DRM (Digital Right Management).

package/src/core/abr/__tests__/{get_estimate_from_buffer_levels.test.ts → buffer_based_chooser.test.ts}

@@ -21,79 +21,55 @@
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 
-describe("getEstimateFromBufferLevels", () => {
+describe("BufferBasedChooser", () => {
   beforeEach(() => {
     jest.resetModules();
   });
 
   it("should return the first bitrate if the current bitrate is undefined", () => {
-    const logger = {};
+    const logger = { debug: jest.fn() };
     jest.mock("../../../log", () => ({ __esModule: true as const,
                                        default: logger }));
-    const getEstimateFromBufferLevels = require("../get_estimate_from_buffer_levels")
-      .default;
-    expect(getEstimateFromBufferLevels({
-      bufferGap: 0,
-      speed: 1,
-    }, [], [])).toEqual(undefined);
-    expect(getEstimateFromBufferLevels({
+    const BufferBasedChooser = require("../buffer_based_chooser").default;
+    expect(new BufferBasedChooser([]).getEstimate({ bufferGap: 0, speed: 1 }))
+      .toEqual(undefined);
+    expect(new BufferBasedChooser([1, 2, 3]).getEstimate({
       bufferGap: 0,
       speed: 1,
-    }, [1, 2, 3], [0, 5, 10])).toEqual(1);
-    expect(getEstimateFromBufferLevels({
+    })).toEqual(1);
+    expect(new BufferBasedChooser([10, 20]).getEstimate({
       bufferGap: 0,
       speed: 1,
       currentBitrate: undefined,
       currentScore: undefined,
-    }, [10, 20], [0, 58])).toEqual(10);
-    expect(getEstimateFromBufferLevels({
+    })).toEqual(10);
+    expect(new BufferBasedChooser([1, 2, 3]).getEstimate({
       bufferGap: 0,
       speed: 1,
       currentBitrate: undefined,
       currentScore: 4,
-    }, [1, 2, 3], [0, 5, 10])).toEqual(1);
-    expect(getEstimateFromBufferLevels({
+    })).toEqual(1);
+    expect(new BufferBasedChooser([1, 2, 3]).getEstimate({
       bufferGap: 0,
       speed: 1,
       currentScore: 1,
-    }, [1, 2, 3], [0, 5, 10])).toEqual(1);
+    })).toEqual(1);
   });
 
   /* eslint-disable max-len */
   it("should log an error and return the first bitrate if the given bitrate does not exist", () => {
   /* eslint-enable max-len */
-    const logger = { error: jest.fn() };
+    const logger = { debug: jest.fn(), error: jest.fn() };
     jest.mock("../../../log", () => ({ __esModule: true as const,
                                        default: logger }));
-    const getEstimateFromBufferLevels = require("../get_estimate_from_buffer_levels")
-      .default;
+    const BufferBasedChooser = require("../buffer_based_chooser").default;
 
-    expect(getEstimateFromBufferLevels({
+    expect(new BufferBasedChooser([10, 20]).getEstimate({
       bufferGap: 0,
       speed: 1,
       currentBitrate: 30,
       currentScore: undefined,
-    }, [10, 20], [0, 58])).toEqual(10);
-    expect(logger.error).toHaveBeenCalledTimes(1);
-    expect(logger.error)
-      .toHaveBeenCalledWith("ABR: Current Bitrate not found in the calculated levels");
-  });
-
-  /* eslint-disable max-len */
-  it("should log an error and return the first bitrate if the given bitrates and levels are of different length", () => {
-  /* eslint-enable max-len */
-    const logger = { error: jest.fn() };
-    jest.mock("../../../log", () => ({ __esModule: true as const,
-                                       default: logger }));
-    const getEstimateFromBufferLevels = require("../get_estimate_from_buffer_levels")
-      .default;
-
-    expect(getEstimateFromBufferLevels({
-      bufferGap: 0,
-      speed: 1,
-      currentBitrate: 10,
-      currentScore: undefined,
-    }, [10, 20], [0, 58, 12])).toEqual(10);
+    })).toEqual(10);
     expect(logger.error).toHaveBeenCalledTimes(1);
     expect(logger.error)
       .toHaveBeenCalledWith("ABR: Current Bitrate not found in the calculated levels");
@@ -102,234 +78,229 @@ describe("getEstimateFromBufferLevels", () => {
   /* 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", () => {
   /* eslint-enable max-len */
-    const logger = {};
+    const logger = { debug: jest.fn() };
     jest.mock("../../../log", () => ({ __esModule: true as const,
                                        default: logger }));
-    const getEstimateFromBufferLevels = require("../get_estimate_from_buffer_levels")
-      .default;
-    expect(getEstimateFromBufferLevels({
+    const BufferBasedChooser = require("../buffer_based_chooser").default;
+    expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
       bufferGap: 16,
       speed: 1,
       currentBitrate: 10,
       currentScore: 1.01,
-    }, [10, 20, 40], [0, 15, 20])).toEqual(20);
-    expect(getEstimateFromBufferLevels({
+    })).toEqual(20);
+    expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
       bufferGap: 30,
       speed: 1,
       currentBitrate: 20,
       currentScore: 1.01,
-    }, [10, 20, 40], [0, 15, 20])).toEqual(40);
-    expect(getEstimateFromBufferLevels({
+    })).toEqual(40);
+    expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
       bufferGap: 30,
       speed: 1,
       currentBitrate: 20,
       currentScore: 100,
-    }, [10, 20, 40], [0, 15, 20])).toEqual(40);
-    expect(getEstimateFromBufferLevels({
+    })).toEqual(40);
+    expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
       bufferGap: 30,
       speed: 2,
       currentBitrate: 20,
       currentScore: 2.1,
-    }, [10, 20, 40], [0, 15, 20])).toEqual(40);
-    expect(getEstimateFromBufferLevels({
+    })).toEqual(40);
+    expect(new BufferBasedChooser([10, 20, 20, 40]).getEstimate({
       bufferGap: 30,
       speed: 2,
       currentBitrate: 20,
       currentScore: 2.1,
-    }, [10, 20, 20, 40], [0, 15, 15, 20])).toEqual(40);
-    expect(getEstimateFromBufferLevels({
+    })).toEqual(40);
+    expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
       bufferGap: 30,
       speed: 0, // 0 is a special case
       currentBitrate: 20,
       currentScore: 100,
-    }, [10, 20, 40], [0, 15, 20])).toEqual(40);
+    })).toEqual(40);
   });
 
   /* 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", () => {
   /* eslint-enable max-len */
-    const logger = {};
+    const logger = { debug: jest.fn() };
     jest.mock("../../../log", () => ({ __esModule: true as const,
                                        default: logger }));
-    const getEstimateFromBufferLevels = require("../get_estimate_from_buffer_levels")
-      .default;
-    expect(getEstimateFromBufferLevels({
+    const BufferBasedChooser = require("../buffer_based_chooser").default;
+    expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
       bufferGap: 15,
       speed: 1,
       currentBitrate: 10,
       currentScore: 1.01,
-    }, [10, 20, 40], [0, 15, 20])).toEqual(20);
-    expect(getEstimateFromBufferLevels({
+    })).toEqual(20);
+    expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
       bufferGap: 20,
       speed: 1,
       currentBitrate: 20,
       currentScore: 1.01,
-    }, [10, 20, 40], [0, 15, 20])).toEqual(40);
-    expect(getEstimateFromBufferLevels({
+    })).toEqual(40);
+    expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
       bufferGap: 20,
       speed: 1,
       currentBitrate: 20,
       currentScore: 100,
-    }, [10, 20, 40], [0, 15, 20])).toEqual(40);
-    expect(getEstimateFromBufferLevels({
+    })).toEqual(40);
+    expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
       bufferGap: 20,
       speed: 2,
       currentBitrate: 20,
       currentScore: 2.1,
-    }, [10, 20, 40], [0, 15, 20])).toEqual(40);
-    expect(getEstimateFromBufferLevels({
+    })).toEqual(40);
+    expect(new BufferBasedChooser([10, 20, 20, 40]).getEstimate({
       bufferGap: 20,
       speed: 2,
       currentBitrate: 20,
       currentScore: 2.1,
-    }, [10, 20, 20, 40], [0, 15, 15, 20])).toEqual(40);
-    expect(getEstimateFromBufferLevels({
+    })).toEqual(40);
+    expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
       bufferGap: 20,
       speed: 0, // 0 is a special case
       currentBitrate: 20,
       currentScore: 100,
-    }, [10, 20, 40], [0, 15, 20])).toEqual(40);
+    })).toEqual(40);
   });
 
   /* eslint-disable max-len */
   it("should stay at the current bitrate if it is maintainable but we have a buffer inferior to the next level", () => {
   /* eslint-enable max-len */
-    const logger = {};
+    const logger = { debug: jest.fn() };
     jest.mock("../../../log", () => ({ __esModule: true as const,
                                        default: logger }));
-    const getEstimateFromBufferLevels = require("../get_estimate_from_buffer_levels")
-      .default;
-    expect(getEstimateFromBufferLevels({
-      bufferGap: 14.9,
+    const BufferBasedChooser = require("../buffer_based_chooser").default;
+    expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
+      bufferGap: 6,
       speed: 1,
       currentBitrate: 10,
       currentScore: 1.01,
-    }, [10, 20, 40], [0, 15, 20])).toEqual(10);
-    expect(getEstimateFromBufferLevels({
-      bufferGap: 19.9,
+    })).toEqual(10);
+    expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
+      bufferGap: 10,
       speed: 1,
       currentBitrate: 20,
       currentScore: 1.01,
-    }, [10, 20, 40], [0, 15, 20])).toEqual(20);
-    expect(getEstimateFromBufferLevels({
-      bufferGap: 19.9,
+    })).toEqual(20);
+    expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
+      bufferGap: 10,
       speed: 1,
       currentBitrate: 20,
       currentScore: 100,
-    }, [10, 20, 40], [0, 15, 20])).toEqual(20);
-    expect(getEstimateFromBufferLevels({
-      bufferGap: 19.9,
+    })).toEqual(20);
+    expect(new BufferBasedChooser([10, 20, 20, 40]).getEstimate({
+      bufferGap: 10,
       speed: 1,
       currentBitrate: 20,
       currentScore: 100,
-    }, [10, 20, 20, 40], [0, 15, 15, 20])).toEqual(20);
-    expect(getEstimateFromBufferLevels({
-      bufferGap: 19.9,
+    })).toEqual(20);
+    expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
+      bufferGap: 10,
       speed: 2,
       currentBitrate: 20,
       currentScore: 2.1,
-    }, [10, 20, 40], [0, 15, 20])).toEqual(20);
+    })).toEqual(20);
   });
 
   /* eslint-disable max-len */
   it("should stay at the current bitrate if we are currently at the maximum one", () => {
   /* eslint-enable max-len */
-    const logger = {};
+    const logger = { debug: jest.fn() };
     jest.mock("../../../log", () => ({ __esModule: true as const,
                                        default: logger }));
-    const getEstimateFromBufferLevels = require("../get_estimate_from_buffer_levels")
+    const BufferBasedChooser = require("../buffer_based_chooser")
       .default;
-    expect(getEstimateFromBufferLevels({
+    expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
       bufferGap: 100000000000,
       speed: 1,
       currentBitrate: 40,
       currentScore: 1000000,
-    }, [10, 20, 40], [0, 15, 20])).toEqual(40);
-    expect(getEstimateFromBufferLevels({
+    })).toEqual(40);
+    expect(new BufferBasedChooser([10, 20, 40, 40]).getEstimate({
       bufferGap: 100000000000,
       speed: 1,
       currentBitrate: 40,
       currentScore: 1000000,
-    }, [10, 20, 40, 40], [0, 15, 20, 20])).toEqual(40);
+    })).toEqual(40);
   });
 
   /* eslint-disable max-len */
   it("should stay at the current bitrate if the current one is not maintainable due to the speed", () => {
   /* eslint-enable max-len */
-    const logger = {};
+    const logger = { debug: jest.fn() };
     jest.mock("../../../log", () => ({ __esModule: true as const,
                                        default: logger }));
-    const getEstimateFromBufferLevels = require("../get_estimate_from_buffer_levels")
-      .default;
-    expect(getEstimateFromBufferLevels({
+    const BufferBasedChooser = require("../buffer_based_chooser").default;
+    expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
       bufferGap: 15,
       speed: 2,
       currentBitrate: 10,
       currentScore: 1.01,
-    }, [10, 20, 40], [0, 15, 20])).toEqual(10);
-    expect(getEstimateFromBufferLevels({
+    })).toEqual(10);
+    expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
       bufferGap: 20,
       speed: 2,
       currentBitrate: 20,
       currentScore: 1.01,
-    }, [10, 20, 40], [0, 15, 20])).toEqual(20);
-    expect(getEstimateFromBufferLevels({
+    })).toEqual(20);
+    expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
       bufferGap: 20,
       speed: 100,
       currentBitrate: 20,
       currentScore: 100,
-    }, [10, 20, 40], [0, 15, 20])).toEqual(20);
-    expect(getEstimateFromBufferLevels({
+    })).toEqual(20);
+    expect(new BufferBasedChooser([10, 20, 20, 40]).getEstimate({
       bufferGap: 20,
       speed: 100,
       currentBitrate: 20,
       currentScore: 100,
-    }, [10, 20, 20,  40], [0, 15, 15, 20])).toEqual(20);
-    expect(getEstimateFromBufferLevels({
+    })).toEqual(20);
+    expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
       bufferGap: 20,
       speed: 3,
       currentBitrate: 20,
       currentScore: 2.1,
-    }, [10, 20, 40], [0, 15, 20])).toEqual(20);
+    })).toEqual(20);
   });
 
   /* eslint-disable max-len */
   it("should not go to the next bitrate if we do not know if it is maintainable", () => {
   /* eslint-enable max-len */
-    const logger = {};
+    const logger = { debug: jest.fn() };
     jest.mock("../../../log", () => ({ __esModule: true as const,
                                        default: logger }));
-    const getEstimateFromBufferLevels = require("../get_estimate_from_buffer_levels")
-      .default;
-    expect(getEstimateFromBufferLevels({
+    const BufferBasedChooser = require("../buffer_based_chooser").default;
+    expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
       bufferGap: 15,
       speed: 1,
       currentBitrate: 10,
-    }, [10, 20, 40], [0, 15, 20])).toEqual(10);
-    expect(getEstimateFromBufferLevels({
+    })).toEqual(10);
+    expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
       bufferGap: 20,
       speed: 1,
       currentBitrate: 20,
-    }, [10, 20, 40], [0, 15, 20])).toEqual(20);
-    expect(getEstimateFromBufferLevels({
+    })).toEqual(20);
+    expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
       bufferGap: 20,
       speed: 1,
       currentBitrate: 20,
-    }, [10, 20, 40], [0, 15, 20])).toEqual(20);
-    expect(getEstimateFromBufferLevels({
+    })).toEqual(20);
+    expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
       bufferGap: 20,
       speed: 2,
       currentBitrate: 20,
-    }, [10, 20, 40], [0, 15, 20])).toEqual(20);
-    expect(getEstimateFromBufferLevels({
+    })).toEqual(20);
+    expect(new BufferBasedChooser([10, 20, 20, 40]).getEstimate({
       bufferGap: 20,
       speed: 2,
       currentBitrate: 20,
-    }, [10, 20, 20, 40], [0, 15, 15, 20])).toEqual(20);
-    expect(getEstimateFromBufferLevels({
+    })).toEqual(20);
+    expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
       bufferGap: 20,
       speed: 0, // 0 is a special case
       currentBitrate: 20,
-    }, [10, 20, 40], [0, 15, 20])).toEqual(20);
+    })).toEqual(20);
   });
 });

package/src/core/abr/bandwidth_estimator.ts

@@ -17,10 +17,6 @@
 import config from "../../config";
 import EWMA from "./utils/ewma";
 
-const { ABR_MINIMUM_TOTAL_BYTES,
-        ABR_MINIMUM_CHUNK_SIZE,
-        ABR_FAST_EMA,
-        ABR_SLOW_EMA } = config;
 
 /**
  * Calculate a mean bandwidth based on the bytes downloaded and the amount
@@ -35,6 +31,7 @@ export default class BandwidthEstimator {
   private _bytesSampled : number;
 
   constructor() {
+    const { ABR_FAST_EMA, ABR_SLOW_EMA } = config.getCurrent();
     /**
      * A fast-moving average.
      * @private
@@ -63,6 +60,7 @@ export default class BandwidthEstimator {
    *   request.
    */
   public addSample(durationInMs : number, numberOfBytes : number) : void {
+    const { ABR_MINIMUM_CHUNK_SIZE } = config.getCurrent();
     if (numberOfBytes < ABR_MINIMUM_CHUNK_SIZE) {
       return;
     }
@@ -80,6 +78,7 @@ export default class BandwidthEstimator {
    * @returns {Number|undefined}
    */
   public getEstimate() : number|undefined {
+    const { ABR_MINIMUM_TOTAL_BYTES } = config.getCurrent();
     if (this._bytesSampled < ABR_MINIMUM_TOTAL_BYTES) {
       return undefined;
     }
@@ -94,6 +93,7 @@ export default class BandwidthEstimator {
    * Reset the bandwidth estimation.
    */
   public reset() : void {
+    const { ABR_FAST_EMA, ABR_SLOW_EMA } = config.getCurrent();
     this._fastEWMA = new EWMA(ABR_FAST_EMA);
     this._slowEWMA = new EWMA(ABR_SLOW_EMA);
     this._bytesSampled = 0;

package/src/core/abr/buffer_based_chooser.ts

@@ -14,15 +14,9 @@
  * limitations under the License.
  */
 
-import {
-  map,
-  Observable,
-} from "rxjs";
 import log from "../../log";
+import arrayFindIndex from "../../utils/array_find_index";
 import getBufferLevels from "./get_buffer_levels";
-import getEstimateFromBufferLevels, {
-  IBufferBasedChooserPlaybackObservation,
-} from "./get_estimate_from_buffer_levels";
 
 /**
  * Choose a bitrate based on the currently available buffer.
@@ -35,18 +29,89 @@ import getEstimateFromBufferLevels, {
  * "maintanable" or not.
  * If so, we may switch to a better quality, or conversely to a worse quality.
  *
- * @param {Observable} update$
- * @param {Array.<number>} bitrates
- * @returns {Observable}
+ * @class BufferBasedChooser
  */
-export default function BufferBasedChooser(
-  update$ : Observable<IBufferBasedChooserPlaybackObservation>,
-  bitrates: number[]
-) : Observable<number|undefined> {
-  const levelsMap = getBufferLevels(bitrates);
-  log.debug("ABR: Steps for buffer based chooser.",
-            levelsMap.map((l, i) => ({ bufferLevel: l, bitrate: bitrates[i] })));
-  return update$.pipe(map((playbackObservation) => {
-    return getEstimateFromBufferLevels(playbackObservation, bitrates, levelsMap);
-  }));
+export default class BufferBasedChooser {
+  private _levelsMap : number[];
+  private _bitrates : number[];
+
+  /**
+   * @param {Array.<number>} number;
+   */
+  constructor(bitrates : number[]) {
+    this._levelsMap = getBufferLevels(bitrates);
+    this._bitrates = bitrates;
+    log.debug("ABR: Steps for buffer based chooser.",
+              this._levelsMap.map((l, i) => ({ bufferLevel: l, bitrate: bitrates[i] })));
+  }
+
+  /**
+   * @param {Object} playbackObservation
+   * @returns {number|undefined}
+   */
+  public getEstimate(
+    playbackObservation : IBufferBasedChooserPlaybackObservation
+  ) : number | undefined {
+    const bufferLevels = this._levelsMap;
+    const bitrates = this._bitrates;
+    const { bufferGap, currentBitrate, currentScore, speed } = playbackObservation;
+    if (currentBitrate == null) {
+      return bitrates[0];
+    }
+    const currentBitrateIndex = arrayFindIndex(bitrates, b => b === currentBitrate);
+    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 (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];
+        }
+      }
+    }
+
+    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];
+          }
+        }
+        return currentBitrate;
+      }
+    }
+    return currentBitrate;
+  }
+}
+
+/** Playback observation needed by the `BufferBasedChooser`. */
+export interface IBufferBasedChooserPlaybackObservation {
+  /**
+   * Difference in seconds between the current position and the next
+   * non-buffered position
+   */
+  bufferGap : number;
+  /** The bitrate of the currently downloaded segments, in bps. */
+  currentBitrate? : number | undefined;
+  /** The "maintainability score" of the currently downloaded segments. */
+  currentScore? : number | undefined;
+  /** Playback rate wanted */
+  speed : number;
 }

package/src/core/abr/network_analyzer.ts

@@ -25,11 +25,6 @@ import {
 } from "./pending_requests_store";
 import EWMA from "./utils/ewma";
 
-const { ABR_REGULAR_FACTOR,
-        ABR_STARVATION_DURATION_DELTA,
-        ABR_STARVATION_FACTOR,
-        ABR_STARVATION_GAP,
-        OUT_OF_STARVATION_GAP } = config;
 
 /** Object describing the current playback conditions. */
 interface IPlaybackConditionsInfo {
@@ -289,6 +284,10 @@ export default class NetworkAnalyzer {
                       regularBitrateFactor : number; };
 
   constructor(initialBitrate: number, lowLatencyMode: boolean) {
+    const { ABR_STARVATION_GAP,
+            OUT_OF_STARVATION_GAP,
+            ABR_STARVATION_FACTOR,
+            ABR_REGULAR_FACTOR } = config.getCurrent();
     this._initialBitrate = initialBitrate;
     this._inStarvationMode = false;
     this._lowLatencyMode = lowLatencyMode;
@@ -327,14 +326,14 @@ export default class NetworkAnalyzer {
     currentRepresentation : Representation | null,
     currentRequests : IRequestInfo[],
     lastEstimatedBitrate: number|undefined
-  ) : { bandwidthEstimate? : number; bitrateChosen : number } {
+  ) : { bandwidthEstimate? : number | undefined; bitrateChosen : number } {
     let newBitrateCeil : number | undefined; // bitrate ceil for the chosen Representation
     let bandwidthEstimate;
     const localConf = this._config;
     const { bufferGap, position, duration } = playbackInfo;
     const realBufferGap = isFinite(bufferGap) ? bufferGap :
                                                 0;
-
+    const { ABR_STARVATION_DURATION_DELTA } = config.getCurrent();
     // check if should get in/out of starvation mode
     if (isNaN(duration) ||
         realBufferGap + position < duration - ABR_STARVATION_DURATION_DELTA)

package/src/core/abr/pending_requests_store.ts

@@ -70,11 +70,9 @@ export default class PendingRequestsStore {
    */
   public remove(id : string) : void {
     if (this._currentRequests[id] == null) {
-      // TODO This breaks github actions.
-      // Find why
-      // if (__ENVIRONMENT__.CURRENT_ENV === __ENVIRONMENT__.DEV as number) {
-      //   throw new Error("ABR: can't remove unknown request");
-      // }
+      if (__ENVIRONMENT__.CURRENT_ENV === __ENVIRONMENT__.DEV as number) {
+        throw new Error("ABR: can't remove unknown request");
+      }
       log.warn("ABR: can't remove unknown request");
     }
     delete this._currentRequests[id];

package/src/core/abr/representation_estimator.ts

@@ -119,7 +119,7 @@ export interface IABREstimate {
    * have, you will most likely only want to do it when the Representation is
    * known to be maintaninable.
    */
-  knownStableBitrate?: number;
+  knownStableBitrate?: number | undefined;
 }
 
 /** Media properties the `RepresentationEstimator` will need to keep track of. */
@@ -514,8 +514,11 @@ export default function RepresentationEstimator({
       );
 
       const bitrates = representations.map(r => r.bitrate);
-      const bufferBasedEstimation$ = BufferBasedChooser(bufferBasedobservation$, bitrates)
-        .pipe(startWith(undefined));
+      const bufferBasedChooser = new BufferBasedChooser(bitrates);
+      const bufferBasedEstimation$ = bufferBasedobservation$.pipe(
+        map(bbo => bufferBasedChooser.getEstimate(bbo)),
+        startWith(undefined)
+      );
 
       return observableCombineLatest([ observation$,
                                        minAutoBitrate$,