rx-player 3.33.0 → 3.33.1

package/src/core/adaptive/network_analyzer.ts

@@ -1,419 +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 log from "../../log";
-import { Representation } from "../../manifest";
-import arrayFind from "../../utils/array_find";
-import {
-  IRepresentationEstimatorPlaybackObservation,
-} from "./adaptive_representation_selector";
-import BandwidthEstimator from "./utils/bandwidth_estimator";
-import EWMA from "./utils/ewma";
-import {
-  IPendingRequestStoreProgress,
-  IRequestInfo,
-} from "./utils/pending_requests_store";
-
- /** Object describing the current playback conditions. */
-type IPlaybackConditionsInfo = Pick<
-  IRepresentationEstimatorPlaybackObservation,
-  "bufferGap" | "position" | "speed" | "duration">;
-
-/**
- * Get pending segment request(s) starting with the asked segment position.
- * @param {Object} requests - Every requests pending, in a chronological
- * order in terms of segment time.
- * @param {number} neededPosition
- * @returns {Array.<Object>}
- */
-function getConcernedRequests(
-  requests : IRequestInfo[],
-  neededPosition : number
-) : IRequestInfo[] {
-  /** Index of the request for the next needed segment, in `requests`. */
-  let nextSegmentIndex = -1;
-  for (let i = 0; i < requests.length; i++) {
-    const { segment } = requests[i].content;
-    if (segment.duration <= 0) {
-      continue;
-    }
-    const segmentEnd = segment.time + segment.duration;
-    if (!segment.complete) {
-      if (i === requests.length - 1 && neededPosition - segment.time > -1.2) {
-        nextSegmentIndex = i;
-        break;
-      }
-    }
-    if (segmentEnd > neededPosition && neededPosition - segment.time > -1.2) {
-      nextSegmentIndex = i;
-      break;
-    }
-  }
-
-  if (nextSegmentIndex < 0) { // Not found
-    return [];
-  }
-
-  const nextRequest = requests[nextSegmentIndex];
-  const segmentTime = nextRequest.content.segment.time;
-  const filteredRequests = [nextRequest];
-
-  // Get the possibly multiple requests for that segment's position
-  for (let i = nextSegmentIndex + 1; i < requests.length; i++) {
-    if (requests[i].content.segment.time === segmentTime) {
-      filteredRequests.push(requests[i]);
-    } else {
-      break;
-    }
-  }
-  return filteredRequests;
-}
-
-/**
- * Estimate the __VERY__ recent bandwidth based on a single unfinished request.
- * Useful when the current bandwidth seemed to have fallen quickly.
- *
- * @param {Object} request
- * @returns {number|undefined}
- */
-export function estimateRequestBandwidth(request : IRequestInfo) : number|undefined {
-  if (request.progress.length < 5) { // threshold from which we can consider
-                                     // progress events reliably
-    return undefined;
-  }
-
-  // try to infer quickly the current bitrate based on the
-  // progress events
-  const ewma1 = new EWMA(2);
-  const { progress } = request;
-  for (let i = 1; i < progress.length; i++) {
-    const bytesDownloaded = progress[i].size - progress[i - 1].size;
-    const timeElapsed = progress[i].timestamp - progress[i - 1].timestamp;
-    const reqBitrate = (bytesDownloaded * 8) / (timeElapsed / 1000);
-    ewma1.addSample(timeElapsed / 1000, reqBitrate);
-  }
-  return ewma1.getEstimate();
-}
-
-/**
- * Estimate remaining time for a pending request from a progress event.
- * @param {Object} lastProgressEvent
- * @param {number} bandwidthEstimate
- * @returns {number}
- */
-function estimateRemainingTime(
-  lastProgressEvent: IPendingRequestStoreProgress,
-  bandwidthEstimate : number
-) : number {
-  const remainingData = (lastProgressEvent.totalSize - lastProgressEvent.size) * 8;
-  return Math.max(remainingData / bandwidthEstimate, 0);
-}
-
-/**
- * Check if the request for the most needed segment is too slow.
- * If that's the case, re-calculate the bandwidth urgently based on
- * this single request.
- * @param {Object} pendingRequests - Every requests pending, in a chronological
- * order in terms of segment time.
- * @param {Object} playbackInfo - Information on the current playback.
- * @param {Object|null} currentRepresentation - The Representation being
- * presently being loaded.
- * @param {boolean} lowLatencyMode - If `true`, we're playing the content as a
- * low latency content - where requests might be pending when the segment is
- * still encoded.
- * @param {Number} lastEstimatedBitrate - Last bitrate estimate emitted.
- * @returns {Number|undefined}
- */
-function estimateStarvationModeBitrate(
-  pendingRequests : IRequestInfo[],
-  playbackInfo : IPlaybackConditionsInfo,
-  currentRepresentation : Representation | null,
-  lowLatencyMode : boolean,
-  lastEstimatedBitrate : number|undefined
-) : number|undefined {
-  if (lowLatencyMode) {
-    // TODO Skip only for newer segments?
-    return undefined;
-  }
-  const { bufferGap, speed, position } = playbackInfo;
-  const realBufferGap = isFinite(bufferGap) ? bufferGap :
-                                              0;
-  const nextNeededPosition = position.last + realBufferGap;
-  const concernedRequests = getConcernedRequests(pendingRequests, nextNeededPosition);
-
-  if (concernedRequests.length !== 1) { // 0  == no request
-                                        // 2+ == too complicated to calculate
-    return undefined;
-  }
-
-  const concernedRequest = concernedRequests[0];
-  const now = performance.now();
-
-  let minimumRequestTime = concernedRequest.content.segment.duration * 1.5;
-  minimumRequestTime = Math.min(minimumRequestTime, 3000);
-  minimumRequestTime = Math.max(minimumRequestTime, 12000);
-  if (now - concernedRequest.requestTimestamp < minimumRequestTime) {
-    return undefined;
-  }
-  const lastProgressEvent = concernedRequest.progress.length > 0 ?
-    concernedRequest.progress[concernedRequest.progress.length - 1] :
-    undefined;
-
-  // first, try to do a quick estimate from progress events
-  const bandwidthEstimate = estimateRequestBandwidth(concernedRequest);
-
-  if (lastProgressEvent !== undefined && bandwidthEstimate !== undefined) {
-    const remainingTime = estimateRemainingTime(lastProgressEvent,
-                                                bandwidthEstimate);
-
-    // if the remaining time does seem reliable
-    if ((now - lastProgressEvent.timestamp) / 1000 <= remainingTime) {
-      // Calculate estimated time spent rebuffering if we continue doing that request.
-      const expectedRebufferingTime = remainingTime -
-        (realBufferGap / speed);
-      if (expectedRebufferingTime > 2500) {
-        return bandwidthEstimate;
-      }
-    }
-  }
-
-  if (!concernedRequest.content.segment.complete) {
-    return undefined;
-  }
-
-  const chunkDuration = concernedRequest.content.segment.duration;
-  const requestElapsedTime = (now - concernedRequest.requestTimestamp) / 1000;
-  const reasonableElapsedTime = requestElapsedTime <=
-    ((chunkDuration * 1.5 + 2) / speed);
-  if (currentRepresentation == null || reasonableElapsedTime) {
-    return undefined;
-  }
-
-  // calculate a reduced bitrate from the current one
-  const factor = chunkDuration / requestElapsedTime;
-  const reducedBitrate = currentRepresentation.bitrate * Math.min(0.7, factor);
-  if (lastEstimatedBitrate === undefined ||
-      reducedBitrate < lastEstimatedBitrate)
-  {
-    return reducedBitrate;
-  }
-}
-
-/**
- * Returns true if, based on the current requests, it seems that the ABR should
- * switch immediately if a lower bitrate is more adapted.
- * Returns false if it estimates that you have time before switching to a lower
- * bitrate.
- * @param {Object} playbackInfo - Information on the current playback.
- * @param {Object} requests - Every requests pending, in a chronological
- * order in terms of segment time.
- * @param {boolean} lowLatencyMode - If `true`, we're playing the content as a
- * low latency content, as close to the live edge as possible.
- * @returns {boolean}
- */
-function shouldDirectlySwitchToLowBitrate(
-  playbackInfo : IPlaybackConditionsInfo,
-  requests : IRequestInfo[],
-  lowLatencyMode : boolean
-) : boolean {
-  if (lowLatencyMode) {
-    // TODO only when playing close to the live edge?
-    return true;
-  }
-  const realBufferGap = isFinite(playbackInfo.bufferGap) ? playbackInfo.bufferGap :
-                                                           0;
-  const nextNeededPosition = playbackInfo.position.last + realBufferGap;
-  const nextRequest = arrayFind(requests, ({ content }) =>
-    content.segment.duration > 0 &&
-    (content.segment.time + content.segment.duration) > nextNeededPosition);
-
-  if (nextRequest === undefined) {
-    return true;
-  }
-
-  const now = performance.now();
-  const lastProgressEvent = nextRequest.progress.length > 0 ?
-    nextRequest.progress[nextRequest.progress.length - 1] :
-    undefined;
-
-  // first, try to do a quick estimate from progress events
-  const bandwidthEstimate = estimateRequestBandwidth(nextRequest);
-  if (lastProgressEvent === undefined || bandwidthEstimate === undefined) {
-    return true;
-  }
-
-  const remainingTime = estimateRemainingTime(lastProgressEvent, bandwidthEstimate);
-  if ((now - lastProgressEvent.timestamp) / 1000 > (remainingTime * 1.2)) {
-    return true;
-  }
-  const expectedRebufferingTime = remainingTime -
-    (realBufferGap / playbackInfo.speed);
-  return expectedRebufferingTime > -1.5;
-}
-
-/**
- * Analyze the current network conditions and give a bandwidth estimate as well
- * as a maximum bitrate a Representation should be.
- * @class NetworkAnalyzer
- */
-export default class NetworkAnalyzer {
-  private _lowLatencyMode : boolean;
-  private _inStarvationMode : boolean;
-  private _initialBitrate : number;
-  private _config : { starvationGap : number;
-                      outOfStarvationGap : number;
-                      starvationBitrateFactor : number;
-                      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;
-    if (lowLatencyMode) {
-      this._config = { starvationGap: ABR_STARVATION_GAP.LOW_LATENCY,
-                       outOfStarvationGap: OUT_OF_STARVATION_GAP.LOW_LATENCY,
-                       starvationBitrateFactor: ABR_STARVATION_FACTOR.LOW_LATENCY,
-                       regularBitrateFactor: ABR_REGULAR_FACTOR.LOW_LATENCY };
-    } else {
-      this._config = { starvationGap: ABR_STARVATION_GAP.DEFAULT,
-                       outOfStarvationGap: OUT_OF_STARVATION_GAP.DEFAULT,
-                       starvationBitrateFactor: ABR_STARVATION_FACTOR.DEFAULT,
-                       regularBitrateFactor: ABR_REGULAR_FACTOR.DEFAULT };
-    }
-  }
-
-  /**
-   * Gives an estimate of the current bandwidth and of the bitrate that should
-   * be considered for chosing a `representation`.
-   * This estimate is only based on network metrics.
-   * @param {Object} playbackInfo - Gives current information about playback.
-   * @param {Object} bandwidthEstimator - `BandwidthEstimator` allowing to
-   * produce network bandwidth estimates.
-   * @param {Object|null} currentRepresentation - The Representation currently
-   * chosen.
-   * `null` if no Representation has been chosen yet.
-   * @param {Array.<Object>} currentRequests - All segment requests by segment's
-   * start chronological order
-   * @param {number|undefined} lastEstimatedBitrate - Bitrate emitted during the
-   * last estimate.
-   * @returns {Object}
-   */
-  public getBandwidthEstimate(
-    playbackInfo: IPlaybackConditionsInfo,
-    bandwidthEstimator : BandwidthEstimator,
-    currentRepresentation : Representation | null,
-    currentRequests : IRequestInfo[],
-    lastEstimatedBitrate: number|undefined
-  ) : { 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.last < duration - ABR_STARVATION_DURATION_DELTA)
-    {
-      if (!this._inStarvationMode && realBufferGap <= localConf.starvationGap) {
-        log.info("ABR: enter starvation mode.");
-        this._inStarvationMode = true;
-      } else if (this._inStarvationMode &&
-                 realBufferGap >= localConf.outOfStarvationGap)
-      {
-        log.info("ABR: exit starvation mode.");
-        this._inStarvationMode = false;
-      }
-    } else if (this._inStarvationMode) {
-      log.info("ABR: exit starvation mode.");
-      this._inStarvationMode = false;
-    }
-
-    // If in starvation mode, check if a quick new estimate can be done
-    // from the last requests.
-    // If so, cancel previous estimates and replace it by the new one
-    if (this._inStarvationMode) {
-      bandwidthEstimate = estimateStarvationModeBitrate(currentRequests,
-                                                        playbackInfo,
-                                                        currentRepresentation,
-                                                        this._lowLatencyMode,
-                                                        lastEstimatedBitrate);
-
-      if (bandwidthEstimate != null) {
-        log.info("ABR: starvation mode emergency estimate:", bandwidthEstimate);
-        bandwidthEstimator.reset();
-        newBitrateCeil = currentRepresentation == null ?
-          bandwidthEstimate :
-          Math.min(bandwidthEstimate, currentRepresentation.bitrate);
-      }
-    }
-
-    // if newBitrateCeil is not yet defined, do the normal estimation
-    if (newBitrateCeil == null) {
-      bandwidthEstimate = bandwidthEstimator.getEstimate();
-
-      if (bandwidthEstimate != null) {
-        newBitrateCeil = bandwidthEstimate *
-          (this._inStarvationMode ? localConf.starvationBitrateFactor :
-                                    localConf.regularBitrateFactor);
-      } else if (lastEstimatedBitrate != null) {
-        newBitrateCeil = lastEstimatedBitrate *
-          (this._inStarvationMode ? localConf.starvationBitrateFactor :
-                                    localConf.regularBitrateFactor);
-      } else {
-        newBitrateCeil = this._initialBitrate;
-      }
-    }
-
-    if (playbackInfo.speed > 1) {
-      newBitrateCeil /= playbackInfo.speed;
-    }
-
-    return { bandwidthEstimate, bitrateChosen: newBitrateCeil };
-  }
-
-  /**
-   * For a given wanted bitrate, tells if should switch urgently.
-   * @param {number} bitrate - The new estimated bitrate.
-   * @param {Object|null} currentRepresentation - The Representation being
-   * presently being loaded.
-   * @param {Array.<Object>} currentRequests - All segment requests by segment's
-   * start chronological order
-   * @param {Object} playbackInfo - Information on the current playback.
-   * @returns {boolean}
-   */
-  public isUrgent(
-    bitrate: number,
-    currentRepresentation : Representation | null,
-    currentRequests : IRequestInfo[],
-    playbackInfo: IPlaybackConditionsInfo
-  ) : boolean {
-    if (currentRepresentation === null) {
-      return true;
-    } else if (bitrate >= currentRepresentation.bitrate) {
-      return false;
-    }
-    return shouldDirectlySwitchToLowBitrate(playbackInfo,
-                                            currentRequests,
-                                            this._lowLatencyMode);
-  }
-}

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

