rx-player 3.25.2 → 3.26.3-dev.2022021400

package/src/utils/task_canceller.ts

@@ -0,0 +1,326 @@
+/**
+ * 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 assert from "./assert";
+import noop from "./noop";
+
+/**
+ * Class facilitating asynchronous task cancellation.
+ *
+ * This class can be used to notify some code running an asynchronous task (for
+ * example, a request) that is should abort what it is doing (for example, abort
+ * a request when it isn't needed anymore).
+ *
+ * To do that, the code which might ask for cancellation have to create a new
+ * `TaskCanceller`:
+ * ```js
+ * const canceller = new TaskCanceller();
+ * ```
+ *
+ * And has to provide its associated `CancellationSignal` to the code running
+ * the asynchronous task:
+ * ```js
+ * runAsyncTask(canceller.signal);
+ * ```
+ *
+ * In the asynchronous task, the signal can be listened to (see documentation
+ * on `CancellationSignal` for more information):
+ * ```js
+ * function runAsyncTask(cancellationSignal) {
+ *  // Let's say this function returns a Promise (this is not mandatory however)
+ *  return Promise((resolve, reject) => {
+ *    // In this example, we'll even catch the case where an asynchronous task
+ *    // was already cancelled before being called.
+ *    // This ensure that no code will run if that's the case.
+ *    if (cancellationSignal.isCancelled) {
+ *      // Here we're rejecting the CancellationError to notify the caller that
+ *      // this error was due to the task being aborted.
+ *      reject(cancellationSignal.cancellationError);
+ *      return;
+ *    }
+ *
+ *    // Example:
+ *    // performing asynchronous task and registering callbacks on success/failure.
+ *    const myCancellableTask = doSomeAsyncTasks()
+ *      .onFinished(onTaskFinished);
+ *      .onFailed(onTaskFailed);
+ *
+ *    // Run a callback when/if the corresponding `TaskCanceller` was triggered.
+ *    // Run immediately if the TaskCanceller was already triggered.
+ *    const deregisterSignal = cancellationSignal.register(onCancellation);
+ *
+ *    // Callback called on cancellation (if this task was cancelled while the
+ *    // cancellationSignal's listener is still registered).
+ *    // The `error` in argument is linked to that cancellation. It is usually
+ *    // expected that the same Error instance is used when rejecting Promises.
+ *    function onCancellation(error : CancellationError) {
+ *      // abort asynchronous task
+ *      myCancellableTask.cancel();
+ *
+ *      // In this example, reject the current pending Promise
+ *      reject(CancellationError);
+ *    }
+ *
+ *    // Callback called after the asynchronous task has finished with success.
+ *    function onTaskFinished() {
+ *      // Stop listening to the cancellationSignal
+ *      deregisterSignal();
+ *
+ *      // Resolve the Promise
+ *      resolve();
+ *    }
+ *
+ *    // Callback called after the asynchronous task has finished with failure.
+ *    function onTaskFailed(someError : Error) {
+ *      // Stop listening to the cancellationSignal
+ *      deregisterSignal();
+ *
+ *      // Resolve the Promise
+ *      reject(error);
+ *    }
+ *  });
+ * }
+ * ```
+ *
+ * The code asking for cancellation can then trigger a cancellation at any time
+ * (even before the signal was given) and listen to possible CancellationErrors
+ * to know when it was cancelled.
+ * ```js
+ * const canceller = new TaskCanceller();
+ *
+ * runAsyncTask(canceller.signal)
+ *   .then(() => { console.log("Task succeeded!"); )
+ *   .catch((err) => {
+ *      if (TaskCanceller.isCancellationError(err)) {
+ *        console.log("Task cancelled!");
+ *      } else {
+ *        console.log("Task failed:", err);
+ *      }
+ *   });
+ * canceller.cancel(); // Cancel the task, calling registered callbacks
+ * ```
+ * @class TaskCanceller
+ */
+export default class TaskCanceller {
+  /**
+   * `CancellationSignal` that can be given to an async task, so it can be
+   * notified that it should be aborted when this `TaskCanceller` is triggered
+   * (through its `cancel` method).
+   */
+  public signal : CancellationSignal;
+  /**
+   * `true` if this `TaskCanceller` has already been triggered.
+   * `false` otherwise.
+   */
+  public isUsed : boolean;
+  /**
+   * @private
+   * Internal function called when the `TaskCanceller` is triggered`.
+   */
+  private _trigger : (error : CancellationError) => void;
+
+  /**
+   * Creates a new `TaskCanceller`, with its own `CancellationSignal` created
+   * as its `signal` provide.
+   * You can then pass this property to async task you wish to be cancellable.
+   */
+  constructor() {
+    const [trigger, register] = createCancellationFunctions();
+    this.isUsed = false;
+    this._trigger = trigger;
+    this.signal = new CancellationSignal(register);
+  }
+
+  /**
+   * "Trigger" the `TaskCanceller`, notify through its associated
+   * `CancellationSignal` (its `signal` property) that a task should be aborted.
+   *
+   * Once called the `TaskCanceller` is permanently triggered.
+   *
+   * An optional CancellationError can be given in argument for when this
+   * cancellation is actually triggered as a chain reaction from a previous
+   * cancellation.
+   * @param {Error} [originError]
+   */
+  public cancel(originError? : CancellationError) : void {
+    if (this.isUsed) {
+      return ;
+    }
+    this.isUsed = true;
+    const cancellationError = originError ?? new CancellationError();
+    this._trigger(cancellationError);
+  }
+
+  /**
+   * Check that the `error` in argument is a `CancellationError`, most likely
+   * meaning that the linked error is due to a task aborted via a
+   * `CancellationSignal`.
+   * @param {*} error
+   * @returns {boolean}
+   */
+  static isCancellationError(error : unknown) : boolean {
+    return error instanceof CancellationError;
+  }
+}
+
+/**
+ * Class associated to a TaskCanceller allowing to be notified when a task
+ * needs to be aborted.
+ * @class
+ */
+export class CancellationSignal {
+  /**
+   * True when the associated `TaskCanceller` was already triggered, meaning
+   * that the current task needs to be aborted.
+   */
+  public isCancelled : boolean;
+  /**
+   * Error associated to the cancellation.
+   * Can be used to notify to a caller that this task was aborted (for example
+   * by rejecting it through the Promise associated to that task).
+   *
+   * Always set if `isCancelled` is equal to `true`.
+   */
+  public cancellationError : CancellationError | null;
+
+  /**
+   * @private
+   * Functions called when the corresponding `TaskCanceller` is triggered.
+   * Those should perform all logic allowing to cancel the current task(s)
+   * which depend on this CancellationSignal.
+   */
+  private _listeners : Array<(error : CancellationError) => void>;
+
+  /**
+   * Creates a new CancellationSignal.
+   * /!\ Note: Only a `TaskCanceller` is supposed to be able to create one.
+   * @param {Function} registerToSource - Function called when the task is
+   * cancelled.
+   */
+  constructor(registerToSource : (listener: ICancellationListener) => void) {
+    this.isCancelled = false;
+    this.cancellationError = null;
+    this._listeners = [];
+
+    registerToSource((cancellationError : CancellationError) : void => {
+      this.cancellationError = cancellationError;
+      this.isCancelled = true;
+      while (this._listeners.length > 0) {
+        const listener = this._listeners.splice(this._listeners.length - 1, 1)[0];
+        listener(cancellationError);
+      }
+    });
+  }
+
+  /**
+   * Registers a function that will be called when/if the current task is
+   * cancelled.
+   *
+   * Multiple calls to `register` can be performed to register multiple
+   * callbacks on cancellation associated to the same `CancellationSignal`.
+   *
+   * @param {Function} fn - This function should perform all logic allowing to
+   * abort everything the task is doing.
+   *
+   * It takes in argument the `CancellationError` which was created when the
+   * task was aborted.
+   * You can use this error to notify callers that the task has been aborted,
+   * for example through a rejected Promise.
+   *
+   * @return {Function} - Removes that cancellation listener. You can call this
+   * once you don't want the callback to be triggered anymore (e.g. after the
+   * task succeeded or failed).
+   * You don't need to call that function when cancellation has already been
+   * performed.
+   */
+  public register(fn : ICancellationListener) : () => void {
+    if (this.isCancelled) {
+      assert(this.cancellationError !== null);
+      fn(this.cancellationError);
+    }
+    this._listeners.push(fn);
+    return () => this.deregister(fn);
+  }
+
+  /**
+   * De-register a function registered through the `register` function.
+   * Do nothing if that function wasn't registered.
+   *
+   * You can call this method when using the return value of `register` is not
+   * practical.
+   * @param {Function} fn
+   */
+  public deregister(fn : ICancellationListener) : void {
+    if (this.isCancelled) {
+      return;
+    }
+    for (let i = 0; i < this._listeners.length; i++) {
+      if (this._listeners[i] === fn) {
+        this._listeners.splice(i, 1);
+        return;
+      }
+    }
+  }
+}
+
+/**
+ * Helper type allowing a `CancellationSignal` to register to a cancellation asked
+ * by a `TaskCanceller`.
+ */
+export type ICancellationListener = (error : CancellationError) => void;
+
+/**
+ * Error created when a task is cancelled through the TaskCanceller.
+ *
+ * @class CancellationError
+ * @extends Error
+ */
+export class CancellationError extends Error {
+  public readonly name : "CancellationError";
+  public readonly message : string;
+
+  /**
+   * @param {string} message
+   */
+  constructor() {
+    super();
+    // @see https://stackoverflow.com/questions/41102060/typescript-extending-error-class
+    Object.setPrototypeOf(this, CancellationError.prototype);
+
+    this.name = "CancellationError";
+    this.message = "This task was cancelled.";
+  }
+}
+
+/**
+ * Helper function allowing communication between a `TaskCanceller` and a
+ * `CancellationSignal`.
+ * @returns {Array.<Function>}
+ */
+function createCancellationFunctions() : [
+  (error : CancellationError) => void,
+  (newListener : ICancellationListener) => void
+] {
+  let listener : (error : CancellationError) => void = noop;
+  return [
+    function trigger(error : CancellationError) {
+      listener(error);
+    },
+    function register(newListener : ICancellationListener) {
+      listener = newListener;
+    },
+  ];
+}

