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

package/dist/_esm5.processed/core/segment_buffers/implementations/audio_video/audio_video_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 { fromEvent, interval, Observable, Subject, takeUntil, tap, } from "rxjs";
 import { tryToChangeSourceBufferType, } from "../../../../compat";
 import config from "../../../../config";
 import log from "../../../../log";
@@ -37,7 +36,9 @@ import areArraysOfNumbersEqual from "../../../../utils/are_arrays_of_numbers_equ
 import assertUnreachable from "../../../../utils/assert_unreachable";
 import { toUint8Array } from "../../../../utils/byte_parsing";
 import hashBuffer from "../../../../utils/hash_buffer";
+import noop from "../../../../utils/noop";
 import objectAssign from "../../../../utils/object_assign";
+import TaskCanceller, { CancellationError, } from "../../../../utils/task_canceller";
 import { SegmentBuffer, SegmentBufferOperation, } from "../types";
 /**
  * Allows to push and remove new segments to a SourceBuffer in a FIFO queue (not
@@ -55,12 +56,12 @@ var AudioVideoSegmentBuffer = /** @class */ (function (_super) {
      * @constructor
      * @param {string} bufferType
      * @param {string} codec
-     * @param {SourceBuffer} sourceBuffer
+     * @param {MediaSource} mediaSource
      */
     function AudioVideoSegmentBuffer(bufferType, codec, mediaSource) {
         var _this = _super.call(this) || this;
         var sourceBuffer = mediaSource.addSourceBuffer(codec);
-        _this._destroy$ = new Subject();
+        _this._canceller = new TaskCanceller();
         _this.bufferType = bufferType;
         _this._mediaSource = mediaSource;
         _this._sourceBuffer = sourceBuffer;
@@ -68,16 +69,23 @@ var AudioVideoSegmentBuffer = /** @class */ (function (_super) {
         _this._pendingTask = null;
         _this._lastInitSegment = null;
         _this.codec = codec;
-        var SOURCE_BUFFER_FLUSHING_INTERVAL = config.getCurrent().SOURCE_BUFFER_FLUSHING_INTERVAL;
+        var onError = _this._onPendingTaskError.bind(_this);
+        var reCheck = _this._flush.bind(_this);
         // Some browsers (happened with firefox 66) sometimes "forget" to send us
         // `update` or `updateend` events.
         // In that case, we're completely unable to continue the queue here and
         // stay locked in a waiting state.
         // This interval is here to check at regular intervals if the underlying
         // SourceBuffer is currently updating.
-        interval(SOURCE_BUFFER_FLUSHING_INTERVAL).pipe(tap(function () { return _this._flush(); }), takeUntil(_this._destroy$)).subscribe();
-        fromEvent(_this._sourceBuffer, "error").pipe(tap(function (err) { return _this._onPendingTaskError(err); }), takeUntil(_this._destroy$)).subscribe();
-        fromEvent(_this._sourceBuffer, "updateend").pipe(tap(function () { return _this._flush(); }), takeUntil(_this._destroy$)).subscribe();
+        var SOURCE_BUFFER_FLUSHING_INTERVAL = config.getCurrent().SOURCE_BUFFER_FLUSHING_INTERVAL;
+        var intervalId = setInterval(reCheck, SOURCE_BUFFER_FLUSHING_INTERVAL);
+        _this._sourceBuffer.addEventListener("error", onError);
+        _this._sourceBuffer.addEventListener("updateend", reCheck);
+        _this._canceller.signal.register(function () {
+            clearInterval(intervalId);
+            _this._sourceBuffer.removeEventListener("error", onError);
+            _this._sourceBuffer.removeEventListener("updateend", reCheck);
+        });
         return _this;
     }
     /**
@@ -104,38 +112,40 @@ var AudioVideoSegmentBuffer = /** @class */ (function (_super) {
      * `data.chunk` argument to null.
      *
      * @param {Object} infos
-     * @returns {Observable}
+     * @param {Object} cancellationSignal
+     * @returns {Promise}
      */
-    AudioVideoSegmentBuffer.prototype.pushChunk = function (infos) {
+    AudioVideoSegmentBuffer.prototype.pushChunk = function (infos, cancellationSignal) {
         assertPushedDataIsBufferSource(infos);
         log.debug("AVSB: receiving order to push data to the SourceBuffer", this.bufferType, getLoggableSegmentId(infos.inventoryInfos));
         return this._addToQueue({ type: SegmentBufferOperation.Push,
-            value: infos });
+            value: infos }, cancellationSignal);
     };
     /**
      * 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}
      */
-    AudioVideoSegmentBuffer.prototype.removeBuffer = function (start, end) {
+    AudioVideoSegmentBuffer.prototype.removeBuffer = function (start, end, cancellationSignal) {
         log.debug("AVSB: receiving order to remove data from the SourceBuffer", this.bufferType, start, end);
         return this._addToQueue({ type: SegmentBufferOperation.Remove,
-            value: { start: start, end: end } });
+            value: { start: start, end: end } }, cancellationSignal);
     };
     /**
      * 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}
+     * @returns {Promise}
      */
-    AudioVideoSegmentBuffer.prototype.endOfSegment = function (infos) {
+    AudioVideoSegmentBuffer.prototype.endOfSegment = function (infos, cancellationSignal) {
         log.debug("AVSB: receiving order for validating end of segment", this.bufferType, getLoggableSegmentId(infos));
         return this._addToQueue({ type: SegmentBufferOperation.EndOfSegment,
-            value: infos });
+            value: infos }, cancellationSignal);
     };
     /**
      * Returns the currently buffered data, in a TimeRanges object.
@@ -175,16 +185,15 @@ var AudioVideoSegmentBuffer = /** @class */ (function (_super) {
      * @private
      */
     AudioVideoSegmentBuffer.prototype.dispose = function () {
-        this._destroy$.next();
-        this._destroy$.complete();
+        this._canceller.cancel();
         if (this._pendingTask !== null) {
-            this._pendingTask.subject.complete();
+            this._pendingTask.reject(new CancellationError());
             this._pendingTask = null;
         }
         while (this._queue.length > 0) {
             var nextElement = this._queue.shift();
             if (nextElement !== undefined) {
-                nextElement.subject.complete();
+                nextElement.reject(new CancellationError());
             }
         }
         if (this._mediaSource.readyState === "open") {
@@ -198,7 +207,7 @@ var AudioVideoSegmentBuffer = /** @class */ (function (_super) {
     };
     /**
      * Called when an error arised that made the current task fail.
-     * @param {Event} error
+     * @param {Event} err
      */
     AudioVideoSegmentBuffer.prototype._onPendingTaskError = function (err) {
         this._lastInitSegment = null; // initialize init segment as a security
@@ -207,7 +216,7 @@ var AudioVideoSegmentBuffer = /** @class */ (function (_super) {
                 err :
                 new Error("An unknown error occured when doing operations " +
                     "on the SourceBuffer");
-            this._pendingTask.subject.error(error);
+            this._pendingTask.reject(error);
         }
     };
     /**
@@ -218,22 +227,20 @@ var AudioVideoSegmentBuffer = /** @class */ (function (_super) {
      * Cancel queued operation on unsubscription.
      * @private
      * @param {Object} operation
-     * @returns {Observable}
+     * @param {Object} cancellationSignal
+     * @returns {Promise}
      */
-    AudioVideoSegmentBuffer.prototype._addToQueue = function (operation) {
+    AudioVideoSegmentBuffer.prototype._addToQueue = function (operation, cancellationSignal) {
         var _this = this;
-        return new Observable(function (obs) {
+        return new Promise(function (resolve, reject) {
+            if (cancellationSignal.cancellationError !== null) {
+                return reject(cancellationSignal.cancellationError);
+            }
             var shouldRestartQueue = _this._queue.length === 0 &&
                 _this._pendingTask === null;
-            var subject = new Subject();
-            var queueItem = objectAssign({ subject: subject }, operation);
+            var queueItem = objectAssign({ resolve: resolve, reject: reject }, operation);
             _this._queue.push(queueItem);
-            var subscription = subject.subscribe(obs);
-            if (shouldRestartQueue) {
-                _this._flush();
-            }
-            return function () {
-                subscription.unsubscribe();
+            cancellationSignal.register(function (error) {
                 // Remove the corresponding element from the AudioVideoSegmentBuffer's
                 // queue.
                 // If the operation was a pending task, it should still continue to not
@@ -242,7 +249,13 @@ var AudioVideoSegmentBuffer = /** @class */ (function (_super) {
                 if (index >= 0) {
                     _this._queue.splice(index, 1);
                 }
-            };
+                queueItem.resolve = noop;
+                queueItem.reject = noop;
+                reject(error);
+            });
+            if (shouldRestartQueue) {
+                _this._flush();
+            }
         });
     };
     /**
@@ -272,10 +285,9 @@ var AudioVideoSegmentBuffer = /** @class */ (function (_super) {
                     default:
                         assertUnreachable(task);
                 }
-                var subject = task.subject;
+                var resolve = task.resolve;
                 this._pendingTask = null;
-                subject.next();
-                subject.complete();
+                resolve();
                 this._flush(); // Go to next item in queue
                 return;
             }
@@ -301,7 +313,7 @@ var AudioVideoSegmentBuffer = /** @class */ (function (_super) {
                         e :
                         new Error("An unknown error occured when preparing a push operation");
                     this._lastInitSegment = null; // initialize init segment as a security
-                    nextItem.subject.error(error);
+                    nextItem.reject(error);
                     return;
                 }
                 this._pendingTask = objectAssign({ data: dataToPush,
@@ -345,7 +357,7 @@ var AudioVideoSegmentBuffer = /** @class */ (function (_super) {
      *
      * This method allows to "prepare" that push operation so that all is left is
      * to push the returned segment data one after the other (from first to last).
-     * @param {Object} item
+     * @param {Object} data
      * @returns {Object}
      */
     AudioVideoSegmentBuffer.prototype._preparePushOperation = function (data) {

package/dist/_esm5.processed/core/segment_buffers/implementations/image/image_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 { IBifThumbnail } from "../../../../parsers/images/bif";
 import { IEndOfSegmentInfos, IPushChunkInfos, SegmentBuffer } from "../types";
 import ManualTimeRanges from "../utils/manual_time_ranges";
@@ -27,13 +26,15 @@ export default class ImageSegmentBuffer extends SegmentBuffer {
     constructor();
     /**
      * @param {Object} data
+     * @returns {Promise}
      */
-    pushChunk(infos: IPushChunkInfos<unknown>): Observable<void>;
+    pushChunk(infos: IPushChunkInfos<unknown>): Promise<void>;
     /**
      * @param {Number} from
      * @param {Number} to
+     * @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.
@@ -41,9 +42,9 @@ export default class ImageSegmentBuffer extends SegmentBuffer {
      * 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/image/image_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 log from "../../../../log";
 import { SegmentBuffer, } from "../types";
 import ManualTimeRanges from "../utils/manual_time_ranges";
@@ -48,48 +47,50 @@ var ImageSegmentBuffer = /** @class */ (function (_super) {
     }
     /**
      * @param {Object} data
+     * @returns {Promise}
      */
     ImageSegmentBuffer.prototype.pushChunk = function (infos) {
-        var _this = this;
-        return observableDefer(function () {
-            var _a, _b;
-            log.debug("ISB: appending new data.");
-            if (infos.data.chunk === null) {
-                return observableOf(undefined);
-            }
-            var _c = infos.data, appendWindow = _c.appendWindow, chunk = _c.chunk;
-            // The following check is ugly. I don't care, the image buffer is there
-            // due to an ugly deprecated API that will soon disappear
-            var _d = chunk, start = _d.start, end = _d.end, timescale = _d.timescale;
-            var appendWindowStart = (_a = appendWindow[0]) !== null && _a !== void 0 ? _a : 0;
-            var appendWindowEnd = (_b = appendWindow[1]) !== null && _b !== void 0 ? _b : Infinity;
-            var timescaledStart = start / timescale;
-            var timescaledEnd = end / timescale;
-            var startTime = Math.max(appendWindowStart, timescaledStart);
-            var endTime = Math.min(appendWindowEnd, timescaledEnd);
-            _this._buffered.insert(startTime, endTime);
+        var _a, _b;
+        log.debug("ISB: appending new data.");
+        if (infos.data.chunk === null) {
+            return Promise.resolve();
+        }
+        var _c = infos.data, appendWindow = _c.appendWindow, chunk = _c.chunk;
+        // The following check is ugly. I don't care, the image buffer is there
+        // due to an ugly deprecated API that will soon disappear
+        var _d = chunk, start = _d.start, end = _d.end, timescale = _d.timescale;
+        var appendWindowStart = (_a = appendWindow[0]) !== null && _a !== void 0 ? _a : 0;
+        var appendWindowEnd = (_b = appendWindow[1]) !== null && _b !== void 0 ? _b : Infinity;
+        var timescaledStart = start / timescale;
+        var timescaledEnd = end / timescale;
+        var startTime = Math.max(appendWindowStart, timescaledStart);
+        var endTime = Math.min(appendWindowEnd, timescaledEnd);
+        try {
+            this._buffered.insert(startTime, endTime);
             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();
     };
     /**
      * @param {Number} from
      * @param {Number} to
+     * @returns {Promise}
      */
     ImageSegmentBuffer.prototype.removeBuffer = function (start, end) {
-        return observableDefer(function () {
-            log.info("ISB: ignored image data remove order", start, end);
-            // Logic removed as it caused more problems than it resolved:
-            // Image thumbnails are always downloaded as a single BIF file, meaning that
-            // any removing might necessitate to re-load the whole file in the future
-            // which seems pointless.
-            // In any case, image handling through the regular RxPlayer APIs has been
-            // completely deprecated now for several reasons, and should disappear in
-            // the next major version.
-            return observableOf(undefined);
-        });
+        log.info("ISB: ignored image data remove order", start, end);
+        // Logic removed as it caused more problems than it resolved:
+        // Image thumbnails are always downloaded as a single BIF file, meaning that
+        // any removing might necessitate to re-load the whole file in the future
+        // which seems pointless.
+        // In any case, image handling through the regular RxPlayer APIs has been
+        // completely deprecated now for several reasons, and should disappear in
+        // the next major version.
+        return Promise.resolve();
     };
     /**
      * Indicate that every chunks from a Segment has been given to pushChunk so
@@ -98,14 +99,11 @@ var ImageSegmentBuffer = /** @class */ (function (_super) {
      * 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}
      */
     ImageSegmentBuffer.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/text/html/html_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";
 /**
@@ -28,22 +27,18 @@ export default class HTMLTextSegmentBuffer extends SegmentBuffer {
      * Used to know when the user is seeking, for example.
      */
     private readonly _videoElement;
-    /**
-     * When "nexting" that subject, every Observable declared here will be
-     * unsubscribed.
-     * Used for clean-up
-     */
-    private readonly _destroy$;
+    /** Used for clean-up. */
+    private readonly _canceller;
     /** HTMLElement which will contain the cues */
     private readonly _textTrackElement;
     /** Buffer containing the data */
     private readonly _buffer;
     /**
      * We could need us to automatically update styling depending on
-     * `_textTrackElement`'s size. This Subject allows to stop that
+     * `_textTrackElement`'s size. This TaskCanceller allows to stop that
      * regular check.
      */
-    private _clearSizeUpdates$;
+    private _sizeUpdateCanceller;
     /** Information on cues currently displayed. */
     private _currentCues;
     private _buffered;
@@ -55,26 +50,21 @@ export default class HTMLTextSegmentBuffer extends SegmentBuffer {
     /**
      * Push segment on Subscription.
      * @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}
@@ -93,7 +83,7 @@ export default class HTMLTextSegmentBuffer extends SegmentBuffer {
      *
      * /!\ 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}
      */
     pushChunkSync(infos: IPushChunkInfos<unknown>): void;
@@ -109,9 +99,20 @@ export default class HTMLTextSegmentBuffer extends SegmentBuffer {
     private _disableCurrentCues;
     /**
      * Display a new Cue. If one was already present, it will be replaced.
-     * @param {HTMLElement} element
+     * @param {HTMLElement} elements
      */
     private _displayCues;
+    /**
+     * Auto-refresh the display of subtitles according to the media element's
+     * position and events.
+     * @param {Object} cancellationSignal
+     */
+    private autoRefreshSubtitles;
+    /**
+     * Refresh current subtitles according to the current media element's
+     * position.
+     */
+    private refreshSubtitles;
 }
 /** Data of chunks that should be pushed to the NativeTextSegmentBuffer. */
 export interface INativeTextTracksBufferSegmentData {