@@ -1,134 +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 BandwidthEstimator from "../bandwidth_estimator";
-
-describe("ABR - BandwidthEstimator", () => {
-  it("should return undefined if no sample has been added yet", () => {
-    const bwEstimator = new BandwidthEstimator();
-    expect(bwEstimator.getEstimate()).toBe(undefined);
-  });
-
-  it("should return undefined if not enough bytes has been received", () => {
-    const bwEstimator = new BandwidthEstimator();
-    bwEstimator.addSample(800, 10);
-    expect(bwEstimator.getEstimate()).toBe(undefined);
-    bwEstimator.addSample(800, 10);
-    expect(bwEstimator.getEstimate()).toBe(undefined);
-    bwEstimator.addSample(800, 10);
-    expect(bwEstimator.getEstimate()).toBe(undefined);
-    bwEstimator.addSample(80000000, 1000000);
-    expect(bwEstimator.getEstimate()).toBe(100);
-  });
-
-  /* eslint-disable max-len */
-  it("should calculate bitrate in function of consecutive request' durations and size", () => {
-  /* eslint-enable max-len */
-    const bwEstimator = new BandwidthEstimator();
-    bwEstimator.addSample(8000, 1000000);
-    expect(bwEstimator.getEstimate()).toBe(1000000);
-    bwEstimator.addSample(4000, 1000000);
-    expect(bwEstimator.getEstimate()).toBeLessThan(1500000);
-    expect(bwEstimator.getEstimate()).toBeGreaterThan(1400000);
-    bwEstimator.addSample(1000, 1000000);
-    expect(bwEstimator.getEstimate()).toBeLessThan(3000000);
-    expect(bwEstimator.getEstimate()).toBeGreaterThan(2000000);
-  });
-
-  it("should reset the estimation when reset is called", () => {
-    const bwEstimator = new BandwidthEstimator();
-    bwEstimator.addSample(8000, 1000000);
-    bwEstimator.addSample(4000, 1000000);
-    bwEstimator.addSample(1000, 1000000);
-
-    bwEstimator.reset();
-    expect(bwEstimator.getEstimate()).toBe(undefined);
-    bwEstimator.addSample(8000, 1000000);
-    expect(bwEstimator.getEstimate()).toBe(1000000);
-  });
-
-  it("should estimate a low bitrate quicker than a higher one", () => {
-    const bwEstimator = new BandwidthEstimator();
-
-    // 1st test:
-    // we raise the bitrate from 1 mega to 2 mega
-    // we should slowly go toward 2 megas as an estimate
-    bwEstimator.addSample(8000, 1000000); // 1 mega
-    bwEstimator.addSample(4000, 1000000); // 2 mega
-    expect(bwEstimator.getEstimate()).toBeLessThan(1500000);
-    expect(bwEstimator.getEstimate()).toBeGreaterThan(1400000);
-    bwEstimator.addSample(4000, 1000000);
-    expect(bwEstimator.getEstimate()).toBeLessThan(1700000);
-    expect(bwEstimator.getEstimate()).toBeGreaterThan(1600000);
-    bwEstimator.addSample(4000, 1000000);
-    expect(bwEstimator.getEstimate()).toBeLessThan(1800000);
-    expect(bwEstimator.getEstimate()).toBeGreaterThan(1700000);
-    bwEstimator.addSample(4000, 1000000);
-    expect(bwEstimator.getEstimate()).toBeLessThan(1900000);
-    expect(bwEstimator.getEstimate()).toBeGreaterThan(1800000);
-    bwEstimator.addSample(4000, 1000000);
-    expect(bwEstimator.getEstimate()).toBeLessThan(1900000);
-    expect(bwEstimator.getEstimate()).toBeGreaterThan(1800000);
-    bwEstimator.addSample(4000, 1000000); // 6 iterations for 1900000+
-    expect(bwEstimator.getEstimate()).toBeLessThan(2000000);
-    expect(bwEstimator.getEstimate()).toBeGreaterThan(1900000);
-
-    bwEstimator.reset();
-    expect(bwEstimator.getEstimate()).toBe(undefined);
-
-    // 2st test:
-    // we decrease the bitrate from 2 mega to 1 mega
-    // we should quickly go to 1 mega
-    bwEstimator.addSample(4000, 1000000); // 2 mega
-    bwEstimator.addSample(8000, 1000000); // 1 mega - only 1 iteration for sub 1100000!
-    expect(bwEstimator.getEstimate()).toBeLessThan(1100000);
-    expect(bwEstimator.getEstimate()).toBeGreaterThan(1000000);
-
-    bwEstimator.reset();
-    expect(bwEstimator.getEstimate()).toBe(undefined);
-
-    // 3rd test:
-    // we both go up and down, from 5 mega to 10 then to 1 and come back to 10.
-    // the 1 mega estimate should have a very perceptible influence, even when
-    // going back to 10
-    bwEstimator.addSample(2000, 1250000); // 5 mega
-    expect(bwEstimator.getEstimate()).toBe(5000000);
-    bwEstimator.addSample(2000, 1250100); // 5 mega
-    expect(bwEstimator.getEstimate()).toBeGreaterThan(5000000);
-    expect(bwEstimator.getEstimate()).toBeLessThan(5010000);
-    bwEstimator.addSample(1000, 1250700); // 10 mega
-    expect(bwEstimator.getEstimate()).toBeGreaterThan(6000000);
-    expect(bwEstimator.getEstimate()).toBeLessThan(6500000);
-    bwEstimator.addSample(1000, 1251000); // 10 mega
-    expect(bwEstimator.getEstimate()).toBeGreaterThan(6500000);
-    expect(bwEstimator.getEstimate()).toBeLessThan(7000000);
-    bwEstimator.addSample(10000, 1251000); // 1 mega
-    expect(bwEstimator.getEstimate()).toBeGreaterThan(1000000);
-    expect(bwEstimator.getEstimate()).toBeLessThan(1500000);
-    bwEstimator.addSample(1000, 1250000); // 10 mega
-    expect(bwEstimator.getEstimate()).toBeGreaterThan(3000000);
-    expect(bwEstimator.getEstimate()).toBeLessThan(3500000);
-    bwEstimator.addSample(1000, 1250100); // 10 mega
-    expect(bwEstimator.getEstimate()).toBeGreaterThan(3500000);
-    expect(bwEstimator.getEstimate()).toBeLessThan(4000000);
-    bwEstimator.addSample(1000, 1250100); // 10 mega
-    expect(bwEstimator.getEstimate()).toBeGreaterThan(4000000);
-    expect(bwEstimator.getEstimate()).toBeLessThan(4500000);
-    bwEstimator.addSample(1000, 1250100); // 10 mega
-    expect(bwEstimator.getEstimate()).toBeGreaterThan(4500000);
-    expect(bwEstimator.getEstimate()).toBeLessThan(5000000);
-  });
-});

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

