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

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

@@ -13,56 +13,27 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import log from "../../../../log";
-import assert from "../../../../utils/assert";
-import EventEmitter from "../../../../utils/event_emitter";
-import noop from "../../../../utils/noop";
-import objectAssign from "../../../../utils/object_assign";
-import SharedReference from "../../../../utils/reference";
-import TaskCanceller from "../../../../utils/task_canceller";
+import log from "../../../log";
+import assert from "../../../utils/assert";
+import EventEmitter from "../../../utils/event_emitter";
+import noop from "../../../utils/noop";
+import objectAssign from "../../../utils/object_assign";
+import SharedReference from "../../../utils/reference";
+import TaskCanceller from "../../../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.
  */
-export default class DownloadingQueue extends EventEmitter {
+export default class SegmentQueue extends EventEmitter {
     /**
-     * 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.
      */
-    constructor(content, downloadQueue, segmentFetcher, hasInitSegment) {
+    constructor(segmentFetcher) {
         super();
-        this._content = content;
-        this._currentCanceller = null;
-        this._downloadQueue = downloadQueue;
-        this._initSegmentRequest = null;
-        this._mediaSegmentRequest = null;
         this._segmentFetcher = segmentFetcher;
-        this._initSegmentInfoRef = new SharedReference(undefined);
-        this._mediaSegmentAwaitingInitMetadata = null;
-        if (!hasInitSegment) {
-            this._initSegmentInfoRef.setValue(null);
-        }
+        this._currentContentInfo = null;
     }
     /**
      * Returns the initialization segment currently being requested.
@@ -70,7 +41,8 @@ export default class DownloadingQueue extends EventEmitter {
      * @returns {Object | null}
      */
     getRequestedInitSegment() {
-        return this._initSegmentRequest === null ? null : this._initSegmentRequest.segment;
+        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.
@@ -78,62 +50,105 @@ export default class DownloadingQueue extends EventEmitter {
      * @returns {Object | null}
      */
     getRequestedMediaSegment() {
-        return this._mediaSegmentRequest === null ? null : this._mediaSegmentRequest.segment;
+        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.
      */
-    start() {
-        if (this._currentCanceller !== null) {
-            return;
-        }
-        this._currentCanceller = new TaskCanceller();
+    resetForContent(content, hasInitSegment) {
+        var _a;
+        (_a = this._currentContentInfo) === null || _a === void 0 ? void 0 : _a.currentCanceller.cancel();
+        const downloadQueue = new SharedReference({
+            initSegment: null,
+            segmentQueue: [],
+        });
+        const currentCanceller = new TaskCanceller();
+        currentCanceller.signal.register(() => {
+            downloadQueue.finish();
+        });
+        const currentContentInfo = {
+            content,
+            downloadQueue,
+            initSegmentInfoRef: hasInitSegment
+                ? new SharedReference(undefined)
+                : new SharedReference(null),
+            currentCanceller,
+            initSegmentRequest: null,
+            mediaSegmentRequest: null,
+            mediaSegmentAwaitingInitMetadata: null,
+        };
+        this._currentContentInfo = currentContentInfo;
         // Listen for asked media segments
-        this._downloadQueue.onUpdate((queue) => {
+        downloadQueue.onUpdate((queue) => {
             const { segmentQueue } = queue;
             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;
             }
-            const currentSegmentRequest = this._mediaSegmentRequest;
+            const currentSegmentRequest = currentContentInfo.mediaSegmentRequest;
             if (segmentQueue.length === 0) {
                 if (currentSegmentRequest === null) {
                     // There's nothing to load but there's already no request pending.
                     return;
                 }
-                log.debug("Stream: no more media segment to request. Cancelling queue.", this._content.adaptation.type);
-                this._restartMediaSegmentDownloadingQueue();
+                log.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.debug("Stream: Media segments now need to be requested. Starting queue.", this._content.adaptation.type, segmentQueue.length);
-                this._restartMediaSegmentDownloadingQueue();
+                log.debug("SQ: Media segments now need to be requested. Starting queue.", content.adaptation.type, segmentQueue.length);
+                this._restartMediaSegmentDownloadingQueue(currentContentInfo);
                 return;
             }
             else {
                 const nextItem = segmentQueue[0];
                 if (currentSegmentRequest.segment.id !== nextItem.segment.id) {
                     // The most important request if for another segment, request it
-                    log.debug("Stream: Next media segment changed, cancelling previous", this._content.adaptation.type);
-                    this._restartMediaSegmentDownloadingQueue();
+                    log.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.debug("Stream: Priority of next media segment changed, updating", this._content.adaptation.type, currentSegmentRequest.priority, nextItem.priority);
+                    log.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((next) => {
+        downloadQueue.onUpdate((next) => {
             var _a;
-            const initSegmentRequest = this._initSegmentRequest;
+            const initSegmentRequest = currentContentInfo.initSegmentRequest;
             if (next.initSegment !== null && initSegmentRequest !== null) {
                 if (next.initSegment.priority !== initSegmentRequest.priority) {
                     this._segmentFetcher.updatePriority(initSegmentRequest.request, next.initSegment.priority);
@@ -144,41 +159,48 @@ export default class DownloadingQueue extends EventEmitter {
                 return;
             }
             if (next.initSegment === null) {
-                log.debug("Stream: no more init segment to request. Cancelling queue.", this._content.adaptation.type);
+                log.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;
     }
+    /**
+     * Stop the currently-active `SegmentQueue`.
+     *
+     * Do nothing if no queue is active.
+     */
     stop() {
         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.
      */
-    _restartMediaSegmentDownloadingQueue() {
-        if (this._mediaSegmentRequest !== null) {
-            this._mediaSegmentRequest.canceller.cancel();
+    _restartMediaSegmentDownloadingQueue(contentInfo) {
+        if (contentInfo.mediaSegmentRequest !== null) {
+            contentInfo.mediaSegmentRequest.canceller.cancel();
         }
-        const { segmentQueue } = this._downloadQueue.getValue();
+        const { downloadQueue, content, initSegmentInfoRef, currentCanceller } = contentInfo;
+        const { segmentQueue } = downloadQueue.getValue();
         const currentNeededSegment = segmentQueue[0];
         const recursivelyRequestSegments = (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;
             }
             const canceller = new TaskCanceller();
-            const unlinkCanceller = this._currentCanceller === null
+            const unlinkCanceller = currentCanceller === null
                 ? noop
-                : canceller.linkToSignal(this._currentCanceller.signal);
+                : canceller.linkToSignal(currentCanceller.signal);
             const { segment, priority } = startingSegment;
-            const context = objectAssign({ segment }, this._content);
+            const context = objectAssign({ segment }, content);
             /**
              * If `true` , the current task has either errored, finished, or was
              * cancelled.
@@ -190,12 +212,12 @@ export default class DownloadingQueue extends EventEmitter {
              */
             let isWaitingOnInitSegment = false;
             canceller.signal.register(() => {
-                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;
@@ -205,7 +227,7 @@ export default class DownloadingQueue extends EventEmitter {
                 this.trigger("parsedMediaSegment", objectAssign({}, parsed, { segment }));
             };
             const continueToNextSegment = () => {
-                const lastQueue = this._downloadQueue.getValue().segmentQueue;
+                const lastQueue = downloadQueue.getValue().segmentQueue;
                 if (lastQueue.length === 0) {
                     isComplete = true;
                     this.trigger("emptyQueue", null);
@@ -231,14 +253,14 @@ export default class DownloadingQueue extends EventEmitter {
                  * restarted later.
                  */
                 beforeInterrupted() {
-                    log.info("Stream: segment request interrupted temporarly.", segment.id, segment.time);
+                    log.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: (parse) => {
-                    const initTimescale = this._initSegmentInfoRef.getValue();
+                    const initTimescale = initSegmentInfoRef.getValue();
                     if (initTimescale !== undefined) {
                         emitChunk(parse(initTimescale !== null && initTimescale !== void 0 ? initTimescale : undefined));
                     }
@@ -248,7 +270,7 @@ export default class DownloadingQueue extends EventEmitter {
                         // 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((actualTimescale) => {
+                        initSegmentInfoRef.waitUntilDefined((actualTimescale) => {
                             emitChunk(parse(actualTimescale !== null && actualTimescale !== void 0 ? actualTimescale : undefined));
                         }, { clearSignal: canceller.signal });
                     }
@@ -259,9 +281,9 @@ export default class DownloadingQueue extends EventEmitter {
                         this.trigger("fullyLoadedSegment", segment);
                     }
                     else {
-                        this._mediaSegmentAwaitingInitMetadata = segment.id;
-                        this._initSegmentInfoRef.waitUntilDefined(() => {
-                            this._mediaSegmentAwaitingInitMetadata = null;
+                        contentInfo.mediaSegmentAwaitingInitMetadata = segment.id;
+                        initSegmentInfoRef.waitUntilDefined(() => {
+                            contentInfo.mediaSegmentAwaitingInitMetadata = null;
                             isWaitingOnInitSegment = false;
                             this.trigger("fullyLoadedSegment", segment);
                         }, { clearSignal: canceller.signal });
@@ -273,9 +295,9 @@ export default class DownloadingQueue extends EventEmitter {
                  */
                 beforeEnded: () => {
                     unlinkCanceller();
-                    this._mediaSegmentRequest = null;
+                    contentInfo.mediaSegmentRequest = null;
                     if (isWaitingOnInitSegment) {
-                        this._initSegmentInfoRef.waitUntilDefined(continueToNextSegment, {
+                        initSegmentInfoRef.waitUntilDefined(continueToNextSegment, {
                             clearSignal: canceller.signal,
                         });
                     }
@@ -292,30 +314,29 @@ export default class DownloadingQueue extends EventEmitter {
                     this.trigger("error", error);
                 }
             });
-            this._mediaSegmentRequest = { segment, priority, request, canceller };
+            contentInfo.mediaSegmentRequest = { segment, priority, request, canceller };
         };
         recursivelyRequestSegments(currentNeededSegment);
     }
     /**
      * Internal logic performing initialization segment requests.
+     * @param {Object} contentInfo
      * @param {Object} queuedInitSegment
      */
-    _restartInitSegmentDownloadingQueue(queuedInitSegment) {
-        if (this._currentCanceller !== null && this._currentCanceller.isUsed()) {
-            return;
-        }
-        if (this._initSegmentRequest !== null) {
-            this._initSegmentRequest.canceller.cancel();
+    _restartInitSegmentDownloadingQueue(contentInfo, queuedInitSegment) {
+        const { content, initSegmentInfoRef } = contentInfo;
+        if (contentInfo.initSegmentRequest !== null) {
+            contentInfo.initSegmentRequest.canceller.cancel();
         }
         if (queuedInitSegment === null) {
             return;
         }
         const canceller = new TaskCanceller();
-        const unlinkCanceller = this._currentCanceller === null
+        const unlinkCanceller = contentInfo.currentCanceller === null
             ? noop
-            : canceller.linkToSignal(this._currentCanceller.signal);
+            : canceller.linkToSignal(contentInfo.currentCanceller.signal);
         const { segment, priority } = queuedInitSegment;
-        const context = objectAssign({ segment }, this._content);
+        const context = objectAssign({ segment }, content);
         /**
          * If `true` , the current task has either errored, finished, or was
          * cancelled.
@@ -326,11 +347,11 @@ export default class DownloadingQueue extends EventEmitter {
                 this.trigger("requestRetry", { segment, error: err });
             },
             beforeInterrupted: () => {
-                log.info("Stream: init segment request interrupted temporarly.", segment.id);
+                log.info("SQ: init segment request interrupted temporarly.", segment.id);
             },
             beforeEnded: () => {
                 unlinkCanceller();
-                this._initSegmentRequest = null;
+                contentInfo.initSegmentRequest = null;
                 isComplete = true;
             },
             onChunk: (parse) => {
@@ -339,7 +360,7 @@ export default class DownloadingQueue extends EventEmitter {
                 assert(parsed.segmentType === "init", "Should have loaded an init segment.");
                 this.trigger("parsedInitSegment", objectAssign({}, parsed, { 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: () => {
@@ -355,12 +376,12 @@ export default class DownloadingQueue extends EventEmitter {
             }
         });
         canceller.signal.register(() => {
-            this._initSegmentRequest = null;
+            contentInfo.initSegmentRequest = null;
             if (isComplete) {
                 return;
             }
             isComplete = true;
         });
-        this._initSegmentRequest = { segment, priority, request, canceller };
+        contentInfo.initSegmentRequest = { segment, priority, request, canceller };
     }
 }

package/dist/{commonjs/core/fetchers/segment/segment_fetcher_creator.d.ts → es2017/core/fetchers/segment/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/es2017/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/es2017/core/fetchers/segment/{segment_fetcher_creator.js → segment_queue_creator.js}

@@ -17,16 +17,19 @@ import config from "../../../config";
 import CdnPrioritizer from "../cdn_prioritizer";
 import applyPrioritizerToSegmentFetcher from "./prioritized_segment_fetcher";
 import createSegmentFetcher, { getSegmentFetcherRequestOptions } from "./segment_fetcher";
+import SegmentQueue from "./segment_queue";
 import TaskPrioritizer from "./task_prioritizer";
 /**
  * Interact with the transport pipelines to download segments with the right
  * priority.
  *
- * @class SegmentFetcherCreator
+ * @class SegmentQueueCreator
  */
-export default class SegmentFetcherCreator {
+export default class SegmentQueueCreator {
     /**
      * @param {Object} transport
+     * @param {Object} options
+     * @param {Object} cancelSignal
      */
     constructor(transport, cmcdDataBuilder, options, cancelSignal) {
         const cdnPrioritizer = new CdnPrioritizer(cancelSignal);
@@ -43,13 +46,15 @@ export default class SegmentFetcherCreator {
         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.
      */
-    createSegmentFetcher(bufferType, eventListeners) {
+    createSegmentQueue(bufferType, eventListeners) {
         const requestOptions = getSegmentFetcherRequestOptions(this._backoffOptions);
         const pipelines = this._transport[bufferType];
         // Types are very complicated here as they are per-type of buffer.
@@ -61,6 +66,7 @@ export default class SegmentFetcherCreator {
             eventListeners,
             requestOptions,
         });
-        return applyPrioritizerToSegmentFetcher(this._prioritizer, segmentFetcher);
+        const prioritizedSegmentFetcher = applyPrioritizerToSegmentFetcher(this._prioritizer, segmentFetcher);
+        return new SegmentQueue(prioritizedSegmentFetcher);
     }
 }

package/dist/es2017/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/es2017/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"}

package/dist/es2017/core/fetchers/segment/task_prioritizer.js

@@ -2,6 +2,15 @@ import log from "../../../log";
 import arrayFindIndex from "../../../utils/array_find_index";
 import createCancellablePromise from "../../../utils/create_cancellable_promise";
 import TaskCanceller, { CancellationError } 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 {
     /**
      * @param {Options} prioritizerOptions
@@ -240,8 +249,7 @@ export default class TaskPrioritizer {
      * `this._prioritySteps.low`).
      */
     _interruptCancellableTasks() {
-        for (let i = 0; i < this._pendingTasks.length; i++) {
-            const pendingObj = this._pendingTasks[i];
+        for (const pendingObj of this._pendingTasks) {
             if (pendingObj.priority >= this._prioritySteps.low) {
                 this._interruptPendingTask(pendingObj);
                 // The previous call could have a lot of potential side-effects.

package/dist/es2017/core/fetchers/utils/schedule_request.js

@@ -253,7 +253,7 @@ export async function scheduleRequestWithCdns(cdns, cdnPrioritizer, performReque
         const canceller = new TaskCanceller();
         const unlinkCanceller = canceller.linkToSignal(cancellationSignal);
         return new Promise((res, rej) => {
-            /* eslint-disable-next-line @typescript-eslint/no-misused-promises */
+            // eslint-disable-next-line @typescript-eslint/no-misused-promises
             cdnPrioritizer === null || cdnPrioritizer === void 0 ? void 0 : cdnPrioritizer.addEventListener("priorityChange", () => {
                 const updatedPrioritaryCdn = getCdnToRequest();
                 if (cancellationSignal.isCancelled()) {

package/dist/es2017/core/main/common/content_time_boundaries_observer.js

@@ -450,10 +450,10 @@ function getEndingPositionFromAdaptation(adaptation) {
      * This variable allows to optimize the logic here when this is the case.
      */
     let lastIndex;
-    for (let i = 0; i < representations.length; i++) {
-        if (representations[i].index !== lastIndex) {
-            lastIndex = representations[i].index;
-            const lastPosition = representations[i].index.getEnd();
+    for (const representation of representations) {
+        if (representation.index !== lastIndex) {
+            lastIndex = representation.index;
+            const lastPosition = representation.index.getEnd();
             if (lastPosition === undefined) {
                 // we cannot tell
                 return undefined;