rx-player 3.33.0 → 3.33.1

package/src/core/adaptive/utils/__tests__/filter_by_width.test.ts

@@ -1,60 +0,0 @@
-/**
- * Copyright 2017 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import { Representation } from "../../../../manifest";
-import filterByWidth from "../filter_by_width";
-
-describe("ABR - filterByWidth", () => {
-  const fakeReps = [
-    { width : 100 },
-    { width : 1000 },
-    { width : 10000 },
-    { width : 100000 },
-  ];
-
-  const expectedWidthReps = [
-    { width : 100 },
-    { width : 1000 },
-  ];
-
-  describe("filterByWidth", () => {
-    it("should properly filter representations whose width is < 900", () => {
-      expect(filterByWidth(fakeReps as Representation[], 999))
-        .toEqual(expectedWidthReps);
-    });
-
-    it("should return all representations when specified width is over maxWidth", () => {
-      expect(filterByWidth(fakeReps as Representation[], 1000000))
-        .toEqual(fakeReps);
-    });
-
-    it("should return all representations when specified width is infinite", () => {
-      expect(filterByWidth(fakeReps as Representation[], Infinity))
-        .toEqual(fakeReps);
-    });
-
-    it("should return first representation when specified width is 0", () => {
-      expect(filterByWidth(fakeReps as Representation[], 0))
-        .toEqual([{ width: 100 }]);
-    });
-
-    it("should return no representation when specified array is empty", () => {
-      expect(filterByWidth([], 0))
-        .toEqual([]);
-    });
-  });
-
-});

package/src/core/adaptive/utils/__tests__/get_buffer_levels.test.ts

@@ -1,48 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import getBufferLevels from "../get_buffer_levels";
-
-describe("getBufferLevels", () => {
-  it("should return an empty array if given an empty array", () => {
-    expect(getBufferLevels([])).toEqual([]);
-  });
-
-  it("should always set the first step at 0", () => {
-    expect(getBufferLevels([0])).toEqual([0]);
-    expect(getBufferLevels([12])).toEqual([0]);
-    expect(getBufferLevels([Infinity])).toEqual([0]);
-
-    const bufferLevels = getBufferLevels([0, 7, 8, 9]);
-    expect(bufferLevels[0]).toEqual(0);
-  });
-
-  it("should set progressive steps in ascending order", () => {
-    expect(getBufferLevels([1, 7, 8, 9]))
-      .toEqual(getBufferLevels([1, 7, 8, 9]).sort((a, b) => a - b));
-    expect(getBufferLevels([1, 1.1]))
-      .toEqual(getBufferLevels([1, 1.1]).sort((a, b) => a - b));
-  });
-
-  // it.only("should set higher steps differences for higher bitrate differences", () => {
-  //   const steps1 = getBufferLevels([1, 7, 14, 21]);
-  //   const steps2 = getBufferLevels([5, 700, 701, 702]);
-
-  //   expect(steps1[0]).toEqual(steps2[0]);
-  //   expect(steps1).toEqual(steps2);
-  //   expect(steps1[1]).toBeLessThan(steps2[1]);
-  // });
-});

package/src/core/adaptive/utils/__tests__/select_optimal_representation.test.ts

@@ -1,243 +0,0 @@
-/**
- * Copyright 2017 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import { Representation } from "../../../../manifest";
-import selectOptimalRepresentation from "../select_optimal_representation";
-
-describe("ABR - selectOptimalRepresentation", () => {
-  const fakeReps = [
-    { bitrate : 100 },
-    { bitrate : 1000 },
-    { bitrate : 10000 },
-    { bitrate : 100000 },
-  ];
-
-  // eslint-disable-next-line max-len
-  it("should return the best representation when the optimal bitrate given is Infinity and no higher limit exists", () => {
-    expect(selectOptimalRepresentation(fakeReps as Representation[],
-                                       Infinity,
-                                       0,
-                                       Infinity))
-      .toBe(fakeReps[fakeReps.length - 1]);
-    expect(selectOptimalRepresentation(fakeReps as Representation[],
-                                       Infinity,
-                                       100,
-                                       Infinity))
-      .toBe(fakeReps[fakeReps.length - 1]);
-    expect(selectOptimalRepresentation(fakeReps as Representation[],
-                                       Infinity,
-                                       Infinity,
-                                       Infinity))
-      .toBe(fakeReps[fakeReps.length - 1]);
-  });
-
-  // eslint-disable-next-line max-len
-  it("should return the best representation when both the optimal bitrate and the higher limit given are higher or equal than the highest Representation", () => {
-    expect(selectOptimalRepresentation(fakeReps as Representation[],
-                                       100000,
-                                       0,
-                                       100000))
-      .toBe(fakeReps[fakeReps.length - 1]);
-    expect(selectOptimalRepresentation(fakeReps as Representation[],
-                                       100000,
-                                       0,
-                                       900000))
-      .toBe(fakeReps[fakeReps.length - 1]);
-    expect(selectOptimalRepresentation(fakeReps as Representation[],
-                                       900000,
-                                       0,
-                                       100000))
-      .toBe(fakeReps[fakeReps.length - 1]);
-    expect(selectOptimalRepresentation(fakeReps as Representation[],
-                                       900000,
-                                       0,
-                                       900000))
-      .toBe(fakeReps[fakeReps.length - 1]);
-  });
-
-  // eslint-disable-next-line max-len
-  it("should return one below or equal to the maximum bitrate even if optimal is superior", () => {
-    expect(selectOptimalRepresentation(fakeReps as Representation[],
-                                       Infinity,
-                                       0,
-                                       999))
-      .toBe(fakeReps[0]);
-    expect(selectOptimalRepresentation(fakeReps as Representation[],
-                                       Infinity,
-                                       0,
-                                       100))
-      .toBe(fakeReps[0]);
-    expect(selectOptimalRepresentation(fakeReps as Representation[],
-                                       1001,
-                                       0,
-                                       999))
-      .toBe(fakeReps[0]);
-    expect(selectOptimalRepresentation(fakeReps as Representation[],
-                                       1001,
-                                       0,
-                                       1000))
-      .toBe(fakeReps[1]);
-    expect(selectOptimalRepresentation(fakeReps as Representation[],
-                                       Infinity,
-                                       0,
-                                       9999))
-      .toBe(fakeReps[1]);
-    expect(selectOptimalRepresentation(fakeReps as Representation[],
-                                       1001,
-                                       0,
-                                       1000))
-      .toBe(fakeReps[1]);
-  });
-
-  // eslint-disable-next-line max-len
-  it("should chose the minimum if no Representation is below or equal to the maximum bitrate", () => {
-    expect(selectOptimalRepresentation(fakeReps as Representation[],
-                                       1,
-                                       0,
-                                       0))
-      .toBe(fakeReps[0]);
-    expect(selectOptimalRepresentation(fakeReps as Representation[],
-                                       101,
-                                       0,
-                                       0))
-      .toBe(fakeReps[0]);
-    expect(selectOptimalRepresentation(fakeReps as Representation[],
-                                       Infinity,
-                                       0,
-                                       0))
-      .toBe(fakeReps[0]);
-    expect(selectOptimalRepresentation(fakeReps as Representation[],
-                                       Infinity,
-                                       0,
-                                       99))
-      .toBe(fakeReps[0]);
-    expect(selectOptimalRepresentation(fakeReps as Representation[],
-                                       0,
-                                       0,
-                                       99))
-      .toBe(fakeReps[0]);
-  });
-
-  // eslint-disable-next-line max-len
-  it("should return the worst representation when the optimal bitrate given is 0 and no lower limit exists", () => {
-    expect(selectOptimalRepresentation(fakeReps as Representation[],
-                                       0,
-                                       0,
-                                       Infinity))
-      .toBe(fakeReps[0]);
-    expect(selectOptimalRepresentation(fakeReps as Representation[],
-                                       0,
-                                       0,
-                                       0))
-      .toBe(fakeReps[0]);
-    expect(selectOptimalRepresentation(fakeReps as Representation[],
-                                       0,
-                                       0,
-                                       1000))
-      .toBe(fakeReps[0]);
-  });
-
-  // eslint-disable-next-line max-len
-  it("should return the worst representation when both the optimal bitrate and the lower limit given are lower or equal than the lowest Representation", () => {
-    expect(selectOptimalRepresentation(fakeReps as Representation[],
-                                       4,
-                                       0,
-                                       Infinity))
-      .toBe(fakeReps[0]);
-    expect(selectOptimalRepresentation(fakeReps as Representation[],
-                                       100,
-                                       100,
-                                       Infinity))
-      .toBe(fakeReps[0]);
-    expect(selectOptimalRepresentation(fakeReps as Representation[],
-                                       0,
-                                       100,
-                                       100000))
-      .toBe(fakeReps[0]);
-    expect(selectOptimalRepresentation(fakeReps as Representation[],
-                                       100,
-                                       0,
-                                       100000))
-      .toBe(fakeReps[0]);
-  });
-
-  // eslint-disable-next-line max-len
-  it("should return one higher or equal to the minimum bitrate even if optimal is inferior", () => {
-    expect(selectOptimalRepresentation(fakeReps as Representation[],
-                                       0,
-                                       1000,
-                                       Infinity))
-      .toBe(fakeReps[1]);
-    expect(selectOptimalRepresentation(fakeReps as Representation[],
-                                       0,
-                                       1000,
-                                       1000))
-      .toBe(fakeReps[1]);
-    expect(selectOptimalRepresentation(fakeReps as Representation[],
-                                       1000,
-                                       10000,
-                                       Infinity))
-      .toBe(fakeReps[2]);
-  });
-
-  // eslint-disable-next-line max-len
-  it("should chose the maximum if no Representation is higher or equal to the minimum bitrate", () => {
-    expect(selectOptimalRepresentation(fakeReps as Representation[],
-                                       0,
-                                       10000000,
-                                       Infinity))
-      .toBe(fakeReps[fakeReps.length - 1]);
-    expect(selectOptimalRepresentation(fakeReps as Representation[],
-                                       0,
-                                       Infinity,
-                                       Infinity))
-      .toBe(fakeReps[fakeReps.length - 1]);
-    expect(selectOptimalRepresentation(fakeReps as Representation[],
-                                       100,
-                                       Infinity,
-                                       Infinity))
-      .toBe(fakeReps[fakeReps.length - 1]);
-  });
-
-  // eslint-disable-next-line max-len
-  it("should chose one respecting either the minimum or maximum when the minimum is higher than the maximum", () => {
-    expect([fakeReps[0], fakeReps[fakeReps.length - 1]])
-      .toContain(selectOptimalRepresentation(fakeReps as Representation[],
-                                             1000,
-                                             Infinity,
-                                             0));
-    expect([fakeReps[0], fakeReps[fakeReps.length - 1]])
-      .toContain(selectOptimalRepresentation(fakeReps as Representation[],
-                                             0,
-                                             Infinity,
-                                             0));
-    expect([fakeReps[0], fakeReps[fakeReps.length - 1]])
-      .toContain(selectOptimalRepresentation(fakeReps as Representation[],
-                                             Infinity,
-                                             Infinity,
-                                             0));
-    expect([fakeReps[1], fakeReps[2]])
-      .toContain(selectOptimalRepresentation(fakeReps as Representation[],
-                                             1000,
-                                             10000,
-                                             1000));
-    expect([fakeReps[1], fakeReps[2]])
-      .toContain(selectOptimalRepresentation(fakeReps as Representation[],
-                                             10000,
-                                             10000,
-                                             1000));
-  });
-});

package/src/core/adaptive/utils/bandwidth_estimator.ts

@@ -1,88 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import config from "../../../config";
-import EWMA from "./ewma";
-
-
-/**
- * Calculate a mean bandwidth based on the bytes downloaded and the amount
- * of time needed to do so.
- * @class BandwidthEstimator
- */
-export default class BandwidthEstimator {
-  /**
-   * Slowly-moving exponentially weighted moving average.
-   * It reacts fastly to changing network conditions such as sudden slowing/bursts.
-   */
-  private _fastEWMA : EWMA;
-  /** Slowly-moving exponentially weighted moving average. */
-  private _slowEWMA : EWMA;
-  /** Amount of bytes currently used to produce a bandwidth estimate. */
-  private _bytesSampled : number;
-
-  constructor() {
-    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;
-  }
-
-  /**
-   * Takes a bandwidth sample.
-   * @param {number} durationInMs - The amount of time, in milliseconds, for a
-   * particular request.
-   * @param {number} numberOfBytes - The total number of bytes transferred in
-   * that request.
-   */
-  public addSample(durationInMs : number, numberOfBytes : number) : void {
-    const { ABR_MINIMUM_CHUNK_SIZE } = config.getCurrent();
-    if (numberOfBytes < ABR_MINIMUM_CHUNK_SIZE) {
-      return;
-    }
-
-    const bandwidth = numberOfBytes * 8000 / durationInMs;
-    const weight = durationInMs / 1000;
-    this._bytesSampled += numberOfBytes;
-
-    this._fastEWMA.addSample(weight, bandwidth);
-    this._slowEWMA.addSample(weight, bandwidth);
-  }
-
-  /**
-   * Get estimate of the bandwidth, in bits per seconds.
-   * @returns {Number|undefined}
-   */
-  public getEstimate() : number|undefined {
-    const { ABR_MINIMUM_TOTAL_BYTES } = config.getCurrent();
-    if (this._bytesSampled < ABR_MINIMUM_TOTAL_BYTES) {
-      return undefined;
-    }
-
-    // Take the minimum of these two estimates.
-    // This should have the effect of adapting down quickly, but up more slowly.
-    return Math.min(this._fastEWMA.getEstimate(),
-                    this._slowEWMA.getEstimate());
-  }
-
-  /** 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/adaptive/utils/ewma.ts

@@ -1,59 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/**
- * Tweaked implementation of an exponential weighted Moving Average.
- * @class EWMA
- */
-export default class EWMA {
-  private readonly _alpha : number;
-  /** Last average available. `0` if none is available yet. */
-  private _lastEstimate : number;
-  /** Sum of all "weights" given until now. */
-  private _totalWeight : number;
-
-  /**
-   * @param {number} halfLife
-   */
-  constructor(halfLife : number) {
-    // (half-life = log(1/2) / log(Decay Factor)
-    this._alpha = Math.exp(Math.log(0.5) / halfLife);
-    this._lastEstimate = 0;
-    this._totalWeight = 0;
-  }
-
-  /**
-   * @param {number} weight
-   * @param {number} value
-   */
-  public addSample(weight : number, value : number) : void {
-    const adjAlpha = Math.pow(this._alpha, weight);
-    const newEstimate = value * (1 - adjAlpha) +
-                        adjAlpha * this._lastEstimate;
-    if (!isNaN(newEstimate)) {
-      this._lastEstimate = newEstimate;
-      this._totalWeight += weight;
-    }
-  }
-
-  /**
-   * @returns {number} value
-   */
-  public getEstimate() : number {
-    const zeroFactor = 1 - Math.pow(this._alpha, this._totalWeight);
-    return this._lastEstimate / zeroFactor;
-  }
-}

package/src/core/adaptive/utils/filter_by_bitrate.ts

@@ -1,46 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import { Representation } from "../../../manifest";
-import arrayFindIndex from "../../../utils/array_find_index";
-
-/**
- * Get only representations lower or equal to a given bitrate.
- * If no representation is lower than the given bitrate, returns an array containing
- * all Representation(s) with the lowest available bitrate.
- * @param {Array.<Object>} representations - All Representations available
- * @param {Number} bitrate
- * @returns {Array.<Object>}
- */
-export default function filterByBitrate(
-  representations : Representation[],
-  bitrate : number
-) : Representation[] {
-  if (representations.length === 0) {
-    return [];
-  }
-  representations.sort((ra, rb) => ra.bitrate - rb.bitrate);
-  const minimumBitrate = representations[0].bitrate;
-  const bitrateCeil = Math.max(bitrate, minimumBitrate);
-  const firstSuperiorBitrateIndex = arrayFindIndex(
-    representations,
-    (representation) => representation.bitrate > bitrateCeil
-  );
-  if (firstSuperiorBitrateIndex === -1) {
-    return representations; // All representations have lower bitrates.
-  }
-  return representations.slice(0, firstSuperiorBitrateIndex);
-}

package/src/core/adaptive/utils/filter_by_width.ts

@@ -1,49 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import { Representation } from "../../../manifest";
-import arrayFind from "../../../utils/array_find";
-
-/**
- * Filter representations based on their width:
- *   - the highest width considered will be the one linked to the first
- *     representation which has a superior width to the one given.
- * @param {Array.<Object>} representations - The representations array
- * @param {Number} width
- * @returns {Array.<Object>}
- */
-export default function filterByWidth(
-  representations : Representation[],
-  width : number
-) : Representation[] {
-  const sortedRepsByWidth = representations
-    .slice() // clone
-    .sort((a, b) => (a.width ?? 0) - (b.width ?? 0));
-
-  const repWithMaxWidth = arrayFind(sortedRepsByWidth, (representation) =>
-    typeof representation.width === "number" &&
-    representation.width >= width);
-
-  if (repWithMaxWidth === undefined) {
-    return representations;
-  }
-
-  const maxWidth = typeof repWithMaxWidth.width === "number" ? repWithMaxWidth.width :
-                                                               0;
-  return representations.filter(representation =>
-    typeof representation.width === "number" ? representation.width <= maxWidth :
-                                               true);
-}

package/src/core/adaptive/utils/get_buffer_levels.ts

@@ -1,50 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/**
- * Return "Buffer Levels" which are steps of available buffers from which we
- * are normally able switch safely to the next available bitrate.
- * (Following an algorithm close to BOLA)
- * @param {Array.<number>} bitrates - All available bitrates, __sorted__ in
- * ascending order.
- * @returns {Array.<number>}
- */
-export default function getBufferLevels(bitrates : number[]) : number[] {
-  const logs = bitrates.map((b) => Math.log(b / bitrates[0]));
-  const utilities = logs.map(l => l - logs[0] + 1); // normalize
-  const gp = (utilities[utilities.length - 1] - 1) / ((bitrates.length * 2) + 10);
-  const Vp = 1 / gp;
-
-  return bitrates.map((_, i) => minBufferLevelForBitrate(i));
-
-  /**
-   * Get minimum buffer we should keep ahead to pick this bitrate.
-   * @param {number} index
-   * @returns {number}
-   */
-  function minBufferLevelForBitrate(index: number): number {
-    if (index === 0) {
-      return 0;
-    }
-    const boundedIndex = Math.min(Math.max(1, index), bitrates.length - 1);
-    if (bitrates[boundedIndex] === bitrates[boundedIndex - 1]) {
-      return minBufferLevelForBitrate(index - 1);
-    }
-    return Vp * (gp + (bitrates[boundedIndex] * utilities[boundedIndex - 1] -
-      bitrates[boundedIndex - 1] * utilities[boundedIndex]) / (bitrates[boundedIndex] -
-      bitrates[boundedIndex - 1])) + 4;
-  }
-}