rx-player 4.0.0-dev.2023102700 → 4.0.0-dev.2023110700

package/dist/_esm5.processed/core/adaptive/adaptive_representation_selector.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -14,27 +13,32 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-const config_1 = require("../../config");
-const log_1 = require("../../log");
-const noop_1 = require("../../utils/noop");
-const ranges_1 = require("../../utils/ranges");
-const reference_1 = require("../../utils/reference");
-const task_canceller_1 = require("../../utils/task_canceller");
-const buffer_based_chooser_1 = require("./buffer_based_chooser");
-const guess_based_chooser_1 = require("./guess_based_chooser");
-const network_analyzer_1 = require("./network_analyzer");
-const bandwidth_estimator_1 = require("./utils/bandwidth_estimator");
-const filter_by_bitrate_1 = require("./utils/filter_by_bitrate");
-const filter_by_resolution_1 = require("./utils/filter_by_resolution");
-const last_estimate_storage_1 = require("./utils/last_estimate_storage");
-const pending_requests_store_1 = require("./utils/pending_requests_store");
-const representation_score_calculator_1 = require("./utils/representation_score_calculator");
-const select_optimal_representation_1 = require("./utils/select_optimal_representation");
+import config from "../../config";
+import log from "../../log";
+import noop from "../../utils/noop";
+import { getLeftSizeOfRange } from "../../utils/ranges";
+import SharedReference from "../../utils/reference";
+import TaskCanceller from "../../utils/task_canceller";
+import BufferBasedChooser from "./buffer_based_chooser";
+import GuessBasedChooser from "./guess_based_chooser";
+import NetworkAnalyzer from "./network_analyzer";
+import BandwidthEstimator from "./utils/bandwidth_estimator";
+import filterByBitrate from "./utils/filter_by_bitrate";
+import filterByWidth from "./utils/filter_by_width";
+import LastEstimateStorage from "./utils/last_estimate_storage";
+import PendingRequestsStore from "./utils/pending_requests_store";
+import RepresentationScoreCalculator from "./utils/representation_score_calculator";
+import selectOptimalRepresentation from "./utils/select_optimal_representation";
 // Create default shared references
-const limitWidthDefaultRef = new reference_1.default(undefined);
+var manualBitrateDefaultRef = new SharedReference(-1);
+manualBitrateDefaultRef.finish();
+var minAutoBitrateDefaultRef = new SharedReference(0);
+minAutoBitrateDefaultRef.finish();
+var maxAutoBitrateDefaultRef = new SharedReference(Infinity);
+maxAutoBitrateDefaultRef.finish();
+var limitWidthDefaultRef = new SharedReference(undefined);
 limitWidthDefaultRef.finish();
-const throttleBitrateDefaultRef = new reference_1.default(Infinity);
+var throttleBitrateDefaultRef = new SharedReference(Infinity);
 throttleBitrateDefaultRef.finish();
 /**
  * Select the most adapted Representation according to the network and buffer
@@ -44,13 +48,13 @@ throttleBitrateDefaultRef.finish();
  * @returns {Object} - Interface allowing to select a Representation.
  * @see IRepresentationEstimator
  */
