rx-player 3.25.2 → 3.26.3-dev.2022021400

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

@@ -13,11 +13,20 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { of as observableOf, } from "rxjs";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import { combineLatest as observableCombineLatest, map, of as observableOf, } from "rxjs";
 import log from "../../log";
+import objectAssign from "../../utils/object_assign";
 import takeFirstSet from "../../utils/take_first_set";
 import BandwidthEstimator from "./bandwidth_estimator";
-import createFilters from "./create_filters";
 import RepresentationEstimator from "./representation_estimator";
 /**
  * Adaptive BitRate Manager.
@@ -45,27 +54,19 @@ var ABRManager = /** @class */ (function () {
      * state).
      * @param {string} type
      * @param {Array.<Representation>} representations
-     * @param {Observable<Object>} clock$
+     * @param {Observable<Object>} observation$
      * @param {Observable<Object>} streamEvents$
      * @returns {Observable}
      */
-    ABRManager.prototype.get$ = function (type, representations, clock$, streamEvents$) {
+    ABRManager.prototype.get$ = function (type, representations, observation$, streamEvents$) {
+        var _a, _b, _c;
         var bandwidthEstimator = this._getBandwidthEstimator(type);
-        var manualBitrate$ = takeFirstSet(this._manualBitrates[type], observableOf(-1));
-        var minAutoBitrate$ = takeFirstSet(this._minAutoBitrates[type], observableOf(0));
-        var maxAutoBitrate$ = takeFirstSet(this._maxAutoBitrates[type], observableOf(Infinity));
+        var manualBitrate$ = takeFirstSet((_a = this._manualBitrates[type]) === null || _a === void 0 ? void 0 : _a.asObservable(), observableOf(-1));
+        var minAutoBitrate$ = takeFirstSet((_b = this._minAutoBitrates[type]) === null || _b === void 0 ? void 0 : _b.asObservable(), observableOf(0));
+        var maxAutoBitrate$ = takeFirstSet((_c = this._maxAutoBitrates[type]) === null || _c === void 0 ? void 0 : _c.asObservable(), observableOf(Infinity));
         var initialBitrate = takeFirstSet(this._initialBitrates[type], 0);
         var filters$ = createFilters(this._throttlers.limitWidth[type], this._throttlers.throttleBitrate[type], this._throttlers.throttle[type]);
-        return RepresentationEstimator({ bandwidthEstimator: bandwidthEstimator,
-            streamEvents$: streamEvents$,
-            clock$: clock$,
-            filters$: filters$,
-            initialBitrate: initialBitrate,
-            manualBitrate$: manualBitrate$,
-            minAutoBitrate$: minAutoBitrate$,
-            maxAutoBitrate$: maxAutoBitrate$,
-            representations: representations,
-            lowLatencyMode: this._lowLatencyMode });
+        return RepresentationEstimator({ bandwidthEstimator: bandwidthEstimator, streamEvents$: streamEvents$, observation$: observation$, filters$: filters$, initialBitrate: initialBitrate, manualBitrate$: manualBitrate$, minAutoBitrate$: minAutoBitrate$, maxAutoBitrate$: maxAutoBitrate$, representations: representations, lowLatencyMode: this._lowLatencyMode });
     };
     /**
      * @param {string} bufferType
@@ -84,3 +85,32 @@ var ABRManager = /** @class */ (function () {
     return ABRManager;
 }());
 export default ABRManager;
+/**
+ * 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}
+ */
+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, false));
+        })) :
+        observableOf({});
+}

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

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 import config from "../../config";
-import EWMA from "./ewma";
+import EWMA from "./utils/ewma";
 var ABR_MINIMUM_TOTAL_BYTES = config.ABR_MINIMUM_TOTAL_BYTES, ABR_MINIMUM_CHUNK_SIZE = config.ABR_MINIMUM_CHUNK_SIZE, ABR_FAST_EMA = config.ABR_FAST_EMA, ABR_SLOW_EMA = config.ABR_SLOW_EMA;
 /**
  * Calculate a mean bandwidth based on the bytes downloaded and the amount

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

@@ -13,8 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Observable } from "rxjs";
-import { IBufferBasedChooserClockTick } from "./get_estimate_from_buffer_levels";
 /**
  * Choose a bitrate based on the currently available buffer.
  *
@@ -26,8 +24,32 @@ import { IBufferBasedChooserClockTick } from "./get_estimate_from_buffer_levels"
  * "maintanable" or not.
  * If so, we may switch to a better quality, or conversely to a worse quality.
  *
- * @param {Observable} update$
- * @param {Array.<number>} bitrates
- * @returns {Observable}
+ * @class BufferBasedChooser
  */
