rx-player 3.25.2 → 3.26.3-dev.2022021400

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/abr_manager.ts

@@ -15,22 +15,26 @@
  */
 
 import {
+  combineLatest as observableCombineLatest,
+  map,
   Observable,
   of as observableOf,
 } from "rxjs";
 import log from "../../log";
 import { Representation } from "../../manifest";
+import objectAssign from "../../utils/object_assign";
+import { ISharedReference } from "../../utils/reference";
 import takeFirstSet from "../../utils/take_first_set";
 import { IBufferType } from "../segment_buffers";
 import BandwidthEstimator from "./bandwidth_estimator";
-import createFilters from "./create_filters";
 import RepresentationEstimator, {
   IABREstimate,
+  IABRFiltersObject,
   IABRStreamEvents,
-  IRepresentationEstimatorClockTick,
+  IRepresentationEstimatorPlaybackObservation,
 } from "./representation_estimator";
 
-export type IABRManagerClockTick = IRepresentationEstimatorClockTick;
+export type IABRManagerPlaybackObservation = IRepresentationEstimatorPlaybackObservation;
 
 // Options for every RepresentationEstimator
 interface IRepresentationEstimatorsThrottlers {
@@ -48,15 +52,16 @@ export interface IABRManagerArguments {
   lowLatencyMode: boolean; // Some settings can depend on wether you're playing a
                            // low-latency content. Set it to `true` if you're playing
                            // such content.
-  minAutoBitrates: Partial<Record<IBufferType,          // Minimum bitrate chosen
-                                  Observable<number>>>; // when in auto mode, per
-                                                        // type (0 by default)
-  maxAutoBitrates: Partial<Record<IBufferType,          // Maximum bitrate chosen
-                                  Observable<number>>>; // when in auto mode, per
-                                                        // type (Infinity by default)
-  manualBitrates: Partial<Record<IBufferType,          // Manual bitrate set for
-                                 Observable<number>>>; // a given type (-1 for
-                                                       // auto mode)
+
+  /** Minimum bitrate chosen when in auto mode, per type (0 by default) */
+  minAutoBitrates: Partial<Record<IBufferType, ISharedReference<number>>>;
+
+  /** Maximum bitrate chosen when in auto mode, per type (0 by default) */
+  maxAutoBitrates: Partial<Record<IBufferType, ISharedReference<number>>>;
+
+  /** Manually forced bitrate set for a given type (`-1` for auto mode */
+  manualBitrates: Partial<Record<IBufferType, ISharedReference<number>>>;
+
   throttlers: IRepresentationEstimatorsThrottlers; // Throttle from external events
 }
 
@@ -70,9 +75,9 @@ export interface IABRManagerArguments {
 export default class ABRManager {
   private _bandwidthEstimators : Partial<Record<IBufferType, BandwidthEstimator>>;
   private _initialBitrates : Partial<Record<IBufferType, number>>;
-  private _manualBitrates : Partial<Record<IBufferType, Observable<number>>>;
-  private _minAutoBitrates : Partial<Record<IBufferType, Observable<number>>>;
-  private _maxAutoBitrates : Partial<Record<IBufferType, Observable<number>>>;
+  private _manualBitrates : Partial<Record<IBufferType, ISharedReference<number>>>;
+  private _minAutoBitrates : Partial<Record<IBufferType, ISharedReference<number>>>;
+  private _maxAutoBitrates : Partial<Record<IBufferType, ISharedReference<number>>>;
   private _throttlers : IRepresentationEstimatorsThrottlers;
   private _lowLatencyMode : boolean;
 
@@ -95,24 +100,25 @@ export default class ABRManager {
    * state).
    * @param {string} type
    * @param {Array.<Representation>} representations
-   * @param {Observable<Object>} clock$
+   * @param {Observable<Object>} observation$
    * @param {Observable<Object>} streamEvents$
    * @returns {Observable}
    */
   public get$(
     type : IBufferType,
     representations : Representation[],
-    clock$ : Observable<IABRManagerClockTick>,
+    observation$ : Observable<IABRManagerPlaybackObservation>,
     streamEvents$ : Observable<IABRStreamEvents>
   ) : Observable<IABREstimate> {
     const bandwidthEstimator = this._getBandwidthEstimator(type);
     const manualBitrate$ =
-      takeFirstSet<Observable<number>>(this._manualBitrates[type], observableOf(-1));
+      takeFirstSet<Observable<number>>(this._manualBitrates[type]?.asObservable(),
+                                       observableOf(-1));
     const minAutoBitrate$ =
-      takeFirstSet<Observable<number>>(this._minAutoBitrates[type],
+      takeFirstSet<Observable<number>>(this._minAutoBitrates[type]?.asObservable(),
                                        observableOf(0));
     const maxAutoBitrate$ =
-      takeFirstSet<Observable<number>>(this._maxAutoBitrates[type],
+      takeFirstSet<Observable<number>>(this._maxAutoBitrates[type]?.asObservable(),
                                        observableOf(Infinity));
     const initialBitrate = takeFirstSet<number>(this._initialBitrates[type], 0);
     const filters$ = createFilters(this._throttlers.limitWidth[type],
@@ -120,7 +126,7 @@ export default class ABRManager {
                                    this._throttlers.throttle[type]);
     return RepresentationEstimator({ bandwidthEstimator,
                                      streamEvents$,
-                                     clock$,
+                                     observation$,
                                      filters$,
                                      initialBitrate,
                                      manualBitrate$,
@@ -145,3 +151,38 @@ export default class ABRManager {
     return originalBandwidthEstimator;
   }
 }
+
+/**
+ * Create Observable that merge several throttling Observables into one.
+ * @param {Observable} limitWidth$ - Emit the width at which the chosen
+ * Representation should be limited.
+ * @param {Observable} throttleBitrate$ - Emit the maximum bitrate authorized.
+ * @param {Observable} throttle$ - Also emit the maximum bitrate authorized.
+ * Here for legacy reasons.
+ * @returns {Observable}
+ */
+function createFilters(
+  limitWidth$? : Observable<number>,
+  throttleBitrate$? : Observable<number>,
+  throttle$? : Observable<number>
+) : Observable<IABRFiltersObject> {
+  const deviceEventsArray : Array<Observable<IABRFiltersObject>> = [];
+
+  if (limitWidth$ != null) {
+    deviceEventsArray.push(limitWidth$.pipe(map(width => ({ width }))));
+  }
+  if (throttle$ != null) {
+    deviceEventsArray.push(throttle$.pipe(map(bitrate => ({ bitrate }))));
+  }
+  if (throttleBitrate$ != null) {
+    deviceEventsArray.push(throttleBitrate$.pipe(map(bitrate => ({ bitrate }))));
+  }
+
+  // Emit restrictions on the pools of available representations to choose
+  // from.
+  return deviceEventsArray.length > 0 ?
+    observableCombineLatest(deviceEventsArray)
+      .pipe(map((args : IABRFiltersObject[]) =>
+        objectAssign({}, ...args) as IABRFiltersObject)) :
+    observableOf({});
+}

package/src/core/abr/bandwidth_estimator.ts

@@ -15,7 +15,7 @@
  */
 
 import config from "../../config";
-import EWMA from "./ewma";
+import EWMA from "./utils/ewma";
 
 const { ABR_MINIMUM_TOTAL_BYTES,
         ABR_MINIMUM_CHUNK_SIZE,