rx-player 3.25.2 → 3.26.3-dev.2022021400

package/dist/_esm5.processed/core/stream/reload_after_switch.js

@@ -0,0 +1,48 @@
+/**
+ * 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 { map, } from "rxjs";
+import EVENTS from "./events_generators";
+/**
+ * Regularly ask to reload the MediaSource on each playback observation
+ * performed by the playback observer.
+ *
+ * If and only if the Period currently played corresponds to `Period`, applies
+ * an offset to the reloaded position corresponding to `deltaPos`.
+ * This can be useful for example when switching the audio/video track, where
+ * you might want to give back some context if that was the currently played
+ * track.
+ *
+ * @param {Object} period - The Period linked to the Adaptation or
+ * Representation that you want to switch to.
+ * @param {Observable} playbackObserver - emit playback conditions.
+ * Has to emit last playback conditions immediately on subscribe.
+ * @param {number} deltaPos - If the concerned Period is playing at the time
+ * this function is called, we will add this value, in seconds, to the current
+ * position to indicate the position we should reload at.
+ * This value allows to give back context (by replaying some media data) after
+ * a switch.
+ * @returns {Observable}
+ */
+export default function reloadAfterSwitch(period, bufferType, playbackObserver, deltaPos) {
+    return playbackObserver.observe(true).pipe(map(function (observation) {
+        var _a;
+        var currentTime = playbackObserver.getCurrentTime();
+        var pos = currentTime + deltaPos;
+        // Bind to Period start and end
+        var reloadAt = Math.min(Math.max(period.start, pos), (_a = period.end) !== null && _a !== void 0 ? _a : Infinity);
+        return EVENTS.waitingMediaSourceReload(bufferType, period, reloadAt, !observation.isPaused);
+    }));
+}

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

@@ -17,17 +17,19 @@
  * This file allows any Stream to push data to a SegmentBuffer.
  */
 import { Observable } from "rxjs";
+import { IReadOnlyPlaybackObserver } from "../../api";
 import { IPushChunkInfos, SegmentBuffer } from "../../segment_buffers";
 /**
  * Append a segment to the given segmentBuffer.
  * If it leads to a QuotaExceededError, try to run our custom range
  * _garbage collector_ then retry.
  *
- * @param {Observable} clock$
+ * @param {Observable} playbackObserver
  * @param {Object} segmentBuffer
  * @param {Object} dataInfos
  * @returns {Observable}
  */
-export default function appendSegmentToBuffer<T>(clock$: Observable<{
+export default function appendSegmentToBuffer<T>(playbackObserver: IReadOnlyPlaybackObserver<{
     position: number;
-}>, segmentBuffer: SegmentBuffer<T>, dataInfos: IPushChunkInfos<T>): Observable<unknown>;
+    wantedTimeOffset: number;
+}>, segmentBuffer: SegmentBuffer, dataInfos: IPushChunkInfos<T>): Observable<unknown>;

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

@@ -16,8 +16,7 @@
 /**
  * This file allows any Stream to push data to a SegmentBuffer.
  */
-import { concat as observableConcat, } from "rxjs";
-import { catchError, ignoreElements, } from "rxjs/operators";
+import { catchError, concat as observableConcat, mergeMap, ignoreElements, } from "rxjs";
 import { MediaError } from "../../../errors";
 import forceGarbageCollection from "./force_garbage_collection";
 /**
@@ -25,12 +24,12 @@ import forceGarbageCollection from "./force_garbage_collection";
  * If it leads to a QuotaExceededError, try to run our custom range
  * _garbage collector_ then retry.
  *
- * @param {Observable} clock$
+ * @param {Observable} playbackObserver
  * @param {Object} segmentBuffer
  * @param {Object} dataInfos
  * @returns {Observable}
  */
