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

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,32 +14,33 @@
  * 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 getMonotonicTimeStamp from "../../utils/monotonic_timestamp";
-import getBufferLevels from "./utils/get_buffer_levels";
+Object.defineProperty(exports, "__esModule", { value: true });
+const log_1 = require("../../log");
+const array_find_index_1 = require("../../utils/array_find_index");
+const monotonic_timestamp_1 = require("../../utils/monotonic_timestamp");
+const get_buffer_levels_1 = require("./utils/get_buffer_levels");
 /**
  * Minimum amount of time, in milliseconds, during which we are blocked from
  * raising in quality after it had been considered as too high.
  */
-var MINIMUM_BLOCK_RAISE_DELAY = 6000;
+const MINIMUM_BLOCK_RAISE_DELAY = 6000;
 /**
  * Maximum amount of time, in milliseconds, during which we are blocked from
  * raising in quality after it had been considered as too high.
  */
-var MAXIMUM_BLOCK_RAISE_DELAY = 15000;
+const MAXIMUM_BLOCK_RAISE_DELAY = 15000;
 /**
  * Amount of time, in milliseconds, with which the blocking time in raising
  * the quality will be incremented if the current quality estimate is seen
  * as too unstable.
  */
-var RAISE_BLOCKING_DELAY_INCREMENT = 3000;
+const RAISE_BLOCKING_DELAY_INCREMENT = 3000;
 /**
  * Amount of time, in milliseconds, with which the blocking time in raising
  * the quality will be dcremented if the current quality estimate is seen
  * as relatively stable, until `MINIMUM_BLOCK_RAISE_DELAY` is reached.
  */
-var RAISE_BLOCKING_DELAY_DECREMENT = 1000;
+const RAISE_BLOCKING_DELAY_DECREMENT = 1000;
 /**
  * Amount of time, in milliseconds, after the "raise blocking delay" currently
  * in place (during which it is forbidden to raise up in quality), during which
@@ -55,7 +57,7 @@ var RAISE_BLOCKING_DELAY_DECREMENT = 1000;
  * Else, if takes more than 9 seconds, the raise blocking delay might be
  * decremented.
  */
-var STABILITY_CHECK_DELAY = 9000;
+const STABILITY_CHECK_DELAY = 9000;
 /**
  * Choose a bitrate based on the currently available buffer.
  *
@@ -71,37 +73,37 @@ var STABILITY_CHECK_DELAY = 9000;
  *
  * @class BufferBasedChooser
  */
