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

package/dist/_esm5.processed/core/init/stall_avoider.js

@@ -31,12 +31,13 @@ var EPSILON = 1 / 60;
  * encountered and exited.
  * @param {object} playbackObserver - emit the current playback conditions.
  * @param {Object} manifest - The Manifest of the currently-played content.
+ * @param {Object} speed - The last speed set by the user
+ * @param {Observable} lockedStream$
  * @param {Observable} discontinuityUpdate$ - Observable emitting encountered
  * discontinuities for loaded Period and buffer types.
- * @param {Function} setCurrentTime
  * @returns {Observable}
  */
-export default function StallAvoider(playbackObserver, manifest, lockedStream$, discontinuityUpdate$) {
+export default function StallAvoider(playbackObserver, manifest, speed, lockedStream$, discontinuityUpdate$) {
     var initialDiscontinuitiesStore = [];
     /**
      * Emit every known audio and video buffer discontinuities in chronological
@@ -79,10 +80,9 @@ export default function StallAvoider(playbackObserver, manifest, lockedStream$,
     var unlock$ = lockedStream$.pipe(withLatestFrom(playbackObserver.getReference().asObservable()), tap(function (_a) {
         var _b;
         var lockedStreamEvt = _a[0], observation = _a[1];
-        // TODO(PaulB) also skip when the user's wanted speed is set to `0`, as we
-        // might not want to seek in that case?
         if (!observation.rebuffering ||
-            observation.paused || (lockedStreamEvt.bufferType !== "audio" &&
+            observation.paused ||
+            speed.getValue() <= 0 || (lockedStreamEvt.bufferType !== "audio" &&
             lockedStreamEvt.bufferType !== "video")) {
             return;
         }
@@ -103,9 +103,22 @@ export default function StallAvoider(playbackObserver, manifest, lockedStream$,
     /* eslint-disable-next-line @typescript-eslint/no-unsafe-argument */
     ignoreElements());
     var stall$ = playbackObserver.getReference().asObservable().pipe(withLatestFrom(discontinuitiesStore$), map(function (_a) {
+        var _b;
         var observation = _a[0], discontinuitiesStore = _a[1];
         var buffered = observation.buffered, position = observation.position, readyState = observation.readyState, rebuffering = observation.rebuffering, freezing = observation.freezing;
-        var _b = config.getCurrent(), BUFFER_DISCONTINUITY_THRESHOLD = _b.BUFFER_DISCONTINUITY_THRESHOLD, FORCE_DISCONTINUITY_SEEK_DELAY = _b.FORCE_DISCONTINUITY_SEEK_DELAY, FREEZING_STALLED_DELAY = _b.FREEZING_STALLED_DELAY, UNFREEZING_SEEK_DELAY = _b.UNFREEZING_SEEK_DELAY, UNFREEZING_DELTA_POSITION = _b.UNFREEZING_DELTA_POSITION;
+        var _c = config.getCurrent(), BUFFER_DISCONTINUITY_THRESHOLD = _c.BUFFER_DISCONTINUITY_THRESHOLD, FORCE_DISCONTINUITY_SEEK_DELAY = _c.FORCE_DISCONTINUITY_SEEK_DELAY, FREEZING_STALLED_DELAY = _c.FREEZING_STALLED_DELAY, UNFREEZING_SEEK_DELAY = _c.UNFREEZING_SEEK_DELAY, UNFREEZING_DELTA_POSITION = _c.UNFREEZING_DELTA_POSITION;
+        if (!observation.seeking &&
+            isSeekingApproximate &&
+            ignoredStallTimeStamp === null &&
+            lastSeekingPosition !== null &&
+            observation.position < lastSeekingPosition) {
+            log.debug("Init: the device appeared to have seeked back by itself.");
+            var now = performance.now();
+            ignoredStallTimeStamp = now;
+        }
+        lastSeekingPosition = observation.seeking ?
+            Math.max((_b = observation.pendingInternalSeek) !== null && _b !== void 0 ? _b : 0, observation.position) :
+            null;
         if (freezing !== null) {
             var now = performance.now();
             var referenceTimestamp = prevFreezingState === null ?
@@ -130,7 +143,7 @@ export default function StallAvoider(playbackObserver, manifest, lockedStream$,
                 // Return that we're stalled
                 var reason = void 0;
                 if (observation.seeking) {
-                    reason = observation.internalSeeking ? "internal-seek" :
+                    reason = observation.pendingInternalSeek !== null ? "internal-seek" :
                         "seeking";
                 }
                 else {
@@ -145,27 +158,19 @@ export default function StallAvoider(playbackObserver, manifest, lockedStream$,
         // We want to separate a stall situation when a seek is due to a seek done
         // internally by the player to when its due to a regular user seek.
         var stalledReason = rebuffering.reason === "seeking" &&
-            observation.internalSeeking ? "internal-seek" :
+            observation.pendingInternalSeek !== null ?
+            "internal-seek" :
             rebuffering.reason;
-        if (observation.seeking) {
-            lastSeekingPosition = observation.position;
-        }
-        else if (lastSeekingPosition !== null) {
+        if (ignoredStallTimeStamp !== null) {
             var now = performance.now();
-            if (ignoredStallTimeStamp === null) {
-                ignoredStallTimeStamp = now;
+            if (now - ignoredStallTimeStamp < FORCE_DISCONTINUITY_SEEK_DELAY) {
+                log.debug("Init: letting the device get out of a stall by itself");
+                return { type: "stalled",
+                    value: stalledReason };
             }
-            if (isSeekingApproximate && observation.position < lastSeekingPosition) {
-                log.debug("Init: the device appeared to have seeked back by itself.");
-                if (now - ignoredStallTimeStamp < FORCE_DISCONTINUITY_SEEK_DELAY) {
-                    return { type: "stalled",
-                        value: stalledReason };
-                }
-                else {
-                    log.warn("Init: ignored stall for too long, checking discontinuity", now - ignoredStallTimeStamp);
-                }
+            else {
+                log.warn("Init: ignored stall for too long, checking discontinuity", now - ignoredStallTimeStamp);
             }
-            lastSeekingPosition = null;
         }
         ignoredStallTimeStamp = null;
         if (manifest === null) {
@@ -174,7 +179,7 @@ export default function StallAvoider(playbackObserver, manifest, lockedStream$,
         }
         /** Position at which data is awaited. */
         var stalledPosition = rebuffering.position;
-        if (stalledPosition !== null) {
+        if (stalledPosition !== null && speed.getValue() > 0) {
             var skippableDiscontinuity = findSeekableDiscontinuity(discontinuitiesStore, manifest, stalledPosition);
             if (skippableDiscontinuity !== null) {
                 var realSeekTime = skippableDiscontinuity + 0.001;
@@ -197,7 +202,8 @@ export default function StallAvoider(playbackObserver, manifest, lockedStream$,
         // implementation that might drop an injected segment, or in
         // case of small discontinuity in the content.
         var nextBufferRangeGap = getNextRangeGap(buffered, freezePosition);
-        if (nextBufferRangeGap < BUFFER_DISCONTINUITY_THRESHOLD) {
+        if (speed.getValue() > 0 &&
+            nextBufferRangeGap < BUFFER_DISCONTINUITY_THRESHOLD) {
             var seekTo = (freezePosition + nextBufferRangeGap + EPSILON);
             if (playbackObserver.getCurrentTime() < seekTo) {
                 log.warn("Init: discontinuity encountered inferior to the threshold", freezePosition, seekTo, BUFFER_DISCONTINUITY_THRESHOLD);

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

@@ -13,24 +13,30 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Observable } from "rxjs";
+import { IReadOnlySharedReference } from "../../utils/reference";
+import { CancellationSignal } from "../../utils/task_canceller";
+import { IReadOnlyPlaybackObserver } from "../api";
+import { IStreamOrchestratorPlaybackObservation } from "../stream";
 import { SegmentBuffer } from "./implementations";
 export interface IGarbageCollectorArgument {
     /** SegmentBuffer implementation */
     segmentBuffer: SegmentBuffer;
     /** Emit current position in seconds regularly */
-    currentTime$: Observable<number>;
+    playbackObserver: IReadOnlyPlaybackObserver<Pick<IStreamOrchestratorPlaybackObservation, "position">>;
     /** Maximum time to keep behind current time position, in seconds */
-    maxBufferBehind$: Observable<number>;
+    maxBufferBehind: IReadOnlySharedReference<number>;
     /** Minimum time to keep behind current time position, in seconds */
-    maxBufferAhead$: Observable<number>;
+    maxBufferAhead: IReadOnlySharedReference<number>;
 }
 /**
  * Perform cleaning of the buffer according to the values set by the user
- * each time `currentTime$` emits and each times the
+ * each time `playbackObserver` emits and each times the
  * maxBufferBehind/maxBufferAhead values change.
  *
+ * Abort this operation when the `cancellationSignal` emits.
+ *
  * @param {Object} opt
+ * @param {Object} cancellationSignal
  * @returns {Observable}
  */
-export default function BufferGarbageCollector({ segmentBuffer, currentTime$, maxBufferBehind$, maxBufferAhead$, }: IGarbageCollectorArgument): Observable<never>;
+export default function BufferGarbageCollector({ segmentBuffer, playbackObserver, maxBufferBehind, maxBufferAhead }: IGarbageCollectorArgument, cancellationSignal: CancellationSignal): void;

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

@@ -13,23 +13,75 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { combineLatest as observableCombineLatest, concatAll, EMPTY, from as observableFrom, ignoreElements, mergeMap, of as observableOf, } from "rxjs";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 import log from "../../log";
 import { getInnerAndOuterTimeRanges } from "../../utils/ranges";
 /**
  * Perform cleaning of the buffer according to the values set by the user
- * each time `currentTime$` emits and each times the
+ * each time `playbackObserver` emits and each times the
  * maxBufferBehind/maxBufferAhead values change.
  *
+ * Abort this operation when the `cancellationSignal` emits.
+ *
  * @param {Object} opt
+ * @param {Object} cancellationSignal
  * @returns {Observable}
  */
-export default function BufferGarbageCollector(_a) {
-    var segmentBuffer = _a.segmentBuffer, currentTime$ = _a.currentTime$, maxBufferBehind$ = _a.maxBufferBehind$, maxBufferAhead$ = _a.maxBufferAhead$;
-    return observableCombineLatest([currentTime$, maxBufferBehind$, maxBufferAhead$]).pipe(mergeMap(function (_a) {
-        var currentTime = _a[0], maxBufferBehind = _a[1], maxBufferAhead = _a[2];
-        return clearBuffer(segmentBuffer, currentTime, maxBufferBehind, maxBufferAhead);
-    }));
+export default function BufferGarbageCollector(_a, cancellationSignal) {
+    var segmentBuffer = _a.segmentBuffer, playbackObserver = _a.playbackObserver, maxBufferBehind = _a.maxBufferBehind, maxBufferAhead = _a.maxBufferAhead;
+    var lastPosition;
+    playbackObserver.listen(function (o) {
+        var _a;
+        lastPosition = (_a = o.position.pending) !== null && _a !== void 0 ? _a : o.position.last;
+        clean();
+    }, { includeLastObservation: true, clearSignal: cancellationSignal });
+    function clean() {
+        clearBuffer(segmentBuffer, lastPosition, maxBufferBehind.getValue(), maxBufferAhead.getValue(), cancellationSignal)
+            .catch(function (e) {
+            var errMsg = e instanceof Error ?
+                e.message :
+                "Unknown error";
+            log.error("Could not run BufferGarbageCollector:", errMsg);
+        });
+    }
+    maxBufferBehind.onUpdate(clean, { clearSignal: cancellationSignal });
+    maxBufferAhead.onUpdate(clean, { clearSignal: cancellationSignal });
+    clean();
 }
 /**
  * Remove buffer from the browser's memory based on the user's
@@ -45,76 +97,88 @@ export default function BufferGarbageCollector(_a) {
  * @param {Number} position - The current position
  * @param {Number} maxBufferBehind
  * @param {Number} maxBufferAhead
- * @returns {Observable}
+ * @returns {Promise}
  */
-function clearBuffer(segmentBuffer, position, maxBufferBehind, maxBufferAhead) {
-    if (!isFinite(maxBufferBehind) && !isFinite(maxBufferAhead)) {
-        return EMPTY;
-    }
-    var cleanedupRanges = [];
-    var _a = getInnerAndOuterTimeRanges(segmentBuffer.getBufferedRanges(), position), innerRange = _a.innerRange, outerRanges = _a.outerRanges;
-    var collectBufferBehind = function () {
-        if (!isFinite(maxBufferBehind)) {
-            return;
-        }
-        // begin from the oldest
-        for (var i = 0; i < outerRanges.length; i++) {
-            var outerRange = outerRanges[i];
-            if (position - maxBufferBehind >= outerRange.end) {
-                cleanedupRanges.push(outerRange);
-            }
-            else if (position >= outerRange.end &&
-                position - maxBufferBehind > outerRange.start &&
-                position - maxBufferBehind < outerRange.end) {
-                cleanedupRanges.push({ start: outerRange.start,
-                    end: position - maxBufferBehind });
-            }
-        }
-        if (innerRange != null) {
-            if (position - maxBufferBehind > innerRange.start) {
-                cleanedupRanges.push({ start: innerRange.start,
-                    end: position - maxBufferBehind });
-            }
-        }
-    };
-    var collectBufferAhead = function () {
-        if (!isFinite(maxBufferAhead)) {
-            return;
-        }
-        // begin from the oldest
-        for (var i = 0; i < outerRanges.length; i++) {
-            var outerRange = outerRanges[i];
-            if (position + maxBufferAhead <= outerRange.start) {
-                cleanedupRanges.push(outerRange);
-            }
-            else if (position <= outerRange.start &&
-                position + maxBufferAhead < outerRange.end &&
-                position + maxBufferAhead > outerRange.start) {
-                cleanedupRanges.push({ start: position + maxBufferAhead,
-                    end: outerRange.end });
-            }
-        }
-        if (innerRange != null) {
-            if (position + maxBufferAhead < innerRange.end) {
-                cleanedupRanges.push({ start: position + maxBufferAhead,
-                    end: innerRange.end });
+function clearBuffer(segmentBuffer, position, maxBufferBehind, maxBufferAhead, cancellationSignal) {
+    return __awaiter(this, void 0, void 0, function () {
+        var cleanedupRanges, _a, innerRange, outerRanges, collectBufferBehind, collectBufferAhead, _i, cleanedupRanges_1, range;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    if (!isFinite(maxBufferBehind) && !isFinite(maxBufferAhead)) {
+                        return [2 /*return*/, Promise.resolve()];
+                    }
+                    cleanedupRanges = [];
+                    _a = getInnerAndOuterTimeRanges(segmentBuffer.getBufferedRanges(), position), innerRange = _a.innerRange, outerRanges = _a.outerRanges;
+                    collectBufferBehind = function () {
+                        if (!isFinite(maxBufferBehind)) {
+                            return;
+                        }
+                        // begin from the oldest
+                        for (var i = 0; i < outerRanges.length; i++) {
+                            var outerRange = outerRanges[i];
+                            if (position - maxBufferBehind >= outerRange.end) {
+                                cleanedupRanges.push(outerRange);
+                            }
+                            else if (position >= outerRange.end &&
+                                position - maxBufferBehind > outerRange.start &&
+                                position - maxBufferBehind < outerRange.end) {
+                                cleanedupRanges.push({ start: outerRange.start,
+                                    end: position - maxBufferBehind });
+                            }
+                        }
+                        if (innerRange != null) {
+                            if (position - maxBufferBehind > innerRange.start) {
+                                cleanedupRanges.push({ start: innerRange.start,
+                                    end: position - maxBufferBehind });
+                            }
+                        }
+                    };
+                    collectBufferAhead = function () {
+                        if (!isFinite(maxBufferAhead)) {
+                            return;
+                        }
+                        // begin from the oldest
+                        for (var i = 0; i < outerRanges.length; i++) {
+                            var outerRange = outerRanges[i];
+                            if (position + maxBufferAhead <= outerRange.start) {
+                                cleanedupRanges.push(outerRange);
+                            }
+                            else if (position <= outerRange.start &&
+                                position + maxBufferAhead < outerRange.end &&
+                                position + maxBufferAhead > outerRange.start) {
+                                cleanedupRanges.push({ start: position + maxBufferAhead,
+                                    end: outerRange.end });
+                            }
+                        }
+                        if (innerRange != null) {
+                            if (position + maxBufferAhead < innerRange.end) {
+                                cleanedupRanges.push({ start: position + maxBufferAhead,
+                                    end: innerRange.end });
+                            }
+                        }
+                    };
+                    collectBufferBehind();
+                    collectBufferAhead();
+                    _i = 0, cleanedupRanges_1 = cleanedupRanges;
+                    _b.label = 1;
+                case 1:
+                    if (!(_i < cleanedupRanges_1.length)) return [3 /*break*/, 4];
+                    range = cleanedupRanges_1[_i];
+                    if (!(range.start < range.end)) return [3 /*break*/, 3];
+                    log.debug("GC: cleaning range from SegmentBuffer", range.start, range.end);
+                    if (cancellationSignal.cancellationError !== null) {
+                        throw cancellationSignal.cancellationError;
+                    }
+                    return [4 /*yield*/, segmentBuffer.removeBuffer(range.start, range.end, cancellationSignal)];
+                case 2:
+                    _b.sent();
+                    _b.label = 3;
+                case 3:
+                    _i++;
+                    return [3 /*break*/, 1];
+                case 4: return [2 /*return*/];
             }
-        }
-    };
-    collectBufferBehind();
-    collectBufferAhead();
-    var clean$ = observableFrom(cleanedupRanges.map(function (range) {
-        log.debug("GC: cleaning range from SegmentBuffer", range.start, range.end);
-        if (range.start >= range.end) {
-            return observableOf(null);
-        }
-        return segmentBuffer.removeBuffer(range.start, range.end);
-    })).pipe(concatAll(), 
-    // NOTE As of now (RxJS 7.4.0), RxJS defines `ignoreElements` default
-    // first type parameter as `any` instead of the perfectly fine `unknown`,
-    // leading to linter issues, as it forbids the usage of `any`.
-    // This is why we're disabling the eslint rule.
-    /* eslint-disable-next-line @typescript-eslint/no-unsafe-argument */
-    ignoreElements());
-    return clean$;
+        });
+    });
 }

package/dist/_esm5.processed/core/segment_buffers/implementations/audio_video/audio_video_segment_buffer.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 { IEndOfSegmentInfos, IPushChunkInfos, ISBOperation, SegmentBuffer } from "../types";
 /**
  * Allows to push and remove new segments to a SourceBuffer in a FIFO queue (not
@@ -31,10 +31,9 @@ export default class AudioVideoSegmentBuffer extends SegmentBuffer {
     /** SourceBuffer implementation. */
     private readonly _sourceBuffer;
     /**
-     * Subject triggered when this AudioVideoSegmentBuffer is disposed.
-     * Helps to clean-up Observables created at its creation.
+     * Helps to clean-up resource taken at the AudioVideoSegmentBuffer creation.
      */
-    private _destroy$;
+    private _canceller;
     /**
      * Queue of awaited buffer "operations".
      * The first element in this array will be the first performed.
@@ -64,7 +63,7 @@ export default class AudioVideoSegmentBuffer extends SegmentBuffer {
      * @constructor
      * @param {string} bufferType
      * @param {string} codec
-     * @param {SourceBuffer} sourceBuffer
+     * @param {MediaSource} mediaSource
      */
     constructor(bufferType: "audio" | "video", codec: string, mediaSource: MediaSource);
     /**
@@ -91,26 +90,28 @@ export default class AudioVideoSegmentBuffer extends SegmentBuffer {
      * `data.chunk` argument to null.
      *
      * @param {Object} infos
-     * @returns {Observable}
+     * @param {Object} cancellationSignal
+     * @returns {Promise}
      */
-    pushChunk(infos: IPushChunkInfos<unknown>): Observable<void>;
+    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}
      */
-    removeBuffer(start: number, end: number): Observable<void>;
+    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}
+     * @returns {Promise}
      */
-    endOfSegment(infos: IEndOfSegmentInfos): Observable<void>;
+    endOfSegment(infos: IEndOfSegmentInfos, cancellationSignal: CancellationSignal): Promise<void>;
     /**
      * Returns the currently buffered data, in a TimeRanges object.
      * @returns {TimeRanges}
@@ -133,7 +134,7 @@ export default class AudioVideoSegmentBuffer extends SegmentBuffer {
     dispose(): void;
     /**
      * Called when an error arised that made the current task fail.
-     * @param {Event} error
+     * @param {Event} err
      */
     private _onPendingTaskError;
     /**
@@ -144,7 +145,8 @@ export default class AudioVideoSegmentBuffer extends SegmentBuffer {
      * Cancel queued operation on unsubscription.
      * @private
      * @param {Object} operation
-     * @returns {Observable}
+     * @param {Object} cancellationSignal
+     * @returns {Promise}
      */
     private _addToQueue;
     /**
@@ -160,7 +162,7 @@ export default class AudioVideoSegmentBuffer extends SegmentBuffer {
      *
      * 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}
      */
     private _preparePushOperation;