rx-player 4.0.0 → 4.1.0-dev.2024031100

package/dist/es2017/core/stream/orchestrator/stream_orchestrator.js

@@ -16,21 +16,22 @@
 import config from "../../../config";
 import { MediaError } from "../../../errors";
 import log from "../../../log";
+import isNullOrUndefined from "../../../utils/is_null_or_undefined";
 import queueMicrotask from "../../../utils/queue_microtask";
-import { createMappedReference, } from "../../../utils/reference";
+import { createMappedReference } from "../../../utils/reference";
 import SortedList from "../../../utils/sorted_list";
 import TaskCanceller from "../../../utils/task_canceller";
 import WeakMapMemory from "../../../utils/weak_map_memory";
-import { BufferGarbageCollector, } from "../../segment_buffers";
+import { BufferGarbageCollector } from "../../segment_sinks";
 import PeriodStream from "../period";
 import getTimeRangesForContent from "./get_time_ranges_for_content";
 /**
  * Create and manage the various "Streams" needed for the content to
  * play:
  *
- *   - Create or dispose SegmentBuffers depending on the chosen Adaptations.
+ *   - Create or dispose SegmentSinks depending on the chosen Adaptations.
  *
- *   - Push the right segments to those SegmentBuffers depending on the user's
+ *   - Push the right segments to those SegmentSinks depending on the user's
  *     preferences, the current position, the bandwidth, the decryption
  *     conditions...
  *
@@ -43,8 +44,8 @@ import getTimeRangesForContent from "./get_time_ranges_for_content";
  * @param {Object} playbackObserver - Emit position information
  * @param {Object} representationEstimator - Emit bitrate estimates and best
  * Representation to play.
- * @param {Object} segmentBuffersStore - Will be used to lazily create
- * SegmentBuffer instances associated with the current content.
+ * @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} options
  * @param {Object} callbacks - The `StreamOrchestrator` relies on a system of
@@ -66,30 +67,32 @@ import getTimeRangesForContent from "./get_time_ranges_for_content";
  * when triggered, to immediately stop all operations the `PeriodStream` is
  * doing.
  */