-export default function BufferBasedChooser(update$: Observable<IBufferBasedChooserClockTick>, bitrates: number[]): Observable<number | undefined>;
+export default class BufferBasedChooser {
+    private _levelsMap;
+    private _bitrates;
+    /**
+     * @param {Array.<number>} number;
+     */
+    constructor(bitrates: number[]);
+    /**
+     * @param {Object} playbackObservation
+     * @returns {number|undefined}
+     */
+    getEstimate(playbackObservation: IBufferBasedChooserPlaybackObservation): number | undefined;
+}
+/** Playback observation needed by the `BufferBasedChooser`. */
+export interface IBufferBasedChooserPlaybackObservation {
+    /**
+     * Difference in seconds between the current position and the next
+     * non-buffered position
+     */
+    bufferGap: number;
+    /** The bitrate of the currently downloaded segments, in bps. */
+    currentBitrate?: number | undefined;
+    /** The "maintainability score" of the currently downloaded segments. */
+    currentScore?: number | undefined;
+    /** Playback rate wanted */
+    speed: number;
+}

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

@@ -13,10 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { map } from "rxjs/operators";
 import log from "../../log";
+import arrayFindIndex from "../../utils/array_find_index";
 import getBufferLevels from "./get_buffer_levels";
-import getEstimateFromBufferLevels from "./get_estimate_from_buffer_levels";
 /**
  * Choose a bitrate based on the currently available buffer.
  *
@@ -28,14 +27,66 @@ import getEstimateFromBufferLevels from "./get_estimate_from_buffer_levels";
  * "maintanable" or not.
  * If so, we may switch to a better quality, or conversely to a worse quality.
  *
- * @param {Observable} update$
- * @param {Array.<number>} bitrates
- * @returns {Observable}
+ * @class BufferBasedChooser
  */
-export default function BufferBasedChooser(update$, bitrates) {
-    var levelsMap = getBufferLevels(bitrates);
-    log.debug("ABR: Steps for buffer based chooser.", levelsMap.map(function (l, i) { return ({ bufferLevel: l, bitrate: bitrates[i] }); }));
-    return update$.pipe(map(function (clockTick) {
-        return getEstimateFromBufferLevels(clockTick, bitrates, levelsMap);
-    }));
-}
+var BufferBasedChooser = /** @class */ (function () {
+    /**
+     * @param {Array.<number>} number;
+     */
+    function BufferBasedChooser(bitrates) {
+        this._levelsMap = getBufferLevels(bitrates);
+        this._bitrates = bitrates;
+        log.debug("ABR: Steps for buffer based chooser.", this._levelsMap.map(function (l, i) { return ({ bufferLevel: l, bitrate: bitrates[i] }); }));
+    }
+    /**
+     * @param {Object} playbackObservation
+     * @returns {number|undefined}
+     */
+    BufferBasedChooser.prototype.getEstimate = function (playbackObservation) {
+        var bufferLevels = this._levelsMap;
+        var bitrates = this._bitrates;
+        var bufferGap = playbackObservation.bufferGap, currentBitrate = playbackObservation.currentBitrate, currentScore = playbackObservation.currentScore, speed = playbackObservation.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;
+    };
+    return BufferBasedChooser;
+}());
+export default BufferBasedChooser;

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

@@ -37,6 +37,9 @@ export default function getBufferLevels(bitrates) {
             return 0;
         }
         var boundedIndex = Math.min(Math.max(1, index), bitrates.length - 1);
+        if (bitrates[boundedIndex] === bitrates[boundedIndex - 1]) {
+            return minBufferLevelForBitrate(index - 1);
+        }
         return Vp * (gp + (bitrates[boundedIndex] * utilities[boundedIndex - 1] -
             bitrates[boundedIndex - 1] * utilities[boundedIndex]) / (bitrates[boundedIndex] -
             bitrates[boundedIndex - 1])) + 4;

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