-var BufferBasedChooser = /** @class */ (function () {
+class BufferBasedChooser {
     /**
      * @param {Array.<number>} bitrates
      */
-    function BufferBasedChooser(bitrates) {
-        this._levelsMap = getBufferLevels(bitrates).map(function (bl) {
+    constructor(bitrates) {
+        this._levelsMap = (0, get_buffer_levels_1.default)(bitrates).map(bl => {
             return bl + 4; // Add some buffer security as it will be used conjointly with
             // other algorithms anyway
         });
         this._bitrates = bitrates;
         this._lastUnsuitableQualityTimestamp = undefined;
         this._blockRaiseDelay = MINIMUM_BLOCK_RAISE_DELAY;
-        log.debug("ABR: Steps for buffer based chooser.", this._levelsMap.map(function (l, i) { return "bufferLevel: ".concat(l, ", bitrate: ").concat(bitrates[i]); })
+        log_1.default.debug("ABR: Steps for buffer based chooser.", this._levelsMap.map((l, i) => `bufferLevel: ${l}, bitrate: ${bitrates[i]}`)
             .join(" ,"));
     }
     /**
      * @param {Object} playbackObservation
      * @returns {number|undefined}
      */
-    BufferBasedChooser.prototype.onAddedSegment = function (playbackObservation) {
-        var bufferLevels = this._levelsMap;
-        var bitrates = this._bitrates;
-        var bufferGap = playbackObservation.bufferGap, currentBitrate = playbackObservation.currentBitrate, currentScore = playbackObservation.currentScore, speed = playbackObservation.speed;
+    onAddedSegment(playbackObservation) {
+        const bufferLevels = this._levelsMap;
+        const bitrates = this._bitrates;
+        const { bufferGap, currentBitrate, currentScore, speed } = playbackObservation;
         if (currentBitrate == null) {
             this._currentEstimate = bitrates[0];
             return;
         }
-        var currentBitrateIndex = -1;
-        for (var i = 0; i < bitrates.length; i++) {
+        let currentBitrateIndex = -1;
+        for (let i = 0; i < bitrates.length; i++) {
             // There could be bitrate duplicates. Only take the last one to simplify
-            var bitrate = bitrates[i];
+            const bitrate = bitrates[i];
             if (bitrate === currentBitrate) {
                 currentBitrateIndex = i;
             }
@@ -110,39 +112,39 @@ var BufferBasedChooser = /** @class */ (function () {
             }
         }
         if (currentBitrateIndex < 0 || bitrates.length !== bufferLevels.length) {
-            log.error("ABR: Current Bitrate not found in the calculated levels");
+            log_1.default.info("ABR: Current Bitrate not found in the calculated levels");
             this._currentEstimate = bitrates[0];
             return;
         }
-        var scaledScore;
+        let scaledScore;
         if (currentScore !== undefined) {
             scaledScore = speed === 0 ? currentScore.score : (currentScore.score / speed);
         }
-        var actualBufferGap = isFinite(bufferGap) ?
+        const actualBufferGap = isFinite(bufferGap) ?
             bufferGap :
             0;
-        var now = getMonotonicTimeStamp();
+        const now = (0, monotonic_timestamp_1.default)();
         if (actualBufferGap < bufferLevels[currentBitrateIndex] ||
             (scaledScore !== undefined && scaledScore < 1 &&
                 (currentScore === null || currentScore === void 0 ? void 0 : currentScore.confidenceLevel) === 1 /* ScoreConfidenceLevel.HIGH */)) {
-            var timeSincePrev = this._lastUnsuitableQualityTimestamp === undefined ?
+            const timeSincePrev = this._lastUnsuitableQualityTimestamp === undefined ?
                 -1 :
                 now - this._lastUnsuitableQualityTimestamp;
             if (timeSincePrev < this._blockRaiseDelay + STABILITY_CHECK_DELAY) {
-                var newDelay = this._blockRaiseDelay + RAISE_BLOCKING_DELAY_INCREMENT;
+                const newDelay = this._blockRaiseDelay + RAISE_BLOCKING_DELAY_INCREMENT;
                 this._blockRaiseDelay = Math.min(newDelay, MAXIMUM_BLOCK_RAISE_DELAY);
-                log.debug("ABR: Incrementing blocking raise in BufferBasedChooser due " +
+                log_1.default.debug("ABR: Incrementing blocking raise in BufferBasedChooser due " +
                     "to unstable quality", this._blockRaiseDelay);
             }
             else {
-                var newDelay = this._blockRaiseDelay - RAISE_BLOCKING_DELAY_DECREMENT;
+                const newDelay = this._blockRaiseDelay - RAISE_BLOCKING_DELAY_DECREMENT;
                 this._blockRaiseDelay = Math.max(MINIMUM_BLOCK_RAISE_DELAY, newDelay);
-                log.debug("ABR: Lowering quality in BufferBasedChooser", this._blockRaiseDelay);
+                log_1.default.debug("ABR: Lowering quality in BufferBasedChooser", this._blockRaiseDelay);
             }
             this._lastUnsuitableQualityTimestamp = now;
             // Security if multiple bitrates are equal, we now take the first one
-            var baseIndex = arrayFindIndex(bitrates, function (b) { return b === currentBitrate; });
-            for (var i = baseIndex - 1; i >= 0; i--) {
+            const baseIndex = (0, array_find_index_1.default)(bitrates, (b) => b === currentBitrate);
+            for (let i = baseIndex - 1; i >= 0; i--) {
                 if (actualBufferGap >= bufferLevels[i]) {
                     this._currentEstimate = bitrates[i];
                     return;
@@ -158,25 +160,25 @@ var BufferBasedChooser = /** @class */ (function () {
             this._currentEstimate = currentBitrate;
             return;
         }
-        var currentBufferLevel = bufferLevels[currentBitrateIndex];
-        var nextIndex = (function () {
-            for (var i = currentBitrateIndex + 1; i < bufferLevels.length; i++) {
+        const currentBufferLevel = bufferLevels[currentBitrateIndex];
+        const nextIndex = (() => {
+            for (let i = currentBitrateIndex + 1; i < bufferLevels.length; i++) {
                 if (bufferLevels[i] > currentBufferLevel) {
                     return i;
                 }
             }
         })();
         if (nextIndex !== undefined) {
-            var nextBufferLevel = bufferLevels[nextIndex];
+            const nextBufferLevel = bufferLevels[nextIndex];
             if (bufferGap >= nextBufferLevel) {
-                log.debug("ABR: Raising quality in BufferBasedChooser", bitrates[nextIndex]);
+                log_1.default.debug("ABR: Raising quality in BufferBasedChooser", bitrates[nextIndex]);
                 this._currentEstimate = bitrates[nextIndex];
                 return;
             }
         }
         this._currentEstimate = currentBitrate;
         return;
-    };
+    }
     /**
      * Returns the last best Representation's bitrate estimate made by the
      * `BufferBasedChooser` or `undefined` if it has no such guess for now.
@@ -185,9 +187,8 @@ var BufferBasedChooser = /** @class */ (function () {
      *
      * @returns {number|undefined}
      */
-    BufferBasedChooser.prototype.getLastEstimate = function () {
+    getLastEstimate() {
         return this._currentEstimate;
-    };
-    return BufferBasedChooser;
-}());
-export default BufferBasedChooser;
+    }
+}
+exports.default = BufferBasedChooser;

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,10 +14,11 @@
  * 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 getMonotonicTimeStamp from "../../utils/monotonic_timestamp";
-import { estimateRequestBandwidth } from "./network_analyzer";
+Object.defineProperty(exports, "__esModule", { value: true });
+const log_1 = require("../../log");
+const array_find_index_1 = require("../../utils/array_find_index");
+const monotonic_timestamp_1 = require("../../utils/monotonic_timestamp");
+const network_analyzer_1 = require("./network_analyzer");
 /**
  * Estimate which Representation should be played based on risky "guesses".
  *
@@ -30,13 +32,13 @@ import { estimateRequestBandwidth } from "./network_analyzer";
  * don't work (e.g.  low-latency contents).
  * @class GuessBasedChooser
  */
-var GuessBasedChooser = /** @class */ (function () {
+class GuessBasedChooser {
     /**
      * Create a new `GuessBasedChooser`.
      * @param {Object} scoreCalculator
      * @param {Object} prevEstimate
      */
-    function GuessBasedChooser(scoreCalculator, prevEstimate) {
+    constructor(scoreCalculator, prevEstimate) {
         this._scoreCalculator = scoreCalculator;
         this._lastAbrEstimate = prevEstimate;
         this._consecutiveWrongGuesses = 0;
@@ -61,9 +63,9 @@ var GuessBasedChooser = /** @class */ (function () {
      * 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;
+    getGuess(representations, observation, currentRepresentation, incomingBestBitrate, requests) {
+        const { bufferGap, speed } = observation;
+        const lastChosenRep = this._lastAbrEstimate.representation;
         if (lastChosenRep === null) {
             return null; // There's nothing to base our guess on
         }
@@ -78,13 +80,13 @@ var GuessBasedChooser = /** @class */ (function () {
             }
             return null;
         }
-        var scoreData = this._scoreCalculator.getEstimate(currentRepresentation);
+        const scoreData = this._scoreCalculator.getEstimate(currentRepresentation);
         if (this._lastAbrEstimate.algorithmType !== 2 /* ABRAlgorithmType.GuessBased */) {
             if (scoreData === undefined) {
                 return null; // not enough information to start guessing
             }
             if (this._canGuessHigher(bufferGap, speed, scoreData)) {
-                var nextRepresentation = getNextRepresentation(representations, currentRepresentation);
+                const nextRepresentation = getNextRepresentation(representations, currentRepresentation);
                 if (nextRepresentation !== null) {
                     return nextRepresentation;
                 }
@@ -93,18 +95,18 @@ var GuessBasedChooser = /** @class */ (function () {
         }
         // 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);
+            log_1.default.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);
+        const shouldStopGuess = this._shouldStopGuess(currentRepresentation, scoreData, bufferGap, requests);
         if (shouldStopGuess) {
             // Block guesses for a time
             this._consecutiveWrongGuesses++;
-            this._blockGuessesUntil = getMonotonicTimeStamp() +
+            this._blockGuessesUntil = (0, monotonic_timestamp_1.default)() +
                 Math.min(this._consecutiveWrongGuesses * 15000, 120000);
             return getPreviousRepresentation(representations, currentRepresentation);
         }
@@ -112,13 +114,13 @@ var GuessBasedChooser = /** @class */ (function () {
             return currentRepresentation;
         }
         if (this._canGuessHigher(bufferGap, speed, scoreData)) {
-            var nextRepresentation = getNextRepresentation(representations, currentRepresentation);
+            const nextRepresentation = getNextRepresentation(representations, currentRepresentation);
             if (nextRepresentation !== null) {
                 return nextRepresentation;
             }
         }
         return currentRepresentation;
-    };
+    }
     /**
      * Returns `true` if we've enough confidence on the current situation to make
      * a higher guess.
@@ -127,13 +129,12 @@ var GuessBasedChooser = /** @class */ (function () {
      * @param {Array} scoreData
      * @returns {boolean}
      */
-    GuessBasedChooser.prototype._canGuessHigher = function (bufferGap, speed, _a) {
-        var score = _a.score, confidenceLevel = _a.confidenceLevel;
+    _canGuessHigher(bufferGap, speed, { score, confidenceLevel }) {
         return isFinite(bufferGap) && bufferGap >= 2.5 &&
-            getMonotonicTimeStamp() > this._blockGuessesUntil &&
+            (0, monotonic_timestamp_1.default)() > this._blockGuessesUntil &&
             confidenceLevel === 1 /* ScoreConfidenceLevel.HIGH */ &&
             score / speed > 1.01;
-    };
+    }
     /**
      * Returns `true` if the pending guess of `lastGuess` seems to not
      * be maintainable and as such should be stopped.
@@ -143,20 +144,19 @@ var GuessBasedChooser = /** @class */ (function () {
      * @param {Array.<Object>} requests
      * @returns {boolean}
      */
-    GuessBasedChooser.prototype._shouldStopGuess = function (lastGuess, scoreData, bufferGap, requests) {
+    _shouldStopGuess(lastGuess, scoreData, bufferGap, requests) {
         if (scoreData !== undefined && scoreData.score < 1.01) {
             return true;
         }
         else if ((scoreData === undefined || scoreData.score < 1.2) && bufferGap < 0.6) {
             return true;
         }
-        var guessedRepresentationRequests = requests.filter(function (req) {
+        const guessedRepresentationRequests = requests.filter(req => {
             return req.content.representation.id === lastGuess.id;
         });
-        var now = getMonotonicTimeStamp();
-        for (var _i = 0, guessedRepresentationRequests_1 = guessedRepresentationRequests; _i < guessedRepresentationRequests_1.length; _i++) {
-            var req = guessedRepresentationRequests_1[_i];
-            var requestElapsedTime = now - req.requestTimestamp;
+        const now = (0, monotonic_timestamp_1.default)();
+        for (const req of guessedRepresentationRequests) {
+            const requestElapsedTime = now - req.requestTimestamp;
             if (req.content.segment.isInit) {
                 if (requestElapsedTime > 1000) {
                     return true;
@@ -166,15 +166,15 @@ var GuessBasedChooser = /** @class */ (function () {
                 return true;
             }
             else {
-                var fastBw = estimateRequestBandwidth(req);
+                const fastBw = (0, network_analyzer_1.estimateRequestBandwidth)(req);
                 if (fastBw !== undefined && fastBw < lastGuess.bitrate * 0.8) {
                     return true;
                 }
             }
         }
         return false;
-    };
-    GuessBasedChooser.prototype._isLastGuessValidated = function (lastGuess, incomingBestBitrate, scoreData) {
+    }
+    _isLastGuessValidated(lastGuess, incomingBestBitrate, scoreData) {
         if (scoreData !== undefined &&
             scoreData.confidenceLevel === 1 /* ScoreConfidenceLevel.HIGH */ &&
             scoreData.score > 1.5) {
@@ -183,10 +183,9 @@ var GuessBasedChooser = /** @class */ (function () {
         return incomingBestBitrate >= lastGuess.bitrate &&
             (this._lastMaintanableBitrate === null ||
                 this._lastMaintanableBitrate < lastGuess.bitrate);
-    };
-    return GuessBasedChooser;
-}());
-export default GuessBasedChooser;
+    }
+}
+exports.default = GuessBasedChooser;
 /**
  * From the array of Representations given, returns the Representation with a
  * bitrate immediately superior to the current one.
@@ -201,13 +200,10 @@ export default GuessBasedChooser;
  * @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;
-    });
+    const len = representations.length;
+    let index = (0, array_find_index_1.default)(representations, ({ id }) => id === currentRepresentation.id);
     if (index < 0) {
-        log.error("ABR: Current Representation not found.");
+        log_1.default.error("ABR: Current Representation not found.");
         return null;
     }
     while (++index < len) {
@@ -226,12 +222,9 @@ function getNextRepresentation(representations, currentRepresentation) {
  * @returns {Object|null}
  */
 function getPreviousRepresentation(representations, currentRepresentation) {
-    var index = arrayFindIndex(representations, function (_a) {
-        var id = _a.id;
-        return id === currentRepresentation.id;
-    });
+    let index = (0, array_find_index_1.default)(representations, ({ id }) => id === currentRepresentation.id);
     if (index < 0) {
-        log.error("ABR: Current Representation not found.");
+        log_1.default.error("ABR: Current Representation not found.");
         return null;
     }
     while (--index >= 0) {

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,5 +14,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import AdaptiveRepresentationSelector from "./adaptive_representation_selector";
-export default AdaptiveRepresentationSelector;
+Object.defineProperty(exports, "__esModule", { value: true });
+const adaptive_representation_selector_1 = require("./adaptive_representation_selector");
+exports.default = adaptive_representation_selector_1.default;