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

package/src/core/fetchers/segment/{segment_fetcher_creator.ts → segment_queue_creator.ts}

@@ -20,26 +20,26 @@ import type { CancellationSignal } from "../../../utils/task_canceller";
 import type CmcdDataBuilder from "../../cmcd";
 import type { IBufferType } from "../../segment_sinks";
 import CdnPrioritizer from "../cdn_prioritizer";
-import type { IPrioritizedSegmentFetcher } from "./prioritized_segment_fetcher";
 import applyPrioritizerToSegmentFetcher from "./prioritized_segment_fetcher";
 import type { ISegmentFetcherLifecycleCallbacks } from "./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 {
   /**
    * Transport pipelines of the currently choosen streaming protocol (e.g. DASH,
    * Smooth etc.).
    */
   private readonly _transport: ITransportPipelines;
   /**
-   * `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
@@ -48,22 +48,25 @@ export default class SegmentFetcherCreator {
    */
   private readonly _prioritizer: TaskPrioritizer<void>;
   /**
-   * 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: ISegmentFetcherCreatorBackoffOptions;
+  private readonly _backoffOptions: ISegmentQueueCreatorBackoffOptions;
 
+  /** Class allowing to select a CDN when multiple are available for a given resource. */
   private readonly _cdnPrioritizer: CdnPrioritizer;
 
   private _cmcdDataBuilder: CmcdDataBuilder | null;
 
   /**
    * @param {Object} transport
+   * @param {Object} options
+   * @param {Object} cancelSignal
    */
   constructor(
     transport: ITransportPipelines,
     cmcdDataBuilder: CmcdDataBuilder | null,
-    options: ISegmentFetcherCreatorBackoffOptions,
+    options: ISegmentQueueCreatorBackoffOptions,
     cancelSignal: CancellationSignal,
   ) {
     const cdnPrioritizer = new CdnPrioritizer(cancelSignal);
@@ -82,16 +85,18 @@ export default class SegmentFetcherCreator {
   }
 
   /**
-   * 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(
+  public createSegmentQueue(
     bufferType: IBufferType,
     eventListeners: ISegmentFetcherLifecycleCallbacks,
-  ): IPrioritizedSegmentFetcher<unknown> {
+  ): SegmentQueue<unknown> {
     const requestOptions = getSegmentFetcherRequestOptions(this._backoffOptions);
     const pipelines = this._transport[bufferType];
 
@@ -104,12 +109,16 @@ export default class SegmentFetcherCreator {
       eventListeners,
       requestOptions,
     });
-    return applyPrioritizerToSegmentFetcher(this._prioritizer, segmentFetcher);
+    const prioritizedSegmentFetcher = applyPrioritizerToSegmentFetcher(
+      this._prioritizer,
+      segmentFetcher,
+    );
+    return new SegmentQueue(prioritizedSegmentFetcher);
   }
 }
 
-/** 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.
@@ -124,5 +133,13 @@ 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;
 }

package/src/core/fetchers/segment/task_prioritizer.ts

@@ -4,6 +4,15 @@ import createCancellablePromise from "../../../utils/create_cancellable_promise"
 import type { CancellationSignal } from "../../../utils/task_canceller";
 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<T> {
   /**
    * Priority of the most prioritary task currently running.
@@ -287,8 +296,7 @@ export default class TaskPrioritizer<T> {
    * `this._prioritySteps.low`).
    */
   private _interruptCancellableTasks(): void {
-    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);
 

package/src/core/fetchers/utils/schedule_request.ts

@@ -310,7 +310,7 @@ export async function scheduleRequestWithCdns<T>(
     const canceller = new TaskCanceller();
     const unlinkCanceller = canceller.linkToSignal(cancellationSignal);
     return new Promise<T>((res, rej) => {
-      /* eslint-disable-next-line @typescript-eslint/no-misused-promises */
+      // eslint-disable-next-line @typescript-eslint/no-misused-promises
       cdnPrioritizer?.addEventListener(
         "priorityChange",
         () => {

package/src/core/main/common/content_time_boundaries_observer.ts

@@ -616,10 +616,10 @@ function getEndingPositionFromAdaptation(
    * This variable allows to optimize the logic here when this is the case.
    */
   let lastIndex: IRepresentationIndex | undefined;
-  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;

package/src/core/main/worker/content_preparer.ts

@@ -23,7 +23,7 @@ import type { IRepresentationEstimator } from "../../adaptive";
 import createAdaptiveRepresentationSelector from "../../adaptive";
 import CmcdDataBuilder from "../../cmcd";
 import type { IManifestRefreshSettings } from "../../fetchers";
-import { ManifestFetcher, SegmentFetcherCreator } from "../../fetchers";
+import { ManifestFetcher, SegmentQueueCreator } from "../../fetchers";
 import SegmentSinksStore from "../../segment_sinks";
 import type { INeedsMediaSourceReloadPayload } from "../../stream";
 import DecipherabilityFreezeDetector from "../common/DecipherabilityFreezeDetector";
@@ -129,7 +129,7 @@ export default class ContentPreparer {
         },
       );
 
-      const segmentFetcherCreator = new SegmentFetcherCreator(
+      const segmentQueueCreator = new SegmentQueueCreator(
         dashPipelines,
         cmcdDataBuilder,
         context.segmentRetryOptions,
@@ -160,7 +160,7 @@ export default class ContentPreparer {
         manifestFetcher,
         representationEstimator,
         segmentSinksStore,
-        segmentFetcherCreator,
+        segmentQueueCreator,
         workerTextSender,
         trackChoiceSetter,
       };
@@ -359,10 +359,10 @@ export interface IPreparedContentData {
   /** Allows to send timed text media data so it can be rendered. */
   workerTextSender: WorkerTextDisplayerInterface | null;
   /**
-   * Allows to create `SegmentFetcher` which simplifies complex media segment
+   * Allows to create `SegmentQueue` which simplifies complex media segment
    * fetching.
    */
-  segmentFetcherCreator: SegmentFetcherCreator;
+  segmentQueueCreator: SegmentQueueCreator;
   /**
    * Allows to store and update the wanted tracks and Representation inside that
    * track.

package/src/core/main/worker/send_message.ts

@@ -11,7 +11,7 @@ export default function sendMessage(
     postMessage(msg);
   } else {
     // TypeScript made a mistake here, and 2busy2fix
-    /* eslint-disable-next-line */
+    // eslint-disable-next-line
     (postMessage as any)(msg, transferables);
   }
 }

package/src/core/main/worker/worker_main.ts

@@ -511,7 +511,7 @@ function loadOrReloadPreparedContent(
     mediaSource,
     representationEstimator,
     segmentSinksStore,
-    segmentFetcherCreator,
+    segmentQueueCreator,
   } = preparedContent;
   const { drmSystemId, enableFastSwitching, initialTime, onCodecSwitch } = val;
   playbackObservationRef.onUpdate((observation) => {
@@ -586,7 +586,7 @@ function loadOrReloadPreparedContent(
     playbackObserver,
     representationEstimator,
     segmentSinksStore,
-    segmentFetcherCreator,
+    segmentQueueCreator,
     {
       wantedBufferAhead,
       maxVideoBufferSize,

package/src/core/segment_sinks/implementations/text/text_segment_buffer.ts

@@ -228,15 +228,11 @@ export interface ITextDisplayerInterface {
  * a hack to tell TypeScript to perform that check.
  */
 if ((__ENVIRONMENT__.CURRENT_ENV as number) === (__ENVIRONMENT__.DEV as number)) {
-  /* eslint-disable @typescript-eslint/no-unused-vars */
-  /* eslint-disable @typescript-eslint/ban-ts-comment */
-  // @ts-ignore
+  // @ts-expect-error: unused function for type checking
   function _checkType(input: ITextTrackSegmentData): void {
     function checkEqual(_arg: ITextTracksBufferSegmentData): void {
       /* nothing */
     }
     checkEqual(input);
   }
-  /* eslint-enable @typescript-eslint/no-unused-vars */
-  /* eslint-enable @typescript-eslint/ban-ts-comment */
 }

package/src/core/segment_sinks/inventory/segment_inventory.ts

@@ -1338,8 +1338,7 @@ function prettyPrintInventory(inventory: IBufferedChunk[]): string {
   }
 
   let str = "";
-  for (let i = 0; i < inventory.length; i++) {
-    const chunk = inventory[i];
+  for (const chunk of inventory) {
     if (chunk.bufferedStart !== undefined && chunk.bufferedEnd !== undefined) {
       const periodId = chunk.infos.period.id;
       const representationId = chunk.infos.representation.id;

package/src/core/segment_sinks/segment_buffers_store.ts

@@ -21,6 +21,7 @@ import { SourceBufferType } from "../../mse";
 import assert from "../../utils/assert";
 import createCancellablePromise from "../../utils/create_cancellable_promise";
 import isNullOrUndefined from "../../utils/is_null_or_undefined";
+import noop from "../../utils/noop";
 import type { CancellationSignal } from "../../utils/task_canceller";
 import type { IBufferType, SegmentSink } from "./implementations";
 import { AudioVideoSegmentSink } from "./implementations";
@@ -212,8 +213,8 @@ export default class SegmentSinksStore {
       return Promise.resolve();
     }
     return createCancellablePromise(cancelWaitSignal, (res) => {
-      /* eslint-disable-next-line prefer-const */
-      let onAddedOrDisabled: () => void;
+      // eslint-disable-next-line prefer-const
+      let onAddedOrDisabled: () => void = noop;
 
       const removeCallback = () => {
         const indexOf = this._onNativeBufferAddedOrDisabled.indexOf(onAddedOrDisabled);

package/src/core/stream/adaptation/adaptation_stream.ts

@@ -58,7 +58,7 @@ export default function AdaptationStream(
     options,
     representationEstimator,
     segmentSink,
-    segmentFetcherCreator,
+    segmentQueueCreator,
     wantedBufferAhead,
     maxVideoBufferSize,
   }: IAdaptationStreamArguments,
@@ -117,7 +117,7 @@ export default function AdaptationStream(
   );
 
   /** Allows a `RepresentationStream` to easily fetch media segments. */
-  const segmentFetcher = segmentFetcherCreator.createSegmentFetcher(
+  const segmentQueue = segmentQueueCreator.createSegmentQueue(
     adaptation.type,
     /* eslint-disable @typescript-eslint/unbound-method */
     {
@@ -435,7 +435,7 @@ export default function AdaptationStream(
         playbackObserver,
         content: { representation, adaptation, period, manifest },
         segmentSink,
-        segmentFetcher,
+        segmentQueue,
         terminate: terminateCurrentStream,
         options: {
           bufferGoal,

package/src/core/stream/adaptation/types.ts

@@ -6,7 +6,7 @@ import type {
 } from "../../../public_types";
 import type { IReadOnlySharedReference } from "../../../utils/reference";
 import type { IRepresentationEstimator } from "../../adaptive";
-import type { SegmentFetcherCreator } from "../../fetchers";
+import type { SegmentQueueCreator } from "../../fetchers";
 import type { IBufferType, SegmentSink } from "../../segment_sinks";
 import type {
   IRepresentationsChoice,
@@ -141,7 +141,7 @@ export interface IAdaptationStreamArguments {
   /** SourceBuffer wrapper - needed to push media segments. */
   segmentSink: SegmentSink;
   /** Module used to fetch the wanted media segments. */
-  segmentFetcherCreator: SegmentFetcherCreator;
+  segmentQueueCreator: SegmentQueueCreator;
   /**
    * "Buffer goal" wanted, or the ideal amount of time ahead of the current
    * position in the current SegmentSink. When this amount has been reached

package/src/core/stream/orchestrator/get_time_ranges_for_content.ts

@@ -44,8 +44,7 @@ export default function getTimeRangesForContent(
   const accumulator: IRange[] = [];
   const inventory = segmentSink.getLastKnownInventory();
 
-  for (let i = 0; i < inventory.length; i++) {
-    const chunk = inventory[i];
+  for (const chunk of inventory) {
     const hasContent = contents.some((content) => {
       return (
         chunk.infos.period.id === content.period.id &&

package/src/core/stream/orchestrator/stream_orchestrator.ts

@@ -32,7 +32,7 @@ import type { CancellationSignal } from "../../../utils/task_canceller";
 import TaskCanceller from "../../../utils/task_canceller";
 import WeakMapMemory from "../../../utils/weak_map_memory";
 import type { IRepresentationEstimator } from "../../adaptive";
-import type { SegmentFetcherCreator } from "../../fetchers";
+import type { SegmentQueueCreator } from "../../fetchers";
 import type { IBufferType, SegmentSink } from "../../segment_sinks";
 import type SegmentSinksStore from "../../segment_sinks";
 import { BufferGarbageCollector } from "../../segment_sinks";
@@ -68,7 +68,7 @@ import getTimeRangesForContent from "./get_time_ranges_for_content";
  * Representation to play.
  * @param {Object} segmentSinksStore - Will be used to lazily create
  * SegmentSink instances associated with the current content.
- * @param {Object} segmentFetcherCreator - Allow to download segments.
+ * @param {Object} segmentQueueCreator - Allow to download segments.
  * @param {Object} options
  * @param {Object} callbacks - The `StreamOrchestrator` relies on a system of
  * callbacks that it will call on various events.
@@ -94,7 +94,7 @@ export default function StreamOrchestrator(
   playbackObserver: IReadOnlyPlaybackObserver<IStreamOrchestratorPlaybackObservation>,
   representationEstimator: IRepresentationEstimator,
   segmentSinksStore: SegmentSinksStore,
-  segmentFetcherCreator: SegmentFetcherCreator,
+  segmentQueueCreator: SegmentQueueCreator,
   options: IStreamOrchestratorOptions,
   callbacks: IStreamOrchestratorCallbacks,
   orchestratorCancelSignal: CancellationSignal,
@@ -499,7 +499,7 @@ export default function StreamOrchestrator(
       content: { manifest, period: basePeriod },
       garbageCollectors,
       maxVideoBufferSize,
-      segmentFetcherCreator,
+      segmentQueueCreator,
       segmentSinksStore,
       options,
       playbackObserver,

package/src/core/stream/period/period_stream.ts

@@ -83,7 +83,7 @@ export default function PeriodStream(
     garbageCollectors,
     playbackObserver,
     representationEstimator,
-    segmentFetcherCreator,
+    segmentQueueCreator,
     segmentSinksStore,
     options,
     wantedBufferAhead,
@@ -351,7 +351,7 @@ export default function PeriodStream(
         playbackObserver: adaptationPlaybackObserver,
         representationEstimator,
         segmentSink,
-        segmentFetcherCreator,
+        segmentQueueCreator,
         wantedBufferAhead,
         maxVideoBufferSize,
       },

package/src/core/stream/period/types.ts

@@ -10,7 +10,7 @@ import type SharedReference from "../../../utils/reference";
 import type { CancellationSignal } from "../../../utils/task_canceller";
 import type WeakMapMemory from "../../../utils/weak_map_memory";
 import type { IRepresentationEstimator } from "../../adaptive";
-import type { SegmentFetcherCreator } from "../../fetchers";
+import type { SegmentQueueCreator } from "../../fetchers";
 import type { IBufferType, SegmentSink } from "../../segment_sinks";
 import type SegmentSinksStore from "../../segment_sinks";
 import type {
@@ -106,7 +106,7 @@ export interface IPeriodStreamArguments {
     SegmentSink,
     (cancelSignal: CancellationSignal) => void
   >;
-  segmentFetcherCreator: SegmentFetcherCreator;
+  segmentQueueCreator: SegmentQueueCreator;
   segmentSinksStore: SegmentSinksStore;
   playbackObserver: IReadOnlyPlaybackObserver<IPeriodStreamPlaybackObservation>;
   options: IPeriodStreamOptions;

package/src/core/stream/representation/representation_stream.ts

@@ -27,20 +27,17 @@ import config from "../../../config";
 import log from "../../../log";
 import type { ISegment } from "../../../manifest";
 import objectAssign from "../../../utils/object_assign";
-import SharedReference from "../../../utils/reference";
 import type { CancellationSignal } from "../../../utils/task_canceller";
 import TaskCanceller, { CancellationError } from "../../../utils/task_canceller";
+import type {
+  IParsedInitSegmentPayload,
+  IParsedSegmentPayload,
+} from "../../fetchers/segment/segment_queue";
 import type {
   IQueuedSegment,
   IRepresentationStreamArguments,
   IRepresentationStreamCallbacks,
 } from "./types";
-import type {
-  IDownloadQueueItem,
-  IParsedInitSegmentPayload,
-  IParsedSegmentPayload,
-} from "./utils/downloading_queue";
-import DownloadingQueue from "./utils/downloading_queue";
 import getBufferStatus from "./utils/get_buffer_status";
 import getSegmentPriority from "./utils/get_segment_priority";
 import pushInitSegment from "./utils/push_init_segment";
@@ -87,7 +84,7 @@ export default function RepresentationStream<TSegmentDataType>(
     options,
     playbackObserver,
     segmentSink,
-    segmentFetcher,
+    segmentQueue,
     terminate,
   }: IRepresentationStreamArguments<TSegmentDataType>,
   callbacks: IRepresentationStreamCallbacks,
@@ -122,15 +119,6 @@ export default function RepresentationStream<TSegmentDataType>(
     }
   });
 
-  /** Emit the last scheduled downloading queue for segments. */
-  const lastSegmentQueue = new SharedReference<IDownloadQueueItem>(
-    {
-      initSegment: null,
-      segmentQueue: [],
-    },
-    segmentsLoadingCanceller.signal,
-  );
-
   /** If `true`, the current Representation has a linked initialization segment. */
   const hasInitSegment = initSegmentState.segment !== null;
 
@@ -167,45 +155,60 @@ export default function RepresentationStream<TSegmentDataType>(
     }
   }
 
-  /** Will load every segments in `lastSegmentQueue` */
-  const downloadingQueue = new DownloadingQueue(
-    content,
-    lastSegmentQueue,
-    segmentFetcher,
-    hasInitSegment,
-  );
-  downloadingQueue.addEventListener("error", (err) => {
+  segmentQueue.addEventListener("error", (err) => {
     if (segmentsLoadingCanceller.signal.isCancelled()) {
       return; // ignore post requests-cancellation loading-related errors,
     }
     globalCanceller.cancel(); // Stop every operations
     callbacks.error(err);
   });
-  downloadingQueue.addEventListener("parsedInitSegment", onParsedChunk);
-  downloadingQueue.addEventListener("parsedMediaSegment", onParsedChunk);
-  downloadingQueue.addEventListener("emptyQueue", checkStatus);
-  downloadingQueue.addEventListener("requestRetry", (payload) => {
-    callbacks.warning(payload.error);
-    if (segmentsLoadingCanceller.signal.isCancelled()) {
-      return; // If the previous callback led to loading operations being stopped, skip
-    }
-    const retriedSegment = payload.segment;
-    const { index } = representation;
-    if (index.isSegmentStillAvailable(retriedSegment) === false) {
-      checkStatus();
-    } else if (index.canBeOutOfSyncError(payload.error, retriedSegment)) {
-      callbacks.manifestMightBeOufOfSync();
-    }
-  });
-  downloadingQueue.addEventListener("fullyLoadedSegment", (segment) => {
-    segmentSink
-      .signalSegmentComplete(objectAssign({ segment }, content))
-      .catch(onFatalBufferError);
-  });
-  downloadingQueue.start();
+  segmentQueue.addEventListener(
+    "parsedInitSegment",
+    onParsedChunk,
+    segmentsLoadingCanceller.signal,
+  );
+  segmentQueue.addEventListener(
+    "parsedMediaSegment",
+    onParsedChunk,
+    segmentsLoadingCanceller.signal,
+  );
+  segmentQueue.addEventListener(
+    "emptyQueue",
+    checkStatus,
+    segmentsLoadingCanceller.signal,
+  );
+  segmentQueue.addEventListener(
+    "requestRetry",
+    (payload) => {
+      callbacks.warning(payload.error);
+      if (segmentsLoadingCanceller.signal.isCancelled()) {
+        return; // If the previous callback led to loading operations being stopped, skip
+      }
+      const retriedSegment = payload.segment;
+      const { index } = representation;
+      if (index.isSegmentStillAvailable(retriedSegment) === false) {
+        checkStatus();
+      } else if (index.canBeOutOfSyncError(payload.error, retriedSegment)) {
+        callbacks.manifestMightBeOufOfSync();
+      }
+    },
+    segmentsLoadingCanceller.signal,
+  );
+  segmentQueue.addEventListener(
+    "fullyLoadedSegment",
+    (segment) => {
+      segmentSink
+        .signalSegmentComplete(objectAssign({ segment }, content))
+        .catch(onFatalBufferError);
+    },
+    segmentsLoadingCanceller.signal,
+  );
+
+  /** Emit the last scheduled downloading queue for segments. */
+  const segmentsToLoadRef = segmentQueue.resetForContent(content, hasInitSegment);
+
   segmentsLoadingCanceller.signal.register(() => {
-    downloadingQueue.removeEventListener();
-    downloadingQueue.stop();
+    segmentQueue.stop();
   });
 
   playbackObserver.listen(checkStatus, {
@@ -286,14 +289,14 @@ export default function RepresentationStream<TSegmentDataType>(
 
     const terminateVal = terminate.getValue();
     if (terminateVal === null) {
-      lastSegmentQueue.setValue({
+      segmentsToLoadRef.setValue({
         initSegment: neededInitSegment,
         segmentQueue: neededSegments,
       });
     } else if (terminateVal.urgent) {
       log.debug("Stream: Urgent switch, terminate now.", bufferType);
-      lastSegmentQueue.setValue({ initSegment: null, segmentQueue: [] });
-      lastSegmentQueue.finish();
+      segmentsToLoadRef.setValue({ initSegment: null, segmentQueue: [] });
+      segmentsToLoadRef.finish();
       segmentsLoadingCanceller.cancel();
       callbacks.terminating();
       return;
@@ -304,8 +307,8 @@ export default function RepresentationStream<TSegmentDataType>(
       // is wanted instead, whichever comes first.
 
       const mostNeededSegment = neededSegments[0];
-      const initSegmentRequest = downloadingQueue.getRequestedInitSegment();
-      const currentSegmentRequest = downloadingQueue.getRequestedMediaSegment();
+      const initSegmentRequest = segmentQueue.getRequestedInitSegment();
+      const currentSegmentRequest = segmentQueue.getRequestedMediaSegment();
 
       const nextQueue =
         currentSegmentRequest === null ||
@@ -315,13 +318,13 @@ export default function RepresentationStream<TSegmentDataType>(
           : [mostNeededSegment];
 
       const nextInit = initSegmentRequest === null ? null : neededInitSegment;
-      lastSegmentQueue.setValue({
+      segmentsToLoadRef.setValue({
         initSegment: nextInit,
         segmentQueue: nextQueue,
       });
       if (nextQueue.length === 0 && nextInit === null) {
         log.debug("Stream: No request left, terminate", bufferType);
-        lastSegmentQueue.finish();
+        segmentsToLoadRef.finish();
         segmentsLoadingCanceller.cancel();
         callbacks.terminating();
         return;

package/src/core/stream/representation/types.ts

@@ -18,7 +18,7 @@ import type {
 } from "../../../public_types";
 import type { IRange } from "../../../utils/ranges";
 import type { IReadOnlySharedReference } from "../../../utils/reference";
-import type { IPrioritizedSegmentFetcher } from "../../fetchers";
+import type { SegmentQueue } from "../../fetchers";
 import type { IBufferType, SegmentSink } from "../../segment_sinks";
 
 /** Callbacks called by the `RepresentationStream` on various events. */
@@ -257,7 +257,7 @@ export interface IRepresentationStreamArguments<TSegmentDataType> {
   /** The `SegmentSink` on which segments will be pushed. */
   segmentSink: SegmentSink;
   /** Interface used to load new segments. */
-  segmentFetcher: IPrioritizedSegmentFetcher<TSegmentDataType>;
+  segmentQueue: SegmentQueue<TSegmentDataType>;
   /**
    * Reference emitting when the RepresentationStream should "terminate".
    *
@@ -333,7 +333,6 @@ export interface IRepresentationsChoice {
    * How the Streams should react if another, not currently authorized,
    * Representation was previously playing.
    */
-  /* eslint-disable @typescript-eslint/no-duplicate-type-constituents */
+  // eslint-disable-next-line @typescript-eslint/no-duplicate-type-constituents
   switchingMode: IVideoRepresentationsSwitchingMode | IAudioRepresentationsSwitchingMode;
-  /* eslint-enable @typescript-eslint/no-duplicate-type-constituents */
 }

package/src/core/stream/representation/utils/get_needed_segments.ts

@@ -215,8 +215,7 @@ export default function getNeededSegments({
     }
 
     // check if the segment is already downloaded
-    for (let i = 0; i < reusableSegments.length; i++) {
-      const completeSeg = reusableSegments[i];
+    for (const completeSeg of reusableSegments) {
       const areFromSamePeriod = completeSeg.infos.period.id === content.period.id;
       // Check if content are from same period, as there can't be overlapping
       // periods, we should consider a segment as already downloaded if