rx-player 3.28.1-dev.2022083000 → 3.29.0-dev.2022090500

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

@@ -28,31 +28,16 @@ var __extends = (this && this.__extends) || (function () {
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
 })();
-import { concat as observableConcat, defer as observableDefer, interval as observableInterval, map, merge as observableMerge, of as observableOf, startWith, Subject, switchMap, takeUntil, } from "rxjs";
 import { events, onHeightWidthChange, } from "../../../../../compat";
 import config from "../../../../../config";
 import log from "../../../../../log";
+import TaskCanceller from "../../../../../utils/task_canceller";
 import { SegmentBuffer, } from "../../types";
 import ManualTimeRanges from "../../utils/manual_time_ranges";
 import parseTextTrackToElements from "./parsers";
 import TextTrackCuesStore from "./text_track_cues_store";
 import updateProportionalElements from "./update_proportional_elements";
-var onEnded$ = events.onEnded$, onSeeked$ = events.onSeeked$, onSeeking$ = events.onSeeking$;
-/**
- * Generate the interval at which TextTrack HTML Cues should be refreshed.
- * @param {HTMLMediaElement} videoElement
- * @returns {Observable}
- */
-function generateRefreshInterval(videoElement) {
-    var seeking$ = onSeeking$(videoElement);
-    var seeked$ = onSeeked$(videoElement);
-    var ended$ = onEnded$(videoElement);
-    var MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL = config.getCurrent().MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL;
-    var manualRefresh$ = observableMerge(seeked$, ended$);
-    var autoRefresh$ = observableInterval(MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL)
-        .pipe(startWith(null));
-    return manualRefresh$.pipe(startWith(null), switchMap(function () { return observableConcat(autoRefresh$.pipe(map(function () { return true; }), takeUntil(seeking$)), observableOf(false)); }));
-}
+var onEnded = events.onEnded, onSeeked = events.onSeeked, onSeeking = events.onSeeking;
 /**
  * @param {Element} element
  * @param {Element} child
@@ -101,72 +86,44 @@ var HTMLTextSegmentBuffer = /** @class */ (function (_super) {
         _this._buffered = new ManualTimeRanges();
         _this._videoElement = videoElement;
         _this._textTrackElement = textTrackElement;
-        _this._clearSizeUpdates$ = new Subject();
-        _this._destroy$ = new Subject();
+        _this._sizeUpdateCanceller = new TaskCanceller();
+        _this._canceller = new TaskCanceller();
         _this._buffer = new TextTrackCuesStore();
         _this._currentCues = [];
-        // update text tracks
-        generateRefreshInterval(_this._videoElement)
-            .pipe(takeUntil(_this._destroy$))
-            .subscribe(function (shouldDisplay) {
-            if (!shouldDisplay) {
-                _this._disableCurrentCues();
-                return;
-            }
-            var MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL = config.getCurrent().MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL;
-            // to spread the time error, we divide the regular chosen interval.
-            var time = Math.max(_this._videoElement.currentTime +
-                (MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL / 1000) / 2, 0);
-            var cues = _this._buffer.get(time);
-            if (cues.length === 0) {
-                _this._disableCurrentCues();
-            }
-            else {
-                _this._displayCues(cues);
-            }
-        });
+        _this.autoRefreshSubtitles(_this._canceller.signal);
         return _this;
     }
     /**
      * Push segment on Subscription.
      * @param {Object} infos
-     * @returns {Observable}
+     * @returns {Promise}
      */
     HTMLTextSegmentBuffer.prototype.pushChunk = function (infos) {
-        var _this = this;
-        return observableDefer(function () {
-            _this.pushChunkSync(infos);
-            return observableOf(undefined);
-        });
+        try {
+            this.pushChunkSync(infos);
+        }
+        catch (err) {
+            return Promise.reject(err);
+        }
+        return Promise.resolve();
     };
     /**
      * Remove buffered data.
      * @param {number} start - start position, in seconds
      * @param {number} end - end position, in seconds
-     * @returns {Observable}
+     * @returns {Promise}
      */
     HTMLTextSegmentBuffer.prototype.removeBuffer = function (start, end) {
-        var _this = this;
-        return observableDefer(function () {
-            _this.removeBufferSync(start, end);
-            return observableOf(undefined);
-        });
+        this.removeBufferSync(start, end);
+        return Promise.resolve();
     };
     /**
-     * Indicate that every chunks from a Segment has been given to pushChunk so
-     * far.
-     * This will update our internal Segment inventory accordingly.
-     * The returned Observable will emit and complete successively once the whole
-     * segment has been pushed and this indication is acknowledged.
      * @param {Object} infos
-     * @returns {Observable}
+     * @returns {Promise}
      */
-    HTMLTextSegmentBuffer.prototype.endOfSegment = function (_infos) {
-        var _this = this;
-        return observableDefer(function () {
-            _this._segmentInventory.completeSegment(_infos, _this._buffered);
-            return observableOf(undefined);
-        });
+    HTMLTextSegmentBuffer.prototype.endOfSegment = function (infos) {
+        this._segmentInventory.completeSegment(infos, this._buffered);
+        return Promise.resolve();
     };
     /**
      * Returns the currently buffered data, in a TimeRanges object.
@@ -180,8 +137,7 @@ var HTMLTextSegmentBuffer = /** @class */ (function (_super) {
         this._disableCurrentCues();
         this._buffer.remove(0, Infinity);
         this._buffered.remove(0, Infinity);
-        this._destroy$.next();
-        this._destroy$.complete();
+        this._canceller.cancel();
     };
     /**
      * Push the text track contained in `data` to the HTMLTextSegmentBuffer
@@ -195,7 +151,7 @@ var HTMLTextSegmentBuffer = /** @class */ (function (_super) {
      *
      * /!\ This method won't add any data to the linked inventory.
      * Please use the `pushChunk` method for most use-cases.
-     * @param {Object} data
+     * @param {Object} infos
      * @returns {boolean}
      */
     HTMLTextSegmentBuffer.prototype.pushChunkSync = function (infos) {
@@ -282,7 +238,7 @@ var HTMLTextSegmentBuffer = /** @class */ (function (_super) {
      * Remove the current cue from being displayed.
      */
     HTMLTextSegmentBuffer.prototype._disableCurrentCues = function () {
-        this._clearSizeUpdates$.next();
+        this._sizeUpdateCanceller.cancel();
         if (this._currentCues.length > 0) {
             for (var i = 0; i < this._currentCues.length; i++) {
                 safelyRemoveChild(this._textTrackElement, this._currentCues[i].element);
@@ -292,7 +248,7 @@ var HTMLTextSegmentBuffer = /** @class */ (function (_super) {
     };
     /**
      * Display a new Cue. If one was already present, it will be replaced.
-     * @param {HTMLElement} element
+     * @param {HTMLElement} elements
      */
     HTMLTextSegmentBuffer.prototype._displayCues = function (elements) {
         var nothingChanged = this._currentCues.length === elements.length &&
@@ -302,7 +258,7 @@ var HTMLTextSegmentBuffer = /** @class */ (function (_super) {
         }
         // Remove and re-display everything
         // TODO More intelligent handling
-        this._clearSizeUpdates$.next();
+        this._sizeUpdateCanceller.cancel();
         for (var i = 0; i < this._currentCues.length; i++) {
             safelyRemoveChild(this._textTrackElement, this._currentCues[i].element);
         }
@@ -316,17 +272,73 @@ 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 });
             var TEXT_TRACK_SIZE_CHECKS_INTERVAL = config.getCurrent().TEXT_TRACK_SIZE_CHECKS_INTERVAL;
             // update propertionally-sized elements periodically
-            onHeightWidthChange(this._textTrackElement, TEXT_TRACK_SIZE_CHECKS_INTERVAL)
-                .pipe(takeUntil(this._clearSizeUpdates$), takeUntil(this._destroy$))
-                .subscribe(function (_a) {
+            var heightWidthRef = onHeightWidthChange(this._textTrackElement, TEXT_TRACK_SIZE_CHECKS_INTERVAL, this._sizeUpdateCanceller.signal);
+            heightWidthRef.onUpdate(function (_a) {
                 var height = _a.height, width = _a.width;
                 for (var i = 0; i < proportionalCues.length; i++) {
                     var _b = proportionalCues[i], resolution = _b.resolution, element = _b.element;
                     updateProportionalElements(height, width, resolution, element);
                 }
+            }, { clearSignal: this._sizeUpdateCanceller.signal,
+                emitCurrentValue: true });
+        }
+    };
+    /**
+     * Auto-refresh the display of subtitles according to the media element's
+     * position and events.
+     * @param {Object} cancellationSignal
+     */
+    HTMLTextSegmentBuffer.prototype.autoRefreshSubtitles = function (cancellationSignal) {
+        var _this = this;
+        var autoRefreshCanceller = null;
+        var MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL = config.getCurrent().MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL;
+        var startAutoRefresh = function () {
+            stopAutoRefresh();
+            autoRefreshCanceller = new TaskCanceller({ cancelOn: cancellationSignal });
+            var intervalId = setInterval(function () { return _this.refreshSubtitles(); }, MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL);
+            autoRefreshCanceller.signal.register(function () {
+                clearInterval(intervalId);
             });
+            _this.refreshSubtitles();
+        };
+        onSeeking(this._videoElement, function () {
+            stopAutoRefresh();
+            _this._disableCurrentCues();
+        }, cancellationSignal);
+        onSeeked(this._videoElement, startAutoRefresh, cancellationSignal);
+        onEnded(this._videoElement, startAutoRefresh, cancellationSignal);
+        function stopAutoRefresh() {
+            if (autoRefreshCanceller !== null) {
+                autoRefreshCanceller.cancel();
+                autoRefreshCanceller = null;
+            }
+        }
+    };
+    /**
+     * Refresh current subtitles according to the current media element's
+     * position.
+     */
+    HTMLTextSegmentBuffer.prototype.refreshSubtitles = function () {
+        var videoElt = this._videoElement;
+        var MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL = config.getCurrent().MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL;
+        var time;
+        if (videoElt.paused || videoElt.playbackRate <= 0) {
+            time = videoElt.currentTime;
+        }
+        else {
+            // to spread the time error, we divide the regular chosen interval.
+            time = Math.max(this._videoElement.currentTime +
+                (MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL / 1000) / 2, 0);
+        }
+        var cues = this._buffer.get(time);
+        if (cues.length === 0) {
+            this._disableCurrentCues();
+        }
+        else {
+            this._displayCues(cues);
         }
     };
     return HTMLTextSegmentBuffer;

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

@@ -13,7 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Observable } from "rxjs";
 import { IEndOfSegmentInfos, IPushChunkInfos, SegmentBuffer } from "../../types";
 import ManualTimeRanges from "../../utils/manual_time_ranges";
 /**
@@ -35,26 +34,21 @@ export default class NativeTextSegmentBuffer extends SegmentBuffer {
     constructor(videoElement: HTMLMediaElement, hideNativeSubtitle: boolean);
     /**
      * @param {Object} infos
-     * @returns {Observable}
+     * @returns {Promise}
      */
-    pushChunk(infos: IPushChunkInfos<unknown>): Observable<void>;
+    pushChunk(infos: IPushChunkInfos<unknown>): Promise<void>;
     /**
      * Remove buffered data.
      * @param {number} start - start position, in seconds
      * @param {number} end - end position, in seconds
-     * @returns {Observable}
+     * @returns {Promise}
      */
-    removeBuffer(start: number, end: number): Observable<void>;
+    removeBuffer(start: number, end: number): Promise<void>;
     /**
-     * Indicate that every chunks from a Segment has been given to pushChunk so
-     * far.
-     * This will update our internal Segment inventory accordingly.
-     * The returned Observable will emit and complete successively once the whole
-     * segment has been pushed and this indication is acknowledged.
      * @param {Object} infos
-     * @returns {Observable}
+     * @returns {Promise}
      */
-    endOfSegment(_infos: IEndOfSegmentInfos): Observable<void>;
+    endOfSegment(_infos: IEndOfSegmentInfos): Promise<void>;
     /**
      * Returns the currently buffered data, in a TimeRanges object.
      * @returns {TimeRanges}

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

@@ -28,7 +28,6 @@ var __extends = (this && this.__extends) || (function () {
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
 })();
-import { defer as observableDefer, of as observableOf, } from "rxjs";
 import { addTextTrack, } from "../../../../../compat";
 import removeCue from "../../../../../compat/remove_cue";
 import log from "../../../../../log";
@@ -61,21 +60,20 @@ var NativeTextSegmentBuffer = /** @class */ (function (_super) {
     }
     /**
      * @param {Object} infos
-     * @returns {Observable}
+     * @returns {Promise}
      */
     NativeTextSegmentBuffer.prototype.pushChunk = function (infos) {
-        var _this = this;
-        return observableDefer(function () {
-            var _a, _b;
-            log.debug("NTSB: Appending new native text tracks");
-            if (infos.data.chunk === null) {
-                return observableOf(undefined);
-            }
-            var _c = infos.data, timestampOffset = _c.timestampOffset, appendWindow = _c.appendWindow, chunk = _c.chunk;
-            assertChunkIsTextTrackSegmentData(chunk);
-            var startTime = chunk.start, endTime = chunk.end, dataString = chunk.data, type = chunk.type, language = chunk.language;
-            var appendWindowStart = (_a = appendWindow[0]) !== null && _a !== void 0 ? _a : 0;
-            var appendWindowEnd = (_b = appendWindow[1]) !== null && _b !== void 0 ? _b : Infinity;
+        var _a, _b;
+        log.debug("NTSB: Appending new native text tracks");
+        if (infos.data.chunk === null) {
+            return Promise.resolve();
+        }
+        var _c = infos.data, timestampOffset = _c.timestampOffset, appendWindow = _c.appendWindow, chunk = _c.chunk;
+        assertChunkIsTextTrackSegmentData(chunk);
+        var startTime = chunk.start, endTime = chunk.end, dataString = chunk.data, type = chunk.type, language = chunk.language;
+        var appendWindowStart = (_a = appendWindow[0]) !== null && _a !== void 0 ? _a : 0;
+        var appendWindowEnd = (_b = appendWindow[1]) !== null && _b !== void 0 ? _b : Infinity;
+        try {
             var cues = parseTextTrackToCues(type, dataString, timestampOffset, language);
             if (appendWindowStart !== 0 && appendWindowEnd !== Infinity) {
                 // Removing before window start
@@ -101,33 +99,33 @@ var NativeTextSegmentBuffer = /** @class */ (function (_super) {
                     i--;
                 }
             }
-            var start;
+            var start = void 0;
             if (startTime !== undefined) {
                 start = Math.max(appendWindowStart, startTime);
             }
             else {
                 if (cues.length <= 0) {
                     log.warn("NTSB: Current text tracks have no cues nor start time. Aborting");
-                    return observableOf(undefined);
+                    return Promise.resolve();
                 }
                 log.warn("NTSB: No start time given. Guessing from cues.");
                 start = cues[0].startTime;
             }
-            var end;
+            var end = void 0;
             if (endTime !== undefined) {
                 end = Math.min(appendWindowEnd, endTime);
             }
             else {
                 if (cues.length <= 0) {
                     log.warn("NTSB: Current text tracks have no cues nor end time. Aborting");
-                    return observableOf(undefined);
+                    return Promise.resolve();
                 }
                 log.warn("NTSB: No end time given. Guessing from cues.");
                 end = cues[cues.length - 1].endTime;
             }
             if (end <= start) {
                 log.warn("NTSB: Invalid text track appended: ", "the start time is inferior or equal to the end time.");
-                return observableOf(undefined);
+                return Promise.resolve();
             }
             if (cues.length > 0) {
                 var firstCue = cues[0];
@@ -135,51 +133,43 @@ var NativeTextSegmentBuffer = /** @class */ (function (_super) {
                 // ones are in the past. this is supposed to fix an issue on
                 // IE/Edge.
                 // TODO Move to compat
-                var currentCues = _this._track.cues;
+                var currentCues = this._track.cues;
                 if (currentCues !== null && currentCues.length > 0) {
                     if (firstCue.startTime < currentCues[currentCues.length - 1].startTime) {
-                        _this._removeData(firstCue.startTime, +Infinity);
+                        this._removeData(firstCue.startTime, +Infinity);
                     }
                 }
                 for (var i = 0; i < cues.length; i++) {
-                    _this._track.addCue(cues[i]);
+                    this._track.addCue(cues[i]);
                 }
             }
-            _this._buffered.insert(start, end);
+            this._buffered.insert(start, end);
             if (infos.inventoryInfos !== null) {
-                _this._segmentInventory.insertChunk(infos.inventoryInfos);
+                this._segmentInventory.insertChunk(infos.inventoryInfos);
             }
-            return observableOf(undefined);
-        });
+        }
+        catch (err) {
+            return Promise.reject(err);
+        }
+        return Promise.resolve();
     };
     /**
      * Remove buffered data.
      * @param {number} start - start position, in seconds
      * @param {number} end - end position, in seconds
-     * @returns {Observable}
+     * @returns {Promise}
      */
     NativeTextSegmentBuffer.prototype.removeBuffer = function (start, end) {
-        var _this = this;
-        return observableDefer(function () {
-            _this._removeData(start, end);
-            return observableOf(undefined);
-        });
+        this._removeData(start, end);
+        return Promise.resolve();
     };
     /**
-     * Indicate that every chunks from a Segment has been given to pushChunk so
-     * far.
-     * This will update our internal Segment inventory accordingly.
-     * The returned Observable will emit and complete successively once the whole
-     * segment has been pushed and this indication is acknowledged.
      * @param {Object} infos
-     * @returns {Observable}
+     * @returns {Promise}
      */
     NativeTextSegmentBuffer.prototype.endOfSegment = function (_infos) {
-        var _this = this;
-        return observableDefer(function () {
-            _this._segmentInventory.completeSegment(_infos, _this._buffered);
-            return observableOf(undefined);
-        });
+        this._segmentInventory.completeSegment(_infos, this._buffered);
+        return Promise.resolve();
     };
     /**
      * Returns the currently buffered data, in a TimeRanges object.

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

@@ -13,8 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Observable } from "rxjs";
 import { Adaptation, ISegment, Period, Representation } from "../../../manifest";
+import { CancellationSignal } from "../../../utils/task_canceller";
 import SegmentInventory, { IBufferedChunk, IBufferedHistoryEntry, IChunkContext, IInsertedChunkInfos } from "../inventory";
 /**
  * Class allowing to push segments and remove data to a buffer to be able
@@ -93,26 +93,29 @@ export declare abstract class SegmentBuffer {
      * `data.chunk` argument to null.
      *
      * @param {Object} infos
-     * @returns {Observable}
+     * @param {Object} cancellationSignal
+     * @returns {Promise}
      */
-    abstract pushChunk(infos: IPushChunkInfos<unknown>): Observable<void>;
+    abstract pushChunk(infos: IPushChunkInfos<unknown>, cancellationSignal: CancellationSignal): Promise<void>;
     /**
      * Remove buffered data (added to the same FIFO queue than `pushChunk`).
      * @param {number} start - start position, in seconds
      * @param {number} end - end position, in seconds
-     * @returns {Observable}
+     * @param {Object} cancellationSignal
+     * @returns {Promise}
      */
-    abstract removeBuffer(start: number, end: number): Observable<void>;
+    abstract removeBuffer(start: number, end: number, cancellationSignal: CancellationSignal): Promise<void>;
     /**
      * Indicate that every chunks from a Segment has been given to pushChunk so
      * far.
      * This will update our internal Segment inventory accordingly.
-     * The returned Observable will emit and complete successively once the whole
-     * segment has been pushed and this indication is acknowledged.
+     * The returned Promise will resolve once the whole segment has been pushed
+     * and this indication is acknowledged.
      * @param {Object} infos
-     * @returns {Observable}
+     * @param {Object} cancellationSignal
+     * @returns {Promise}
      */
-    abstract endOfSegment(infos: IEndOfSegmentInfos): Observable<void>;
+    abstract endOfSegment(infos: IEndOfSegmentInfos, cancellationSignal: CancellationSignal): Promise<void>;
     /**
      * Returns the currently buffered data, in a TimeRanges object.
      * @returns {TimeRanges}

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

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Observable } from "rxjs";
+import { CancellationSignal } from "../../utils/task_canceller";
 import { IBufferType, SegmentBuffer } from "./implementations";
 /** Options available for a "text" SegmentBuffer */
 export declare type ITextTrackSegmentBufferOptions = {
@@ -43,7 +43,7 @@ declare type INativeMediaBufferType = "audio" | "video";
  * To be able to use a SegmentBuffer linked to a native media buffer, you
  * will first need to create it, but also wait until the other one is either
  * created or explicitely disabled through the `disableSegmentBuffer` method.
- * The Observable returned by `waitForUsableBuffers` will emit when
+ * The Promise returned by `waitForUsableBuffers` will emit when
  * that is the case.
  *
  * @class SegmentBuffersStore
@@ -73,7 +73,7 @@ export default class SegmentBuffersStore {
     /**
      * Callbacks called after a SourceBuffer is either created or disabled.
      * Used for example to trigger the `this.waitForUsableBuffers`
-     * Observable.
+     * Promise.
      */
     private _onNativeBufferAddedOrDisabled;
     /**
@@ -129,7 +129,7 @@ export default class SegmentBuffersStore {
      * content need to all be created (by creating SegmentBuffers linked to them)
      * before any one can be used.
      *
-     * This function will return an Observable emitting when any and all native
+     * This function will return a Promise resolving when any and all native
      * SourceBuffers can be used.
      *
      * From https://w3c.github.io/media-source/#methods
@@ -137,9 +137,10 @@ export default class SegmentBuffersStore {
      *   exception if the media element has reached the HAVE_METADATA
      *   readyState. This can occur if the user agent's media engine
      *   does not support adding more tracks during playback.
-     * @return {Observable}
+     * @param {Object} cancelWaitSignal
+     * @return {Promise}
      */
-    waitForUsableBuffers(): Observable<void>;
+    waitForUsableBuffers(cancelWaitSignal: CancellationSignal): Promise<void>;
     /**
      * Explicitely disable the SegmentBuffer for a given buffer type.
      * A call to this function is needed at least for unused native buffer types

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

@@ -13,7 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Observable, of as observableOf, } from "rxjs";
 import { MediaError } from "../../errors";
 import features from "../../features";
 import log from "../../log";
@@ -38,7 +37,7 @@ var POSSIBLE_BUFFER_TYPES = ["audio",
  * To be able to use a SegmentBuffer linked to a native media buffer, you
  * will first need to create it, but also wait until the other one is either
  * created or explicitely disabled through the `disableSegmentBuffer` method.
- * The Observable returned by `waitForUsableBuffers` will emit when
+ * The Promise returned by `waitForUsableBuffers` will emit when
  * that is the case.
  *
  * @class SegmentBuffersStore
@@ -126,7 +125,7 @@ var SegmentBuffersStore = /** @class */ (function () {
      * content need to all be created (by creating SegmentBuffers linked to them)
      * before any one can be used.
      *
-     * This function will return an Observable emitting when any and all native
+     * This function will return a Promise resolving when any and all native
      * SourceBuffers can be used.
      *
      * From https://w3c.github.io/media-source/#methods
@@ -134,19 +133,27 @@ var SegmentBuffersStore = /** @class */ (function () {
      *   exception if the media element has reached the HAVE_METADATA
      *   readyState. This can occur if the user agent's media engine
      *   does not support adding more tracks during playback.
-     * @return {Observable}
+     * @param {Object} cancelWaitSignal
+     * @return {Promise}
      */
-    SegmentBuffersStore.prototype.waitForUsableBuffers = function () {
+    SegmentBuffersStore.prototype.waitForUsableBuffers = function (cancelWaitSignal) {
         var _this = this;
         if (this._areNativeBuffersUsable()) {
-            return observableOf(undefined);
+            return Promise.resolve();
         }
-        return new Observable(function (obs) {
-            _this._onNativeBufferAddedOrDisabled.push(function () {
+        return new Promise(function (res, rej) {
+            var onAddedOrDisabled = function () {
                 if (_this._areNativeBuffersUsable()) {
-                    obs.next(undefined);
-                    obs.complete();
+                    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);
             });
         });
     };

package/dist/_esm5.processed/core/stream/orchestrator/stream_orchestrator.js

@@ -22,15 +22,18 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     }
     return to.concat(ar || Array.prototype.slice.call(from));
 };
-import { combineLatest, concat as observableConcat, defer as observableDefer, distinctUntilChanged, EMPTY, exhaustMap, filter, ignoreElements, map, merge as observableMerge, mergeMap, of as observableOf, share, startWith, Subject, take, takeUntil, tap, } from "rxjs";
+import { combineLatest, concat as observableConcat, defer as observableDefer, distinctUntilChanged, EMPTY, exhaustMap, filter, ignoreElements, map, merge as observableMerge, mergeMap, Observable, of as observableOf, share, startWith, Subject, take, takeUntil, tap, } from "rxjs";
 import config from "../../../config";
 import { MediaError } from "../../../errors";
 import log from "../../../log";
 import deferSubscriptions from "../../../utils/defer_subscriptions";
 import { fromEvent } from "../../../utils/event_emitter";
 import filterMap from "../../../utils/filter_map";
+import { createMappedReference, } from "../../../utils/reference";
+import fromCancellablePromise from "../../../utils/rx-from_cancellable_promise";
 import nextTickObs from "../../../utils/rx-next-tick";
 import SortedList from "../../../utils/sorted_list";
+import TaskCanceller from "../../../utils/task_canceller";
 import WeakMapMemory from "../../../utils/weak_map_memory";
 import { BufferGarbageCollector, } from "../../segment_buffers";
 import EVENTS from "../events_generators";
@@ -77,12 +80,15 @@ export default function StreamOrchestrator(content, playbackObserver, representa
         var defaultMaxAhead = MAXIMUM_MAX_BUFFER_AHEAD[bufferType] != null ?
             MAXIMUM_MAX_BUFFER_AHEAD[bufferType] :
             Infinity;
-        return BufferGarbageCollector({
-            segmentBuffer: segmentBuffer,
-            currentTime$: playbackObserver.getReference().asObservable()
-                .pipe(map(function (o) { var _a; return (_a = o.position.pending) !== null && _a !== void 0 ? _a : o.position.last; })),
-            maxBufferBehind$: maxBufferBehind.asObservable().pipe(map(function (val) { return Math.min(val, defaultMaxBehind); })),
-            maxBufferAhead$: maxBufferAhead.asObservable().pipe(map(function (val) { return Math.min(val, defaultMaxAhead); })),
+        return new Observable(function () {
+            var canceller = new TaskCanceller();
+            BufferGarbageCollector({ segmentBuffer: segmentBuffer, playbackObserver: playbackObserver, maxBufferBehind: createMappedReference(maxBufferBehind, function (val) {
+                    return Math.min(val, defaultMaxBehind);
+                }, canceller.signal),
+                maxBufferAhead: createMappedReference(maxBufferAhead, function (val) {
+                    return Math.min(val, defaultMaxAhead);
+                }, canceller.signal) }, canceller.signal);
+            return function () { canceller.cancel(); };
         });
     });
     // Every PeriodStreams for every possible types
@@ -222,8 +228,13 @@ export default function StreamOrchestrator(content, playbackObserver, representa
             destroyStreams$.next();
             return observableConcat.apply(void 0, __spreadArray(__spreadArray([], rangesToClean.map(function (_a) {
                 var start = _a.start, end = _a.end;
-                return start >= end ? EMPTY :
-                    segmentBuffer.removeBuffer(start, end).pipe(ignoreElements());
+                if (start >= end) {
+                    return EMPTY;
+                }
+                var canceller = new TaskCanceller();
+                return fromCancellablePromise(canceller, function () {
+                    return segmentBuffer.removeBuffer(start, end, canceller.signal);
+                }).pipe(ignoreElements());
             }), false), [
                 // Schedule micro task before checking the last playback observation
                 // to reduce the risk of race conditions where the next observation