rx-player 3.26.1 → 3.26.2

package/src/core/abr/guess_based_chooser.ts

@@ -0,0 +1,308 @@
+/**
+ * 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 log from "../../log";
+import { Representation } from "../../manifest";
+import arrayFindIndex from "../../utils/array_find_index";
+import LastEstimateStorage, {
+  ABRAlgorithmType,
+} from "./last_estimate_storage";
+import { estimateRequestBandwidth } from "./network_analyzer";
+import { IRequestInfo } from "./pending_requests_store";
+import RepresentationScoreCalculator, {
+  ScoreConfidenceLevel,
+} from "./representation_score_calculator";
+
+/**
+ * Estimate which Representation should be played based on risky "guesses".
+ *
+ * Basically, this `GuessBasedChooser` will attempt switching to the superior
+ * quality when conditions allows this and then check if we're able to maintain
+ * this quality. If we're not, it will rollbacks to the previous, maintaninable,
+ * guess.
+ *
+ * The algorithm behind the `GuessBasedChooser` is very risky in terms of
+ * rebuffering chances. As such, it should only be used when other approach
+ * don't work (e.g.  low-latency contents).
+ * @class GuessBasedChooser
+ */
+export default class GuessBasedChooser {
+  private _lastAbrEstimate : LastEstimateStorage;
+  private _scoreCalculator : RepresentationScoreCalculator;
+  private _consecutiveWrongGuesses : number;
+  private _blockGuessesUntil : number;
+  private _lastMaintanableBitrate : number | null;
+
+  /**
+   * Create a new `GuessBasedChooser`.
+   * @param {Object} scoreCalculator
+   * @param {Object} prevEstimate
+   */
+  constructor(
+    scoreCalculator : RepresentationScoreCalculator,
+    prevEstimate : LastEstimateStorage
+  ) {
+    this._scoreCalculator = scoreCalculator;
+    this._lastAbrEstimate = prevEstimate;
+    this._consecutiveWrongGuesses = 0;
+    this._blockGuessesUntil = 0;
+    this._lastMaintanableBitrate = null;
+  }
+
+  /**
+   * Perform a "guess", which basically indicates which Representation should be
+   * chosen according to the `GuessBasedChooser`.
+   *
+   * @param {Array.<Object>} representations - Array of all Representation the
+   * GuessBasedChooser can choose from, sorted by bitrate ascending.
+   * /!\ It is very important that Representation in that Array are sorted by
+   * bitrate ascending for this method to work as intented.
+   * @param {Object} observation - Last playback observation performed.
+   * @param {Object} currentRepresentation - The Representation currently
+   * loading.
+   * @param {number} incomingBestBitrate - The bitrate of the Representation
+   * chosen by the more optimistic of the other ABR algorithms currently.
+   * @param {Array.<Object>} requests - Information on all pending requests.
+   * @returns {Object|null} - If a guess is made, return that guess, else
+   * returns `null` (in which case you should fallback to another ABR
+   * algorithm).
+   */
+  public getGuess(
+    representations : Representation[],
+    observation : {
+      /**
+       * For the concerned media buffer, difference in seconds between the next
+       * position where no segment data is available and the current position.
+       */
+      bufferGap: number;
+      /**
+       * Last "playback rate" set by the user. This is the ideal "playback rate" at
+       * which the media should play.
+       */
+      speed: number;
+    },
+    currentRepresentation : Representation,
+    incomingBestBitrate : number,
+    requests : IRequestInfo[]
+  ) : Representation | null {
+    const { bufferGap, speed } = observation;
+    const lastChosenRep = this._lastAbrEstimate.representation;
+    if (lastChosenRep === null) {
+      return null; // There's nothing to base our guess on
+    }
+
+    if (incomingBestBitrate > lastChosenRep.bitrate) {
+      // ABR estimates are already superior or equal to the guess
+      // we'll be doing here, so no need to guess
+      if (this._lastAbrEstimate.algorithmType === ABRAlgorithmType.GuessBased) {
+        if (this._lastAbrEstimate.representation !== null) {
+          this._lastMaintanableBitrate = this._lastAbrEstimate.representation.bitrate;
+        }
+        this._consecutiveWrongGuesses = 0;
+      }
+      return null;
+    }
+
+    const scoreData = this._scoreCalculator.getEstimate(currentRepresentation);
+    if (this._lastAbrEstimate.algorithmType !== ABRAlgorithmType.GuessBased) {
+      if (scoreData === undefined) {
+        return null; // not enough information to start guessing
+      }
+      if (this._canGuessHigher(bufferGap, speed, scoreData)) {
+        const nextRepresentation = getNextRepresentation(representations,
+                                                         currentRepresentation);
+        if (nextRepresentation !== null) {
+          return nextRepresentation;
+        }
+      }
+      return null;
+    }
+
+    // If we reached here, we're currently already in guessing mode
+
+    if (this._isLastGuessValidated(lastChosenRep, incomingBestBitrate, scoreData)) {
+      log.debug("ABR: Guessed Representation validated", lastChosenRep.bitrate);
+      this._lastMaintanableBitrate = lastChosenRep.bitrate;
+      this._consecutiveWrongGuesses = 0;
+    }
+
+    if (currentRepresentation.id !== lastChosenRep.id) {
+      return lastChosenRep;
+    }
+
+    const shouldStopGuess = this._shouldStopGuess(currentRepresentation,
+                                                  scoreData,
+                                                  bufferGap,
+                                                  requests);
+    if (shouldStopGuess) {
+      // Block guesses for a time
+      this._consecutiveWrongGuesses++;
+      this._blockGuessesUntil = performance.now() +
+        Math.min(this._consecutiveWrongGuesses * 15000, 120000);
+      return getPreviousRepresentation(representations, currentRepresentation);
+    } else if (scoreData === undefined) {
+      return currentRepresentation;
+    }
+
+    if (this._canGuessHigher(bufferGap, speed, scoreData)) {
+      const nextRepresentation = getNextRepresentation(representations,
+                                                       currentRepresentation);
+      if (nextRepresentation !== null) {
+        return nextRepresentation;
+      }
+    }
+    return currentRepresentation;
+  }
+
+  /**
+   * Returns `true` if we've enough confidence on the current situation to make
+   * a higher guess.
+   * @param {number} bufferGap
+   * @param {number} speed
+   * @param {Array} scoreData
+   * @returns {boolean}
+   */
+  private _canGuessHigher(
+    bufferGap : number,
+    speed : number,
+    [score, scoreConfidenceLevel] : [number, ScoreConfidenceLevel]
+  ) : boolean {
+    return isFinite(bufferGap) && bufferGap >= 2.5 &&
+           performance.now() > this._blockGuessesUntil &&
+           scoreConfidenceLevel === ScoreConfidenceLevel.HIGH &&
+           score / speed > 1.01;
+  }
+
+  /**
+   * Returns `true` if the pending guess of `lastGuess` seems to not
+   * be maintainable and as such should be stopped.
+   * @param {Object} lastGuess
+   * @param {Array} scoreData
+   * @param {number} bufferGap
+   * @param {Array.<Object>} requests
+   * @returns {boolean}
+   */
+  private _shouldStopGuess(
+    lastGuess : Representation,
+    scoreData : [number, ScoreConfidenceLevel] | undefined,
+    bufferGap : number,
+    requests : IRequestInfo[]
+  ) : boolean {
+    if (scoreData !== undefined && scoreData[0] < 1.01) {
+      return true;
+    } else if ((scoreData === undefined || scoreData[0] < 1.2) && bufferGap < 0.6) {
+      return true;
+    }
+
+    const guessedRepresentationRequests = requests.filter(req => {
+      return req.content.representation.id === lastGuess.id;
+    });
+
+    const now = performance.now();
+    for (const req of guessedRepresentationRequests) {
+      const requestElapsedTime = now - req.requestTimestamp;
+      if (req.content.segment.isInit) {
+        if (requestElapsedTime > 1000) {
+          return true;
+        }
+      } else if (requestElapsedTime > req.content.segment.duration * 1000 + 200) {
+        return true;
+      } else {
+        const fastBw = estimateRequestBandwidth(req);
+        if (fastBw !== undefined && fastBw < lastGuess.bitrate * 0.8) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  private _isLastGuessValidated(
+    lastGuess : Representation,
+    incomingBestBitrate : number,
+    scoreData : [number, ScoreConfidenceLevel] | undefined
+  ) : boolean {
+    if (scoreData !== undefined &&
+        scoreData[1] === ScoreConfidenceLevel.HIGH &&
+        scoreData[0] > 1.5)
+    {
+      return true;
+    }
+    return incomingBestBitrate >= lastGuess.bitrate &&
+      (this._lastMaintanableBitrate === null ||
+        this._lastMaintanableBitrate < lastGuess.bitrate);
+  }
+}
+
+/**
+ * From the array of Representations given, returns the Representation with a
+ * bitrate immediately superior to the current one.
+ * Returns `null` if that "next" Representation is not found.
+ *
+ * /!\ The representations have to be already sorted by bitrate, in ascending
+ * order.
+ * @param {Array.<Object>} representations - Available representations to choose
+ * from, sorted by bitrate in ascending order.
+ * @param {Object} currentRepresentation - The Representation currently
+ * considered.
+ * @returns {Object|null}
+ */
+function getNextRepresentation(
+  representations : Representation[],
+  currentRepresentation : Representation
+) : Representation | null {
+  const len = representations.length;
+  let index = arrayFindIndex(representations,
+                             ({ id }) => id === currentRepresentation.id);
+  if (index < 0) {
+    log.error("ABR: Current Representation not found.");
+    return null;
+  }
+
+  while (++index < len) {
+    if (representations[index].bitrate > currentRepresentation.bitrate) {
+      return representations[index];
+    }
+  }
+  return null;
+}
+
+/**
+ * From the array of Representations given, returns the Representation with a
+ * bitrate immediately inferior.
+ * Returns `null` if that "previous" Representation is not found.
+ * @param {Array.<Object>} representations
+ * @param {Object} representation
+ * @returns {Object|null}
+ */
+function getPreviousRepresentation(
+  representations : Representation[],
+  currentRepresentation : Representation
+) : Representation | null {
+  let index = arrayFindIndex(representations,
+                             ({ id }) => id === currentRepresentation.id);
+  if (index < 0) {
+    log.error("ABR: Current Representation not found.");
+    return null;
+  }
+
+  while (--index >= 0) {
+    if (representations[index].bitrate < currentRepresentation.bitrate) {
+      return representations[index];
+    }
+  }
+  return null;
+}

package/src/core/abr/index.ts

@@ -16,21 +16,25 @@
 
 import ABRManager, {
   IABRManagerArguments,
-  IABRManagerClockTick,
+  IABRManagerPlaybackObservation,
 } from "./abr_manager";
 export {
   IABRAddedSegmentEvent,
-  IABRStreamEvents,
   IABREstimate,
   IABRMetricsEvent,
+  IABRMetricsEventValue,
   IABRRepresentationChangeEvent,
   IABRRequestBeginEvent,
+  IABRRequestBeginEventValue,
   IABRRequestEndEvent,
+  IABRRequestEndEventValue,
   IABRRequestProgressEvent,
+  IABRRequestProgressEventValue,
+  IABRStreamEvents,
 } from "./representation_estimator";
 
 export default ABRManager;
 export {
   IABRManagerArguments,
-  IABRManagerClockTick,
+  IABRManagerPlaybackObservation,
 };

package/src/core/abr/last_estimate_storage.ts

@@ -0,0 +1,79 @@
+/**
+ * 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";
+
+/** Stores the last estimate made by the `RepresentationEstimator`. */
+export default class LastEstimateStorage {
+  /**
+   * Estimated bandwitdh in the last estimate.
+   * `undefined` either if no estimate has been performed yet or if the
+   * bandwidth was unknown during the last estimate.
+   */
+  public bandwidth : number | undefined;
+  /**
+   * Estimated Representation in the last estimate.
+   * `null` if no estimate has been performed yet.
+   */
+  public representation : Representation | null;
+
+  /** Algorithm type used to make the last Representation estimate. */
+  public algorithmType : ABRAlgorithmType;
+
+  constructor() {
+    this.bandwidth = undefined;
+    this.representation = null;
+    this.algorithmType = ABRAlgorithmType.None;
+  }
+
+  /**
+   * Update this `LastEstimateStorage` with new values.
+   * @param {Object} representation - Estimated Representation.
+   * @param {number|undefined} bandwidth - Estimated bandwidth.
+   * @param {boolean} wasGuessed - If `true`, this estimate was a guess made by
+   * the `GuessingEstimator`.
+   */
+  public update(
+    representation : Representation,
+    bandwidth : number | undefined,
+    algorithmType : ABRAlgorithmType
+  ) : void {
+    this.representation = representation;
+    this.bandwidth = bandwidth;
+    this.algorithmType = algorithmType;
+  }
+}
+
+/** Identify an algorithm used to perform a Representation estimate.  */
+export const enum ABRAlgorithmType {
+ /**
+  * Buffer-based algorithm using mostly the size of the buffer to determine the
+  * best Representation.
+  */
+  BufferBased,
+  /**
+   * Bandwidth-based algorithm using mostly the speed at which segments are
+   * downloaded to determine the best Representation.
+   */
+  BandwidthBased,
+  /**
+   * Guess-based algorithm, which iterates through Representation and
+   * try to find the best one empirically.
+   */
+  GuessBased,
+    /** None of the other or no algorithm was used yet. */
+  None,
+}

package/src/core/abr/network_analyzer.ts

@@ -18,13 +18,12 @@ import config from "../../config";
 import log from "../../log";
 import { Representation } from "../../manifest";
 import arrayFind from "../../utils/array_find";
-import arrayFindIndex from "../../utils/array_find_index";
 import BandwidthEstimator from "./bandwidth_estimator";
-import EWMA from "./ewma";
 import {
-  IProgressEventValue,
+  IPendingRequestStoreProgress,
   IRequestInfo,
 } from "./pending_requests_store";
+import EWMA from "./utils/ewma";
 
 const { ABR_REGULAR_FACTOR,
         ABR_STARVATION_DURATION_DELTA,
@@ -52,7 +51,8 @@ interface IPlaybackConditionsInfo {
 
 /**
  * Get pending segment request(s) starting with the asked segment position.
- * @param {Object} requests
+ * @param {Object} requests - Every requests pending, in a chronological
+ * order in terms of segment time.
  * @param {number} position
  * @returns {Array.<Object>}
  */
@@ -61,26 +61,36 @@ function getConcernedRequests(
   neededPosition : number
 ) : IRequestInfo[] {
   /** Index of the request for the next needed segment, in `requests`. */
-  const nextSegmentIndex = arrayFindIndex(requests, (request) => {
-    if (request.duration <= 0) {
-      return false;
+  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;
+      }
     }
-    const segmentEnd = request.time + request.duration;
-    return segmentEnd > neededPosition &&
-           neededPosition - request.time > -1.2;
-  });
+    if (segmentEnd > neededPosition && neededPosition - segment.time > -1.2) {
+      nextSegmentIndex = i;
+      break;
+    }
+  }
 
   if (nextSegmentIndex < 0) { // Not found
     return [];
   }
 
   const nextRequest = requests[nextSegmentIndex];
-  const segmentTime = nextRequest.time;
+  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].time === segmentTime) {
+    if (requests[i].content.segment.time === segmentTime) {
       filteredRequests.push(requests[i]);
     } else {
       break;
@@ -96,7 +106,7 @@ function getConcernedRequests(
  * @param {Object} request
  * @returns {number|undefined}
  */
-function estimateRequestBandwidth(request : IRequestInfo) : 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;
@@ -122,7 +132,7 @@ function estimateRequestBandwidth(request : IRequestInfo) : number|undefined {
  * @returns {number}
  */
 function estimateRemainingTime(
-  lastProgressEvent: IProgressEventValue,
+  lastProgressEvent: IPendingRequestStoreProgress,
   bandwidthEstimate : number
 ) : number {
   const remainingData = (lastProgressEvent.totalSize - lastProgressEvent.size) * 8;
@@ -133,10 +143,14 @@ function estimateRemainingTime(
  * 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 - Current pending requests.
+ * @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}
  */
@@ -144,8 +158,13 @@ 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;
@@ -158,7 +177,6 @@ function estimateStarvationModeBitrate(
   }
 
   const concernedRequest = concernedRequests[0];
-  const chunkDuration = concernedRequest.duration;
   const now = performance.now();
   const lastProgressEvent = concernedRequest.progress.length > 0 ?
     concernedRequest.progress[concernedRequest.progress.length - 1] :
@@ -182,6 +200,11 @@ function estimateStarvationModeBitrate(
     }
   }
 
+  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);
@@ -204,22 +227,28 @@ function estimateStarvationModeBitrate(
  * 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
+ * @param {Object} playbackInfo - Information on the current playback.
  * @param {Object} requests - Every requests pending, in a chronological
  * order in terms of segment time.
- * @param {number} abrStarvationGap - "Buffer gap" from which we enter a
- * "starvation mode".
+ * @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[]
+  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 + realBufferGap;
-  const nextRequest = arrayFind(requests, (r) =>
-    r.duration > 0 && (r.time + r.duration) > nextNeededPosition);
+  const nextRequest = arrayFind(requests, ({ content }) =>
+    content.segment.duration > 0 &&
+    (content.segment.time + content.segment.duration) > nextNeededPosition);
 
   if (nextRequest === undefined) {
     return true;
@@ -251,6 +280,7 @@ function shouldDirectlySwitchToLowBitrate(
  * @class NetworkAnalyzer
  */
 export default class NetworkAnalyzer {
+  private _lowLatencyMode : boolean;
   private _inStarvationMode : boolean;
   private _initialBitrate : number;
   private _config : { starvationGap : number;
@@ -261,6 +291,7 @@ export default class NetworkAnalyzer {
   constructor(initialBitrate: number, lowLatencyMode: boolean) {
     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,
@@ -278,11 +309,16 @@ export default class NetworkAnalyzer {
    * 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
-   * @param {Object|null} currentRepresentation
-   * @param {Array.<Object>} currentRequests
-   * @param {number|undefined} lastEstimatedBitrate
+   * @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(
@@ -324,6 +360,7 @@ export default class NetworkAnalyzer {
       bandwidthEstimate = estimateStarvationModeBitrate(currentRequests,
                                                         playbackInfo,
                                                         currentRepresentation,
+                                                        this._lowLatencyMode,
                                                         lastEstimatedBitrate);
 
       if (bandwidthEstimate != null) {
@@ -361,8 +398,12 @@ export default class NetworkAnalyzer {
 
   /**
    * For a given wanted bitrate, tells if should switch urgently.
-   * @param {number} bitrate
-   * @param {Object} playbackInfo
+   * @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(
@@ -378,6 +419,8 @@ export default class NetworkAnalyzer {
     } else if (bitrate > currentRepresentation.bitrate) {
       return !this._inStarvationMode;
     }
-    return shouldDirectlySwitchToLowBitrate(playbackInfo, currentRequests);
+    return shouldDirectlySwitchToLowBitrate(playbackInfo,
+                                            currentRequests,
+                                            this._lowLatencyMode);
   }
 }