rx-player 4.2.0-dev.2024090300 → 4.2.0-dev.2024090500

package/dist/commonjs/core/{stream/representation/utils/downloading_queue.js → fetchers/segment/segment_queue.js}

@@ -30,57 +30,28 @@ var __extends = (this && this.__extends) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-var log_1 = require("../../../../log");
-var assert_1 = require("../../../../utils/assert");
-var event_emitter_1 = require("../../../../utils/event_emitter");
-var noop_1 = require("../../../../utils/noop");
-var object_assign_1 = require("../../../../utils/object_assign");
-var reference_1 = require("../../../../utils/reference");
-var task_canceller_1 = require("../../../../utils/task_canceller");
+var log_1 = require("../../../log");
+var assert_1 = require("../../../utils/assert");
+var event_emitter_1 = require("../../../utils/event_emitter");
+var noop_1 = require("../../../utils/noop");
+var object_assign_1 = require("../../../utils/object_assign");
+var reference_1 = require("../../../utils/reference");
+var task_canceller_1 = require("../../../utils/task_canceller");
 /**
- * Class scheduling segment downloads for a single Representation.
- *
- * TODO The request scheduling abstractions might be simplified by integrating
- * the `DownloadingQueue` in the segment fetchers code, instead of having it as
- * an utilis of the `RepresentationStream` like here.
- * @class DownloadingQueue
+ * Class scheduling segment downloads as a FIFO queue.
  */