package/src/utils/uniq.ts

@@ -40,7 +40,7 @@ function uniqFromSet<T>(arr: T[]) : T[] {
  */
 export default  typeof window !== "undefined" &&
                 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-                typeof (window as any).Set === "function" &&
+                typeof window.Set === "function" &&
                 typeof Array.from === "function" ? uniqFromSet :
                                                    uniqFromFilter;
 export {

package/tsconfig.json

@@ -4,6 +4,7 @@
     "allowJs": true,
     "target": "es2017",
     "lib": ["es2017", "dom"],
+    "exactOptionalPropertyTypes": true,
     "forceConsistentCasingInFileNames": true,
     "skipLibCheck": false,
     "noImplicitAny": true,
@@ -15,7 +16,10 @@
     "types": ["rxjs", "node", "jest"],
     "moduleResolution": "node",
     "typeRoots": [
-      "./src/typings",
+      "./src/typings/pinkie.d.ts",
+      "./src/typings/next-tick.d.ts",
+      "./src/typings/object-assign.d.ts",
+      "./src/typings/globals.d.ts",
       "./node_modules/@types"
     ]
   },

package/tsconfig.modules.json

@@ -4,6 +4,7 @@
     "declaration": true,
     "target": "es5",
     "lib": ["es2017", "dom"],
+    "exactOptionalPropertyTypes": true,
     "forceConsistentCasingInFileNames": true,
     "skipLibCheck": false,
     "noImplicitAny": true,
@@ -16,14 +17,19 @@
     "moduleResolution": "node",
     "module": "es2015",
     "typeRoots": [
-      "./src/typings",
+      "./scripts/build/constants.d.ts",
+      "./src/typings/pinkie.d.ts",
+      "./src/typings/next-tick.d.ts",
+      "./src/typings/object-assign.d.ts",
       "./node_modules/@types"
     ]
   },
   "include": [
-    "./src/**/*.ts"
+    "./src/**/*.ts",
+    "./scripts/build/constants.d.ts"
   ],
   "exclude":[
-    "./src/**/*.test.ts"
+    "./src/**/*.test.ts",
+    "./src/typings/globals.d.ts"
   ]
 }

