rx-player 3.27.0-dev.2022032100 → 3.27.0

package/dist/_esm5.processed/core/stream/representation/get_buffer_status.js

@@ -55,8 +55,8 @@ export default function getBufferStatus(content, wantedStartPosition, playbackOb
     /** Callback allowing to retrieve a segment's history in the buffer. */
     var getBufferedHistory = segmentBuffer.getSegmentHistory.bind(segmentBuffer);
     /** List of segments we will need to download. */
-    var _b = getNeededSegments({ content: content, bufferedSegments: bufferedSegments, currentPlaybackTime: currentPlaybackTime, fastSwitchThreshold: fastSwitchThreshold, getBufferedHistory: getBufferedHistory, neededRange: neededRange, segmentsBeingPushed: segmentsBeingPushed, maxBufferSize: maxBufferSize }), neededSegments = _b.neededSegments, isBufferFull = _b.isBufferFull;
-    var prioritizedNeededSegments = neededSegments.map(function (segment) { return ({
+    var _b = getNeededSegments({ content: content, bufferedSegments: bufferedSegments, currentPlaybackTime: currentPlaybackTime, fastSwitchThreshold: fastSwitchThreshold, getBufferedHistory: getBufferedHistory, neededRange: neededRange, segmentsBeingPushed: segmentsBeingPushed, maxBufferSize: maxBufferSize }), segmentsToLoad = _b.segmentsToLoad, segmentsOnHold = _b.segmentsOnHold, isBufferFull = _b.isBufferFull;
+    var prioritizedNeededSegments = segmentsToLoad.map(function (segment) { return ({
         priority: getSegmentPriority(segment.time, wantedStartPosition),
         segment: segment,
     }); });
@@ -68,7 +68,8 @@ export default function getBufferStatus(content, wantedStartPosition, playbackOb
     var lastPosition = representation.index.getLastPosition();
     if (!representation.index.isInitialized() ||
         period.end === undefined ||
-        prioritizedNeededSegments.length > 0) {
+        prioritizedNeededSegments.length > 0 ||
+        segmentsOnHold.length > 0) {
         hasFinishedLoading = false;
     }
     else {
@@ -112,6 +113,11 @@ export default function getBufferStatus(content, wantedStartPosition, playbackOb
         if (segmentsBeingPushed.length > 0) {
             nextSegmentStart = Math.min.apply(Math, segmentsBeingPushed.map(function (info) { return info.segment.time; }));
         }
+        if (segmentsOnHold.length > 0) {
+            nextSegmentStart = nextSegmentStart !== null ?
+                Math.min(nextSegmentStart, segmentsOnHold[0].time) :
+                segmentsOnHold[0].time;
+        }
         if (prioritizedNeededSegments.length > 0) {
             nextSegmentStart = nextSegmentStart !== null ?
                 Math.min(nextSegmentStart, prioritizedNeededSegments[0].segment.time) :

package/dist/_esm5.processed/core/stream/representation/get_needed_segments.d.ts

@@ -65,7 +65,17 @@ export interface IGetNeededSegmentsArguments {
     getBufferedHistory: (context: IChunkContext) => IBufferedHistoryEntry[];
 }
 interface INeededSegments {
-    neededSegments: ISegment[];
+    /** Segments that should be loaded right now, by chronological order. */
+    segmentsToLoad: ISegment[];
+    /**
+     * Segments that should be loaded, but not right now, due to some other
+     * constraints, such as memory limitations.
+     */
+    segmentsOnHold: ISegment[];
+    /**
+     * If `true` the buffer is currently full according to the given limits.
+     * Memory should be freed if possible, for example by cleaning the buffers.
+     */
     isBufferFull: boolean;
 }
 /**

package/dist/_esm5.processed/core/stream/representation/get_needed_segments.js

@@ -32,8 +32,6 @@ export default function getNeededSegments(_a) {
     var bufferedSegments = _a.bufferedSegments, content = _a.content, currentPlaybackTime = _a.currentPlaybackTime, fastSwitchThreshold = _a.fastSwitchThreshold, getBufferedHistory = _a.getBufferedHistory, neededRange = _a.neededRange, segmentsBeingPushed = _a.segmentsBeingPushed, maxBufferSize = _a.maxBufferSize;
     var representation = content.representation;
     var availableBufferSize = getAvailableBufferSize(bufferedSegments, segmentsBeingPushed, maxBufferSize);
-    // Current buffer length in seconds
-    var bufferLength = getBufferLength(bufferedSegments, segmentsBeingPushed);
     var availableSegmentsForRange = representation.index
         .getSegments(neededRange.start, neededRange.end - neededRange.start);
     // Remove from `bufferedSegments` any segments we would prefer to replace:
@@ -63,15 +61,16 @@ export default function getNeededSegments(_a) {
         }
         return true;
     });
-    var _b = config.getCurrent(), MINIMUM_SEGMENT_SIZE = _b.MINIMUM_SEGMENT_SIZE, MIN_BUFFER_LENGTH = _b.MIN_BUFFER_LENGTH, MIN_BUFFER_DISTANCE_BEFORE_CLEAN_UP = _b.MIN_BUFFER_DISTANCE_BEFORE_CLEAN_UP;
-    var isMemorySaturated = false;
+    var _b = config.getCurrent(), MINIMUM_SEGMENT_SIZE = _b.MINIMUM_SEGMENT_SIZE, MIN_BUFFER_AHEAD = _b.MIN_BUFFER_AHEAD;
+    var shouldStopLoadingSegments = false;
     /**
      * Epsilon compensating for rounding errors when comparing the start and end
      * time of multiple segments.
      */
     var ROUNDING_ERROR = Math.min(1 / 60, MINIMUM_SEGMENT_SIZE);
     var isBufferFull = false;
-    var neededSegments = availableSegmentsForRange.filter(function (segment) {
+    var segmentsOnHold = [];
+    var segmentsToLoad = availableSegmentsForRange.filter(function (segment) {
         var contentObject = objectAssign({ segment: segment }, content);
         // First, check that the segment is not already being pushed
         if (segmentsBeingPushed.length > 0) {
@@ -85,17 +84,8 @@ export default function getNeededSegments(_a) {
         if (segment.isInit) {
             return true; // never skip initialization segments
         }
-        if (isMemorySaturated) {
-            // If we are so saturated in memory
-            // That we cannot download atleast till
-            // NeededRange.Start ( current position ) + a CONST
-            // Then the buffer is full
-            if (time < neededRange.start + MIN_BUFFER_DISTANCE_BEFORE_CLEAN_UP) {
-                isBufferFull = true;
-            }
-        }
-        if (isMemorySaturated &&
-            bufferLength > MIN_BUFFER_LENGTH) {
+        if (shouldStopLoadingSegments) {
+            segmentsOnHold.push(segment);
             return false;
         }
         if (segment.complete && duration < MINIMUM_SEGMENT_SIZE) {
@@ -138,27 +128,34 @@ export default function getNeededSegments(_a) {
                 }
             }
         }
+        var estimatedSegmentSize = (duration * content.representation.bitrate) / 8000;
+        if (availableBufferSize - estimatedSegmentSize < 0) {
+            isBufferFull = true;
+            if (time > neededRange.start + MIN_BUFFER_AHEAD) {
+                shouldStopLoadingSegments = true;
+                segmentsOnHold.push(segment);
+                return false;
+            }
+        }
         // check if there is an hole in place of the segment currently
         for (var i = 0; i < segmentsToKeep.length; i++) {
             var completeSeg = segmentsToKeep[i];
-            if (completeSeg.end > time) {
-                // `true` if `completeSeg` starts too far after `time`
-                return completeSeg.start > time + ROUNDING_ERROR ||
-                    // `true` if `completeSeg` ends too soon before `end`
-                    getLastContiguousSegment(segmentsToKeep, i).end < end - ROUNDING_ERROR;
+            // For the first already-loaded segment, take the first one ending after
+            // this one' s start
+            if ((completeSeg.end + ROUNDING_ERROR) > time) {
+                var shouldLoad = completeSeg.start > time + ROUNDING_ERROR ||
+                    getLastContiguousSegment(segmentsToKeep, i).end <
+                        end - ROUNDING_ERROR;
+                if (shouldLoad) {
+                    availableBufferSize -= estimatedSegmentSize;
+                }
+                return shouldLoad;
             }
         }
-        var estimatedSegmentSize = (duration * content.representation.bitrate) / 8000;
-        if (availableBufferSize - estimatedSegmentSize < 0 &&
-            bufferLength > MIN_BUFFER_LENGTH) {
-            isMemorySaturated = true;
-            return false;
-        }
         availableBufferSize -= estimatedSegmentSize;
-        bufferLength += duration;
         return true;
     });
-    return { neededSegments: neededSegments, isBufferFull: isBufferFull };
+    return { segmentsToLoad: segmentsToLoad, segmentsOnHold: segmentsOnHold, isBufferFull: isBufferFull };
 }
 /**
  * Compute the estimated available buffer size in memory in kilobytes
@@ -178,28 +175,13 @@ function getAvailableBufferSize(bufferedSegments, segmentsBeingPushed, maxVideoB
     }, 0);
     return bufferedSegments.reduce(function (size, chunk) {
         if (chunk.chunkSize !== undefined) {
-            return size - (chunk.chunkSize / 8000);
+            return size - (chunk.chunkSize / 1000);
         }
         else {
             return size;
         }
     }, availableBufferSize);
 }
-/**
- * Compute the length of the buffer in seconds
- * @param bufferedSegments
- * @param segmentsBeingPushed
- * @returns bufferLength in seconds
- */
-function getBufferLength(bufferedSegments, segmentsBeingPushed) {
-    var bufferLength = bufferedSegments.reduce(function (length, segment) {
-        return length + (segment.end - segment.start);
-    }, 0);
-    var bufferBeingPushed = segmentsBeingPushed.reduce(function (length, segment) {
-        return length + segment.segment.duration;
-    }, 0);
-    return bufferLength + bufferBeingPushed;
-}
 /**
  * From the given array of buffered chunks (`bufferedSegments`) returns the last
  * buffered chunk contiguous with the one at the `startIndex` index given.

package/dist/_esm5.processed/core/stream/representation/representation_stream.js

@@ -166,10 +166,12 @@ export default function RepresentationStream(_a) {
         var UPTO_CURRENT_POSITION_CLEANUP = config.getCurrent().UPTO_CURRENT_POSITION_CLEANUP;
         if (status.isBufferFull) {
             var gcedPosition = Math.max(0, wantedStartPosition - UPTO_CURRENT_POSITION_CLEANUP);
-            bufferRemoval = segmentBuffer
-                .removeBuffer(0, gcedPosition)
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-                .pipe(ignoreElements());
+            if (gcedPosition > 0) {
+                bufferRemoval = segmentBuffer
+                    .removeBuffer(0, gcedPosition)
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+                    .pipe(ignoreElements());
+            }
         }
         return status.shouldRefreshManifest ?
             observableConcat(observableOf(EVENTS.needsManifestRefresh()), bufferStatusEvt, bufferRemoval) :

package/dist/_esm5.processed/default_config.d.ts

@@ -934,33 +934,6 @@ declare const DEFAULT_CONFIG: {
      * This wasn't battle-tested however.
      */
     EME_MAX_STORED_PERSISTENT_SESSION_INFORMATION: number;
-    /**
-     * Attempts to closing a MediaKeySession can fail, most likely because the
-     * MediaKeySession was not initialized yet.
-     * When we consider that we're in one of these case, we will retry to close it.
-     *
-     * To avoid going into an infinite loop of retry, this number indicates a
-     * maximum number of attemps we're going to make (`0` meaning no retry at all,
-     * `1` only one retry and so on).
-     */
-    EME_SESSION_CLOSING_MAX_RETRY: number;
-    /**
-     * When closing a MediaKeySession failed due to the reasons explained for the
-     * `EME_SESSION_CLOSING_MAX_RETRY` config property, we may (among other
-     * triggers) choose to wait a delay raising exponentially at each retry before
-     * that new attempt.
-     * This value indicates the initial value for this delay, in milliseconds.
-     */
-    EME_SESSION_CLOSING_INITIAL_DELAY: number;
-    /**
-     * When closing a MediaKeySession failed due to the reasons explained for the
-     * `EME_SESSION_CLOSING_MAX_RETRY` config property, we may (among other
-     * triggers) choose to wait a delay raising exponentially at each retry before
-     * that new attempt.
-     * This value indicates the maximum possible value for this delay, in
-     * milliseconds.
-     */
-    EME_SESSION_CLOSING_MAX_DELAY: number;
     /**
      * After loading a persistent MediaKeySession, the RxPlayer needs to ensure
      * that its keys still allow to decrypt a content.
@@ -1092,17 +1065,11 @@ declare const DEFAULT_CONFIG: {
      * there can be in that history.
      */
     BUFFERED_HISTORY_MAXIMUM_ENTRIES: number;
-    /**
-     * Minimum buffer (in seconds) we should have, regardless of memory
-     * constraints
-     */
-    MIN_BUFFER_LENGTH: number;
     /**
      * Minimum buffer in seconds ahead relative to current time
-     * we should be able to download
-     * Before trying to agressively free up memory
+     * we should be able to download, even in cases of saturated memory.
      */
-    MIN_BUFFER_DISTANCE_BEFORE_CLEAN_UP: number;
+    MIN_BUFFER_AHEAD: number;
     /**
      * Distance in seconds behind the current position
      * the player will free up to in the case we agressively free up memory

package/dist/_esm5.processed/default_config.js

@@ -978,33 +978,6 @@ var DEFAULT_CONFIG = {
      * This wasn't battle-tested however.
      */
     EME_MAX_STORED_PERSISTENT_SESSION_INFORMATION: 1000,
-    /**
-     * Attempts to closing a MediaKeySession can fail, most likely because the
-     * MediaKeySession was not initialized yet.
-     * When we consider that we're in one of these case, we will retry to close it.
-     *
-     * To avoid going into an infinite loop of retry, this number indicates a
-     * maximum number of attemps we're going to make (`0` meaning no retry at all,
-     * `1` only one retry and so on).
-     */
-    EME_SESSION_CLOSING_MAX_RETRY: 5,
-    /**
-     * When closing a MediaKeySession failed due to the reasons explained for the
-     * `EME_SESSION_CLOSING_MAX_RETRY` config property, we may (among other
-     * triggers) choose to wait a delay raising exponentially at each retry before
-     * that new attempt.
-     * This value indicates the initial value for this delay, in milliseconds.
-     */
-    EME_SESSION_CLOSING_INITIAL_DELAY: 100,
-    /**
-     * When closing a MediaKeySession failed due to the reasons explained for the
-     * `EME_SESSION_CLOSING_MAX_RETRY` config property, we may (among other
-     * triggers) choose to wait a delay raising exponentially at each retry before
-     * that new attempt.
-     * This value indicates the maximum possible value for this delay, in
-     * milliseconds.
-     */
-    EME_SESSION_CLOSING_MAX_DELAY: 1000,
     /**
      * After loading a persistent MediaKeySession, the RxPlayer needs to ensure
      * that its keys still allow to decrypt a content.
@@ -1124,17 +1097,11 @@ var DEFAULT_CONFIG = {
      * there can be in that history.
      */
     BUFFERED_HISTORY_MAXIMUM_ENTRIES: 200,
-    /**
-     * Minimum buffer (in seconds) we should have, regardless of memory
-     * constraints
-     */
-    MIN_BUFFER_LENGTH: 5,
     /**
      * Minimum buffer in seconds ahead relative to current time
-     * we should be able to download
-     * Before trying to agressively free up memory
+     * we should be able to download, even in cases of saturated memory.
      */
-    MIN_BUFFER_DISTANCE_BEFORE_CLEAN_UP: 10,
+    MIN_BUFFER_AHEAD: 5,
     /**
      * Distance in seconds behind the current position
      * the player will free up to in the case we agressively free up memory

package/dist/_esm5.processed/transports/dash/add_segment_integrity_checks_to_loader.js

@@ -36,53 +36,54 @@ import inferSegmentContainer from "../utils/infer_segment_container";
  */
 export default function addSegmentIntegrityChecks(segmentLoader) {
     return function (url, content, initialCancelSignal, callbacks) {
-        return new Promise(function (res, rej) {
-            var canceller = new TaskCanceller();
-            var unregisterCancelLstnr = initialCancelSignal
-                .register(function onCheckCancellation(err) {
-                canceller.cancel();
-                rej(err);
-            });
-            /**
-             * If the data's seems to be corrupted, cancel the loading task and reject
-             * with an `INTEGRITY_ERROR` error.
-             * @param {*} data
-             */
-            function cancelAndRejectOnBadIntegrity(data) {
-                if (!(data instanceof Array) && !(data instanceof Uint8Array) ||
-                    inferSegmentContainer(content.adaptation.type, content.representation) !== "mp4") {
-                    return;
-                }
-                try {
-                    checkISOBMFFIntegrity(new Uint8Array(data), content.segment.isInit);
-                }
-                catch (err) {
-                    unregisterCancelLstnr();
-                    canceller.cancel();
-                    rej(err);
-                }
-            }
-            segmentLoader(url, content, canceller.signal, __assign(__assign({}, callbacks), { onNewChunk: function (data) {
-                    cancelAndRejectOnBadIntegrity(data);
-                    if (!canceller.isUsed) {
+        return new Promise(function (resolve, reject) {
+            var requestCanceller = new TaskCanceller({ cancelOn: initialCancelSignal });
+            // Reject the `CancellationError` when `requestCanceller`'s signal emits
+            // `stopRejectingOnCancel` here is a function allowing to stop this mechanism
+            var stopRejectingOnCancel = requestCanceller.signal.register(reject);
+            segmentLoader(url, content, requestCanceller.signal, __assign(__assign({}, callbacks), { onNewChunk: function (data) {
+                    try {
+                        trowOnIntegrityError(data);
                         callbacks.onNewChunk(data);
                     }
+                    catch (err) {
+                        // Do not reject with a `CancellationError` after cancelling the request
+                        stopRejectingOnCancel();
+                        // Cancel the request
+                        requestCanceller.cancel();
+                        // Reject with thrown error
+                        reject(err);
+                    }
                 } })).then(function (info) {
-                if (canceller.isUsed) {
+                if (requestCanceller.isUsed) {
                     return;
                 }
-                unregisterCancelLstnr();
+                stopRejectingOnCancel();
                 if (info.resultType === "segment-loaded") {
-                    cancelAndRejectOnBadIntegrity(info.resultData.responseData);
+                    try {
+                        trowOnIntegrityError(info.resultData.responseData);
+                    }
+                    catch (err) {
+                        reject(err);
+                        return;
+                    }
                 }
-                res(info);
+                resolve(info);
             }, function (error) {
-                // The segmentLoader's cancellations cases are all handled here
-                if (!TaskCanceller.isCancellationError(error)) {
-                    unregisterCancelLstnr();
-                    rej(error);
-                }
+                stopRejectingOnCancel();
+                reject(error);
             });
         });
+        /**
+         * If the data's seems to be corrupted, throws an `INTEGRITY_ERROR` error.
+         * @param {*} data
+         */
+        function trowOnIntegrityError(data) {
+            if (!(data instanceof ArrayBuffer) && !(data instanceof Uint8Array) ||
+                inferSegmentContainer(content.adaptation.type, content.representation) !== "mp4") {
+                return;
+            }
+            checkISOBMFFIntegrity(new Uint8Array(data), content.segment.isInit);
+        }
     };
 }

package/dist/_esm5.processed/utils/reference.js

@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 import { Observable, } from "rxjs";
-import log from "../log";
 /**
  * Create an `ISharedReference` object encapsulating the mutable `initialValue`
  * value of type T.
@@ -61,7 +60,6 @@ export function createSharedReference(initialValue) {
                     throw new Error("Finished shared references cannot be updated");
                 }
                 else {
-                    log.error("Finished shared references cannot be updated");
                     return;
                 }
             }

package/dist/_esm5.processed/utils/task_canceller.d.ts

@@ -131,8 +131,15 @@ export default class TaskCanceller {
      * Creates a new `TaskCanceller`, with its own `CancellationSignal` created
      * as its `signal` provide.
      * You can then pass this property to async task you wish to be cancellable.
+     * @param {Object|undefined} options
      */
-    constructor();
+    constructor(options?: {
+        /**
+         * If set the TaskCanceller created here will automatically be triggered
+         * when that signal emits.
+         */
+        cancelOn?: CancellationSignal | undefined;
+    } | undefined);
     /**
      * "Trigger" the `TaskCanceller`, notify through its associated
      * `CancellationSignal` (its `signal` property) that a task should be aborted.

package/dist/_esm5.processed/utils/task_canceller.js

@@ -132,12 +132,20 @@ var TaskCanceller = /** @class */ (function () {
      * Creates a new `TaskCanceller`, with its own `CancellationSignal` created
      * as its `signal` provide.
      * You can then pass this property to async task you wish to be cancellable.
+     * @param {Object|undefined} options
      */
-    function TaskCanceller() {
+    function TaskCanceller(options) {
+        var _this = this;
         var _a = createCancellationFunctions(), trigger = _a[0], register = _a[1];
         this.isUsed = false;
         this._trigger = trigger;
         this.signal = new CancellationSignal(register);
+        if ((options === null || options === void 0 ? void 0 : options.cancelOn) !== undefined) {
+            var unregisterParent = options.cancelOn.register(function () {
+                _this.cancel();
+            });
+            this.signal.register(unregisterParent);
+        }
     }
     /**
      * "Trigger" the `TaskCanceller`, notify through its associated