@@ -1,79 +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 EWMA from "../ewma";
-
-describe("ABR - EWMA", () => {
-  it("should return the last bitrate if half-life is at 0", () => {
-    const ewma = new EWMA(0);
-    ewma.addSample(8000, 1000000);
-    expect(ewma.getEstimate()).toBe(1000000);
-    ewma.addSample(4000, 7000000);
-    expect(ewma.getEstimate()).toBe(7000000);
-    ewma.addSample(1000, 6666600);
-    expect(ewma.getEstimate()).toBe(6666600);
-  });
-
-  it("should returns the correct value bitrate for a given positive half-life", () => {
-    // "slow" evolution
-    const ewma1 = new EWMA(15);
-    ewma1.addSample(1, 50);
-    expect(ewma1.getEstimate()).toBeLessThan(50 + 0.1);
-    expect(ewma1.getEstimate()).toBeGreaterThan(50 - 0.1);
-    ewma1.addSample(5, 100);
-    expect(ewma1.getEstimate()).toBeLessThan(92 + 1);
-    expect(ewma1.getEstimate()).toBeGreaterThan(92 - 1);
-    ewma1.addSample(3, 1);
-    expect(ewma1.getEstimate()).toBeLessThan(58 + 1);
-    expect(ewma1.getEstimate()).toBeGreaterThan(58 - 1);
-    ewma1.addSample(8, 45);
-    expect(ewma1.getEstimate()).toBeLessThan(50 + 1);
-    expect(ewma1.getEstimate()).toBeGreaterThan(50 - 1);
-    ewma1.addSample(9, 45);
-    expect(ewma1.getEstimate()).toBeLessThan(48 + 1);
-    expect(ewma1.getEstimate()).toBeGreaterThan(48 - 1);
-    ewma1.addSample(200, 300);
-    expect(ewma1.getEstimate()).toBeLessThan(300 + 0.1);
-    expect(ewma1.getEstimate()).toBeGreaterThan(300 - 0.1);
-    ewma1.addSample(10, 1);
-    expect(ewma1.getEstimate()).toBeLessThan(189 + 1);
-    expect(ewma1.getEstimate()).toBeGreaterThan(189 - 1);
-
-    // fast evolution
-    const ewma2 = new EWMA(2);
-    ewma2.addSample(1, +50);
-    expect(ewma2.getEstimate()).toBeLessThan(50 + 0.1);
-    expect(ewma2.getEstimate()).toBeGreaterThan(50 - 0.1);
-    ewma2.addSample(5, 100);
-    expect(ewma2.getEstimate()).toBeLessThan(97 + 0.1);
-    expect(ewma2.getEstimate()).toBeGreaterThan(97 - 0.1);
-    ewma2.addSample(3, 1);
-    expect(ewma2.getEstimate()).toBeLessThan(32 + 0.1);
-    expect(ewma2.getEstimate()).toBeGreaterThan(32 - 0.1);
-    ewma2.addSample(8, 45);
-    expect(ewma2.getEstimate()).toBeLessThan(44 + 1);
-    expect(ewma2.getEstimate()).toBeGreaterThan(44 - 1);
-    ewma2.addSample(9, 45);
-    expect(ewma2.getEstimate()).toBeLessThan(45 + 0.1);
-    expect(ewma2.getEstimate()).toBeGreaterThan(45 - 0.1);
-    ewma2.addSample(200, 300);
-    expect(ewma2.getEstimate()).toBeLessThan(300 + 0.1);
-    expect(ewma2.getEstimate()).toBeGreaterThan(300 - 0.1);
-    ewma2.addSample(10, 1);
-    expect(ewma2.getEstimate()).toBeLessThan(10 + 0.5);
-    expect(ewma2.getEstimate()).toBeGreaterThan(10 - 0.5);
-  });
-});

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

