rx-player 3.26.1 → 3.26.2

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

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export interface IBufferBasedChooserClockTick {
+export interface IBufferBasedChooserPlaybackObservation {
     bufferGap: number;
     currentBitrate?: number;
     currentScore?: number;
@@ -21,9 +21,9 @@ export interface IBufferBasedChooserClockTick {
 }
 /**
  * From the buffer gap, choose a representation.
- * @param {Object} clockTick
+ * @param {Object} playbackObservation
  * @param {Array.<Number>} bitrates
  * @param {Array.<Number>} bufferLevels
  * @returns {Object|undefined}
  */
-export default function getEstimateFromBufferLevels(clockTick: IBufferBasedChooserClockTick, bitrates: number[], bufferLevels: number[]): number | undefined;
+export default function getEstimateFromBufferLevels(playbackObservation: IBufferBasedChooserPlaybackObservation, bitrates: number[], bufferLevels: number[]): number | undefined;

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

@@ -17,13 +17,13 @@ import log from "../../log";
 import arrayFindIndex from "../../utils/array_find_index";
 /**
  * From the buffer gap, choose a representation.
- * @param {Object} clockTick
+ * @param {Object} playbackObservation
  * @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;
+export default function getEstimateFromBufferLevels(playbackObservation, bitrates, bufferLevels) {
+    var bufferGap = playbackObservation.bufferGap, currentBitrate = playbackObservation.currentBitrate, currentScore = playbackObservation.currentScore, speed = playbackObservation.speed;
     if (currentBitrate == null) {
         return bitrates[0];
     }

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
+}

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

@@ -0,0 +1,37 @@
+/**
+ * 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.
+ */
+/** Stores the last estimate made by the `RepresentationEstimator`. */
+var LastEstimateStorage = /** @class */ (function () {
+    function LastEstimateStorage() {
+        this.bandwidth = undefined;
+        this.representation = null;
+        this.algorithmType = 3 /* 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`.
+     */
+    LastEstimateStorage.prototype.update = function (representation, bandwidth, algorithmType) {
+        this.representation = representation;
+        this.bandwidth = bandwidth;
+        this.algorithmType = algorithmType;
+    };
+    return LastEstimateStorage;
+}());
+export default LastEstimateStorage;

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

@@ -33,12 +33,21 @@ interface IPlaybackConditionsInfo {
     /** `duration` property of the HTMLMediaElement on which the content plays. */
     duration: number;
 }
+/**
+ * Estimate the __VERY__ recent bandwidth based on a single unfinished request.
+ * Useful when the current bandwidth seemed to have fallen quickly.
+ *
+ * @param {Object} request
+ * @returns {number|undefined}
+ */
+export declare function estimateRequestBandwidth(request: IRequestInfo): number | undefined;
 /**
  * Analyze the current network conditions and give a bandwidth estimate as well
  * as a maximum bitrate a Representation should be.
  * @class NetworkAnalyzer
  */
 export default class NetworkAnalyzer {
+    private _lowLatencyMode;
     private _inStarvationMode;
     private _initialBitrate;
     private _config;
@@ -47,11 +56,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}
      */
     getBandwidthEstimate(playbackInfo: IPlaybackConditionsInfo, bandwidthEstimator: BandwidthEstimator, currentRepresentation: Representation | null, currentRequests: IRequestInfo[], lastEstimatedBitrate: number | undefined): {
@@ -60,8 +74,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}
      */
     isUrgent(bitrate: number, currentRepresentation: Representation | null, currentRequests: IRequestInfo[], playbackInfo: IPlaybackConditionsInfo): boolean;