@@ -0,0 +1,95 @@
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Representation } from "../../manifest";
+import LastEstimateStorage from "./last_estimate_storage";
+import { IRequestInfo } from "./pending_requests_store";
+import RepresentationScoreCalculator 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;
+    private _scoreCalculator;
+    private _consecutiveWrongGuesses;
+    private _blockGuessesUntil;
+    private _lastMaintanableBitrate;
+    /**
+     * Create a new `GuessBasedChooser`.
+     * @param {Object} scoreCalculator
+     * @param {Object} prevEstimate
+     */
+    constructor(scoreCalculator: RepresentationScoreCalculator, prevEstimate: LastEstimateStorage);
+    /**
+     * 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).
+     */
+    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;
+    /**
+     * 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;
+    /**
+     * 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;
+    private _isLastGuessValidated;
+}

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

@@ -0,0 +1,242 @@
+/**
+ * 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";
+import { estimateRequestBandwidth } from "./network_analyzer";
+/**
+ * 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
+ */
+var GuessBasedChooser = /** @class */ (function () {
+    /**
+     * Create a new `GuessBasedChooser`.
+     * @param {Object} scoreCalculator
+     * @param {Object} prevEstimate
+     */
+    function GuessBasedChooser(scoreCalculator, prevEstimate) {
+        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).
+     */
+    GuessBasedChooser.prototype.getGuess = function (representations, observation, currentRepresentation, incomingBestBitrate, requests) {
+        var bufferGap = observation.bufferGap, speed = observation.speed;
+        var 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 === 2 /* GuessBased */) {
+                if (this._lastAbrEstimate.representation !== null) {
+                    this._lastMaintanableBitrate = this._lastAbrEstimate.representation.bitrate;
+                }
+                this._consecutiveWrongGuesses = 0;
+            }
+            return null;
+        }
+        var scoreData = this._scoreCalculator.getEstimate(currentRepresentation);
+        if (this._lastAbrEstimate.algorithmType !== 2 /* GuessBased */) {
+            if (scoreData === undefined) {
+                return null; // not enough information to start guessing
+            }
+            if (this._canGuessHigher(bufferGap, speed, scoreData)) {
+                var 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;
+        }
+        var 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)) {
+            var 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}
+     */
+    GuessBasedChooser.prototype._canGuessHigher = function (bufferGap, speed, _a) {
+        var score = _a[0], scoreConfidenceLevel = _a[1];
+        return isFinite(bufferGap) && bufferGap >= 2.5 &&
+            performance.now() > this._blockGuessesUntil &&
+            scoreConfidenceLevel === 1 /* 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}
+     */
+    GuessBasedChooser.prototype._shouldStopGuess = function (lastGuess, scoreData, bufferGap, requests) {
+        if (scoreData !== undefined && scoreData[0] < 1.01) {
+            return true;
+        }
+        else if ((scoreData === undefined || scoreData[0] < 1.2) && bufferGap < 0.6) {
+            return true;
+        }
+        var guessedRepresentationRequests = requests.filter(function (req) {
+            return req.content.representation.id === lastGuess.id;
+        });
+        var now = performance.now();
+        for (var _i = 0, guessedRepresentationRequests_1 = guessedRepresentationRequests; _i < guessedRepresentationRequests_1.length; _i++) {
+            var req = guessedRepresentationRequests_1[_i];
+            var 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 {
+                var fastBw = estimateRequestBandwidth(req);
+                if (fastBw !== undefined && fastBw < lastGuess.bitrate * 0.8) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    };
+    GuessBasedChooser.prototype._isLastGuessValidated = function (lastGuess, incomingBestBitrate, scoreData) {
+        if (scoreData !== undefined &&
+            scoreData[1] === 1 /* HIGH */ &&
+            scoreData[0] > 1.5) {
+            return true;
+        }
+        return incomingBestBitrate >= lastGuess.bitrate &&
+            (this._lastMaintanableBitrate === null ||
+                this._lastMaintanableBitrate < lastGuess.bitrate);
+    };
+    return GuessBasedChooser;
+}());
+export default GuessBasedChooser;
+/**
+ * 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, currentRepresentation) {
+    var len = representations.length;
+    var index = arrayFindIndex(representations, function (_a) {
+        var id = _a.id;
+        return 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, currentRepresentation) {
+    var index = arrayFindIndex(representations, function (_a) {
+        var id = _a.id;
+        return 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/dist/_esm5.processed/core/abr/index.d.ts

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import ABRManager, { IABRManagerArguments, IABRManagerClockTick } from "./abr_manager";
-export { IABRAddedSegmentEvent, IABRStreamEvents, IABREstimate, IABRMetricsEvent, IABRRepresentationChangeEvent, IABRRequestBeginEvent, IABRRequestEndEvent, IABRRequestProgressEvent, } from "./representation_estimator";
+import ABRManager, { IABRManagerArguments, IABRManagerPlaybackObservation } from "./abr_manager";
+export { IABRAddedSegmentEvent, IABREstimate, IABRMetricsEvent, IABRMetricsEventValue, IABRRepresentationChangeEvent, IABRRequestBeginEvent, IABRRequestBeginEventValue, IABRRequestEndEvent, IABRRequestEndEventValue, IABRRequestProgressEvent, IABRRequestProgressEventValue, IABRStreamEvents, } from "./representation_estimator";
 export default ABRManager;
-export { IABRManagerArguments, IABRManagerClockTick, };
+export { IABRManagerArguments, IABRManagerPlaybackObservation, };

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

@@ -0,0 +1,61 @@
+/**
+ * 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.
+     */
+    bandwidth: number | undefined;
+    /**
+     * Estimated Representation in the last estimate.
+     * `null` if no estimate has been performed yet.
+     */
+    representation: Representation | null;
+    /** Algorithm type used to make the last Representation estimate. */
+    algorithmType: ABRAlgorithmType;
+    constructor();
+    /**
+     * 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`.
+     */
+    update(representation: Representation, bandwidth: number | undefined, algorithmType: ABRAlgorithmType): void;
+}
+/** Identify an algorithm used to perform a Representation estimate.  */
+export declare const enum ABRAlgorithmType {
+    /**
+     * Buffer-based algorithm using mostly the size of the buffer to determine the
+     * best Representation.
+     */
+    BufferBased = 0,
+    /**
+     * Bandwidth-based algorithm using mostly the speed at which segments are
+     * downloaded to determine the best Representation.
+     */
+    BandwidthBased = 1,
+    /**
+     * Guess-based algorithm, which iterates through Representation and
+     * try to find the best one empirically.
+     */
+    GuessBased = 2,
+    /** None of the other or no algorithm was used yet. */
+    None = 3
+}