package/dist/_esm5.processed/compat/is_playback_stuck.d.ts

@@ -1,28 +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.
- */
-/**
- * firefox fix: sometimes playback can be stalled, even if we are in a buffer.
- * TODO This seems to be about an old Firefox version. Delete it?
- * @param {number} time
- * @param {Object|null} currentRange
- * @param {string} state
- * @param {Boolean} isStalled
- * @returns {Boolean}
- */
-export default function isPlaybackStuck(time: number, currentRange: {
-    start: number;
-    end: number;
-} | null, state: string, isStalled: boolean): boolean;

package/dist/_esm5.processed/compat/is_playback_stuck.js

@@ -1,33 +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 { isFirefox } from "./browser_detection";
-/**
- * firefox fix: sometimes playback can be stalled, even if we are in a buffer.
- * TODO This seems to be about an old Firefox version. Delete it?
- * @param {number} time
- * @param {Object|null} currentRange
- * @param {string} state
- * @param {Boolean} isStalled
- * @returns {Boolean}
- */
-export default function isPlaybackStuck(time, currentRange, state, isStalled) {
-    var FREEZE_THRESHOLD = 10; // freeze threshold in seconds
-    return (isFirefox &&
-        isStalled &&
-        state === "timeupdate" &&
-        currentRange != null &&
-        currentRange.end - time > FREEZE_THRESHOLD);
-}

