rx-player 4.0.0-beta.0 → 4.0.0-beta.2

package/dist/_esm5.processed/core/segment_buffers/implementations/audio_video/audio_video_segment_buffer.d.ts

@@ -49,16 +49,25 @@ export default class AudioVideoSegmentBuffer extends SegmentBuffer {
      */
     private _pendingTask;
     /**
-     * Keep track of the of the latest init segment pushed in the linked
-     * SourceBuffer.
+     * Keep track of the unique identifier of the  of the latest init segment
+     * pushed to the linked SourceBuffer.
      *
-     * This allows to be sure the right initialization segment is pushed before
-     * any chunk is.
+     * Such identifiers are first declared through the `declareInitSegment`
+     * method and the corresponding initialization segment is then pushed through
+     * the `pushChunk` method.
+     *
+     * Keeping track of this allows to be sure the right initialization segment is
+     * pushed before any chunk is.
      *
      * `null` if no initialization segment have been pushed to the
      * `AudioVideoSegmentBuffer` yet.
      */
-    private _lastInitSegment;
+    private _lastInitSegmentUniqueId;
+    /**
+     * Link unique identifiers for initialization segments (as communicated by
+     * `declareInitSegment`) to the corresponding initialization data.
+     */
+    private _initSegmentsMap;
     /**
      * @constructor
      * @param {string} bufferType
@@ -66,6 +75,8 @@ export default class AudioVideoSegmentBuffer extends SegmentBuffer {
      * @param {MediaSource} mediaSource
      */
     constructor(bufferType: "audio" | "video", codec: string, mediaSource: MediaSource);
+    declareInitSegment(uniqueId: string, initSegmentData: unknown): void;
+    freeInitSegment(uniqueId: string): void;
     /**
      * Push a chunk of the media segment given to the attached SourceBuffer, in a
      * FIFO queue.
@@ -162,9 +173,9 @@ export default class AudioVideoSegmentBuffer extends SegmentBuffer {
      */
     private _preparePushOperation;
     /**
-     * Return `true` if the given `segmentData` is the same segment than the last
+     * Return `true` if the given `uniqueId` is the identifier of the last
      * initialization segment pushed to the `AudioVideoSegmentBuffer`.
-     * @param {BufferSource} segmentData
+     * @param {string} uniqueId
      * @returns {boolean}
      */
     private _isLastInitSegment;

package/dist/_esm5.processed/core/segment_buffers/implementations/audio_video/audio_video_segment_buffer.js

@@ -32,10 +32,8 @@ import { tryToChangeSourceBufferType, } from "../../../../compat";
 import config from "../../../../config";
 import log from "../../../../log";
 import { getLoggableSegmentId } from "../../../../manifest";
-import areArraysOfNumbersEqual from "../../../../utils/are_arrays_of_numbers_equal";
 import assertUnreachable from "../../../../utils/assert_unreachable";
-import { toUint8Array } from "../../../../utils/byte_parsing";
-import hashBuffer from "../../../../utils/hash_buffer";
+import createCancellablePromise from "../../../../utils/create_cancellable_promise";
 import noop from "../../../../utils/noop";
 import objectAssign from "../../../../utils/object_assign";
 import TaskCanceller, { CancellationError, } from "../../../../utils/task_canceller";
@@ -67,8 +65,9 @@ var AudioVideoSegmentBuffer = /** @class */ (function (_super) {
         _this._sourceBuffer = sourceBuffer;
         _this._queue = [];
         _this._pendingTask = null;
-        _this._lastInitSegment = null;
+        _this._lastInitSegmentUniqueId = null;
         _this.codec = codec;
+        _this._initSegmentsMap = new Map();
         var onError = _this._onPendingTaskError.bind(_this);
         var reCheck = _this._flush.bind(_this);
         // Some browsers (happened with firefox 66) sometimes "forget" to send us
@@ -88,6 +87,13 @@ var AudioVideoSegmentBuffer = /** @class */ (function (_super) {
         });
         return _this;
     }
+    AudioVideoSegmentBuffer.prototype.declareInitSegment = function (uniqueId, initSegmentData) {
+        assertDataIsBufferSource(initSegmentData);
+        this._initSegmentsMap.set(uniqueId, initSegmentData);
+    };
+    AudioVideoSegmentBuffer.prototype.freeInitSegment = function (uniqueId) {
+        this._initSegmentsMap.delete(uniqueId);
+    };
     /**
      * Push a chunk of the media segment given to the attached SourceBuffer, in a
      * FIFO queue.
@@ -116,7 +122,7 @@ var AudioVideoSegmentBuffer = /** @class */ (function (_super) {
      * @returns {Promise}
      */
     AudioVideoSegmentBuffer.prototype.pushChunk = function (infos, cancellationSignal) {
-        assertPushedDataIsBufferSource(infos);
+        assertDataIsBufferSource(infos.data.chunk);
         log.debug("AVSB: receiving order to push data to the SourceBuffer", this.bufferType, getLoggableSegmentId(infos.inventoryInfos));
         return this._addToQueue({ type: SegmentBufferOperation.Push,
             value: infos }, cancellationSignal);
@@ -210,7 +216,7 @@ var AudioVideoSegmentBuffer = /** @class */ (function (_super) {
      * @param {Event} err
      */
     AudioVideoSegmentBuffer.prototype._onPendingTaskError = function (err) {
-        this._lastInitSegment = null; // initialize init segment as a security
+        this._lastInitSegmentUniqueId = null; // initialize init segment as a security
         if (this._pendingTask !== null) {
             var error = err instanceof Error ?
                 err :
@@ -227,15 +233,15 @@ var AudioVideoSegmentBuffer = /** @class */ (function (_super) {
      */
     AudioVideoSegmentBuffer.prototype._addToQueue = function (operation, cancellationSignal) {
         var _this = this;
-        return new Promise(function (resolve, reject) {
-            if (cancellationSignal.cancellationError !== null) {
-                return reject(cancellationSignal.cancellationError);
-            }
+        return createCancellablePromise(cancellationSignal, function (resolve, reject) {
             var shouldRestartQueue = _this._queue.length === 0 &&
                 _this._pendingTask === null;
             var queueItem = objectAssign({ resolve: resolve, reject: reject }, operation);
             _this._queue.push(queueItem);
-            cancellationSignal.register(function (error) {
+            if (shouldRestartQueue) {
+                _this._flush();
+            }
+            return function () {
                 // Remove the corresponding element from the AudioVideoSegmentBuffer's
                 // queue.
                 // If the operation was a pending task, it should still continue to not
@@ -246,11 +252,7 @@ var AudioVideoSegmentBuffer = /** @class */ (function (_super) {
                 }
                 queueItem.resolve = noop;
                 queueItem.reject = noop;
-                reject(error);
-            });
-            if (shouldRestartQueue) {
-                _this._flush();
-            }
+            };
         });
     };
     /**
@@ -307,7 +309,7 @@ var AudioVideoSegmentBuffer = /** @class */ (function (_super) {
                     var error = e instanceof Error ?
                         e :
                         new Error("An unknown error occured when preparing a push operation");
-                    this._lastInitSegment = null; // initialize init segment as a security
+                    this._lastInitSegmentUniqueId = null; // initialize init segment as a security
                     nextItem.reject(error);
                     return;
                 }
@@ -395,14 +397,16 @@ var AudioVideoSegmentBuffer = /** @class */ (function (_super) {
         else if (appendWindow[1] !== this._sourceBuffer.appendWindowEnd) {
             this._sourceBuffer.appendWindowEnd = appendWindow[1];
         }
-        if (data.initSegment !== null &&
-            (hasUpdatedSourceBufferType || !this._isLastInitSegment(data.initSegment))) {
+        if (data.initSegmentUniqueId !== null &&
+            (hasUpdatedSourceBufferType ||
+                !this._isLastInitSegment(data.initSegmentUniqueId))) {
             // Push initialization segment before the media segment
-            var segmentData = data.initSegment;
+            var segmentData = this._initSegmentsMap.get(data.initSegmentUniqueId);
+            if (segmentData === undefined) {
+                throw new Error("Invalid initialization segment uniqueId");
+            }
             dataToPush.push(segmentData);
-            var initU8 = toUint8Array(segmentData);
-            this._lastInitSegment = { data: initU8,
-                hash: hashBuffer(initU8) };
+            this._lastInitSegmentUniqueId = data.initSegmentUniqueId;
         }
         if (data.chunk !== null) {
             dataToPush.push(data.chunk);
@@ -410,27 +414,16 @@ var AudioVideoSegmentBuffer = /** @class */ (function (_super) {
         return dataToPush;
     };
     /**
-     * Return `true` if the given `segmentData` is the same segment than the last
+     * Return `true` if the given `uniqueId` is the identifier of the last
      * initialization segment pushed to the `AudioVideoSegmentBuffer`.
-     * @param {BufferSource} segmentData
+     * @param {string} uniqueId
      * @returns {boolean}
      */
-    AudioVideoSegmentBuffer.prototype._isLastInitSegment = function (segmentData) {
-        if (this._lastInitSegment === null) {
+    AudioVideoSegmentBuffer.prototype._isLastInitSegment = function (uniqueId) {
+        if (this._lastInitSegmentUniqueId === null) {
             return false;
         }
-        if (this._lastInitSegment.data === segmentData) {
-            return true;
-        }
-        var oldInit = this._lastInitSegment.data;
-        if (oldInit.byteLength === segmentData.byteLength) {
-            var newInitU8 = toUint8Array(segmentData);
-            if (hashBuffer(newInitU8) === this._lastInitSegment.hash &&
-                areArraysOfNumbersEqual(oldInit, newInitU8)) {
-                return true;
-            }
-        }
-        return false;
+        return this._lastInitSegmentUniqueId === uniqueId;
     };
     return AudioVideoSegmentBuffer;
 }(SegmentBuffer));
@@ -439,21 +432,16 @@ export default AudioVideoSegmentBuffer;
  * Throw if the given input is not in the expected format.
  * Allows to enforce runtime type-checking as compile-time type-checking here is
  * difficult to enforce.
- * @param {Object} pushedData
+ * @param {Object} data
  */
-function assertPushedDataIsBufferSource(pushedData) {
+function assertDataIsBufferSource(data) {
     if (0 /* __ENVIRONMENT__.CURRENT_ENV */ === 0 /* __ENVIRONMENT__.PRODUCTION */) {
         return;
     }
-    var _a = pushedData.data, chunk = _a.chunk, initSegment = _a.initSegment;
-    if (typeof chunk !== "object" ||
-        typeof initSegment !== "object" ||
-        (chunk !== null &&
-            !(chunk instanceof ArrayBuffer) &&
-            !(chunk.buffer instanceof ArrayBuffer)) ||
-        (initSegment !== null &&
-            !(initSegment instanceof ArrayBuffer) &&
-            !(initSegment.buffer instanceof ArrayBuffer))) {
+    if (typeof data !== "object" ||
+        (data !== null &&
+            !(data instanceof ArrayBuffer) &&
+            !(data.buffer instanceof ArrayBuffer))) {
         throw new Error("Invalid data given to the AudioVideoSegmentBuffer");
     }
 }

package/dist/_esm5.processed/core/segment_buffers/implementations/text/html/html_text_segment_buffer.d.ts

@@ -47,6 +47,14 @@ export default class HTMLTextSegmentBuffer extends SegmentBuffer {
      * @param {HTMLElement} textTrackElement
      */
     constructor(videoElement: HTMLMediaElement, textTrackElement: HTMLElement);
+    /**
+     * @param {string} uniqueId
+     */
+    declareInitSegment(uniqueId: string): void;
+    /**
+     * @param {string} uniqueId
+     */
+    freeInitSegment(uniqueId: string): void;
     /**
      * Push text segment to the HTMLTextSegmentBuffer.
      * @param {Object} infos

package/dist/_esm5.processed/core/segment_buffers/implementations/text/html/html_text_segment_buffer.js

@@ -93,6 +93,18 @@ var HTMLTextSegmentBuffer = /** @class */ (function (_super) {
         _this.autoRefreshSubtitles(_this._canceller.signal);
         return _this;
     }
+    /**
+     * @param {string} uniqueId
+     */
+    HTMLTextSegmentBuffer.prototype.declareInitSegment = function (uniqueId) {
+        log.warn("ISB: Declaring initialization segment for image SegmentBuffer", uniqueId);
+    };
+    /**
+     * @param {string} uniqueId
+     */
+    HTMLTextSegmentBuffer.prototype.freeInitSegment = function (uniqueId) {
+        log.warn("ISB: Freeing initialization segment for image SegmentBuffer", uniqueId);
+    };
     /**
      * Push text segment to the HTMLTextSegmentBuffer.
      * @param {Object} infos
@@ -272,7 +284,8 @@ var HTMLTextSegmentBuffer = /** @class */ (function (_super) {
         var proportionalCues = this._currentCues
             .filter(function (cue) { return cue.resolution !== null; });
         if (proportionalCues.length > 0) {
-            this._sizeUpdateCanceller = new TaskCanceller({ cancelOn: this._canceller.signal });
+            this._sizeUpdateCanceller = new TaskCanceller();
+            this._sizeUpdateCanceller.linkToSignal(this._canceller.signal);
             var TEXT_TRACK_SIZE_CHECKS_INTERVAL = config.getCurrent().TEXT_TRACK_SIZE_CHECKS_INTERVAL;
             // update propertionally-sized elements periodically
             var heightWidthRef = onHeightWidthChange(this._textTrackElement, TEXT_TRACK_SIZE_CHECKS_INTERVAL, this._sizeUpdateCanceller.signal);
@@ -297,7 +310,8 @@ var HTMLTextSegmentBuffer = /** @class */ (function (_super) {
         var MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL = config.getCurrent().MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL;
         var startAutoRefresh = function () {
             stopAutoRefresh();
-            autoRefreshCanceller = new TaskCanceller({ cancelOn: cancellationSignal });
+            autoRefreshCanceller = new TaskCanceller();
+            autoRefreshCanceller.linkToSignal(cancellationSignal);
             var intervalId = setInterval(function () { return _this.refreshSubtitles(); }, MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL);
             autoRefreshCanceller.signal.register(function () {
                 clearInterval(intervalId);

package/dist/_esm5.processed/core/segment_buffers/implementations/text/native/native_text_segment_buffer.d.ts

@@ -31,6 +31,14 @@ export default class NativeTextSegmentBuffer extends SegmentBuffer {
      * @param {HTMLMediaElement} videoElement
      */
     constructor(videoElement: HTMLMediaElement);
+    /**
+     * @param {string} uniqueId
+     */
+    declareInitSegment(uniqueId: string): void;
+    /**
+     * @param {string} uniqueId
+     */
+    freeInitSegment(uniqueId: string): void;
     /**
      * @param {Object} infos
      * @returns {Promise}

package/dist/_esm5.processed/core/segment_buffers/implementations/text/native/native_text_segment_buffer.js

@@ -57,6 +57,18 @@ var NativeTextSegmentBuffer = /** @class */ (function (_super) {
         _this._trackElement = trackElement;
         return _this;
     }
+    /**
+     * @param {string} uniqueId
+     */
+    NativeTextSegmentBuffer.prototype.declareInitSegment = function (uniqueId) {
+        log.warn("ISB: Declaring initialization segment for image SegmentBuffer", uniqueId);
+    };
+    /**
+     * @param {string} uniqueId
+     */
+    NativeTextSegmentBuffer.prototype.freeInitSegment = function (uniqueId) {
+        log.warn("ISB: Freeing initialization segment for image SegmentBuffer", uniqueId);
+    };
     /**
      * @param {Object} infos
      * @returns {Promise}

package/dist/_esm5.processed/core/segment_buffers/implementations/types.d.ts

@@ -68,6 +68,8 @@ export declare abstract class SegmentBuffer {
      */
     codec: string | undefined;
     constructor();
+    abstract declareInitSegment(uniqueId: string, initSegmentData: unknown): void;
+    abstract freeInitSegment(uniqueId: string): void;
     /**
      * Push a chunk of the media segment given to the attached buffer, in a
      * FIFO queue.
@@ -77,7 +79,8 @@ export declare abstract class SegmentBuffer {
      * pushed.
      *
      * Depending on the type of data appended, the pushed chunk might rely on an
-     * initialization segment, given through the `data.initSegment` property.
+     * initialization segment, which had to be previously declared through the
+     * `declareInitSegment` method.
      *
      * Such initialization segment will be first pushed to the buffer if the
      * last pushed segment was associated to another initialization segment.
@@ -87,7 +90,7 @@ export declare abstract class SegmentBuffer {
      * reference).
      *
      * If you don't need any initialization segment to push the wanted chunk, you
-     * can just set `data.initSegment` to `null`.
+     * can just set the corresponding property to `null`.
      *
      * You can also only push an initialization segment by setting the
      * `data.chunk` argument to null.
@@ -177,12 +180,16 @@ export type IBufferType = "audio" | "video" | "text";
  */
 export interface IPushedChunkData<T> {
     /**
-     * The whole initialization segment's data related to the chunk you want to
+     * The `uniqueId` of the initialization segment linked to the data you want to
      * push.
+     *
+     * That identifier should previously have been declared through the
+     * `declareInitSegment` method and not freed.
+     *
      * To set to `null` either if no initialization data is needed, or if you are
      * confident that the last pushed one is compatible.
      */
-    initSegment: T | null;
+    initSegmentUniqueId: string | null;
     /**
      * Chunk you want to push.
      * This can be the whole decodable segment's data or just a decodable sub-part

package/dist/_esm5.processed/core/segment_buffers/index.d.ts

@@ -15,7 +15,7 @@
  */
 import BufferGarbageCollector from "./garbage_collector";
 import { IBufferType, IEndOfSegmentInfos, IEndOfSegmentOperation, IPushChunkInfos, IPushedChunkData, IPushOperation, IRemoveOperation, ISBOperation, SegmentBuffer, SegmentBufferOperation } from "./implementations";
-import { IBufferedChunk, IChunkContext, getFirstSegmentAfterPeriod, getLastSegmentBeforePeriod } from "./inventory";
+import { IBufferedChunk, IChunkContext, IInsertedChunkInfos, getFirstSegmentAfterPeriod, getLastSegmentBeforePeriod } from "./inventory";
 import SegmentBuffersStore, { ISegmentBufferOptions, ITextTrackSegmentBufferOptions } from "./segment_buffers_store";
 export default SegmentBuffersStore;
-export { BufferGarbageCollector, ISegmentBufferOptions, ITextTrackSegmentBufferOptions, SegmentBuffer, IBufferType, IBufferedChunk, IChunkContext, IPushChunkInfos, IPushedChunkData, IEndOfSegmentInfos, SegmentBufferOperation, ISBOperation, IEndOfSegmentOperation, IPushOperation, IRemoveOperation, getFirstSegmentAfterPeriod, getLastSegmentBeforePeriod, };
+export { BufferGarbageCollector, ISegmentBufferOptions, ITextTrackSegmentBufferOptions, SegmentBuffer, IBufferType, IBufferedChunk, IChunkContext, IInsertedChunkInfos, IPushChunkInfos, IPushedChunkData, IEndOfSegmentInfos, SegmentBufferOperation, ISBOperation, IEndOfSegmentOperation, IPushOperation, IRemoveOperation, getFirstSegmentAfterPeriod, getLastSegmentBeforePeriod, };

package/dist/_esm5.processed/core/segment_buffers/segment_buffers_store.js

@@ -16,6 +16,7 @@
 import { MediaError } from "../../errors";
 import features from "../../features";
 import log from "../../log";
+import createCancellablePromise from "../../utils/create_cancellable_promise";
 import { AudioVideoSegmentBuffer, } from "./implementations";
 var POSSIBLE_BUFFER_TYPES = ["audio",
     "video",
@@ -137,20 +138,23 @@ var SegmentBuffersStore = /** @class */ (function () {
         if (this._areNativeBuffersUsable()) {
             return Promise.resolve();
         }
-        return new Promise(function (res, rej) {
-            var onAddedOrDisabled = function () {
+        return createCancellablePromise(cancelWaitSignal, function (res) {
+            /* eslint-disable-next-line prefer-const */
+            var onAddedOrDisabled;
+            var removeCallback = function () {
+                var indexOf = _this._onNativeBufferAddedOrDisabled.indexOf(onAddedOrDisabled);
+                if (indexOf >= 0) {
+                    _this._onNativeBufferAddedOrDisabled.splice(indexOf, 1);
+                }
+            };
+            onAddedOrDisabled = function () {
                 if (_this._areNativeBuffersUsable()) {
+                    removeCallback();
                     res();
                 }
             };
             _this._onNativeBufferAddedOrDisabled.push(onAddedOrDisabled);
-            cancelWaitSignal.register(function (error) {
-                var indexOf = _this._onNativeBufferAddedOrDisabled.indexOf(onAddedOrDisabled);
-                if (indexOf >= 0) {
-                    _this._onNativeBufferAddedOrDisabled.splice(indexOf, 1);
-                }
-                rej(error);
-            });
+            return removeCallback;
         });
     };
     /**

package/dist/_esm5.processed/core/stream/adaptation/adaptation_stream.js

@@ -38,6 +38,8 @@ import config from "../../../config";
 import { formatError } from "../../../errors";
 import log from "../../../log";
 import assertUnreachable from "../../../utils/assert_unreachable";
+import cancellableSleep from "../../../utils/cancellable_sleep";
+import noop from "../../../utils/noop";
 import objectAssign from "../../../utils/object_assign";
 import { createMappedReference, createSharedReference, } from "../../../utils/reference";
 import TaskCanceller from "../../../utils/task_canceller";
@@ -78,7 +80,8 @@ export default function AdaptationStream(_a, callbacks, parentCancelSignal) {
     var playbackObserver = _a.playbackObserver, content = _a.content, options = _a.options, representationEstimator = _a.representationEstimator, segmentBuffer = _a.segmentBuffer, segmentFetcherCreator = _a.segmentFetcherCreator, wantedBufferAhead = _a.wantedBufferAhead, maxVideoBufferSize = _a.maxVideoBufferSize;
     var manifest = content.manifest, period = content.period, adaptation = content.adaptation;
     /** Allows to cancel everything the `AdaptationStream` is doing. */
-    var adapStreamCanceller = new TaskCanceller({ cancelOn: parentCancelSignal });
+    var adapStreamCanceller = new TaskCanceller();
+    adapStreamCanceller.linkToSignal(parentCancelSignal);
     /**
      * The buffer goal ratio base itself on the value given by `wantedBufferAhead`
      * to determine a more dynamic buffer goal for a given Representation.
@@ -133,9 +136,10 @@ export default function AdaptationStream(_a, callbacks, parentCancelSignal) {
             cancelCurrentStreams.cancel();
         }
         representationsList.setValueIfChanged(val.representations);
-        cancelCurrentStreams = new TaskCanceller({ cancelOn: adapStreamCanceller.signal });
+        cancelCurrentStreams = new TaskCanceller();
+        cancelCurrentStreams.linkToSignal(adapStreamCanceller.signal);
         onRepresentationsChoiceChange(val, cancelCurrentStreams.signal).catch(function (err) {
-            if ((cancelCurrentStreams === null || cancelCurrentStreams === void 0 ? void 0 : cancelCurrentStreams.isUsed) === true &&
+            if ((cancelCurrentStreams === null || cancelCurrentStreams === void 0 ? void 0 : cancelCurrentStreams.isUsed()) === true &&
                 TaskCanceller.isCancellationError(err)) {
                 return;
             }
@@ -187,7 +191,7 @@ export default function AdaptationStream(_a, callbacks, parentCancelSignal) {
                         return [4 /*yield*/, segmentBuffer.removeBuffer(range.start, range.end, fnCancelSignal)];
                     case 5:
                         _c.sent();
-                        if (fnCancelSignal.isCancelled) {
+                        if (fnCancelSignal.isCancelled()) {
                             return [2 /*return*/];
                         }
                         _c.label = 6;
@@ -197,7 +201,7 @@ export default function AdaptationStream(_a, callbacks, parentCancelSignal) {
                     case 7:
                         if (switchStrat.type === "flush-buffer") {
                             callbacks.needsBufferFlush();
-                            if (fnCancelSignal.isCancelled) {
+                            if (fnCancelSignal.isCancelled()) {
                                 return [2 /*return*/];
                             }
                         }
@@ -226,7 +230,8 @@ export default function AdaptationStream(_a, callbacks, parentCancelSignal) {
          * terminating and as such the next one might be immediately created
          * recursively.
          */
-        var repStreamTerminatingCanceller = new TaskCanceller({ cancelOn: fnCancelSignal });
+        var repStreamTerminatingCanceller = new TaskCanceller();
+        repStreamTerminatingCanceller.linkToSignal(fnCancelSignal);
         var representation = estimateRef.getValue().representation;
         if (representation === null) {
             return;
@@ -254,11 +259,11 @@ export default function AdaptationStream(_a, callbacks, parentCancelSignal) {
         }, { clearSignal: repStreamTerminatingCanceller.signal, emitCurrentValue: true });
         var repInfo = { type: adaptation.type, period: period, representation: representation };
         currentRepresentation.setValue(representation);
-        if (adapStreamCanceller.isUsed) {
+        if (adapStreamCanceller.isUsed()) {
             return; // previous callback has stopped everything by side-effect
         }
         callbacks.representationChange(repInfo);
-        if (adapStreamCanceller.isUsed) {
+        if (adapStreamCanceller.isUsed()) {
             return; // previous callback has stopped everything by side-effect
         }
         var representationStreamCallbacks = {
@@ -274,13 +279,13 @@ export default function AdaptationStream(_a, callbacks, parentCancelSignal) {
             },
             addedSegment: function (segmentInfo) {
                 abrCallbacks.addedSegment(segmentInfo);
-                if (adapStreamCanceller.isUsed) {
+                if (adapStreamCanceller.isUsed()) {
                     return;
                 }
                 callbacks.addedSegment(segmentInfo);
             },
             terminating: function () {
-                if (repStreamTerminatingCanceller.isUsed) {
+                if (repStreamTerminatingCanceller.isUsed()) {
                     return; // Already handled
                 }
                 repStreamTerminatingCanceller.cancel();
@@ -302,7 +307,8 @@ export default function AdaptationStream(_a, callbacks, parentCancelSignal) {
      * anything this function is doing and free allocated resources.
      */
     function createRepresentationStream(representation, terminateCurrentStream, representationStreamCallbacks, fnCancelSignal) {
-        var bufferGoalCanceller = new TaskCanceller({ cancelOn: fnCancelSignal });
+        var bufferGoalCanceller = new TaskCanceller();
+        bufferGoalCanceller.linkToSignal(fnCancelSignal);
         var bufferGoal = createMappedReference(wantedBufferAhead, function (prev) {
             return prev * getBufferGoalRatio(representation);
         }, bufferGoalCanceller.signal);
@@ -317,16 +323,24 @@ export default function AdaptationStream(_a, callbacks, parentCancelSignal) {
                     defaultCode: "NONE",
                     defaultReason: "Unknown `RepresentationStream` error",
                 });
-                if (formattedError.code === "BUFFER_FULL_ERROR") {
+                if (formattedError.code !== "BUFFER_FULL_ERROR") {
+                    representationStreamCallbacks.error(err);
+                }
+                else {
                     var wba = wantedBufferAhead.getValue();
                     var lastBufferGoalRatio = (_a = bufferGoalRatioMap.get(representation.id)) !== null && _a !== void 0 ? _a : 1;
-                    if (lastBufferGoalRatio <= 0.25 || wba * lastBufferGoalRatio <= 2) {
+                    // 70%, 49%, 34.3%, 24%, 16.81%, 11.76%, 8.24% and 5.76%
+                    var newBufferGoalRatio = lastBufferGoalRatio * 0.7;
+                    if (newBufferGoalRatio <= 0.05 || wba * newBufferGoalRatio <= 2) {
                         throw formattedError;
                     }
-                    bufferGoalRatioMap.set(representation.id, lastBufferGoalRatio - 0.25);
-                    return createRepresentationStream(representation, terminateCurrentStream, representationStreamCallbacks, fnCancelSignal);
+                    bufferGoalRatioMap.set(representation.id, newBufferGoalRatio);
+                    // We wait 4 seconds to let the situation evolve by itself before
+                    // retrying loading segments with a lower buffer goal
+                    cancellableSleep(4000, adapStreamCanceller.signal).then(function () {
+                        return createRepresentationStream(representation, terminateCurrentStream, representationStreamCallbacks, fnCancelSignal);
+                    }).catch(noop);
                 }
-                representationStreamCallbacks.error(err);
             },
             terminating: function () {
                 bufferGoalCanceller.cancel();

package/dist/_esm5.processed/core/stream/adaptation/utils/create_representation_estimator.d.ts

@@ -0,0 +1,47 @@
+/**
+ * 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 Manifest, { Adaptation, Period, Representation } from "../../../../manifest";
+import { IPlayerError } from "../../../../public_types";
+import { IReadOnlySharedReference } from "../../../../utils/reference";
+import { CancellationSignal } from "../../../../utils/task_canceller";
+import { IABREstimate, IRepresentationEstimatorPlaybackObservation, IRepresentationEstimator, IRepresentationEstimatorCallbacks } from "../../../adaptive";
+import { IReadOnlyPlaybackObserver } from "../../../api";
+/**
+ * Produce estimates to know which Representation should be played.
+ * @param {Object} content - The Manifest, Period and Adaptation wanted.
+ * @param {Object} representationEstimator - `IRepresentationEstimator` which
+ * will produce Representation estimates.
+ * @param {Object} currentRepresentation - Reference emitting the
+ * currently-loaded Representation.
+ * @param {Object} playbackObserver - Allows to observe the current playback
+ * conditions.
+ * @param {Function} onFatalError - Callback called when a fatal error was
+ * thrown. Once this callback is called, no estimate will be produced.
+ * @param {Object} cancellationSignal - `CancellationSignal` allowing to abort
+ * the production of estimates (and clean-up all linked resources).
+ * @returns {Object} - Returns an object with the following properties:
+ *   - `estimateRef`: Reference emitting the last estimate
+ *   - `abrCallbacks`: Callbacks allowing to report back network and playback
+ *     activities to improve the estimates given.
+ */
+export default function getRepresentationEstimate(content: {
+    manifest: Manifest;
+    period: Period;
+    adaptation: Adaptation;
+}, representationEstimator: IRepresentationEstimator, currentRepresentation: IReadOnlySharedReference<Representation | null>, playbackObserver: IReadOnlyPlaybackObserver<IRepresentationEstimatorPlaybackObservation>, onFatalError: (err: IPlayerError) => void, cancellationSignal: CancellationSignal): {
+    estimateRef: IReadOnlySharedReference<IABREstimate>;
+    abrCallbacks: IRepresentationEstimatorCallbacks;
+};