@@ -1,56 +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 filterByBitrate from "../filter_by_bitrate";
-
-describe("ABR - filterByBitrate", () => {
-  const fakeReps = [
-    { bitrate : 100 },
-    { bitrate : 100 },
-    { bitrate : 1000 },
-    { bitrate : 10000 },
-    { bitrate : 100000 },
-  ];
-
-  describe("filterByBitrate", () => {
-    it("should return no Representation if no Representation was specified", () => {
-      expect(filterByBitrate([], Infinity))
-        .toEqual([]);
-    });
-
-    it("should return all representations when specified bitrate is infinite", () => {
-      expect(filterByBitrate(fakeReps as Representation[], Infinity))
-        .toEqual(fakeReps);
-    });
-
-    it("should return the lowest representation when specified bitrate is 0", () => {
-      const expectedFilteredReps = [ { bitrate : 100 },
-                                     { bitrate : 100 } ];
-      expect(filterByBitrate(fakeReps as Representation[], 0))
-        .toEqual(expectedFilteredReps);
-    });
-
-    it("should filter representation when specified bitrate is 999", () => {
-      const expectedFilteredReps = [ { bitrate : 100 },
-                                     { bitrate : 100 },
-                                     { bitrate : 1000 } ];
-      expect(filterByBitrate(fakeReps as Representation[], 1010))
-        .toEqual(expectedFilteredReps);
-    });
-  });
-
-});