package/dist/_esm5.processed/core/abr/cached_segment_detector.js

@@ -1,60 +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";
-var CACHE_LOAD_DURATION_THRESHOLDS = config.CACHE_LOAD_DURATION_THRESHOLDS;
-/**
- * From segment download duration, tells if a segment
- * may have been loaded from cache.
- * @param {string} contentType
- * @param {number} downloadDuration
- */
-function mayBeFromCache(contentType, downloadDuration) {
-    var cacheLoadDurationThreshold = CACHE_LOAD_DURATION_THRESHOLDS[contentType];
-    return downloadDuration < cacheLoadDurationThreshold;
-}
-/**
- * Returns a function used to determine if a segment was loaded
- * from cache or not.
- * @returns {function}
- */
-export default function generateCachedSegmentDetector() {
-    var hasAlreadyLoadedNonCachedContent = false;
-    /**
-     * Determines with request duration if a loaded chunk may have been loaded
-     * from cache, and return true if should ignore the metrics for representation
-     * chooser.
-     * @param {Object} content
-     * @param {number} duration
-     * @returns {boolean}
-     */
-    return function shouldIgnoreMetrics(content, downloadDuration) {
-        var contentType = content.adaptation.type;
-        if (contentType === "text" || contentType === "image") {
-            return false;
-        }
-        var segmentMayBeFromCache = mayBeFromCache(contentType, downloadDuration);
-        if (segmentMayBeFromCache && hasAlreadyLoadedNonCachedContent) {
-            // We already loaded not cached segments.
-            // Do not consider cached segments anymore.
-            return true;
-        }
-        if (!segmentMayBeFromCache && !hasAlreadyLoadedNonCachedContent) {
-            // First segment not loaded from cache.
-            hasAlreadyLoadedNonCachedContent = true;
-        }
-        return false;
-    };
-}

package/dist/_esm5.processed/core/abr/create_filters.d.ts

@@ -1,27 +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 { Observable } from "rxjs";
-import { IABRFiltersObject } from "./representation_estimator";
-/**
- * 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}
- */
-export default function createFilters(limitWidth$?: Observable<number>, throttleBitrate$?: Observable<number>, throttle$?: Observable<number>): Observable<IABRFiltersObject>;

package/dist/_esm5.processed/core/abr/create_filters.js