-var DownloadingQueue = /** @class */ (function (_super) {
-    __extends(DownloadingQueue, _super);
+var SegmentQueue = /** @class */ (function (_super) {
+    __extends(SegmentQueue, _super);
     /**
-     * Create a new `DownloadingQueue`.
+     * Create a new `SegmentQueue`.
      *
-     * @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) {
+    function SegmentQueue(segmentFetcher) {
         var _this = _super.call(this) || this;
-        _this._content = content;
-        _this._currentCanceller = null;
-        _this._downloadQueue = downloadQueue;
-        _this._initSegmentRequest = null;
-        _this._mediaSegmentRequest = null;
         _this._segmentFetcher = segmentFetcher;
-        _this._initSegmentInfoRef = new reference_1.default(undefined);
-        _this._mediaSegmentAwaitingInitMetadata = null;
-        if (!hasInitSegment) {
-            _this._initSegmentInfoRef.setValue(null);
-        }
+        _this._currentContentInfo = null;
         return _this;
     }
     /**
@@ -88,72 +59,116 @@ var DownloadingQueue = /** @class */ (function (_super) {
      * Returns `null` if no initialization segment request is pending.
      * @returns {Object | null}
      */
-    DownloadingQueue.prototype.getRequestedInitSegment = function () {
-        return this._initSegmentRequest === null ? null : this._initSegmentRequest.segment;
+    SegmentQueue.prototype.getRequestedInitSegment = function () {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = this._currentContentInfo) === null || _a === void 0 ? void 0 : _a.initSegmentRequest) === null || _b === void 0 ? void 0 : _b.segment) !== null && _c !== void 0 ? _c : null;
     };
     /**
      * Returns the media segment currently being requested.
      * Returns `null` if no media segment request is pending.
      * @returns {Object | null}
      */
-    DownloadingQueue.prototype.getRequestedMediaSegment = function () {
-        return this._mediaSegmentRequest === null ? null : this._mediaSegmentRequest.segment;
+    SegmentQueue.prototype.getRequestedMediaSegment = function () {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = this._currentContentInfo) === null || _a === void 0 ? void 0 : _a.mediaSegmentRequest) === null || _b === void 0 ? void 0 : _b.segment) !== null && _c !== void 0 ? _c : null;
     };
     /**
-     * Start the current downloading queue, emitting events as it loads and parses
-     * initialization and media segments.
+     * Return an object allowing to schedule segment requests linked to the given
+     * content.
+     * The `SegmentQueue` will emit events as it loads and parses initialization
+     * and media segments.
+     *
+     * Calling this method resets all previous queues that were previously started
+     * on the same instance.
+     *
+     * @param {Object} content - The context of the Representation you want to
+     * load segments for.
+     * @param {boolean} hasInitSegment - Declare that an initialization segment
+     * will need to be downloaded.
+     *
+     * A `SegmentQueue` 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
+     * `SegmentQueue` waiting indefinitely for it.
+     *
+     * By setting that value to `false`, you anounce to the `SegmentQueue`
+     * that it should not wait for an initialization segment before parsing a
+     * media segment.
+     * @returns {Object} - `SharedReference` on which the queue of segment for
+     * that content can be communicated and updated. See type for more
+     * information.
      */
-    DownloadingQueue.prototype.start = function () {
+    SegmentQueue.prototype.resetForContent = function (content, hasInitSegment) {
         var _this = this;
-        if (this._currentCanceller !== null) {
-            return;
-        }
-        this._currentCanceller = new task_canceller_1.default();
+        var _a;
+        (_a = this._currentContentInfo) === null || _a === void 0 ? void 0 : _a.currentCanceller.cancel();
+        var downloadQueue = new reference_1.default({
+            initSegment: null,
+            segmentQueue: [],
+        });
+        var currentCanceller = new task_canceller_1.default();
+        currentCanceller.signal.register(function () {
+            downloadQueue.finish();
+        });
+        var currentContentInfo = {
+            content: content,
+            downloadQueue: downloadQueue,
+            initSegmentInfoRef: hasInitSegment
+                ? new reference_1.default(undefined)
+                : new reference_1.default(null),
+            currentCanceller: currentCanceller,
+            initSegmentRequest: null,
+            mediaSegmentRequest: null,
+            mediaSegmentAwaitingInitMetadata: null,
+        };
+        this._currentContentInfo = currentContentInfo;
         // Listen for asked media segments
-        this._downloadQueue.onUpdate(function (queue) {
+        downloadQueue.onUpdate(function (queue) {
             var segmentQueue = queue.segmentQueue;
             if (segmentQueue.length > 0 &&
-                segmentQueue[0].segment.id === _this._mediaSegmentAwaitingInitMetadata) {
+                segmentQueue[0].segment.id ===
+                    currentContentInfo.mediaSegmentAwaitingInitMetadata) {
                 // The most needed segment is still the same one, and there's no need to
                 // update its priority as the request already ended, just quit.
                 return;
             }
-            var currentSegmentRequest = _this._mediaSegmentRequest;
+            var currentSegmentRequest = currentContentInfo.mediaSegmentRequest;
             if (segmentQueue.length === 0) {
                 if (currentSegmentRequest === null) {
                     // There's nothing to load but there's already no request pending.
                     return;
                 }
-                log_1.default.debug("Stream: no more media segment to request. Cancelling queue.", _this._content.adaptation.type);
-                _this._restartMediaSegmentDownloadingQueue();
+                log_1.default.debug("SQ: no more media segment to request. Cancelling queue.", content.adaptation.type);
+                _this._restartMediaSegmentDownloadingQueue(currentContentInfo);
                 return;
             }
             else if (currentSegmentRequest === null) {
                 // There's no request although there are needed segments: start requests
-                log_1.default.debug("Stream: Media segments now need to be requested. Starting queue.", _this._content.adaptation.type, segmentQueue.length);
-                _this._restartMediaSegmentDownloadingQueue();
+                log_1.default.debug("SQ: Media segments now need to be requested. Starting queue.", content.adaptation.type, segmentQueue.length);
+                _this._restartMediaSegmentDownloadingQueue(currentContentInfo);
                 return;
             }
             else {
                 var nextItem = segmentQueue[0];
                 if (currentSegmentRequest.segment.id !== nextItem.segment.id) {
                     // The most important request if for another segment, request it
-                    log_1.default.debug("Stream: Next media segment changed, cancelling previous", _this._content.adaptation.type);
-                    _this._restartMediaSegmentDownloadingQueue();
+                    log_1.default.debug("SQ: Next media segment changed, cancelling previous", content.adaptation.type);
+                    _this._restartMediaSegmentDownloadingQueue(currentContentInfo);
                     return;
                 }
                 if (currentSegmentRequest.priority !== nextItem.priority) {
                     // The priority of the most important request has changed, update it
-                    log_1.default.debug("Stream: Priority of next media segment changed, updating", _this._content.adaptation.type, currentSegmentRequest.priority, nextItem.priority);
+                    log_1.default.debug("SQ: Priority of next media segment changed, updating", content.adaptation.type, currentSegmentRequest.priority, nextItem.priority);
                     _this._segmentFetcher.updatePriority(currentSegmentRequest.request, nextItem.priority);
                 }
                 return;
             }
-        }, { emitCurrentValue: true, clearSignal: this._currentCanceller.signal });
+        }, { emitCurrentValue: true, clearSignal: currentCanceller.signal });
         // Listen for asked init segment
-        this._downloadQueue.onUpdate(function (next) {
+        downloadQueue.onUpdate(function (next) {
             var _a;
-            var initSegmentRequest = _this._initSegmentRequest;
+            var initSegmentRequest = currentContentInfo.initSegmentRequest;
             if (next.initSegment !== null && initSegmentRequest !== null) {
                 if (next.initSegment.priority !== initSegmentRequest.priority) {
                     _this._segmentFetcher.updatePriority(initSegmentRequest.request, next.initSegment.priority);
@@ -164,42 +179,49 @@ var DownloadingQueue = /** @class */ (function (_super) {
                 return;
             }
             if (next.initSegment === null) {
-                log_1.default.debug("Stream: no more init segment to request. Cancelling queue.", _this._content.adaptation.type);
+                log_1.default.debug("SQ: no more init segment to request. Cancelling queue.", content.adaptation.type);
             }
-            _this._restartInitSegmentDownloadingQueue(next.initSegment);
-        }, { emitCurrentValue: true, clearSignal: this._currentCanceller.signal });
+            _this._restartInitSegmentDownloadingQueue(currentContentInfo, next.initSegment);
+        }, { emitCurrentValue: true, clearSignal: currentCanceller.signal });
+        return downloadQueue;
     };
-    DownloadingQueue.prototype.stop = function () {
+    /**
+     * Stop the currently-active `SegmentQueue`.
+     *
+     * Do nothing if no queue is active.
+     */
+    SegmentQueue.prototype.stop = function () {
         var _a;
-        (_a = this._currentCanceller) === null || _a === void 0 ? void 0 : _a.cancel();
-        this._currentCanceller = null;
+        (_a = this._currentContentInfo) === null || _a === void 0 ? void 0 : _a.currentCanceller.cancel();
+        this._currentContentInfo = null;
     };
     /**
      * Internal logic performing media segment requests.
      */
-    DownloadingQueue.prototype._restartMediaSegmentDownloadingQueue = function () {
+    SegmentQueue.prototype._restartMediaSegmentDownloadingQueue = function (contentInfo) {
         var _this = this;
-        if (this._mediaSegmentRequest !== null) {
-            this._mediaSegmentRequest.canceller.cancel();
+        if (contentInfo.mediaSegmentRequest !== null) {
+            contentInfo.mediaSegmentRequest.canceller.cancel();
         }
-        var segmentQueue = this._downloadQueue.getValue().segmentQueue;
+        var downloadQueue = contentInfo.downloadQueue, content = contentInfo.content, initSegmentInfoRef = contentInfo.initSegmentInfoRef, currentCanceller = contentInfo.currentCanceller;
+        var segmentQueue = downloadQueue.getValue().segmentQueue;
         var currentNeededSegment = segmentQueue[0];
         var recursivelyRequestSegments = function (startingSegment) {
-            if (_this._currentCanceller !== null && _this._currentCanceller.isUsed()) {
-                _this._mediaSegmentRequest = null;
+            if (currentCanceller !== null && currentCanceller.isUsed()) {
+                contentInfo.mediaSegmentRequest = null;
                 return;
             }
             if (startingSegment === undefined) {
-                _this._mediaSegmentRequest = null;
+                contentInfo.mediaSegmentRequest = null;
                 _this.trigger("emptyQueue", null);
                 return;
             }
             var canceller = new task_canceller_1.default();
-            var unlinkCanceller = _this._currentCanceller === null
+            var unlinkCanceller = currentCanceller === null
                 ? noop_1.default
-                : canceller.linkToSignal(_this._currentCanceller.signal);
+                : canceller.linkToSignal(currentCanceller.signal);
             var segment = startingSegment.segment, priority = startingSegment.priority;
-            var context = (0, object_assign_1.default)({ segment: segment }, _this._content);
+            var context = (0, object_assign_1.default)({ segment: segment }, content);
             /**
              * If `true` , the current task has either errored, finished, or was
              * cancelled.
@@ -211,12 +233,12 @@ var DownloadingQueue = /** @class */ (function (_super) {
              */
             var isWaitingOnInitSegment = false;
             canceller.signal.register(function () {
-                _this._mediaSegmentRequest = null;
+                contentInfo.mediaSegmentRequest = null;
                 if (isComplete) {
                     return;
                 }
-                if (_this._mediaSegmentAwaitingInitMetadata === segment.id) {
-                    _this._mediaSegmentAwaitingInitMetadata = null;
+                if (contentInfo.mediaSegmentAwaitingInitMetadata === segment.id) {
+                    contentInfo.mediaSegmentAwaitingInitMetadata = null;
                 }
                 isComplete = true;
                 isWaitingOnInitSegment = false;
@@ -226,7 +248,7 @@ var DownloadingQueue = /** @class */ (function (_super) {
                 _this.trigger("parsedMediaSegment", (0, object_assign_1.default)({}, parsed, { segment: segment }));
             };
             var continueToNextSegment = function () {
-                var lastQueue = _this._downloadQueue.getValue().segmentQueue;
+                var lastQueue = downloadQueue.getValue().segmentQueue;
                 if (lastQueue.length === 0) {
                     isComplete = true;
                     _this.trigger("emptyQueue", null);
@@ -252,14 +274,14 @@ var DownloadingQueue = /** @class */ (function (_super) {
                  * restarted later.
                  */
                 beforeInterrupted: function () {
-                    log_1.default.info("Stream: segment request interrupted temporarly.", segment.id, segment.time);
+                    log_1.default.info("SQ: segment request interrupted temporarly.", segment.id, segment.time);
                 },
                 /**
                  * Callback called when a decodable chunk of the segment is available.
                  * @param {Function} parse - Function allowing to parse the segment.
                  */
                 onChunk: function (parse) {
-                    var initTimescale = _this._initSegmentInfoRef.getValue();
+                    var initTimescale = initSegmentInfoRef.getValue();
                     if (initTimescale !== undefined) {
                         emitChunk(parse(initTimescale !== null && initTimescale !== void 0 ? initTimescale : undefined));
                     }
@@ -269,7 +291,7 @@ var DownloadingQueue = /** @class */ (function (_super) {
                         // but I found it globally clearer to segregate the two cases,
                         // especially to always have a meaningful `isWaitingOnInitSegment`
                         // boolean which is a very important variable.
-                        _this._initSegmentInfoRef.waitUntilDefined(function (actualTimescale) {
+                        initSegmentInfoRef.waitUntilDefined(function (actualTimescale) {
                             emitChunk(parse(actualTimescale !== null && actualTimescale !== void 0 ? actualTimescale : undefined));
                         }, { clearSignal: canceller.signal });
                     }
@@ -280,9 +302,9 @@ var DownloadingQueue = /** @class */ (function (_super) {
                         _this.trigger("fullyLoadedSegment", segment);
                     }
                     else {
-                        _this._mediaSegmentAwaitingInitMetadata = segment.id;
-                        _this._initSegmentInfoRef.waitUntilDefined(function () {
-                            _this._mediaSegmentAwaitingInitMetadata = null;
+                        contentInfo.mediaSegmentAwaitingInitMetadata = segment.id;
+                        initSegmentInfoRef.waitUntilDefined(function () {
+                            contentInfo.mediaSegmentAwaitingInitMetadata = null;
                             isWaitingOnInitSegment = false;
                             _this.trigger("fullyLoadedSegment", segment);
                         }, { clearSignal: canceller.signal });
@@ -294,9 +316,9 @@ var DownloadingQueue = /** @class */ (function (_super) {
                  */
                 beforeEnded: function () {
                     unlinkCanceller();
-                    _this._mediaSegmentRequest = null;
+                    contentInfo.mediaSegmentRequest = null;
                     if (isWaitingOnInitSegment) {
-                        _this._initSegmentInfoRef.waitUntilDefined(continueToNextSegment, {
+                        initSegmentInfoRef.waitUntilDefined(continueToNextSegment, {
                             clearSignal: canceller.signal,
                         });
                     }
@@ -313,31 +335,30 @@ var DownloadingQueue = /** @class */ (function (_super) {
                     _this.trigger("error", error);
                 }
             });
-            _this._mediaSegmentRequest = { segment: segment, priority: priority, request: request, canceller: canceller };
+            contentInfo.mediaSegmentRequest = { segment: segment, priority: priority, request: request, canceller: canceller };
         };
         recursivelyRequestSegments(currentNeededSegment);
     };
     /**
      * Internal logic performing initialization segment requests.
+     * @param {Object} contentInfo
      * @param {Object} queuedInitSegment
      */
-    DownloadingQueue.prototype._restartInitSegmentDownloadingQueue = function (queuedInitSegment) {
+    SegmentQueue.prototype._restartInitSegmentDownloadingQueue = function (contentInfo, queuedInitSegment) {
         var _this = this;
-        if (this._currentCanceller !== null && this._currentCanceller.isUsed()) {
-            return;
-        }
-        if (this._initSegmentRequest !== null) {
-            this._initSegmentRequest.canceller.cancel();
+        var content = contentInfo.content, initSegmentInfoRef = contentInfo.initSegmentInfoRef;
+        if (contentInfo.initSegmentRequest !== null) {
+            contentInfo.initSegmentRequest.canceller.cancel();
         }
         if (queuedInitSegment === null) {
             return;
         }
         var canceller = new task_canceller_1.default();
-        var unlinkCanceller = this._currentCanceller === null
+        var unlinkCanceller = contentInfo.currentCanceller === null
             ? noop_1.default
-            : canceller.linkToSignal(this._currentCanceller.signal);
+            : canceller.linkToSignal(contentInfo.currentCanceller.signal);
         var segment = queuedInitSegment.segment, priority = queuedInitSegment.priority;
-        var context = (0, object_assign_1.default)({ segment: segment }, this._content);
+        var context = (0, object_assign_1.default)({ segment: segment }, content);
         /**
          * If `true` , the current task has either errored, finished, or was
          * cancelled.
@@ -348,11 +369,11 @@ var DownloadingQueue = /** @class */ (function (_super) {
                 _this.trigger("requestRetry", { segment: segment, error: err });
             },
             beforeInterrupted: function () {
-                log_1.default.info("Stream: init segment request interrupted temporarly.", segment.id);
+                log_1.default.info("SQ: init segment request interrupted temporarly.", segment.id);
             },
             beforeEnded: function () {
                 unlinkCanceller();
-                _this._initSegmentRequest = null;
+                contentInfo.initSegmentRequest = null;
                 isComplete = true;
             },
             onChunk: function (parse) {
@@ -361,7 +382,7 @@ var DownloadingQueue = /** @class */ (function (_super) {
                 (0, assert_1.default)(parsed.segmentType === "init", "Should have loaded an init segment.");
                 _this.trigger("parsedInitSegment", (0, object_assign_1.default)({}, parsed, { segment: segment }));
                 if (parsed.segmentType === "init") {
-                    _this._initSegmentInfoRef.setValue((_a = parsed.initTimescale) !== null && _a !== void 0 ? _a : null);
+                    initSegmentInfoRef.setValue((_a = parsed.initTimescale) !== null && _a !== void 0 ? _a : null);
                 }
             },
             onAllChunksReceived: function () {
@@ -377,14 +398,14 @@ var DownloadingQueue = /** @class */ (function (_super) {
             }
         });
         canceller.signal.register(function () {
-            _this._initSegmentRequest = null;
+            contentInfo.initSegmentRequest = null;
             if (isComplete) {
                 return;
             }
             isComplete = true;
         });
-        this._initSegmentRequest = { segment: segment, priority: priority, request: request, canceller: canceller };
+        contentInfo.initSegmentRequest = { segment: segment, priority: priority, request: request, canceller: canceller };
     };
-    return DownloadingQueue;
+    return SegmentQueue;
 }(event_emitter_1.default));
-exports.default = DownloadingQueue;
+exports.default = SegmentQueue;

package/dist/commonjs/core/fetchers/segment/{segment_fetcher_creator.d.ts → segment_queue_creator.d.ts}

@@ -17,22 +17,22 @@ import type { ITransportPipelines } from "../../../transports";
 import type { CancellationSignal } from "../../../utils/task_canceller";
 import type CmcdDataBuilder from "../../cmcd";
 import type { IBufferType } from "../../segment_sinks";
-import type { IPrioritizedSegmentFetcher } from "./prioritized_segment_fetcher";
 import type { ISegmentFetcherLifecycleCallbacks } from "./segment_fetcher";
+import SegmentQueue from "./segment_queue";
 /**
  * Interact with the transport pipelines to download segments with the right
  * priority.
  *
- * @class SegmentFetcherCreator
+ * @class SegmentQueueCreator
  */
-export default class SegmentFetcherCreator {
+export default class SegmentQueueCreator {
     /**
      * Transport pipelines of the currently choosen streaming protocol (e.g. DASH,
      * Smooth etc.).
      */
     private readonly _transport;
     /**
-     * `TaskPrioritizer` linked to this SegmentFetcherCreator.
+     * `TaskPrioritizer` linked to this SegmentQueueCreator.
      *
      * Note: this is typed as `any` because segment loaders / parsers can use
      * different types depending on the type of buffer. We could maybe be smarter
@@ -41,27 +41,32 @@ export default class SegmentFetcherCreator {
      */
     private readonly _prioritizer;
     /**
-     * Options used by the SegmentFetcherCreator, e.g. to allow configuration on
+     * Options used by the SegmentQueueCreator, e.g. to allow configuration on
      * segment retries (number of retries maximum, default delay and so on).
      */
     private readonly _backoffOptions;
+    /** Class allowing to select a CDN when multiple are available for a given resource. */
     private readonly _cdnPrioritizer;
     private _cmcdDataBuilder;
     /**
      * @param {Object} transport
+     * @param {Object} options
+     * @param {Object} cancelSignal
      */
-    constructor(transport: ITransportPipelines, cmcdDataBuilder: CmcdDataBuilder | null, options: ISegmentFetcherCreatorBackoffOptions, cancelSignal: CancellationSignal);
+    constructor(transport: ITransportPipelines, cmcdDataBuilder: CmcdDataBuilder | null, options: ISegmentQueueCreatorBackoffOptions, cancelSignal: CancellationSignal);
     /**
-     * Create a segment fetcher, allowing to easily perform segment requests.
+     * Create a `SegmentQueue`, allowing to easily perform segment requests.
      * @param {string} bufferType - The type of buffer concerned (e.g. "audio",
      * "video", etc.)
      * @param {Object} eventListeners
-     * @returns {Object}
+     * @returns {Object} - `SegmentQueue`, which is an abstraction allowing to
+     * perform a queue of segment requests for a given media type (here defined by
+     * `bufferType`) with associated priorities.
      */
-    createSegmentFetcher(bufferType: IBufferType, eventListeners: ISegmentFetcherLifecycleCallbacks): IPrioritizedSegmentFetcher<unknown>;
+    createSegmentQueue(bufferType: IBufferType, eventListeners: ISegmentFetcherLifecycleCallbacks): SegmentQueue<unknown>;
 }
-/** Options used by the `SegmentFetcherCreator`. */
-export interface ISegmentFetcherCreatorBackoffOptions {
+/** Options used by the `SegmentQueueCreator`. */
+export interface ISegmentQueueCreatorBackoffOptions {
     /**
      * Whether the content is played in a low-latency mode.
      * This has an impact on default backoff delays.
@@ -76,6 +81,14 @@ export interface ISegmentFetcherCreatorBackoffOptions {
      * `undefined` will lead to a default, large, timeout being used.
      */
     requestTimeout: number | undefined;
+    /**
+     * Timeout for just the "connection" part of the request, before data is
+     * actually being transferred.
+     *
+     * Setting a lower `connectionTimeout` than a `requestTimeout` allows to
+     * fail faster without having to take into account a potentially low
+     * bandwidth.
+     */
     connectionTimeout: number | undefined;
 }
-//# sourceMappingURL=segment_fetcher_creator.d.ts.map
+//# sourceMappingURL=segment_queue_creator.d.ts.map

package/dist/commonjs/core/fetchers/segment/segment_queue_creator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"segment_queue_creator.d.ts","sourceRoot":"","sources":["../../../../../src/core/fetchers/segment/segment_queue_creator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,KAAK,EAAoB,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AACjF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AACxE,OAAO,KAAK,eAAe,MAAM,YAAY,CAAC;AAC9C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAGvD,OAAO,KAAK,EAAE,iCAAiC,EAAE,MAAM,mBAAmB,CAAC;AAE3E,OAAO,YAAY,MAAM,iBAAiB,CAAC;AAG3C;;;;;GAKG;AACH,MAAM,CAAC,OAAO,OAAO,mBAAmB;IACtC;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAsB;IACjD;;;;;;;OAOG;IACH,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAwB;IACrD;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAqC;IAErE,uFAAuF;IACvF,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAiB;IAEjD,OAAO,CAAC,gBAAgB,CAAyB;IAEjD;;;;OAIG;gBAED,SAAS,EAAE,mBAAmB,EAC9B,eAAe,EAAE,eAAe,GAAG,IAAI,EACvC,OAAO,EAAE,kCAAkC,EAC3C,YAAY,EAAE,kBAAkB;IAiBlC;;;;;;;;OAQG;IACI,kBAAkB,CACvB,UAAU,EAAE,WAAW,EACvB,cAAc,EAAE,iCAAiC,GAChD,YAAY,CAAC,OAAO,CAAC;CAmBzB;AAED,iDAAiD;AACjD,MAAM,WAAW,kCAAkC;IACjD;;;OAGG;IACH,cAAc,EAAE,OAAO,CAAC;IACxB,iEAAiE;IACjE,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B;;;;;OAKG;IACH,cAAc,EAAE,MAAM,GAAG,SAAS,CAAC;IACnC;;;;;;;OAOG;IACH,iBAAiB,EAAE,MAAM,GAAG,SAAS,CAAC;CACvC"}

package/dist/commonjs/core/fetchers/segment/{segment_fetcher_creator.js → segment_queue_creator.js}

@@ -19,18 +19,21 @@ var config_1 = require("../../../config");
 var cdn_prioritizer_1 = require("../cdn_prioritizer");
 var prioritized_segment_fetcher_1 = require("./prioritized_segment_fetcher");
 var segment_fetcher_1 = require("./segment_fetcher");
+var segment_queue_1 = require("./segment_queue");
 var task_prioritizer_1 = require("./task_prioritizer");
 /**
  * Interact with the transport pipelines to download segments with the right
  * priority.
  *
- * @class SegmentFetcherCreator
+ * @class SegmentQueueCreator
  */
-var SegmentFetcherCreator = /** @class */ (function () {
+var SegmentQueueCreator = /** @class */ (function () {
     /**
      * @param {Object} transport
+     * @param {Object} options
+     * @param {Object} cancelSignal
      */
-    function SegmentFetcherCreator(transport, cmcdDataBuilder, options, cancelSignal) {
+    function SegmentQueueCreator(transport, cmcdDataBuilder, options, cancelSignal) {
         var cdnPrioritizer = new cdn_prioritizer_1.default(cancelSignal);
         var _a = config_1.default.getCurrent(), MIN_CANCELABLE_PRIORITY = _a.MIN_CANCELABLE_PRIORITY, MAX_HIGH_PRIORITY_LEVEL = _a.MAX_HIGH_PRIORITY_LEVEL;
         this._transport = transport;
@@ -45,13 +48,15 @@ var SegmentFetcherCreator = /** @class */ (function () {
         this._cmcdDataBuilder = cmcdDataBuilder;
     }
     /**
-     * Create a segment fetcher, allowing to easily perform segment requests.
+     * Create a `SegmentQueue`, allowing to easily perform segment requests.
      * @param {string} bufferType - The type of buffer concerned (e.g. "audio",
      * "video", etc.)
      * @param {Object} eventListeners
-     * @returns {Object}
+     * @returns {Object} - `SegmentQueue`, which is an abstraction allowing to
+     * perform a queue of segment requests for a given media type (here defined by
+     * `bufferType`) with associated priorities.
      */
-    SegmentFetcherCreator.prototype.createSegmentFetcher = function (bufferType, eventListeners) {
+    SegmentQueueCreator.prototype.createSegmentQueue = function (bufferType, eventListeners) {
         var requestOptions = (0, segment_fetcher_1.getSegmentFetcherRequestOptions)(this._backoffOptions);
         var pipelines = this._transport[bufferType];
         // Types are very complicated here as they are per-type of buffer.
@@ -63,8 +68,9 @@ var SegmentFetcherCreator = /** @class */ (function () {
             eventListeners: eventListeners,
             requestOptions: requestOptions,
         });
-        return (0, prioritized_segment_fetcher_1.default)(this._prioritizer, segmentFetcher);
+        var prioritizedSegmentFetcher = (0, prioritized_segment_fetcher_1.default)(this._prioritizer, segmentFetcher);
+        return new segment_queue_1.default(prioritizedSegmentFetcher);
     };
-    return SegmentFetcherCreator;
+    return SegmentQueueCreator;
 }());
-exports.default = SegmentFetcherCreator;
+exports.default = SegmentQueueCreator;

package/dist/commonjs/core/fetchers/segment/task_prioritizer.d.ts

@@ -1,4 +1,13 @@
 import type { CancellationSignal } from "../../../utils/task_canceller";
+/**
+ * Utilitary class which allows to perform multiple tasks at once each with an
+ * associated priority.
+ *
+ * This class will then schedule the given tasks in the right order based on the
+ * priorities.
+ *
+ * @class TaskPrioritizer
+ */
 export default class TaskPrioritizer<T> {
     /**
      * Priority of the most prioritary task currently running.

package/dist/commonjs/core/fetchers/segment/task_prioritizer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"task_prioritizer.d.ts","sourceRoot":"","sources":["../../../../../src/core/fetchers/segment/task_prioritizer.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AAGxE,MAAM,CAAC,OAAO,OAAO,eAAe,CAAC,CAAC;IACpC;;;OAGG;IACH,OAAO,CAAC,mBAAmB,CAAgB;IAC3C,2EAA2E;IAC3E,OAAO,CAAC,aAAa,CAA6B;IAClD,gCAAgC;IAChC,OAAO,CAAC,aAAa,CAA6B;IAClD,qCAAqC;IACrC,OAAO,CAAC,cAAc,CAA4B;IAElD;;OAEG;gBACS,EAAE,aAAa,EAAE,EAAE,mBAAmB;IAclD;;;;;;;;;;;;;;;;;;;;;OAqBG;IACI,MAAM,CACX,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,EAClB,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,yBAAyB,EACpC,YAAY,EAAE,kBAAkB,GAC/B,OAAO,CAAC,CAAC,CAAC;IAoFb,OAAO,CAAC,QAAQ;IA2BhB;;;;OAIG;IACI,cAAc,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI;IAwElE;;;;;;;OAOG;IACH,OAAO,CAAC,wBAAwB;IAwBhC;;;;OAIG;IACH,OAAO,CAAC,0BAA0B;IAclC;;;;OAIG;IACH,OAAO,CAAC,2BAA2B;IAUnC;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IAkB7B;;;;;OAKG;IACH,OAAO,CAAC,gBAAgB;IAIxB;;;;OAIG;IACH,OAAO,CAAC,2BAA2B;CAMpC;AAkBD;;;;;;GAMG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI,CAAC,kBAAkB,EAAE,kBAAkB,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC;AAwBhF,gDAAgD;AAChD,MAAM,WAAW,mBAAmB;IAClC,qCAAqC;IACrC,aAAa,EAAE,yBAAyB,CAAC;CAC1C;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,WAAW,yBAAyB;IACxC,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;GAGG;AACH,MAAM,WAAW,yBAAyB;IACxC;;;;;OAKG;IACH,iBAAiB,IAAI,IAAI,CAAC;IAC1B;;;;;;OAMG;IACH,WAAW,IAAI,IAAI,CAAC;CACrB"}
+{"version":3,"file":"task_prioritizer.d.ts","sourceRoot":"","sources":["../../../../../src/core/fetchers/segment/task_prioritizer.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AAGxE;;;;;;;;GAQG;AACH,MAAM,CAAC,OAAO,OAAO,eAAe,CAAC,CAAC;IACpC;;;OAGG;IACH,OAAO,CAAC,mBAAmB,CAAgB;IAC3C,2EAA2E;IAC3E,OAAO,CAAC,aAAa,CAA6B;IAClD,gCAAgC;IAChC,OAAO,CAAC,aAAa,CAA6B;IAClD,qCAAqC;IACrC,OAAO,CAAC,cAAc,CAA4B;IAElD;;OAEG;gBACS,EAAE,aAAa,EAAE,EAAE,mBAAmB;IAclD;;;;;;;;;;;;;;;;;;;;;OAqBG;IACI,MAAM,CACX,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,EAClB,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,yBAAyB,EACpC,YAAY,EAAE,kBAAkB,GAC/B,OAAO,CAAC,CAAC,CAAC;IAoFb,OAAO,CAAC,QAAQ;IA2BhB;;;;OAIG;IACI,cAAc,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI;IAwElE;;;;;;;OAOG;IACH,OAAO,CAAC,wBAAwB;IAwBhC;;;;OAIG;IACH,OAAO,CAAC,0BAA0B;IAalC;;;;OAIG;IACH,OAAO,CAAC,2BAA2B;IAUnC;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IAkB7B;;;;;OAKG;IACH,OAAO,CAAC,gBAAgB;IAIxB;;;;OAIG;IACH,OAAO,CAAC,2BAA2B;CAMpC;AAkBD;;;;;;GAMG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI,CAAC,kBAAkB,EAAE,kBAAkB,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC;AAwBhF,gDAAgD;AAChD,MAAM,WAAW,mBAAmB;IAClC,qCAAqC;IACrC,aAAa,EAAE,yBAAyB,CAAC;CAC1C;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,WAAW,yBAAyB;IACxC,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;GAGG;AACH,MAAM,WAAW,yBAAyB;IACxC;;;;;OAKG;IACH,iBAAiB,IAAI,IAAI,CAAC;IAC1B;;;;;;OAMG;IACH,WAAW,IAAI,IAAI,CAAC;CACrB"}