-export default function appendSegmentToBuffer(clock$, segmentBuffer, dataInfos) {
+export default function appendSegmentToBuffer(playbackObserver, segmentBuffer, dataInfos) {
     var append$ = segmentBuffer.pushChunk(dataInfos);
     return append$.pipe(catchError(function (appendError) {
         if (!(appendError instanceof Error) || appendError.name !== "QuotaExceededError") {
@@ -39,10 +38,13 @@ export default function appendSegmentToBuffer(clock$, segmentBuffer, dataInfos)
                 "An unknown error happened when pushing content";
             throw new MediaError("BUFFER_APPEND_ERROR", reason);
         }
-        return observableConcat(forceGarbageCollection(clock$, segmentBuffer).pipe(ignoreElements()), append$).pipe(catchError(function (forcedGCError) {
-            var reason = forcedGCError instanceof Error ? forcedGCError.toString() :
-                "Could not clean the buffer";
-            throw new MediaError("BUFFER_FULL_ERROR", reason);
+        return playbackObserver.observe(true).pipe(mergeMap(function (observation) {
+            var currentPos = observation.position + observation.wantedTimeOffset;
+            return observableConcat(forceGarbageCollection(currentPos, segmentBuffer).pipe(ignoreElements()), append$).pipe(catchError(function (forcedGCError) {
+                var reason = forcedGCError instanceof Error ? forcedGCError.toString() :
+                    "Could not clean the buffer";
+                throw new MediaError("BUFFER_FULL_ERROR", reason);
+            }));
         }));
     }));
 }

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

@@ -0,0 +1,222 @@
+/**
+ * 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 { Observable } from "rxjs";
+import { ICustomError } from "../../../errors";
+import Manifest, { Adaptation, ISegment, Period, Representation } from "../../../manifest";
+import { ISegmentParserParsedInitChunk, ISegmentParserParsedMediaChunk } from "../../../transports";
+import { IReadOnlySharedReference } from "../../../utils/reference";
+import { IPrioritizedSegmentFetcher } from "../../fetchers";
+import { IQueuedSegment } from "../types";
+/**
+ * Class scheduling segment downloads for a single Representation.
+ * @class DownloadingQueue
+ */
+export default class DownloadingQueue<T> {
+    /** Context of the Representation that will be loaded through this DownloadingQueue. */
+    private _content;
+    /**
+     * Observable doing segment requests and emitting related events.
+     * We only can have maximum one at a time.
+     * `null` when `start` has never been called.
+     */
+    private _currentObs$;
+    /**
+     * Current queue of segments scheduled for download.
+     *
+     * Segments whose request are still pending are still in that queue. Segments
+     * are only removed from it once their request has succeeded.
+     */
+    private _downloadQueue;
+    /**
+     * Pending request for the initialization segment.
+     * `null` if no request is pending for it.
+     */
+    private _initSegmentRequest;
+    /**
+     * Pending request for a media (i.e. non-initialization) segment.
+     * `null` if no request is pending for it.
+     */
+    private _mediaSegmentRequest;
+    /** Interface used to load segments. */
+    private _segmentFetcher;
+    /** Emit the timescale anounced in the initialization segment once parsed. */
+    private _initSegmentMetadata$;
+    /**
+     * Some media segments might have been loaded and are only awaiting for the
+     * initialization segment to be parsed before being parsed themselves.
+     * This `Set` will contain the `id` property of all segments that are
+     * currently awaiting this event.
+     */
+    private _mediaSegmentsAwaitingInitMetadata;
+    /**
+     * Create a new `DownloadingQueue`.
+     *
+     * @param {Object} content - The context of the Representation you want to
+     * load segments for.
+     * @param {Object} downloadQueue - Queue of segments you want to load.
+     * @param {Object} segmentFetcher - Interface to facilitate the download of
+     * segments.
+     * @param {boolean} hasInitSegment - Declare that an initialization segment
+     * will need to be downloaded.
+     *
+     * A `DownloadingQueue` ALWAYS wait for the initialization segment to be
+     * loaded and parsed before parsing a media segment.
+     *
+     * In cases where no initialization segment exist, this would lead to the
+     * `DownloadingQueue` waiting indefinitely for it.
+     *
+     * By setting that value to `false`, you anounce to the `DownloadingQueue`
+     * that it should not wait for an initialization segment before parsing a
+     * media segment.
+     */
+    constructor(content: IDownloadingQueueContext, downloadQueue: IReadOnlySharedReference<IDownloadQueueItem>, segmentFetcher: IPrioritizedSegmentFetcher<T>, hasInitSegment: boolean);
+    /**
+     * Returns the initialization segment currently being requested.
+     * Returns `null` if no initialization segment request is pending.
+     * @returns {Object}
+     */
+    getRequestedInitSegment(): ISegment | null;
+    /**
+     * Returns the media segment currently being requested.
+     * Returns `null` if no media segment request is pending.
+     * @returns {Object}
+     */
+    getRequestedMediaSegment(): ISegment | null;
+    /**
+     * Start the current downloading queue, emitting events as it loads and parses
+     * initialization and media segments.
+     *
+     * If it was already started, returns the same - shared - Observable.
+     * @returns {Observable}
+     */
+    start(): Observable<IDownloadingQueueEvent<T>>;
+    /**
+     * Internal logic performing media segment requests.
+     * @returns {Observable}
+     */
+    private _requestMediaSegments;
+    /**
+     * Internal logic performing initialization segment requests.
+     * @param {Object} queuedInitSegment
+     * @returns {Observable}
+     */
+    private _requestInitSegment;
+}
+/** Event sent by the DownloadingQueue. */
+export declare type IDownloadingQueueEvent<T> = IParsedInitSegmentEvent<T> | IParsedSegmentEvent<T> | IEndOfSegmentEvent | ILoaderRetryEvent | IEndOfQueueEvent;
+/**
+ * Notify that the initialization segment has been fully loaded and parsed.
+ *
+ * You can now push that segment to its corresponding buffer and use its parsed
+ * metadata.
+ *
+ * Only sent if an initialization segment exists (when the `DownloadingQueue`'s
+ * `hasInitSegment` constructor option has been set to `true`).
+ * In that case, an `IParsedInitSegmentEvent` will always be sent before any
+ * `IParsedSegmentEvent` event is sent.
+ */
+export declare type IParsedInitSegmentEvent<T> = ISegmentParserParsedInitChunk<T> & {
+    segment: ISegment;
+    type: "parsed-init";
+};
+/**
+ * Notify that a media chunk (decodable sub-part of a media segment) has been
+ * loaded and parsed.
+ *
+ * If an initialization segment exists (when the `DownloadingQueue`'s
+ * `hasInitSegment` constructor option has been set to `true`), an
+ * `IParsedSegmentEvent` will always be sent AFTER the `IParsedInitSegmentEvent`
+ * event.
+ *
+ * It can now be pushed to its corresponding buffer. Note that there might be
+ * multiple `IParsedSegmentEvent` for a single segment, if that segment is
+ * divided into multiple decodable chunks.
+ * You will know that all `IParsedSegmentEvent` have been loaded for a given
+ * segment once you received the `IEndOfSegmentEvent` for that segment.
+ */
+export declare type IParsedSegmentEvent<T> = ISegmentParserParsedMediaChunk<T> & {
+    segment: ISegment;
+    type: "parsed-media";
+};
+/** Notify that a media or initialization segment has been fully-loaded. */
+export interface IEndOfSegmentEvent {
+    type: "end-of-segment";
+    value: {
+        segment: ISegment;
+    };
+}
+/**
+ * Notify that a media or initialization segment request is retried.
+ * This happened most likely because of an HTTP error.
+ */
+export interface ILoaderRetryEvent {
+    type: "retry";
+    value: {
+        segment: ISegment;
+        error: ICustomError;
+    };
+}
+/**
+ * Notify that the media segment queue is now empty.
+ * This can be used to re-check if any segment are now needed.
+ */
+export interface IEndOfQueueEvent {
+    type: "end-of-queue";
+    value: null;
+}
+/**
+ * Structure of the object that has to be emitted through the `downloadQueue`
+ * Observable, to signal which segments are currently needed.
+ */
+export interface IDownloadQueueItem {
+    /**
+     * A potential initialization segment that needs to be loaded and parsed.
+     * It will generally be requested in parralel of the first media segments.
+     *
+     * Can be set to `null` if you don't need to load the initialization segment
+     * for now.
+     *
+     * If the `DownloadingQueue`'s `hasInitSegment` constructor option has been
+     * set to `true`, no media segment will be parsed before the initialization
+     * segment has been loaded and parsed.
+     */
+    initSegment: IQueuedSegment | null;
+    /**
+     * The queue of media segments currently needed for download.
+     *
+     * Those will be loaded from the first element in that queue to the last
+     * element in it.
+     *
+     * Note that any media segments in the segment queue will only be parsed once
+     * either of these is true:
+     *   - An initialization segment has been loaded and parsed by this
+     *     `DownloadingQueue` instance.
+     *   - The `DownloadingQueue`'s `hasInitSegment` constructor option has been
+     *     set to `false`.
+     */
+    segmentQueue: IQueuedSegment[];
+}
+/** Context for segments downloaded through the DownloadingQueue. */
+export interface IDownloadingQueueContext {
+    /** Adaptation linked to the segments you want to load. */
+    adaptation: Adaptation;
+    /** Manifest linked to the segments you want to load. */
+    manifest: Manifest;
+    /** Period linked to the segments you want to load. */
+    period: Period;
+    /** Representation linked to the segments you want to load. */
+    representation: Representation;
+}

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

@@ -0,0 +1,254 @@
+/**
+ * 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 { concat as observableConcat, defer as observableDefer, EMPTY, filter, finalize, map, merge as observableMerge, mergeMap, of as observableOf, ReplaySubject, share, switchMap, take, } from "rxjs";
+import log from "../../../log";
+import assert from "../../../utils/assert";
+import assertUnreachable from "../../../utils/assert_unreachable";
+import objectAssign from "../../../utils/object_assign";
+/**
+ * Class scheduling segment downloads for a single Representation.
+ * @class DownloadingQueue
+ */
+var DownloadingQueue = /** @class */ (function () {
+    /**
+     * Create a new `DownloadingQueue`.
+     *
+     * @param {Object} content - The context of the Representation you want to
+     * load segments for.
+     * @param {Object} downloadQueue - Queue of segments you want to load.
+     * @param {Object} segmentFetcher - Interface to facilitate the download of
+     * segments.
+     * @param {boolean} hasInitSegment - Declare that an initialization segment
+     * will need to be downloaded.
+     *
+     * A `DownloadingQueue` ALWAYS wait for the initialization segment to be
+     * loaded and parsed before parsing a media segment.
+     *
+     * In cases where no initialization segment exist, this would lead to the
+     * `DownloadingQueue` waiting indefinitely for it.
+     *
+     * By setting that value to `false`, you anounce to the `DownloadingQueue`
+     * that it should not wait for an initialization segment before parsing a
+     * media segment.
+     */
+    function DownloadingQueue(content, downloadQueue, segmentFetcher, hasInitSegment) {
+        this._content = content;
+        this._currentObs$ = null;
+        this._downloadQueue = downloadQueue;
+        this._initSegmentRequest = null;
+        this._mediaSegmentRequest = null;
+        this._segmentFetcher = segmentFetcher;
+        this._initSegmentMetadata$ = new ReplaySubject(1);
+        this._mediaSegmentsAwaitingInitMetadata = new Set();
+        if (!hasInitSegment) {
+            this._initSegmentMetadata$.next(undefined);
+        }
+    }
+    /**
+     * Returns the initialization segment currently being requested.
+     * Returns `null` if no initialization segment request is pending.
+     * @returns {Object}
+     */
+    DownloadingQueue.prototype.getRequestedInitSegment = function () {
+        return this._initSegmentRequest === null ? null :
+            this._initSegmentRequest.segment;
+    };
+    /**
+     * Returns the media segment currently being requested.
+     * Returns `null` if no media segment request is pending.
+     * @returns {Object}
+     */
+    DownloadingQueue.prototype.getRequestedMediaSegment = function () {
+        return this._mediaSegmentRequest === null ? null :
+            this._mediaSegmentRequest.segment;
+    };
+    /**
+     * Start the current downloading queue, emitting events as it loads and parses
+     * initialization and media segments.
+     *
+     * If it was already started, returns the same - shared - Observable.
+     * @returns {Observable}
+     */
+    DownloadingQueue.prototype.start = function () {
+        var _this = this;
+        if (this._currentObs$ !== null) {
+            return this._currentObs$;
+        }
+        var obs = observableDefer(function () {
+            var mediaQueue$ = _this._downloadQueue.asObservable().pipe(filter(function (_a) {
+                var segmentQueue = _a.segmentQueue;
+                // First, the first elements of the segmentQueue might be already
+                // loaded but awaiting the initialization segment to be parsed.
+                // Filter those out.
+                var nextSegmentToLoadIdx = 0;
+                for (; nextSegmentToLoadIdx < segmentQueue.length; nextSegmentToLoadIdx++) {
+                    var nextSegment = segmentQueue[nextSegmentToLoadIdx].segment;
+                    if (!_this._mediaSegmentsAwaitingInitMetadata.has(nextSegment.id)) {
+                        break;
+                    }
+                }
+                var currentSegmentRequest = _this._mediaSegmentRequest;
+                if (nextSegmentToLoadIdx >= segmentQueue.length) {
+                    return currentSegmentRequest !== null;
+                }
+                else if (currentSegmentRequest === null) {
+                    return true;
+                }
+                var nextItem = segmentQueue[nextSegmentToLoadIdx];
+                if (currentSegmentRequest.segment.id !== nextItem.segment.id) {
+                    return true;
+                }
+                if (currentSegmentRequest.priority !== nextItem.priority) {
+                    _this._segmentFetcher.updatePriority(currentSegmentRequest.request$, nextItem.priority);
+                }
+                return false;
+            }), switchMap(function (_a) {
+                var segmentQueue = _a.segmentQueue;
+                return segmentQueue.length > 0 ? _this._requestMediaSegments() :
+                    EMPTY;
+            }));
+            var initSegmentPush$ = _this._downloadQueue.asObservable().pipe(filter(function (next) {
+                var initSegmentRequest = _this._initSegmentRequest;
+                if (next.initSegment !== null && initSegmentRequest !== null) {
+                    if (next.initSegment.priority !== initSegmentRequest.priority) {
+                        _this._segmentFetcher.updatePriority(initSegmentRequest.request$, next.initSegment.priority);
+                    }
+                    return false;
+                }
+                else {
+                    return next.initSegment === null || initSegmentRequest === null;
+                }
+            }), switchMap(function (nextQueue) {
+                if (nextQueue.initSegment === null) {
+                    return EMPTY;
+                }
+                return _this._requestInitSegment(nextQueue.initSegment);
+            }));
+            return observableMerge(initSegmentPush$, mediaQueue$);
+        }).pipe(share());
+        this._currentObs$ = obs;
+        return obs;
+    };
+    /**
+     * Internal logic performing media segment requests.
+     * @returns {Observable}
+     */
+    DownloadingQueue.prototype._requestMediaSegments = function () {
+        var _this = this;
+        var segmentQueue = this._downloadQueue.getValue().segmentQueue;
+        var currentNeededSegment = segmentQueue[0];
+        var recursivelyRequestSegments = function (startingSegment) {
+            if (startingSegment === undefined) {
+                return observableOf({ type: "end-of-queue",
+                    value: null });
+            }
+            var segment = startingSegment.segment, priority = startingSegment.priority;
+            var context = objectAssign({ segment: segment }, _this._content);
+            var request$ = _this._segmentFetcher.createRequest(context, priority);
+            _this._mediaSegmentRequest = { segment: segment, priority: priority, request$: request$ };
+            return request$
+                .pipe(mergeMap(function (evt) {
+                switch (evt.type) {
+                    case "retry":
+                        return observableOf({ type: "retry",
+                            value: { segment: segment, error: evt.value } });
+                    case "interrupted":
+                        log.info("Stream: segment request interrupted temporarly.", segment);
+                        return EMPTY;
+                    case "ended":
+                        _this._mediaSegmentRequest = null;
+                        var lastQueue = _this._downloadQueue.getValue().segmentQueue;
+                        if (lastQueue.length === 0) {
+                            return observableOf({ type: "end-of-queue",
+                                value: null });
+                        }
+                        else if (lastQueue[0].segment.id === segment.id) {
+                            lastQueue.shift();
+                        }
+                        return recursivelyRequestSegments(lastQueue[0]);
+                    case "chunk":
+                    case "chunk-complete":
+                        _this._mediaSegmentsAwaitingInitMetadata.add(segment.id);
+                        return _this._initSegmentMetadata$.pipe(take(1), map(function (initTimescale) {
+                            if (evt.type === "chunk-complete") {
+                                return { type: "end-of-segment",
+                                    value: { segment: segment } };
+                            }
+                            var parsed = evt.parse(initTimescale);
+                            assert(parsed.segmentType === "media", "Should have loaded a media segment.");
+                            return objectAssign({}, parsed, { type: "parsed-media", segment: segment });
+                        }), finalize(function () {
+                            _this._mediaSegmentsAwaitingInitMetadata.delete(segment.id);
+                        }));
+                    default:
+                        assertUnreachable(evt);
+                }
+            }));
+        };
+        return observableDefer(function () {
+            return recursivelyRequestSegments(currentNeededSegment);
+        }).pipe(finalize(function () { _this._mediaSegmentRequest = null; }));
+    };
+    /**
+     * Internal logic performing initialization segment requests.
+     * @param {Object} queuedInitSegment
+     * @returns {Observable}
+     */
+    DownloadingQueue.prototype._requestInitSegment = function (queuedInitSegment) {
+        var _this = this;
+        if (queuedInitSegment === null) {
+            this._initSegmentRequest = null;
+            return EMPTY;
+        }
+        var segment = queuedInitSegment.segment, priority = queuedInitSegment.priority;
+        var context = objectAssign({ segment: segment }, this._content);
+        var request$ = this._segmentFetcher.createRequest(context, priority);
+        this._initSegmentRequest = { segment: segment, priority: priority, request$: request$ };
+        return request$
+            .pipe(mergeMap(function (evt) {
+            switch (evt.type) {
+                case "retry":
+                    return observableOf({ type: "retry",
+                        value: { segment: segment, error: evt.value } });
+                case "interrupted":
+                    log.info("Stream: init segment request interrupted temporarly.", segment);
+                    return EMPTY;
+                case "chunk":
+                    var parsed_1 = evt.parse(undefined);
+                    assert(parsed_1.segmentType === "init", "Should have loaded an init segment.");
+                    return observableConcat(observableOf(objectAssign({}, parsed_1, { type: "parsed-init", segment: segment })), 
+                    // We want to emit parsing information strictly AFTER the
+                    // initialization segment is emitted. Hence why we perform this
+                    // side-effect a posteriori in a concat operator
+                    observableDefer(function () {
+                        if (parsed_1.segmentType === "init") {
+                            _this._initSegmentMetadata$.next(parsed_1.initTimescale);
+                        }
+                        return EMPTY;
+                    }));
+                case "chunk-complete":
+                    return observableOf({ type: "end-of-segment",
+                        value: { segment: segment } });
+                case "ended":
+                    return EMPTY; // Do nothing, just here to check every case
+                default:
+                    assertUnreachable(evt);
+            }
+        })).pipe(finalize(function () { _this._initSegmentRequest = null; }));
+    };
+    return DownloadingQueue;
+}());
+export default DownloadingQueue;

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

@@ -25,6 +25,4 @@ import { SegmentBuffer } from "../../segment_buffers";
  * @param {Object} bufferingQueue
  * @returns {Observable}
  */
-export default function forceGarbageCollection(timings$: Observable<{
-    position: number;
-}>, bufferingQueue: SegmentBuffer<unknown>): Observable<unknown>;
+export default function forceGarbageCollection(currentPosition: number, bufferingQueue: SegmentBuffer): Observable<unknown>;

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

@@ -13,8 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { from as observableFrom, } from "rxjs";
-import { concatAll, mergeMap, take, } from "rxjs/operators";
+import { concatAll, defer as observableDefer, from as observableFrom, } from "rxjs";
 import config from "../../../config";
 import log from "../../../log";
 import { getInnerAndOuterTimeRanges } from "../../../utils/ranges";
@@ -30,22 +29,21 @@ var GC_GAP_BEEFY = config.BUFFER_GC_GAPS.BEEFY;
  * @param {Object} bufferingQueue
  * @returns {Observable}
  */
-export default function forceGarbageCollection(timings$, bufferingQueue) {
-    // wait for next timing event
-    return timings$.pipe(take(1), mergeMap(function (timing) {
+export default function forceGarbageCollection(currentPosition, bufferingQueue) {
+    return observableDefer(function () {
         log.warn("Stream: Running garbage collector");
         var buffered = bufferingQueue.getBufferedRanges();
-        var cleanedupRanges = selectGCedRanges(timing.position, buffered, GC_GAP_CALM);
+        var cleanedupRanges = selectGCedRanges(currentPosition, buffered, GC_GAP_CALM);
         // more aggressive GC if we could not find any range to clean
         if (cleanedupRanges.length === 0) {
-            cleanedupRanges = selectGCedRanges(timing.position, buffered, GC_GAP_BEEFY);
+            cleanedupRanges = selectGCedRanges(currentPosition, buffered, GC_GAP_BEEFY);
         }
         log.debug("Stream: GC cleaning", cleanedupRanges);
         return observableFrom(cleanedupRanges.map(function (_a) {
             var start = _a.start, end = _a.end;
             return bufferingQueue.removeBuffer(start, end);
         })).pipe(concatAll());
-    }));
+    });
 }
 /**
  * Buffer garbage collector algorithm.
@@ -65,18 +63,17 @@ function selectGCedRanges(position, buffered, gcGap) {
     var cleanedupRanges = [];
     // start by trying to remove all ranges that do not contain the
     // current time and respect the gcGap
-    // respect the gcGap? FIXME?
     for (var i = 0; i < outerRanges.length; i++) {
         var outerRange = outerRanges[i];
-        if (position - gcGap < outerRange.end) {
+        if (position - gcGap > outerRange.end) {
             cleanedupRanges.push(outerRange);
         }
-        else if (position + gcGap > outerRange.start) {
+        else if (position + gcGap < outerRange.start) {
             cleanedupRanges.push(outerRange);
         }
     }
     // try to clean up some space in the current range
-    if (innerRange != null) {
+    if (innerRange !== null) {
         log.debug("Stream: GC removing part of inner range", cleanedupRanges);
         if (position - gcGap > innerRange.start) {
             cleanedupRanges.push({ start: innerRange.start,