@@ -1,52 +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.
- */
-var __spreadArray = (this && this.__spreadArray) || function (to, from) {
-    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
-        to[j] = from[i];
-    return to;
-};
-import { combineLatest as observableCombineLatest, of as observableOf, } from "rxjs";
-import { map } from "rxjs/operators";
-import objectAssign from "../../utils/object_assign";
-/**
- * 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}
- */
-export default function createFilters(limitWidth$, throttleBitrate$, throttle$) {
-    var deviceEventsArray = [];
-    if (limitWidth$ != null) {
-        deviceEventsArray.push(limitWidth$.pipe(map(function (width) { return ({ width: width }); })));
-    }
-    if (throttle$ != null) {
-        deviceEventsArray.push(throttle$.pipe(map(function (bitrate) { return ({ bitrate: bitrate }); })));
-    }
-    if (throttleBitrate$ != null) {
-        deviceEventsArray.push(throttleBitrate$.pipe(map(function (bitrate) { return ({ bitrate: bitrate }); })));
-    }
-    // Emit restrictions on the pools of available representations to choose
-    // from.
-    return deviceEventsArray.length > 0 ?
-        observableCombineLatest(deviceEventsArray)
-            .pipe(map(function (args) {
-            return objectAssign.apply(void 0, __spreadArray([{}], args));
-        })) :
-        observableOf({});
-}

package/dist/_esm5.processed/core/abr/get_estimate_from_buffer_levels.d.ts

@@ -1,29 +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.
- */
-export interface IBufferBasedChooserClockTick {
-    bufferGap: number;
-    currentBitrate?: number;
-    currentScore?: number;
-    speed: number;
-}
-/**
- * From the buffer gap, choose a representation.
- * @param {Object} clockTick
- * @param {Array.<Number>} bitrates
- * @param {Array.<Number>} bufferLevels
- * @returns {Object|undefined}
- */
-export default function getEstimateFromBufferLevels(clockTick: IBufferBasedChooserClockTick, bitrates: number[], bufferLevels: number[]): number | undefined;

package/dist/_esm5.processed/core/abr/get_estimate_from_buffer_levels.js

@@ -1,67 +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 log from "../../log";
-import arrayFindIndex from "../../utils/array_find_index";
-/**
- * From the buffer gap, choose a representation.
- * @param {Object} clockTick
- * @param {Array.<Number>} bitrates
- * @param {Array.<Number>} bufferLevels
- * @returns {Object|undefined}
- */
-export default function getEstimateFromBufferLevels(clockTick, bitrates, bufferLevels) {
-    var bufferGap = clockTick.bufferGap, currentBitrate = clockTick.currentBitrate, currentScore = clockTick.currentScore, speed = clockTick.speed;
-    if (currentBitrate == null) {
-        return bitrates[0];
-    }
-    var currentBitrateIndex = arrayFindIndex(bitrates, function (b) { return b === currentBitrate; });
-    if (currentBitrateIndex < 0 || bitrates.length !== bufferLevels.length) {
-        log.error("ABR: Current Bitrate not found in the calculated levels");
-        return bitrates[0];
-    }
-    var scaledScore;
-    if (currentScore != null) {
-        scaledScore = speed === 0 ? currentScore : (currentScore / speed);
-    }
-    if (scaledScore != null && scaledScore > 1) {
-        var currentBufferLevel_1 = bufferLevels[currentBitrateIndex];
-        var nextIndex = (function () {
-            for (var i = currentBitrateIndex + 1; i < bufferLevels.length; i++) {
-                if (bufferLevels[i] > currentBufferLevel_1) {
-                    return i;
-                }
-            }
-        })();
-        if (nextIndex != null) {
-            var nextBufferLevel = bufferLevels[nextIndex];
-            if (bufferGap >= nextBufferLevel) {
-                return bitrates[nextIndex];
-            }
-        }
-    }
-    if (scaledScore == null || scaledScore < 1.15) {
-        var currentBufferLevel = bufferLevels[currentBitrateIndex];
-        if (bufferGap < currentBufferLevel) {
-            for (var i = currentBitrateIndex - 1; i >= 0; i--) {
-                if (bitrates[i] < currentBitrate) {
-                    return bitrates[i];
-                }
-            }
-            return currentBitrate;
-        }
-    }
-    return currentBitrate;
-}