-export default function StreamOrchestrator(content, playbackObserver, representationEstimator, segmentBuffersStore, segmentFetcherCreator, options, callbacks, orchestratorCancelSignal) {
+export default function StreamOrchestrator(content, playbackObserver, representationEstimator, segmentSinksStore, segmentFetcherCreator, options, callbacks, orchestratorCancelSignal) {
     const { manifest, initialPeriod } = content;
     const { maxBufferAhead, maxBufferBehind, wantedBufferAhead, maxVideoBufferSize } = options;
-    const { MINIMUM_MAX_BUFFER_AHEAD, MAXIMUM_MAX_BUFFER_AHEAD, MAXIMUM_MAX_BUFFER_BEHIND } = config.getCurrent();
+    const { MINIMUM_MAX_BUFFER_AHEAD, MAXIMUM_MAX_BUFFER_AHEAD, MAXIMUM_MAX_BUFFER_BEHIND, } = config.getCurrent();
     // Keep track of a unique BufferGarbageCollector created per
-    // SegmentBuffer.
-    const garbageCollectors = new WeakMapMemory((segmentBuffer) => {
+    // SegmentSink.
+    const garbageCollectors = new WeakMapMemory((segmentSink) => {
         var _a, _b;
-        const { bufferType } = segmentBuffer;
+        const { bufferType } = segmentSink;
         const defaultMaxBehind = (_a = MAXIMUM_MAX_BUFFER_BEHIND[bufferType]) !== null && _a !== void 0 ? _a : Infinity;
         const maxAheadHigherBound = (_b = MAXIMUM_MAX_BUFFER_AHEAD[bufferType]) !== null && _b !== void 0 ? _b : Infinity;
         return (gcCancelSignal) => {
-            BufferGarbageCollector({ segmentBuffer,
+            BufferGarbageCollector({
+                segmentSink,
                 playbackObserver,
                 maxBufferBehind: createMappedReference(maxBufferBehind, (val) => Math.min(val, defaultMaxBehind), gcCancelSignal),
                 maxBufferAhead: createMappedReference(maxBufferAhead, (val) => {
                     var _a;
                     const lowerBound = Math.max(val, (_a = MINIMUM_MAX_BUFFER_AHEAD[bufferType]) !== null && _a !== void 0 ? _a : 0);
                     return Math.min(lowerBound, maxAheadHigherBound);
-                }, gcCancelSignal) }, gcCancelSignal);
+                }, gcCancelSignal),
+            }, gcCancelSignal);
         };
     });
     // Create automatically the right `PeriodStream` for every possible types
-    for (const bufferType of segmentBuffersStore.getBufferTypes()) {
+    for (const bufferType of segmentSinksStore.getBufferTypes()) {
         manageEveryStreams(bufferType, initialPeriod);
     }
     /**
@@ -145,7 +148,7 @@ export default function StreamOrchestrator(content, playbackObserver, representa
             if (orchestratorCancelSignal.isCancelled()) {
                 return;
             }
-            onDecipherabilityUpdates(evt).catch(err => {
+            onDecipherabilityUpdates(evt).catch((err) => {
                 if (orchestratorCancelSignal.isCancelled()) {
                     return;
                 }
@@ -162,10 +165,11 @@ export default function StreamOrchestrator(content, playbackObserver, representa
                     // Only reload the MediaSource when the more immediately required
                     // Period is the one it is asked for
                     const firstPeriod = periodList.head();
-                    if (firstPeriod === undefined ||
-                        firstPeriod.id !== payload.period.id) {
-                        callbacks.lockedStream({ bufferType: payload.bufferType,
-                            period: payload.period });
+                    if (firstPeriod === undefined || firstPeriod.id !== payload.period.id) {
+                        callbacks.lockedStream({
+                            bufferType: payload.bufferType,
+                            period: payload.period,
+                        });
                     }
                     else {
                         callbacks.needsMediaSourceReload({
@@ -200,12 +204,11 @@ export default function StreamOrchestrator(content, playbackObserver, representa
         function isOutOfPeriodList(time) {
             const head = periodList.head();
             const last = periodList.last();
-            if (head == null || last == null) { // if no period
+            if (head === undefined || last === undefined) {
+                // if no period
                 return true;
             }
-            return head.start > time ||
-                (last.end == null ? Infinity :
-                    last.end) < time;
+            return (head.start > time || (isNullOrUndefined(last.end) ? Infinity : last.end) < time);
         }
         /**
          * React to a Manifest's decipherability updates.
@@ -213,36 +216,35 @@ export default function StreamOrchestrator(content, playbackObserver, representa
          * @returns {Promise}
          */
         async function onDecipherabilityUpdates(updates) {
-            const segmentBufferStatus = segmentBuffersStore.getStatus(bufferType);
-            const ofCurrentType = updates
-                .filter(update => update.adaptation.type === bufferType);
+            const segmentSinkStatus = segmentSinksStore.getStatus(bufferType);
+            const ofCurrentType = updates.filter((update) => update.adaptation.type === bufferType);
             if (
             // No update concerns the current type of data
             ofCurrentType.length === 0 ||
-                segmentBufferStatus.type !== "initialized" ||
+                segmentSinkStatus.type !== "initialized" ||
                 // The update only notifies of now-decipherable streams
-                ofCurrentType.every(x => x.representation.decipherable === true)) {
+                ofCurrentType.every((x) => x.representation.decipherable === true)) {
                 // Data won't have to be removed from the buffers, no need to stop the
                 // current Streams.
                 return;
             }
-            const segmentBuffer = segmentBufferStatus.value;
-            const resettedContent = ofCurrentType.filter(update => update.representation.decipherable === undefined);
-            const undecipherableContent = ofCurrentType.filter(update => update.representation.decipherable === false);
+            const segmentSink = segmentSinkStatus.value;
+            const resettedContent = ofCurrentType.filter((update) => update.representation.decipherable === undefined);
+            const undecipherableContent = ofCurrentType.filter((update) => update.representation.decipherable === false);
             /**
              * Time ranges now containing undecipherable content.
              * Those should first be removed and, depending on the platform, may
              * need Supplementary actions as playback issues may remain even after
              * removal.
              */
-            const undecipherableRanges = getTimeRangesForContent(segmentBuffer, undecipherableContent);
+            const undecipherableRanges = getTimeRangesForContent(segmentSink, undecipherableContent);
             /**
              * Time ranges now containing content whose decipherability status came
              * back to being unknown.
              * To simplify its handling, those are just removed from the buffer.
              * Less considerations have to be taken than for the `undecipherableRanges`.
              */
-            const rangesToRemove = getTimeRangesForContent(segmentBuffer, resettedContent);
+            const rangesToRemove = getTimeRangesForContent(segmentSink, resettedContent);
             // First close all Stream currently active so they don't continue to
             // load and push segments.
             enableOutOfBoundsCheck = false;
@@ -255,7 +257,7 @@ export default function StreamOrchestrator(content, playbackObserver, representa
             currentCanceller.cancel();
             currentCanceller = new TaskCanceller();
             currentCanceller.linkToSignal(orchestratorCancelSignal);
-            /** Remove from the `SegmentBuffer` all the concerned time ranges. */
+            /** Remove from the `SegmentSink` all the concerned time ranges. */
             for (const { start, end } of [...undecipherableRanges, ...rangesToRemove]) {
                 if (orchestratorCancelSignal.isCancelled()) {
                     return;
@@ -264,7 +266,7 @@ export default function StreamOrchestrator(content, playbackObserver, representa
                     if (orchestratorCancelSignal.isCancelled()) {
                         return;
                     }
-                    await segmentBuffer.removeBuffer(start, end);
+                    await segmentSink.removeBuffer(start, end);
                 }
             }
             // Schedule micro task before checking the last playback observation
@@ -290,7 +292,7 @@ export default function StreamOrchestrator(content, playbackObserver, representa
                 }
                 const lastPosition = observation.position.getWanted();
                 const newInitialPeriod = manifest.getPeriodForTime(lastPosition);
-                if (newInitialPeriod == null) {
+                if (newInitialPeriod === undefined) {
                     callbacks.error(new MediaError("MEDIA_TIME_NOT_FOUND", "The wanted position is not found in the Manifest."));
                     return;
                 }
@@ -350,22 +352,26 @@ export default function StreamOrchestrator(content, playbackObserver, representa
                 }
                 log.info("Stream: Destroying PeriodStream as the current playhead moved above it", bufferType, basePeriod.start, position.getWanted(), basePeriod.end);
                 stopListeningObservations();
-                consecutivePeriodStreamCb.periodStreamCleared({ type: bufferType,
+                consecutivePeriodStreamCb.periodStreamCleared({
+                    type: bufferType,
                     manifest,
-                    period: basePeriod });
+                    period: basePeriod,
+                });
                 currentStreamCanceller.cancel();
             }
         }, { clearSignal: cancelSignal, includeLastObservation: true });
-        const periodStreamArgs = { bufferType,
+        const periodStreamArgs = {
+            bufferType,
             content: { manifest, period: basePeriod },
             garbageCollectors,
             maxVideoBufferSize,
             segmentFetcherCreator,
-            segmentBuffersStore,
+            segmentSinksStore,
             options,
             playbackObserver,
             representationEstimator,
-            wantedBufferAhead };
+            wantedBufferAhead,
+        };
         const periodStreamCallbacks = Object.assign(Object.assign({}, consecutivePeriodStreamCb), { streamStatusUpdate(value) {
                 if (value.hasFinishedLoading) {
                     const nextPeriod = manifest.getPeriodAfter(basePeriod);
@@ -377,10 +383,11 @@ export default function StreamOrchestrator(content, playbackObserver, representa
                 else if (nextStreamInfo !== null) {
                     // current Stream is active, destroy next Stream if created
                     log.info("Stream: Destroying next PeriodStream due to current one being active", bufferType, nextStreamInfo.period.start);
-                    consecutivePeriodStreamCb
-                        .periodStreamCleared({ type: bufferType,
+                    consecutivePeriodStreamCb.periodStreamCleared({
+                        type: bufferType,
                         manifest,
-                        period: nextStreamInfo.period });
+                        period: nextStreamInfo.period,
+                    });
                     nextStreamInfo.canceller.cancel();
                     nextStreamInfo = null;
                 }
@@ -406,15 +413,16 @@ export default function StreamOrchestrator(content, playbackObserver, representa
                     return;
                 }
                 log.warn("Stream: Creating next `PeriodStream` while one was already created.", bufferType, nextPeriod.id, nextStreamInfo.period.id);
-                consecutivePeriodStreamCb.periodStreamCleared({ type: bufferType,
+                consecutivePeriodStreamCb.periodStreamCleared({
+                    type: bufferType,
                     manifest,
-                    period: nextStreamInfo.period });
+                    period: nextStreamInfo.period,
+                });
                 nextStreamInfo.canceller.cancel();
             }
             const nextStreamCanceller = new TaskCanceller();
             nextStreamCanceller.linkToSignal(cancelSignal);
-            nextStreamInfo = { canceller: nextStreamCanceller,
-                period: nextPeriod };
+            nextStreamInfo = { canceller: nextStreamCanceller, period: nextPeriod };
             manageConsecutivePeriodStreams(bufferType, nextPeriod, consecutivePeriodStreamCb, nextStreamInfo.canceller.signal);
         }
         /**
@@ -425,7 +433,7 @@ export default function StreamOrchestrator(content, playbackObserver, representa
          * performing checks.
          */
         function handleUnexpectedManifestUpdates(innerCancelSignal) {
-            manifest.addEventListener("manifestUpdate", updates => {
+            manifest.addEventListener("manifestUpdate", (updates) => {
                 // If current period has been unexpectedly removed, ask to reload
                 for (const period of updates.removedPeriods) {
                     if (period.id === basePeriod.id) {
@@ -441,9 +449,11 @@ export default function StreamOrchestrator(content, playbackObserver, representa
                                 if (innerCancelSignal.isCancelled()) {
                                     return;
                                 }
-                                return callbacks.needsMediaSourceReload({ timeOffset: 0,
+                                return callbacks.needsMediaSourceReload({
+                                    timeOffset: 0,
                                     minimumPosition: undefined,
-                                    maximumPosition: undefined });
+                                    maximumPosition: undefined,
+                                });
                             });
                         }
                     }
@@ -458,10 +468,11 @@ export default function StreamOrchestrator(content, playbackObserver, representa
                         if (newNextPeriod === null ||
                             nextStreamInfo.period.id !== newNextPeriod.id) {
                             log.warn("Stream: Destroying next PeriodStream due to new one being added", bufferType, nextStreamInfo.period.start);
-                            consecutivePeriodStreamCb
-                                .periodStreamCleared({ type: bufferType,
+                            consecutivePeriodStreamCb.periodStreamCleared({
+                                type: bufferType,
                                 manifest,
-                                period: nextStreamInfo.period });
+                                period: nextStreamInfo.period,
+                            });
                             nextStreamInfo.canceller.cancel();
                             nextStreamInfo = null;
                         }
@@ -488,7 +499,7 @@ function needsFlushingAfterClean(observation, cleanedRanges) {
     // the corresponding ranges, without seeking or re-switching playback
     // direction which is expected to lead to a low-level flush anyway.
     // There's a 5 seconds security, just to be sure.
-    return observation.speed >= 0 ?
-        cleanedRanges[cleanedRanges.length - 1].end >= curPos - 5 :
-        cleanedRanges[0].start <= curPos + 5;
+    return observation.speed >= 0
+        ? cleanedRanges[cleanedRanges.length - 1].end >= curPos - 5
+        : cleanedRanges[0].start <= curPos + 5;
 }

package/dist/es2017/core/stream/period/period_stream.d.ts

@@ -13,13 +13,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { CancellationSignal } from "../../../utils/task_canceller";
-import { IPeriodStreamArguments, IPeriodStreamCallbacks } from "./types";
+import type { CancellationSignal } from "../../../utils/task_canceller";
+import type { IPeriodStreamArguments, IPeriodStreamCallbacks } from "./types";
 /**
  * Create a single PeriodStream:
- *   - Lazily create (or reuse) a SegmentBuffer for the given type.
+ *   - Lazily create (or reuse) a SegmentSink for the given type.
  *   - Create a Stream linked to an Adaptation each time it changes, to
- *     download and append the corresponding segments to the SegmentBuffer.
+ *     download and append the corresponding segments to the SegmentSink.
  *   - Announce when the Stream is full or is awaiting new Segments through
  *     events
  *
@@ -46,4 +46,4 @@ import { IPeriodStreamArguments, IPeriodStreamCallbacks } from "./types";
  * triggered, to immediately stop all operations the `PeriodStream` is
  * doing.
  */
-export default function PeriodStream({ bufferType, content, garbageCollectors, playbackObserver, representationEstimator, segmentFetcherCreator, segmentBuffersStore, options, wantedBufferAhead, maxVideoBufferSize }: IPeriodStreamArguments, callbacks: IPeriodStreamCallbacks, parentCancelSignal: CancellationSignal): void;
+export default function PeriodStream({ bufferType, content, garbageCollectors, playbackObserver, representationEstimator, segmentFetcherCreator, segmentSinksStore, options, wantedBufferAhead, maxVideoBufferSize, }: IPeriodStreamArguments, callbacks: IPeriodStreamCallbacks, parentCancelSignal: CancellationSignal): void;

package/dist/es2017/core/stream/period/period_stream.js

@@ -14,23 +14,23 @@
  * limitations under the License.
  */
 import config from "../../../config";
-import { formatError, MediaError, } from "../../../errors";
+import { formatError, MediaError } from "../../../errors";
 import log from "../../../log";
-import { toTaggedTrack, } from "../../../manifest";
+import { toTaggedTrack } from "../../../manifest";
 import arrayFind from "../../../utils/array_find";
 import objectAssign from "../../../utils/object_assign";
 import queueMicrotask from "../../../utils/queue_microtask";
 import { getLeftSizeOfRange } from "../../../utils/ranges";
 import SharedReference from "../../../utils/reference";
-import TaskCanceller, { CancellationError, } from "../../../utils/task_canceller";
-import SegmentBuffersStore from "../../segment_buffers";
+import TaskCanceller, { CancellationError } from "../../../utils/task_canceller";
+import SegmentSinksStore from "../../segment_sinks";
 import AdaptationStream from "../adaptation";
 import getAdaptationSwitchStrategy from "./utils/get_adaptation_switch_strategy";
 /**
  * Create a single PeriodStream:
- *   - Lazily create (or reuse) a SegmentBuffer for the given type.
+ *   - Lazily create (or reuse) a SegmentSink for the given type.
  *   - Create a Stream linked to an Adaptation each time it changes, to
- *     download and append the corresponding segments to the SegmentBuffer.
+ *     download and append the corresponding segments to the SegmentSink.
  *   - Announce when the Stream is full or is awaiting new Segments through
  *     events
  *
@@ -57,7 +57,7 @@ import getAdaptationSwitchStrategy from "./utils/get_adaptation_switch_strategy"
  * triggered, to immediately stop all operations the `PeriodStream` is
  * doing.
  */
-export default function PeriodStream({ bufferType, content, garbageCollectors, playbackObserver, representationEstimator, segmentFetcherCreator, segmentBuffersStore, options, wantedBufferAhead, maxVideoBufferSize }, callbacks, parentCancelSignal) {
+export default function PeriodStream({ bufferType, content, garbageCollectors, playbackObserver, representationEstimator, segmentFetcherCreator, segmentSinksStore, options, wantedBufferAhead, maxVideoBufferSize, }, callbacks, parentCancelSignal) {
     const { manifest, period } = content;
     /**
      * Emits the chosen Adaptation and Representations for the current type.
@@ -65,7 +65,12 @@ export default function PeriodStream({ bufferType, content, garbageCollectors, p
      * `undefined` at the beginning (it can be ignored.).
      */
     const adaptationRef = new SharedReference(undefined, parentCancelSignal);
-    callbacks.periodStreamReady({ type: bufferType, manifest, period, adaptationRef });
+    callbacks.periodStreamReady({
+        type: bufferType,
+        manifest,
+        period,
+        adaptationRef,
+    });
     if (parentCancelSignal.isCancelled()) {
         return;
     }
@@ -82,12 +87,13 @@ export default function PeriodStream({ bufferType, content, garbageCollectors, p
             streamCanceller.linkToSignal(parentCancelSignal);
             currentStreamCanceller === null || currentStreamCanceller === void 0 ? void 0 : currentStreamCanceller.cancel(); // Cancel oreviously created stream if one
             currentStreamCanceller = streamCanceller;
-            if (choice === null) { // Current type is disabled for that Period
+            if (choice === null) {
+                // Current type is disabled for that Period
                 log.info(`Stream: Set no ${bufferType} Adaptation. P:`, period.start);
-                const segmentBufferStatus = segmentBuffersStore.getStatus(bufferType);
-                if (segmentBufferStatus.type === "initialized") {
-                    log.info(`Stream: Clearing previous ${bufferType} SegmentBuffer`);
-                    if (SegmentBuffersStore.isNative(bufferType)) {
+                const segmentSinkStatus = segmentSinksStore.getStatus(bufferType);
+                if (segmentSinkStatus.type === "initialized") {
+                    log.info(`Stream: Clearing previous ${bufferType} SegmentSink`);
+                    if (SegmentSinksStore.isNative(bufferType)) {
                         return askForMediaSourceReload(0, true, streamCanceller.signal);
                     }
                     else {
@@ -96,27 +102,31 @@ export default function PeriodStream({ bufferType, content, garbageCollectors, p
                             log.warn("Stream: Can't free buffer: period's start is after its end");
                         }
                         else {
-                            await segmentBufferStatus.value.removeBuffer(period.start, periodEnd);
+                            await segmentSinkStatus.value.removeBuffer(period.start, periodEnd);
                             if (streamCanceller.isUsed()) {
                                 return; // The stream has been cancelled
                             }
                         }
                     }
                 }
-                else if (segmentBufferStatus.type === "uninitialized") {
-                    segmentBuffersStore.disableSegmentBuffer(bufferType);
+                else if (segmentSinkStatus.type === "uninitialized") {
+                    segmentSinksStore.disableSegmentSink(bufferType);
                     if (streamCanceller.isUsed()) {
                         return; // The stream has been cancelled
                     }
                 }
-                callbacks.adaptationChange({ type: bufferType, adaptation: null, period });
+                callbacks.adaptationChange({
+                    type: bufferType,
+                    adaptation: null,
+                    period,
+                });
                 if (streamCanceller.isUsed()) {
                     return; // Previous call has provoken Stream cancellation by side-effect
                 }
                 return createEmptyAdaptationStream(playbackObserver, wantedBufferAhead, bufferType, { period }, callbacks, streamCanceller.signal);
             }
             const adaptations = period.adaptations[bufferType];
-            const adaptation = arrayFind(adaptations !== null && adaptations !== void 0 ? adaptations : [], a => a.id === choice.adaptationId);
+            const adaptation = arrayFind(adaptations !== null && adaptations !== void 0 ? adaptations : [], (a) => a.id === choice.adaptationId);
             if (adaptation === undefined) {
                 currentStreamCanceller.cancel();
                 log.warn("Stream: Unfound chosen Adaptation choice", choice.adaptationId);
@@ -153,12 +163,12 @@ export default function PeriodStream({ bufferType, content, garbageCollectors, p
                 }
             }
             isFirstAdaptationSwitch = false;
-            if (SegmentBuffersStore.isNative(bufferType) &&
-                segmentBuffersStore.getStatus(bufferType).type === "disabled") {
+            if (SegmentSinksStore.isNative(bufferType) &&
+                segmentSinksStore.getStatus(bufferType).type === "disabled") {
                 return askForMediaSourceReload(relativePosAfterSwitch, true, streamCanceller.signal);
             }
             // Reload if the Adaptation disappears from the manifest
-            manifest.addEventListener("manifestUpdate", updates => {
+            manifest.addEventListener("manifestUpdate", (updates) => {
                 // If current period has been unexpectedly removed, ask to reload
                 for (const element of updates.updatedPeriods) {
                     if (element.period.id === period.id) {
@@ -179,18 +189,18 @@ export default function PeriodStream({ bufferType, content, garbageCollectors, p
             if (streamCanceller.isUsed()) {
                 return; // Previous call has provoken cancellation by side-effect
             }
-            const segmentBuffer = createOrReuseSegmentBuffer(segmentBuffersStore, bufferType, adaptation);
-            const strategy = getAdaptationSwitchStrategy(segmentBuffer, period, adaptation, choice.switchingMode, playbackObserver, options);
+            const segmentSink = createOrReuseSegmentSink(segmentSinksStore, bufferType, adaptation);
+            const strategy = getAdaptationSwitchStrategy(segmentSink, period, adaptation, choice.switchingMode, playbackObserver, options);
             if (strategy.type === "needs-reload") {
                 return askForMediaSourceReload(relativePosAfterSwitch, true, streamCanceller.signal);
             }
-            await segmentBuffersStore.waitForUsableBuffers(streamCanceller.signal);
+            await segmentSinksStore.waitForUsableBuffers(streamCanceller.signal);
             if (streamCanceller.isUsed()) {
                 return; // The Stream has since been cancelled
             }
             if (strategy.type === "flush-buffer" || strategy.type === "clean-buffer") {
                 for (const { start, end } of strategy.value) {
-                    await segmentBuffer.removeBuffer(start, end);
+                    await segmentSink.removeBuffer(start, end);
                     if (streamCanceller.isUsed()) {
                         return; // The Stream has since been cancelled
                     }
@@ -199,15 +209,17 @@ export default function PeriodStream({ bufferType, content, garbageCollectors, p
                     // The seek to `relativePosAfterSwitch` is only performed if strategy.type
                     // is "flush-buffer" because there should be no interuption when playing in
                     // with `clean-buffer` strategy
-                    callbacks.needsBufferFlush({ relativeResumingPosition: relativePosAfterSwitch,
-                        relativePosHasBeenDefaulted });
+                    callbacks.needsBufferFlush({
+                        relativeResumingPosition: relativePosAfterSwitch,
+                        relativePosHasBeenDefaulted,
+                    });
                     if (streamCanceller.isUsed()) {
                         return; // Previous callback cancelled the Stream by side-effect
                     }
                 }
             }
-            garbageCollectors.get(segmentBuffer)(streamCanceller.signal);
-            createAdaptationStream(adaptation, representations, segmentBuffer, streamCanceller.signal);
+            garbageCollectors.get(segmentSink)(streamCanceller.signal);
+            createAdaptationStream(adaptation, representations, segmentSink, streamCanceller.signal);
         })().catch((err) => {
             if (err instanceof CancellationError) {
                 return;
@@ -219,29 +231,28 @@ export default function PeriodStream({ bufferType, content, garbageCollectors, p
     /**
      * @param {Object} adaptation
      * @param {Object} representations
-     * @param {Object} segmentBuffer
+     * @param {Object} segmentSink
      * @param {Object} cancelSignal
      */
-    function createAdaptationStream(adaptation, representations, segmentBuffer, cancelSignal) {
+    function createAdaptationStream(adaptation, representations, segmentSink, cancelSignal) {
         const adaptationPlaybackObserver = createAdaptationStreamPlaybackObserver(playbackObserver, adaptation.type);
-        AdaptationStream({ content: { manifest,
-                period,
-                adaptation,
-                representations },
+        AdaptationStream({
+            content: { manifest, period, adaptation, representations },
             options,
             playbackObserver: adaptationPlaybackObserver,
             representationEstimator,
-            segmentBuffer,
+            segmentSink,
             segmentFetcherCreator,
             wantedBufferAhead,
-            maxVideoBufferSize }, Object.assign(Object.assign({}, callbacks), { error: onAdaptationStreamError }), cancelSignal);
+            maxVideoBufferSize,
+        }, Object.assign(Object.assign({}, callbacks), { error: onAdaptationStreamError }), cancelSignal);
         function onAdaptationStreamError(error) {
             // Stream linked to a non-native media buffer should not impact the
             // stability of the player. ie: if a text buffer sends an error, we want
             // to continue playing without any subtitles
-            if (!SegmentBuffersStore.isNative(bufferType)) {
+            if (!SegmentSinksStore.isNative(bufferType)) {
                 log.error(`Stream: ${bufferType} Stream crashed. Aborting it.`, error instanceof Error ? error : "");
-                segmentBuffersStore.disposeSegmentBuffer(bufferType);
+                segmentSinksStore.disposeSegmentSink(bufferType);
                 const formattedError = formatError(error, {
                     defaultCode: "NONE",
                     defaultReason: "Unknown `AdaptationStream` error",
@@ -286,10 +297,12 @@ export default function PeriodStream({ bufferType, content, garbageCollectors, p
                 if (cancelSignal.isCancelled()) {
                     return;
                 }
-                callbacks.waitingMediaSourceReload({ bufferType,
+                callbacks.waitingMediaSourceReload({
+                    bufferType,
                     period,
                     timeOffset,
-                    stayInPeriod });
+                    stayInPeriod,
+                });
             }, { includeLastObservation: true, clearSignal: cancelSignal });
         });
     }
@@ -299,16 +312,16 @@ export default function PeriodStream({ bufferType, content, garbageCollectors, p
  * @param {Object} adaptation
  * @returns {Object}
  */
-function createOrReuseSegmentBuffer(segmentBuffersStore, bufferType, adaptation) {
-    const segmentBufferStatus = segmentBuffersStore.getStatus(bufferType);
-    if (segmentBufferStatus.type === "initialized") {
-        log.info("Stream: Reusing a previous SegmentBuffer for the type", bufferType);
+function createOrReuseSegmentSink(segmentSinksStore, bufferType, adaptation) {
+    const segmentSinkStatus = segmentSinksStore.getStatus(bufferType);
+    if (segmentSinkStatus.type === "initialized") {
+        log.info("Stream: Reusing a previous SegmentSink for the type", bufferType);
         // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-        return segmentBufferStatus.value;
+        return segmentSinkStatus.value;
     }
     const codec = getFirstDeclaredMimeType(adaptation);
     // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-    return segmentBuffersStore.createSegmentBuffer(bufferType, codec);
+    return segmentSinksStore.createSegmentSink(bufferType, codec);
 }
 /**
  * Get mime-type string of the first representation declared in the given
@@ -317,12 +330,11 @@ function createOrReuseSegmentBuffer(segmentBuffersStore, bufferType, adaptation)
  * @returns {string}
  */
 function getFirstDeclaredMimeType(adaptation) {
-    const representations = adaptation.representations.filter(r => {
+    const representations = adaptation.representations.filter((r) => {
         return r.isSupported === true && r.decipherable !== false;
     });
     if (representations.length === 0) {
-        const noRepErr = new MediaError("NO_PLAYABLE_REPRESENTATION", "No Representation in the chosen " +
-            adaptation.type + " Adaptation can be played", { tracks: [toTaggedTrack(adaptation)] });
+        const noRepErr = new MediaError("NO_PLAYABLE_REPRESENTATION", "No Representation in the chosen " + adaptation.type + " Adaptation can be played", { tracks: [toTaggedTrack(adaptation)] });
         throw noRepErr;
     }
     return representations[0].getMimeTypeString();
@@ -344,9 +356,9 @@ function createAdaptationStreamPlaybackObserver(initialPlaybackObserver, trackTy
         function constructAdaptationStreamPlaybackObservation() {
             const baseObservation = observationRef.getValue();
             const buffered = baseObservation.buffered[trackType];
-            const bufferGap = buffered !== null ?
-                getLeftSizeOfRange(buffered, baseObservation.position.getWanted()) :
-                0;
+            const bufferGap = buffered !== null
+                ? getLeftSizeOfRange(buffered, baseObservation.position.getWanted())
+                : 0;
             return objectAssign({}, baseObservation, { bufferGap, buffered });
         }
         function emitAdaptationStreamPlaybackObservation() {
@@ -368,23 +380,31 @@ function createAdaptationStreamPlaybackObserver(initialPlaybackObserver, trackTy
 function createEmptyAdaptationStream(playbackObserver, wantedBufferAhead, bufferType, content, callbacks, cancelSignal) {
     const { period } = content;
     let hasFinishedLoading = false;
-    wantedBufferAhead.onUpdate(sendStatus, { emitCurrentValue: false, clearSignal: cancelSignal });
-    playbackObserver.listen(sendStatus, { includeLastObservation: false, clearSignal: cancelSignal });
+    wantedBufferAhead.onUpdate(sendStatus, {
+        emitCurrentValue: false,
+        clearSignal: cancelSignal,
+    });
+    playbackObserver.listen(sendStatus, {
+        includeLastObservation: false,
+        clearSignal: cancelSignal,
+    });
     sendStatus();
     function sendStatus() {
         const observation = playbackObserver.getReference().getValue();
         const wba = wantedBufferAhead.getValue();
         const position = observation.position.getWanted();
         if (period.end !== undefined && position + wba >= period.end) {
-            log.debug("Stream: full \"empty\" AdaptationStream", bufferType);
+            log.debug('Stream: full "empty" AdaptationStream', bufferType);
             hasFinishedLoading = true;
         }
-        callbacks.streamStatusUpdate({ period,
+        callbacks.streamStatusUpdate({
+            period,
             bufferType,
             imminentDiscontinuity: null,
             position,
             isEmptyStream: true,
             hasFinishedLoading,
-            neededSegments: [] });
+            neededSegments: [],
+        });
     }
 }