-function createAdaptiveRepresentationSelector(options) {
+export default function createAdaptiveRepresentationSelector(options) {
     /**
      * Allows to estimate the current network bandwidth.
      * One per active media type.
      */
-    const bandwidthEstimators = {};
-    const { initialBitrates, throttlers, lowLatencyMode } = options;
+    var bandwidthEstimators = {};
+    var manualBitrates = options.manualBitrates, minAutoBitrates = options.minAutoBitrates, maxAutoBitrates = options.maxAutoBitrates, initialBitrates = options.initialBitrates, throttlers = options.throttlers, lowLatencyMode = options.lowLatencyMode;
     /**
      * Returns Object emitting Representation estimates as well as callbacks
      * allowing to helping it produce them.
@@ -64,22 +68,18 @@ function createAdaptiveRepresentationSelector(options) {
      * @returns {Array.<Object>}
      */
     return function getEstimates(context, currentRepresentation, representations, playbackObserver, stopAllEstimates) {
-        var _a, _b, _c;
-        const { type } = context.adaptation;
-        const bandwidthEstimator = _getBandwidthEstimator(type);
-        const initialBitrate = (_a = initialBitrates[type]) !== null && _a !== void 0 ? _a : 0;
-        const filters = {
-            limitResolution: (_b = throttlers.limitResolution[type]) !== null && _b !== void 0 ? _b : limitWidthDefaultRef,
-            throttleBitrate: (_c = throttlers.throttleBitrate[type]) !== null && _c !== void 0 ? _c : throttleBitrateDefaultRef,
+        var _a, _b, _c, _d, _e, _f, _g;
+        var type = context.adaptation.type;
+        var bandwidthEstimator = _getBandwidthEstimator(type);
+        var manualBitrate = (_a = manualBitrates[type]) !== null && _a !== void 0 ? _a : manualBitrateDefaultRef;
+        var minAutoBitrate = (_b = minAutoBitrates[type]) !== null && _b !== void 0 ? _b : minAutoBitrateDefaultRef;
+        var maxAutoBitrate = (_c = maxAutoBitrates[type]) !== null && _c !== void 0 ? _c : maxAutoBitrateDefaultRef;
+        var initialBitrate = (_d = initialBitrates[type]) !== null && _d !== void 0 ? _d : 0;
+        var filters = {
+            limitWidth: (_e = throttlers.limitWidth[type]) !== null && _e !== void 0 ? _e : limitWidthDefaultRef,
+            throttleBitrate: (_g = (_f = throttlers.throttleBitrate[type]) !== null && _f !== void 0 ? _f : throttlers.throttle[type]) !== null && _g !== void 0 ? _g : throttleBitrateDefaultRef,
         };
-        return getEstimateReference({ bandwidthEstimator,
-            context,
-            currentRepresentation,
-            filters,
-            initialBitrate,
-            playbackObserver,
-            representations,
-            lowLatencyMode }, stopAllEstimates);
+        return getEstimateReference({ bandwidthEstimator: bandwidthEstimator, context: context, currentRepresentation: currentRepresentation, filters: filters, initialBitrate: initialBitrate, manualBitrate: manualBitrate, minAutoBitrate: minAutoBitrate, maxAutoBitrate: maxAutoBitrate, playbackObserver: playbackObserver, representations: representations, lowLatencyMode: lowLatencyMode }, stopAllEstimates);
     };
     /**
      * Returns interface allowing to estimate network throughtput for a given type.
@@ -87,17 +87,16 @@ function createAdaptiveRepresentationSelector(options) {
      * @returns {Object}
      */
     function _getBandwidthEstimator(bufferType) {
-        const originalBandwidthEstimator = bandwidthEstimators[bufferType];
+        var originalBandwidthEstimator = bandwidthEstimators[bufferType];
         if (originalBandwidthEstimator == null) {
-            log_1.default.debug("ABR: Creating new BandwidthEstimator for ", bufferType);
-            const bandwidthEstimator = new bandwidth_estimator_1.default();
+            log.debug("ABR: Creating new BandwidthEstimator for ", bufferType);
+            var bandwidthEstimator = new BandwidthEstimator();
             bandwidthEstimators[bufferType] = bandwidthEstimator;
             return bandwidthEstimator;
         }
         return originalBandwidthEstimator;
     }
 }
-exports.default = createAdaptiveRepresentationSelector;
 /**
  * Estimate regularly the current network bandwidth and the best Representation
  * that can be played according to the current network and playback conditions.
@@ -117,80 +116,75 @@ exports.default = createAdaptiveRepresentationSelector;
  * @param {Object} stopAllEstimates
  * @returns {Array.<Object>}
  */
-function getEstimateReference({ bandwidthEstimator, context, currentRepresentation, filters, initialBitrate, lowLatencyMode, playbackObserver, representations: representationsRef }, stopAllEstimates) {
-    const scoreCalculator = new representation_score_calculator_1.default();
-    const networkAnalyzer = new network_analyzer_1.default(initialBitrate !== null && initialBitrate !== void 0 ? initialBitrate : 0, lowLatencyMode);
-    const requestsStore = new pending_requests_store_1.default();
+function getEstimateReference(_a, stopAllEstimates) {
+    var bandwidthEstimator = _a.bandwidthEstimator, context = _a.context, currentRepresentation = _a.currentRepresentation, filters = _a.filters, initialBitrate = _a.initialBitrate, lowLatencyMode = _a.lowLatencyMode, manualBitrate = _a.manualBitrate, maxAutoBitrate = _a.maxAutoBitrate, minAutoBitrate = _a.minAutoBitrate, playbackObserver = _a.playbackObserver, representationsRef = _a.representations;
+    var scoreCalculator = new RepresentationScoreCalculator();
+    var networkAnalyzer = new NetworkAnalyzer(initialBitrate !== null && initialBitrate !== void 0 ? initialBitrate : 0, lowLatencyMode);
+    var requestsStore = new PendingRequestsStore();
     /**
      * Callback called each time a new segment is pushed, with the information on the
      * new pushed segment.
      */
-    let onAddedSegment = noop_1.default;
-    const callbacks = {
+    var onAddedSegment = noop;
+    var callbacks = {
         metrics: onMetric,
         requestBegin: onRequestBegin,
         requestProgress: onRequestProgress,
         requestEnd: onRequestEnd,
-        addedSegment(val) { onAddedSegment(val); },
+        addedSegment: function (val) { onAddedSegment(val); },
     };
     /**
      * `TaskCanceller` allowing to stop producing estimate.
      * This TaskCanceller is used both for restarting estimates with a new
      * configuration and to cancel them altogether.
      */
-    let currentEstimatesCanceller = new task_canceller_1.default();
+    var currentEstimatesCanceller = new TaskCanceller();
     currentEstimatesCanceller.linkToSignal(stopAllEstimates);
     // Create `SharedReference` on which estimates will be emitted.
-    const estimateRef = createEstimateReference(representationsRef.getValue(), currentEstimatesCanceller.signal);
+    var estimateRef = createEstimateReference(representationsRef.getValue(), currentEstimatesCanceller.signal);
     representationsRef.onUpdate(restartEstimatesProductionFromCurrentConditions, { clearSignal: stopAllEstimates });
-    return { estimates: estimateRef, callbacks };
-    /**
-     * Emit the ABR estimates on various events through the returned
-     * `SharedReference`.
-     * @param {Array.<Object>} unsortedRepresentations - All `Representation` that
-     * the ABR logic can choose from.
-     * @param {Object} innerCancellationSignal - When this `CancellationSignal`
-     * emits, all events registered to to emit new estimates will be unregistered.
-     * Note that the returned reference may still be used to produce new estimates
-     * in the future if you want to even after this signal emits.
-     * @returns {Object} - `SharedReference` through which ABR estimates will be
-     * produced.
-     */
-    function createEstimateReference(unsortedRepresentations, innerCancellationSignal) {
-        if (unsortedRepresentations.length <= 1) {
-            // There's only a single Representation. Just choose it.
-            return new reference_1.default({
+    return { estimates: estimateRef, callbacks: callbacks };
+    function createEstimateReference(representations, innerCancellationSignal) {
+        if (representations.length === 0) {
+            // No Representation given, return `null` as documented
+            return new SharedReference({
+                representation: null,
                 bitrate: undefined,
-                representation: unsortedRepresentations[0],
-                urgent: true,
                 knownStableBitrate: undefined,
+                manual: false,
+                urgent: true,
             });
         }
+        if (representations.length === 1) {
+            // There's only a single Representation. Just choose it.
+            return new SharedReference({ bitrate: undefined,
+                representation: representations[0],
+                manual: false,
+                urgent: true,
+                knownStableBitrate: undefined });
+        }
         /** If true, Representation estimates based on the buffer health might be used. */
-        let allowBufferBasedEstimates = false;
-        /** Ensure `Representation` objects are sorted by bitrates and only rely on this. */
-        const sortedRepresentations = unsortedRepresentations
-            .sort((ra, rb) => ra.bitrate - rb.bitrate);
+        var allowBufferBasedEstimates = false;
         /**
          * Module calculating the optimal Representation based on the current
          * buffer's health (i.e. whether enough data is buffered, history of
          * buffer size etc.).
          */
-        const bufferBasedChooser = new buffer_based_chooser_1.default(sortedRepresentations.map(r => r.bitrate));
+        var bufferBasedChooser = new BufferBasedChooser(representations.map(function (r) { return r.bitrate; }));
         /** Store the previous estimate made here. */
-        const prevEstimate = new last_estimate_storage_1.default();
+        var prevEstimate = new LastEstimateStorage();
         /**
          * Module calculating the optimal Representation by "guessing it" with a
          * step-by-step algorithm.
          * Only used in very specific scenarios.
          */
-        const guessBasedChooser = new guess_based_chooser_1.default(scoreCalculator, prevEstimate);
+        var guessBasedChooser = new GuessBasedChooser(scoreCalculator, prevEstimate);
         // get initial observation for initial estimate
-        let lastPlaybackObservation = playbackObserver.getReference().getValue();
+        var lastPlaybackObservation = playbackObserver.getReference().getValue();
         /** Reference through which estimates are emitted. */
-        const innerEstimateRef = new reference_1.default(getCurrentEstimate());
+        var innerEstimateRef = new SharedReference(getCurrentEstimate());
         // Listen to playback observations
-        playbackObserver.listen((obs) => {
+        playbackObserver.listen(function (obs) {
             lastPlaybackObservation = obs;
             updateEstimate();
         }, { includeLastObservation: false, clearSignal: innerCancellationSignal });
@@ -198,42 +192,59 @@ function getEstimateReference({ bandwidthEstimator, context, currentRepresentati
             if (lastPlaybackObservation === null) {
                 return;
             }
-            const { position, speed } = lastPlaybackObservation;
-            const timeRanges = val.buffered;
-            const bufferGap = (0, ranges_1.getLeftSizeOfBufferedTimeRange)(timeRanges, position.last);
-            const { representation } = val.content;
-            const currentScore = scoreCalculator.getEstimate(representation);
-            const currentBitrate = representation.bitrate;
-            const observation = { bufferGap, currentBitrate, currentScore, speed };
+            var position = lastPlaybackObservation.position, speed = lastPlaybackObservation.speed;
+            var timeRanges = val.buffered;
+            var bufferGap = getLeftSizeOfRange(timeRanges, position.last);
+            var representation = val.content.representation;
+            var currentScore = scoreCalculator.getEstimate(representation);
+            var currentBitrate = representation.bitrate;
+            var observation = { bufferGap: bufferGap, currentBitrate: currentBitrate, currentScore: currentScore, speed: speed };
             bufferBasedChooser.onAddedSegment(observation);
             updateEstimate();
         };
-        innerCancellationSignal.register(() => {
-            onAddedSegment = noop_1.default;
+        innerCancellationSignal.register(function () {
+            onAddedSegment = noop;
         });
-        filters.throttleBitrate.onUpdate(updateEstimate, { clearSignal: innerCancellationSignal });
-        filters.limitResolution.onUpdate(updateEstimate, { clearSignal: innerCancellationSignal });
+        manualBitrate.onUpdate(updateEstimate, { clearSignal: innerCancellationSignal });
+        minAutoBitrate.onUpdate(updateEstimate, { clearSignal: innerCancellationSignal });
+        maxAutoBitrate.onUpdate(updateEstimate, { clearSignal: innerCancellationSignal });
+        filters.limitWidth.onUpdate(updateEstimate, { clearSignal: innerCancellationSignal });
+        filters.limitWidth.onUpdate(updateEstimate, { clearSignal: innerCancellationSignal });
         return innerEstimateRef;
         function updateEstimate() {
             innerEstimateRef.setValue(getCurrentEstimate());
         }
         /** Returns the actual estimate based on all methods and algorithm available. */
         function getCurrentEstimate() {
-            const { bufferGap, position, maximumPosition } = lastPlaybackObservation;
-            const resolutionLimit = filters.limitResolution.getValue();
-            const bitrateThrottle = filters.throttleBitrate.getValue();
-            const currentRepresentationVal = currentRepresentation.getValue();
-            const filteredReps = getFilteredRepresentations(sortedRepresentations, resolutionLimit, bitrateThrottle);
-            const requests = requestsStore.getRequests();
-            const { bandwidthEstimate, bitrateChosen } = networkAnalyzer
-                .getBandwidthEstimate(lastPlaybackObservation, bandwidthEstimator, currentRepresentationVal, requests, prevEstimate.bandwidth);
-            const stableRepresentation = scoreCalculator.getLastStableRepresentation();
-            const knownStableBitrate = stableRepresentation === null ?
+            var manualBitrateVal = manualBitrate.getValue();
+            if (manualBitrateVal >= 0) {
+                // A manual bitrate has been set. Just choose Representation according to it.
+                var manualRepresentation = selectOptimalRepresentation(representations, manualBitrateVal, 0, Infinity);
+                return {
+                    representation: manualRepresentation,
+                    bitrate: undefined,
+                    knownStableBitrate: undefined,
+                    manual: true,
+                    urgent: true, // a manual bitrate switch should happen immediately
+                };
+            }
+            var bufferGap = lastPlaybackObservation.bufferGap, position = lastPlaybackObservation.position, maximumPosition = lastPlaybackObservation.maximumPosition;
+            var widthLimit = filters.limitWidth.getValue();
+            var bitrateThrottle = filters.throttleBitrate.getValue();
+            var currentRepresentationVal = currentRepresentation.getValue();
+            var minAutoBitrateVal = minAutoBitrate.getValue();
+            var maxAutoBitrateVal = maxAutoBitrate.getValue();
+            var filteredReps = getFilteredRepresentations(representations, widthLimit, bitrateThrottle);
+            var requests = requestsStore.getRequests();
+            var _a = networkAnalyzer
+                .getBandwidthEstimate(lastPlaybackObservation, bandwidthEstimator, currentRepresentationVal, requests, prevEstimate.bandwidth), bandwidthEstimate = _a.bandwidthEstimate, bitrateChosen = _a.bitrateChosen;
+            var stableRepresentation = scoreCalculator.getLastStableRepresentation();
+            var knownStableBitrate = stableRepresentation === null ?
                 undefined :
                 stableRepresentation.bitrate / (lastPlaybackObservation.speed > 0 ?
                     lastPlaybackObservation.speed :
                     1);
-            const { ABR_ENTER_BUFFER_BASED_ALGO, ABR_EXIT_BUFFER_BASED_ALGO } = config_1.default.getCurrent();
+            var _b = config.getCurrent(), ABR_ENTER_BUFFER_BASED_ALGO = _b.ABR_ENTER_BUFFER_BASED_ALGO, ABR_EXIT_BUFFER_BASED_ALGO = _b.ABR_EXIT_BUFFER_BASED_ALGO;
             if (allowBufferBasedEstimates && bufferGap <= ABR_EXIT_BUFFER_BASED_ALGO) {
                 allowBufferBasedEstimates = false;
             }
@@ -248,13 +259,13 @@ function getEstimateReference({ bandwidthEstimator, context, currentRepresentati
              * This is a safe enough choice but might be lower than what the user
              * could actually profit from.
              */
-            const chosenRepFromBandwidth = (0, select_optimal_representation_1.default)(filteredReps, bitrateChosen);
+            var chosenRepFromBandwidth = selectOptimalRepresentation(filteredReps, bitrateChosen, minAutoBitrateVal, maxAutoBitrateVal);
             /**
              * Current optimal Representation's bandwidth choosen by a buffer-based
              * adaptive algorithm.
              */
-            const currentBufferBasedEstimate = bufferBasedChooser.getLastEstimate();
-            let currentBestBitrate = chosenRepFromBandwidth.bitrate;
+            var currentBufferBasedEstimate = bufferBasedChooser.getLastEstimate();
+            var currentBestBitrate = chosenRepFromBandwidth.bitrate;
             /**
              * Representation chosen when considering the current buffer size.
              * If defined, takes precedence over `chosenRepFromBandwidth`.
@@ -265,11 +276,11 @@ function getEstimateReference({ bandwidthEstimator, context, currentRepresentati
              * `null` if this buffer size mode is not enabled or if we don't have a
              * choice from it yet.
              */
-            let chosenRepFromBufferSize = null;
+            var chosenRepFromBufferSize = null;
             if (allowBufferBasedEstimates &&
                 currentBufferBasedEstimate !== undefined &&
                 currentBufferBasedEstimate > currentBestBitrate) {
-                chosenRepFromBufferSize = (0, select_optimal_representation_1.default)(filteredReps, currentBufferBasedEstimate);
+                chosenRepFromBufferSize = selectOptimalRepresentation(filteredReps, currentBufferBasedEstimate, minAutoBitrateVal, maxAutoBitrateVal);
                 currentBestBitrate = chosenRepFromBufferSize.bitrate;
             }
             /**
@@ -287,52 +298,52 @@ function getEstimateReference({ bandwidthEstimator, context, currentRepresentati
              *
              * `null` if not enabled or if there's currently no guess.
              */
-            let chosenRepFromGuessMode = null;
+            var chosenRepFromGuessMode = null;
             if (lowLatencyMode &&
                 currentRepresentationVal !== null &&
                 context.manifest.isDynamic &&
                 maximumPosition - position.last < 40) {
                 chosenRepFromGuessMode = guessBasedChooser
-                    .getGuess(sortedRepresentations, lastPlaybackObservation, currentRepresentationVal, currentBestBitrate, requests);
+                    .getGuess(representations, lastPlaybackObservation, currentRepresentationVal, currentBestBitrate, requests);
             }
             if (chosenRepFromGuessMode !== null &&
                 chosenRepFromGuessMode.bitrate > currentBestBitrate) {
-                log_1.default.debug("ABR: Choosing representation with guess-based estimation.", chosenRepFromGuessMode.bitrate, chosenRepFromGuessMode.id);
+                log.debug("ABR: Choosing representation with guess-based estimation.", chosenRepFromGuessMode.bitrate, chosenRepFromGuessMode.id);
                 prevEstimate.update(chosenRepFromGuessMode, bandwidthEstimate, 2 /* ABRAlgorithmType.GuessBased */);
                 return { bitrate: bandwidthEstimate,
                     representation: chosenRepFromGuessMode,
                     urgent: currentRepresentationVal === null ||
                         chosenRepFromGuessMode.bitrate < currentRepresentationVal.bitrate,
-                    knownStableBitrate };
+                    manual: false, knownStableBitrate: knownStableBitrate };
             }
             else if (chosenRepFromBufferSize !== null) {
-                log_1.default.debug("ABR: Choosing representation with buffer-based estimation.", chosenRepFromBufferSize.bitrate, chosenRepFromBufferSize.id);
+                log.debug("ABR: Choosing representation with buffer-based estimation.", chosenRepFromBufferSize.bitrate, chosenRepFromBufferSize.id);
                 prevEstimate.update(chosenRepFromBufferSize, bandwidthEstimate, 0 /* ABRAlgorithmType.BufferBased */);
                 return { bitrate: bandwidthEstimate,
                     representation: chosenRepFromBufferSize,
                     urgent: networkAnalyzer.isUrgent(chosenRepFromBufferSize.bitrate, currentRepresentationVal, requests, lastPlaybackObservation),
-                    knownStableBitrate };
+                    manual: false, knownStableBitrate: knownStableBitrate };
             }
             else {
-                log_1.default.debug("ABR: Choosing representation with bandwidth estimation.", chosenRepFromBandwidth.bitrate, chosenRepFromBandwidth.id);
+                log.debug("ABR: Choosing representation with bandwidth estimation.", chosenRepFromBandwidth.bitrate, chosenRepFromBandwidth.id);
                 prevEstimate.update(chosenRepFromBandwidth, bandwidthEstimate, 1 /* ABRAlgorithmType.BandwidthBased */);
                 return { bitrate: bandwidthEstimate,
                     representation: chosenRepFromBandwidth,
                     urgent: networkAnalyzer.isUrgent(chosenRepFromBandwidth.bitrate, currentRepresentationVal, requests, lastPlaybackObservation),
-                    knownStableBitrate };
+                    manual: false, knownStableBitrate: knownStableBitrate };
             }
         }
     }
     /**
      * Stop previous estimate production (if one) and restart it considering new
-     * conditions (such as a new list of Representations).
+     * conditions (such as a manual bitrate and/or a new list of Representations).
      */
     function restartEstimatesProductionFromCurrentConditions() {
-        const representations = representationsRef.getValue();
+        var representations = representationsRef.getValue();
         currentEstimatesCanceller.cancel();
-        currentEstimatesCanceller = new task_canceller_1.default();
+        currentEstimatesCanceller = new TaskCanceller();
         currentEstimatesCanceller.linkToSignal(stopAllEstimates);
-        const newRef = createEstimateReference(representations, currentEstimatesCanceller.signal);
+        var newRef = createEstimateReference(representations, currentEstimatesCanceller.signal);
         newRef.onUpdate(function onNewEstimate(newEstimate) {
             estimateRef.setValue(newEstimate);
         }, { clearSignal: currentEstimatesCanceller.signal,
@@ -343,17 +354,17 @@ function getEstimateReference({ bandwidthEstimator, context, currentRepresentati
      * @param {Object} value
      */
     function onMetric(value) {
-        const { requestDuration, segmentDuration, size, content } = value;
+        var requestDuration = value.requestDuration, segmentDuration = value.segmentDuration, size = value.size, content = value.content;
         // calculate bandwidth
         bandwidthEstimator.addSample(requestDuration, size);
         if (!content.segment.isInit) {
             // calculate "maintainability score"
-            const { segment, representation } = content;
+            var segment = content.segment, representation = content.representation;
             if (segmentDuration === undefined && !segment.complete) {
                 // We cannot know the real duration of the segment
                 return;
             }
-            const segDur = segmentDuration !== null && segmentDuration !== void 0 ? segmentDuration : segment.duration;
+            var segDur = segmentDuration !== null && segmentDuration !== void 0 ? segmentDuration : segment.duration;
             scoreCalculator.addSample(representation, requestDuration / 1000, segDur);
         }
     }
@@ -373,17 +384,16 @@ function getEstimateReference({ bandwidthEstimator, context, currentRepresentati
 /**
  * Filter representations given through filters options.
  * @param {Array.<Representation>} representations
- * @param {Object | undefined} resolutionLimit
- * @param {number | undefined} bitrateThrottle
+ * @param {number | undefined} widthLimit - Filter Object.
  * @returns {Array.<Representation>}
  */
-function getFilteredRepresentations(representations, resolutionLimit, bitrateThrottle) {
-    let filteredReps = representations;
-    if (bitrateThrottle !== undefined && bitrateThrottle < Infinity) {
-        filteredReps = (0, filter_by_bitrate_1.default)(filteredReps, bitrateThrottle);
+function getFilteredRepresentations(representations, widthLimit, bitrateThrottle) {
+    var filteredReps = representations;
+    if (bitrateThrottle < Infinity) {
+        filteredReps = filterByBitrate(filteredReps, bitrateThrottle);
     }
-    if (resolutionLimit !== undefined) {
-        filteredReps = (0, filter_by_resolution_1.default)(filteredReps, resolutionLimit);
+    if (widthLimit !== undefined) {
+        filteredReps = filterByWidth(filteredReps, widthLimit);
     }
     return filteredReps;
 }

package/dist/_esm5.processed/core/adaptive/buffer_based_chooser.d.ts

@@ -40,8 +40,8 @@ export default class BufferBasedChooser {
      */
     private _currentEstimate;
     /**
-     * Last monotonically-raising timestamp (as defined by the RxPlayer), at which
-     * the current quality was seen as too high by this algorithm.
+     * Laast timestamp, in terms of `performance.now`, at which the current
+     * quality was seen as too high by this algorithm.
      * Begins at `undefined`.
      */
     private _lastUnsuitableQualityTimestamp;