rx-player 4.0.0 → 4.1.0-dev.2024031100

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

@@ -101,21 +101,22 @@ Object.defineProperty(exports, "__esModule", { value: true });
 var config_1 = require("../../../config");
 var errors_1 = require("../../../errors");
 var log_1 = require("../../../log");
+var is_null_or_undefined_1 = require("../../../utils/is_null_or_undefined");
 var queue_microtask_1 = require("../../../utils/queue_microtask");
 var reference_1 = require("../../../utils/reference");
 var sorted_list_1 = require("../../../utils/sorted_list");
 var task_canceller_1 = require("../../../utils/task_canceller");
 var weak_map_memory_1 = require("../../../utils/weak_map_memory");
-var segment_buffers_1 = require("../../segment_buffers");
+var segment_sinks_1 = require("../../segment_sinks");
 var period_1 = require("../period");
 var get_time_ranges_for_content_1 = require("./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...
  *
@@ -128,8 +129,8 @@ var get_time_ranges_for_content_1 = require("./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
@@ -151,32 +152,34 @@ var get_time_ranges_for_content_1 = require("./get_time_ranges_for_content");
  * when triggered, to immediately stop all operations the `PeriodStream` is
  * doing.
  */
-function StreamOrchestrator(content, playbackObserver, representationEstimator, segmentBuffersStore, segmentFetcherCreator, options, callbacks, orchestratorCancelSignal) {
+function StreamOrchestrator(content, playbackObserver, representationEstimator, segmentSinksStore, segmentFetcherCreator, options, callbacks, orchestratorCancelSignal) {
     var e_1, _a;
     var manifest = content.manifest, initialPeriod = content.initialPeriod;
     var maxBufferAhead = options.maxBufferAhead, maxBufferBehind = options.maxBufferBehind, wantedBufferAhead = options.wantedBufferAhead, maxVideoBufferSize = options.maxVideoBufferSize;
     var _b = config_1.default.getCurrent(), MINIMUM_MAX_BUFFER_AHEAD = _b.MINIMUM_MAX_BUFFER_AHEAD, MAXIMUM_MAX_BUFFER_AHEAD = _b.MAXIMUM_MAX_BUFFER_AHEAD, MAXIMUM_MAX_BUFFER_BEHIND = _b.MAXIMUM_MAX_BUFFER_BEHIND;
     // Keep track of a unique BufferGarbageCollector created per
-    // SegmentBuffer.
-    var garbageCollectors = new weak_map_memory_1.default(function (segmentBuffer) {
+    // SegmentSink.
+    var garbageCollectors = new weak_map_memory_1.default(function (segmentSink) {
         var _a, _b;
-        var bufferType = segmentBuffer.bufferType;
+        var bufferType = segmentSink.bufferType;
         var defaultMaxBehind = (_a = MAXIMUM_MAX_BUFFER_BEHIND[bufferType]) !== null && _a !== void 0 ? _a : Infinity;
         var maxAheadHigherBound = (_b = MAXIMUM_MAX_BUFFER_AHEAD[bufferType]) !== null && _b !== void 0 ? _b : Infinity;
         return function (gcCancelSignal) {
-            (0, segment_buffers_1.BufferGarbageCollector)({ segmentBuffer: segmentBuffer, playbackObserver: playbackObserver, maxBufferBehind: (0, reference_1.createMappedReference)(maxBufferBehind, function (val) {
-                    return Math.min(val, defaultMaxBehind);
-                }, gcCancelSignal),
+            (0, segment_sinks_1.BufferGarbageCollector)({
+                segmentSink: segmentSink,
+                playbackObserver: playbackObserver,
+                maxBufferBehind: (0, reference_1.createMappedReference)(maxBufferBehind, function (val) { return Math.min(val, defaultMaxBehind); }, gcCancelSignal),
                 maxBufferAhead: (0, reference_1.createMappedReference)(maxBufferAhead, function (val) {
                     var _a;
                     var 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);
         };
     });
     try {
         // Create automatically the right `PeriodStream` for every possible types
-        for (var _c = __values(segmentBuffersStore.getBufferTypes()), _d = _c.next(); !_d.done; _d = _c.next()) {
+        for (var _c = __values(segmentSinksStore.getBufferTypes()), _d = _c.next(); !_d.done; _d = _c.next()) {
             var bufferType = _d.value;
             manageEveryStreams(bufferType, initialPeriod);
         }
@@ -259,10 +262,11 @@ function StreamOrchestrator(content, playbackObserver, representationEstimator,
                     // Only reload the MediaSource when the more immediately required
                     // Period is the one it is asked for
                     var 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({
@@ -294,12 +298,11 @@ function StreamOrchestrator(content, playbackObserver, representationEstimator,
         function isOutOfPeriodList(time) {
             var head = periodList.head();
             var 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 || ((0, is_null_or_undefined_1.default)(last.end) ? Infinity : last.end) < time);
         }
         /**
          * React to a Manifest's decipherability updates.
@@ -308,33 +311,28 @@ function StreamOrchestrator(content, playbackObserver, representationEstimator,
          */
         function onDecipherabilityUpdates(updates) {
             return __awaiter(this, void 0, void 0, function () {
-                var segmentBufferStatus, ofCurrentType, segmentBuffer, resettedContent, undecipherableContent, undecipherableRanges, rangesToRemove, period, _a, _b, _c, start, end, e_2_1;
+                var segmentSinkStatus, ofCurrentType, segmentSink, resettedContent, undecipherableContent, undecipherableRanges, rangesToRemove, period, _a, _b, _c, start, end, e_2_1;
                 var e_2, _d;
                 return __generator(this, function (_e) {
                     switch (_e.label) {
                         case 0:
-                            segmentBufferStatus = segmentBuffersStore.getStatus(bufferType);
-                            ofCurrentType = updates
-                                .filter(function (update) { return update.adaptation.type === bufferType; });
+                            segmentSinkStatus = segmentSinksStore.getStatus(bufferType);
+                            ofCurrentType = updates.filter(function (update) { return 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(function (x) { return x.representation.decipherable === true; })) {
                                 // Data won't have to be removed from the buffers, no need to stop the
                                 // current Streams.
                                 return [2 /*return*/];
                             }
-                            segmentBuffer = segmentBufferStatus.value;
-                            resettedContent = ofCurrentType.filter(function (update) {
-                                return update.representation.decipherable === undefined;
-                            });
-                            undecipherableContent = ofCurrentType.filter(function (update) {
-                                return update.representation.decipherable === false;
-                            });
-                            undecipherableRanges = (0, get_time_ranges_for_content_1.default)(segmentBuffer, undecipherableContent);
-                            rangesToRemove = (0, get_time_ranges_for_content_1.default)(segmentBuffer, resettedContent);
+                            segmentSink = segmentSinkStatus.value;
+                            resettedContent = ofCurrentType.filter(function (update) { return update.representation.decipherable === undefined; });
+                            undecipherableContent = ofCurrentType.filter(function (update) { return update.representation.decipherable === false; });
+                            undecipherableRanges = (0, get_time_ranges_for_content_1.default)(segmentSink, undecipherableContent);
+                            rangesToRemove = (0, get_time_ranges_for_content_1.default)(segmentSink, resettedContent);
                             // First close all Stream currently active so they don't continue to
                             // load and push segments.
                             enableOutOfBoundsCheck = false;
@@ -362,7 +360,7 @@ function StreamOrchestrator(content, playbackObserver, representationEstimator,
                             if (orchestratorCancelSignal.isCancelled()) {
                                 return [2 /*return*/];
                             }
-                            return [4 /*yield*/, segmentBuffer.removeBuffer(start, end)];
+                            return [4 /*yield*/, segmentSink.removeBuffer(start, end)];
                         case 3:
                             _e.sent();
                             _e.label = 4;
@@ -404,7 +402,7 @@ function StreamOrchestrator(content, playbackObserver, representationEstimator,
                                 }
                                 var lastPosition = observation.position.getWanted();
                                 var newInitialPeriod = manifest.getPeriodForTime(lastPosition);
-                                if (newInitialPeriod == null) {
+                                if (newInitialPeriod === undefined) {
                                     callbacks.error(new errors_1.MediaError("MEDIA_TIME_NOT_FOUND", "The wanted position is not found in the Manifest."));
                                     return;
                                 }
@@ -469,11 +467,26 @@ function StreamOrchestrator(content, playbackObserver, representationEstimator,
                 }
                 log_1.default.info("Stream: Destroying PeriodStream as the current playhead moved above it", bufferType, basePeriod.start, position.getWanted(), basePeriod.end);
                 stopListeningObservations();
-                consecutivePeriodStreamCb.periodStreamCleared({ type: bufferType, manifest: manifest, period: basePeriod });
+                consecutivePeriodStreamCb.periodStreamCleared({
+                    type: bufferType,
+                    manifest: manifest,
+                    period: basePeriod,
+                });
                 currentStreamCanceller.cancel();
             }
         }, { clearSignal: cancelSignal, includeLastObservation: true });
-        var periodStreamArgs = { bufferType: bufferType, content: { manifest: manifest, period: basePeriod }, garbageCollectors: garbageCollectors, maxVideoBufferSize: maxVideoBufferSize, segmentFetcherCreator: segmentFetcherCreator, segmentBuffersStore: segmentBuffersStore, options: options, playbackObserver: playbackObserver, representationEstimator: representationEstimator, wantedBufferAhead: wantedBufferAhead };
+        var periodStreamArgs = {
+            bufferType: bufferType,
+            content: { manifest: manifest, period: basePeriod },
+            garbageCollectors: garbageCollectors,
+            maxVideoBufferSize: maxVideoBufferSize,
+            segmentFetcherCreator: segmentFetcherCreator,
+            segmentSinksStore: segmentSinksStore,
+            options: options,
+            playbackObserver: playbackObserver,
+            representationEstimator: representationEstimator,
+            wantedBufferAhead: wantedBufferAhead,
+        };
         var periodStreamCallbacks = __assign(__assign({}, consecutivePeriodStreamCb), { streamStatusUpdate: function (value) {
                 if (value.hasFinishedLoading) {
                     var nextPeriod = manifest.getPeriodAfter(basePeriod);
@@ -485,8 +498,11 @@ function StreamOrchestrator(content, playbackObserver, representationEstimator,
                 else if (nextStreamInfo !== null) {
                     // current Stream is active, destroy next Stream if created
                     log_1.default.info("Stream: Destroying next PeriodStream due to current one being active", bufferType, nextStreamInfo.period.start);
-                    consecutivePeriodStreamCb
-                        .periodStreamCleared({ type: bufferType, manifest: manifest, period: nextStreamInfo.period });
+                    consecutivePeriodStreamCb.periodStreamCleared({
+                        type: bufferType,
+                        manifest: manifest,
+                        period: nextStreamInfo.period,
+                    });
                     nextStreamInfo.canceller.cancel();
                     nextStreamInfo = null;
                 }
@@ -511,13 +527,16 @@ function StreamOrchestrator(content, playbackObserver, representationEstimator,
                     return;
                 }
                 log_1.default.warn("Stream: Creating next `PeriodStream` while one was already created.", bufferType, nextPeriod.id, nextStreamInfo.period.id);
-                consecutivePeriodStreamCb.periodStreamCleared({ type: bufferType, manifest: manifest, period: nextStreamInfo.period });
+                consecutivePeriodStreamCb.periodStreamCleared({
+                    type: bufferType,
+                    manifest: manifest,
+                    period: nextStreamInfo.period,
+                });
                 nextStreamInfo.canceller.cancel();
             }
             var nextStreamCanceller = new task_canceller_1.default();
             nextStreamCanceller.linkToSignal(cancelSignal);
-            nextStreamInfo = { canceller: nextStreamCanceller,
-                period: nextPeriod };
+            nextStreamInfo = { canceller: nextStreamCanceller, period: nextPeriod };
             manageConsecutivePeriodStreams(bufferType, nextPeriod, consecutivePeriodStreamCb, nextStreamInfo.canceller.signal);
         }
         /**
@@ -547,9 +566,11 @@ function StreamOrchestrator(content, playbackObserver, representationEstimator,
                                     if (innerCancelSignal.isCancelled()) {
                                         return;
                                     }
-                                    return callbacks.needsMediaSourceReload({ timeOffset: 0,
+                                    return callbacks.needsMediaSourceReload({
+                                        timeOffset: 0,
                                         minimumPosition: undefined,
-                                        maximumPosition: undefined });
+                                        maximumPosition: undefined,
+                                    });
                                 });
                             }
                         }
@@ -572,8 +593,11 @@ function StreamOrchestrator(content, playbackObserver, representationEstimator,
                         if (newNextPeriod === null ||
                             nextStreamInfo.period.id !== newNextPeriod.id) {
                             log_1.default.warn("Stream: Destroying next PeriodStream due to new one being added", bufferType, nextStreamInfo.period.start);
-                            consecutivePeriodStreamCb
-                                .periodStreamCleared({ type: bufferType, manifest: manifest, period: nextStreamInfo.period });
+                            consecutivePeriodStreamCb.periodStreamCleared({
+                                type: bufferType,
+                                manifest: manifest,
+                                period: nextStreamInfo.period,
+                            });
                             nextStreamInfo.canceller.cancel();
                             nextStreamInfo = null;
                         }
@@ -601,7 +625,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/commonjs/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/commonjs/core/stream/period/period_stream.js

@@ -83,14 +83,14 @@ var queue_microtask_1 = require("../../../utils/queue_microtask");
 var ranges_1 = require("../../../utils/ranges");
 var reference_1 = require("../../../utils/reference");
 var task_canceller_1 = require("../../../utils/task_canceller");
-var segment_buffers_1 = require("../../segment_buffers");
+var segment_sinks_1 = require("../../segment_sinks");
 var adaptation_1 = require("../adaptation");
 var get_adaptation_switch_strategy_1 = require("./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
  *
@@ -119,7 +119,7 @@ var get_adaptation_switch_strategy_1 = require("./utils/get_adaptation_switch_st
  */
 function PeriodStream(_a, callbacks, parentCancelSignal) {
     var _this = this;
-    var bufferType = _a.bufferType, content = _a.content, garbageCollectors = _a.garbageCollectors, playbackObserver = _a.playbackObserver, representationEstimator = _a.representationEstimator, segmentFetcherCreator = _a.segmentFetcherCreator, segmentBuffersStore = _a.segmentBuffersStore, options = _a.options, wantedBufferAhead = _a.wantedBufferAhead, maxVideoBufferSize = _a.maxVideoBufferSize;
+    var bufferType = _a.bufferType, content = _a.content, garbageCollectors = _a.garbageCollectors, playbackObserver = _a.playbackObserver, representationEstimator = _a.representationEstimator, segmentFetcherCreator = _a.segmentFetcherCreator, segmentSinksStore = _a.segmentSinksStore, options = _a.options, wantedBufferAhead = _a.wantedBufferAhead, maxVideoBufferSize = _a.maxVideoBufferSize;
     var manifest = content.manifest, period = content.period;
     /**
      * Emits the chosen Adaptation and Representations for the current type.
@@ -127,7 +127,12 @@ function PeriodStream(_a, callbacks, parentCancelSignal) {
      * `undefined` at the beginning (it can be ignored.).
      */
     var adaptationRef = new reference_1.default(undefined, parentCancelSignal);
-    callbacks.periodStreamReady({ type: bufferType, manifest: manifest, period: period, adaptationRef: adaptationRef });
+    callbacks.periodStreamReady({
+        type: bufferType,
+        manifest: manifest,
+        period: period,
+        adaptationRef: adaptationRef,
+    });
     if (parentCancelSignal.isCancelled()) {
         return;
     }
@@ -136,7 +141,7 @@ function PeriodStream(_a, callbacks, parentCancelSignal) {
     adaptationRef.onUpdate(function (choice) {
         // As an IIFE to profit from async/await while respecting onUpdate's signature
         (function () { return __awaiter(_this, void 0, void 0, function () {
-            var streamCanceller, segmentBufferStatus, periodEnd, adaptations, adaptation, DELTA_POSITION_AFTER_RELOAD, relativePosHasBeenDefaulted, relativePosAfterSwitch, representations, segmentBuffer, strategy, _a, _b, _c, start, end, e_1_1;
+            var streamCanceller, segmentSinkStatus, periodEnd, adaptations, adaptation, DELTA_POSITION_AFTER_RELOAD, relativePosHasBeenDefaulted, relativePosAfterSwitch, representations, segmentSink, strategy, _a, _b, _c, start, end, e_1_1;
             var e_1, _d;
             var _e;
             return __generator(this, function (_f) {
@@ -150,18 +155,19 @@ function PeriodStream(_a, callbacks, parentCancelSignal) {
                         currentStreamCanceller === null || currentStreamCanceller === void 0 ? void 0 : currentStreamCanceller.cancel(); // Cancel oreviously created stream if one
                         currentStreamCanceller = streamCanceller;
                         if (!(choice === null)) return [3 /*break*/, 7];
+                        // Current type is disabled for that Period
                         log_1.default.info("Stream: Set no ".concat(bufferType, " Adaptation. P:"), period.start);
-                        segmentBufferStatus = segmentBuffersStore.getStatus(bufferType);
-                        if (!(segmentBufferStatus.type === "initialized")) return [3 /*break*/, 5];
-                        log_1.default.info("Stream: Clearing previous ".concat(bufferType, " SegmentBuffer"));
-                        if (!segment_buffers_1.default.isNative(bufferType)) return [3 /*break*/, 1];
+                        segmentSinkStatus = segmentSinksStore.getStatus(bufferType);
+                        if (!(segmentSinkStatus.type === "initialized")) return [3 /*break*/, 5];
+                        log_1.default.info("Stream: Clearing previous ".concat(bufferType, " SegmentSink"));
+                        if (!segment_sinks_1.default.isNative(bufferType)) return [3 /*break*/, 1];
                         return [2 /*return*/, askForMediaSourceReload(0, true, streamCanceller.signal)];
                     case 1:
                         periodEnd = (_e = period.end) !== null && _e !== void 0 ? _e : Infinity;
                         if (!(period.start > periodEnd)) return [3 /*break*/, 2];
                         log_1.default.warn("Stream: Can't free buffer: period's start is after its end");
                         return [3 /*break*/, 4];
-                    case 2: return [4 /*yield*/, segmentBufferStatus.value.removeBuffer(period.start, periodEnd)];
+                    case 2: return [4 /*yield*/, segmentSinkStatus.value.removeBuffer(period.start, periodEnd)];
                     case 3:
                         _f.sent();
                         if (streamCanceller.isUsed()) {
@@ -170,24 +176,26 @@ function PeriodStream(_a, callbacks, parentCancelSignal) {
                         _f.label = 4;
                     case 4: return [3 /*break*/, 6];
                     case 5:
-                        if (segmentBufferStatus.type === "uninitialized") {
-                            segmentBuffersStore.disableSegmentBuffer(bufferType);
+                        if (segmentSinkStatus.type === "uninitialized") {
+                            segmentSinksStore.disableSegmentSink(bufferType);
                             if (streamCanceller.isUsed()) {
                                 return [2 /*return*/]; // The stream has been cancelled
                             }
                         }
                         _f.label = 6;
                     case 6:
-                        callbacks.adaptationChange({ type: bufferType, adaptation: null, period: period });
+                        callbacks.adaptationChange({
+                            type: bufferType,
+                            adaptation: null,
+                            period: period,
+                        });
                         if (streamCanceller.isUsed()) {
                             return [2 /*return*/]; // Previous call has provoken Stream cancellation by side-effect
                         }
                         return [2 /*return*/, createEmptyAdaptationStream(playbackObserver, wantedBufferAhead, bufferType, { period: period }, callbacks, streamCanceller.signal)];
                     case 7:
                         adaptations = period.adaptations[bufferType];
-                        adaptation = (0, array_find_1.default)(adaptations !== null && adaptations !== void 0 ? adaptations : [], function (a) {
-                            return a.id === choice.adaptationId;
-                        });
+                        adaptation = (0, array_find_1.default)(adaptations !== null && adaptations !== void 0 ? adaptations : [], function (a) { return a.id === choice.adaptationId; });
                         if (adaptation === undefined) {
                             currentStreamCanceller.cancel();
                             log_1.default.warn("Stream: Unfound chosen Adaptation choice", choice.adaptationId);
@@ -216,8 +224,8 @@ function PeriodStream(_a, callbacks, parentCancelSignal) {
                             }
                         }
                         isFirstAdaptationSwitch = false;
-                        if (segment_buffers_1.default.isNative(bufferType) &&
-                            segmentBuffersStore.getStatus(bufferType).type === "disabled") {
+                        if (segment_sinks_1.default.isNative(bufferType) &&
+                            segmentSinksStore.getStatus(bufferType).type === "disabled") {
                             return [2 /*return*/, askForMediaSourceReload(relativePosAfterSwitch, true, streamCanceller.signal)];
                         }
                         // Reload if the Adaptation disappears from the manifest
@@ -263,12 +271,12 @@ function PeriodStream(_a, callbacks, parentCancelSignal) {
                         if (streamCanceller.isUsed()) {
                             return [2 /*return*/]; // Previous call has provoken cancellation by side-effect
                         }
-                        segmentBuffer = createOrReuseSegmentBuffer(segmentBuffersStore, bufferType, adaptation);
-                        strategy = (0, get_adaptation_switch_strategy_1.default)(segmentBuffer, period, adaptation, choice.switchingMode, playbackObserver, options);
+                        segmentSink = createOrReuseSegmentSink(segmentSinksStore, bufferType, adaptation);
+                        strategy = (0, get_adaptation_switch_strategy_1.default)(segmentSink, period, adaptation, choice.switchingMode, playbackObserver, options);
                         if (strategy.type === "needs-reload") {
                             return [2 /*return*/, askForMediaSourceReload(relativePosAfterSwitch, true, streamCanceller.signal)];
                         }
-                        return [4 /*yield*/, segmentBuffersStore.waitForUsableBuffers(streamCanceller.signal)];
+                        return [4 /*yield*/, segmentSinksStore.waitForUsableBuffers(streamCanceller.signal)];
                     case 8:
                         _f.sent();
                         if (streamCanceller.isUsed()) {
@@ -283,7 +291,7 @@ function PeriodStream(_a, callbacks, parentCancelSignal) {
                     case 10:
                         if (!!_b.done) return [3 /*break*/, 13];
                         _c = _b.value, start = _c.start, end = _c.end;
-                        return [4 /*yield*/, segmentBuffer.removeBuffer(start, end)];
+                        return [4 /*yield*/, segmentSink.removeBuffer(start, end)];
                     case 11:
                         _f.sent();
                         if (streamCanceller.isUsed()) {
@@ -309,15 +317,18 @@ function PeriodStream(_a, callbacks, parentCancelSignal) {
                             // 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: relativePosHasBeenDefaulted });
+                            callbacks.needsBufferFlush({
+                                relativeResumingPosition: relativePosAfterSwitch,
+                                relativePosHasBeenDefaulted: relativePosHasBeenDefaulted,
+                            });
                             if (streamCanceller.isUsed()) {
                                 return [2 /*return*/]; // Previous callback cancelled the Stream by side-effect
                             }
                         }
                         _f.label = 17;
                     case 17:
-                        garbageCollectors.get(segmentBuffer)(streamCanceller.signal);
-                        createAdaptationStream(adaptation, representations, segmentBuffer, streamCanceller.signal);
+                        garbageCollectors.get(segmentSink)(streamCanceller.signal);
+                        createAdaptationStream(adaptation, representations, segmentSink, streamCanceller.signal);
                         return [2 /*return*/];
                 }
             });
@@ -332,19 +343,28 @@ function PeriodStream(_a, callbacks, parentCancelSignal) {
     /**
      * @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) {
         var adaptationPlaybackObserver = createAdaptationStreamPlaybackObserver(playbackObserver, adaptation.type);
-        (0, adaptation_1.default)({ content: { manifest: manifest, period: period, adaptation: adaptation, representations: representations }, options: options, playbackObserver: adaptationPlaybackObserver, representationEstimator: representationEstimator, segmentBuffer: segmentBuffer, segmentFetcherCreator: segmentFetcherCreator, wantedBufferAhead: wantedBufferAhead, maxVideoBufferSize: maxVideoBufferSize }, __assign(__assign({}, callbacks), { error: onAdaptationStreamError }), cancelSignal);
+        (0, adaptation_1.default)({
+            content: { manifest: manifest, period: period, adaptation: adaptation, representations: representations },
+            options: options,
+            playbackObserver: adaptationPlaybackObserver,
+            representationEstimator: representationEstimator,
+            segmentSink: segmentSink,
+            segmentFetcherCreator: segmentFetcherCreator,
+            wantedBufferAhead: wantedBufferAhead,
+            maxVideoBufferSize: maxVideoBufferSize,
+        }, __assign(__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 (!segment_buffers_1.default.isNative(bufferType)) {
+            if (!segment_sinks_1.default.isNative(bufferType)) {
                 log_1.default.error("Stream: ".concat(bufferType, " Stream crashed. Aborting it."), error instanceof Error ? error : "");
-                segmentBuffersStore.disposeSegmentBuffer(bufferType);
+                segmentSinksStore.disposeSegmentSink(bufferType);
                 var formattedError = (0, errors_1.formatError)(error, {
                     defaultCode: "NONE",
                     defaultReason: "Unknown `AdaptationStream` error",
@@ -389,7 +409,12 @@ function PeriodStream(_a, callbacks, parentCancelSignal) {
                 if (cancelSignal.isCancelled()) {
                     return;
                 }
-                callbacks.waitingMediaSourceReload({ bufferType: bufferType, period: period, timeOffset: timeOffset, stayInPeriod: stayInPeriod });
+                callbacks.waitingMediaSourceReload({
+                    bufferType: bufferType,
+                    period: period,
+                    timeOffset: timeOffset,
+                    stayInPeriod: stayInPeriod,
+                });
             }, { includeLastObservation: true, clearSignal: cancelSignal });
         });
     }
@@ -400,16 +425,16 @@ exports.default = PeriodStream;
  * @param {Object} adaptation
  * @returns {Object}
  */
-function createOrReuseSegmentBuffer(segmentBuffersStore, bufferType, adaptation) {
-    var segmentBufferStatus = segmentBuffersStore.getStatus(bufferType);
-    if (segmentBufferStatus.type === "initialized") {
-        log_1.default.info("Stream: Reusing a previous SegmentBuffer for the type", bufferType);
+function createOrReuseSegmentSink(segmentSinksStore, bufferType, adaptation) {
+    var segmentSinkStatus = segmentSinksStore.getStatus(bufferType);
+    if (segmentSinkStatus.type === "initialized") {
+        log_1.default.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;
     }
     var 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
@@ -422,8 +447,7 @@ function getFirstDeclaredMimeType(adaptation) {
         return r.isSupported === true && r.decipherable !== false;
     });
     if (representations.length === 0) {
-        var noRepErr = new errors_1.MediaError("NO_PLAYABLE_REPRESENTATION", "No Representation in the chosen " +
-            adaptation.type + " Adaptation can be played", { tracks: [(0, manifest_1.toTaggedTrack)(adaptation)] });
+        var noRepErr = new errors_1.MediaError("NO_PLAYABLE_REPRESENTATION", "No Representation in the chosen " + adaptation.type + " Adaptation can be played", { tracks: [(0, manifest_1.toTaggedTrack)(adaptation)] });
         throw noRepErr;
     }
     return representations[0].getMimeTypeString();
@@ -445,9 +469,9 @@ function createAdaptationStreamPlaybackObserver(initialPlaybackObserver, trackTy
         function constructAdaptationStreamPlaybackObservation() {
             var baseObservation = observationRef.getValue();
             var buffered = baseObservation.buffered[trackType];
-            var bufferGap = buffered !== null ?
-                (0, ranges_1.getLeftSizeOfRange)(buffered, baseObservation.position.getWanted()) :
-                0;
+            var bufferGap = buffered !== null
+                ? (0, ranges_1.getLeftSizeOfRange)(buffered, baseObservation.position.getWanted())
+                : 0;
             return (0, object_assign_1.default)({}, baseObservation, { bufferGap: bufferGap, buffered: buffered });
         }
         function emitAdaptationStreamPlaybackObservation() {
@@ -469,17 +493,31 @@ function createAdaptationStreamPlaybackObserver(initialPlaybackObserver, trackTy
 function createEmptyAdaptationStream(playbackObserver, wantedBufferAhead, bufferType, content, callbacks, cancelSignal) {
     var period = content.period;
     var 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() {
         var observation = playbackObserver.getReference().getValue();
         var wba = wantedBufferAhead.getValue();
         var position = observation.position.getWanted();
         if (period.end !== undefined && position + wba >= period.end) {
-            log_1.default.debug("Stream: full \"empty\" AdaptationStream", bufferType);
+            log_1.default.debug('Stream: full "empty" AdaptationStream', bufferType);
             hasFinishedLoading = true;
         }
-        callbacks.streamStatusUpdate({ period: period, bufferType: bufferType, imminentDiscontinuity: null, position: position, isEmptyStream: true, hasFinishedLoading: hasFinishedLoading, neededSegments: [] });
+        callbacks.streamStatusUpdate({
+            period: period,
+            bufferType: bufferType,
+            imminentDiscontinuity: null,
+            position: position,
+            isEmptyStream: true,
+            hasFinishedLoading: hasFinishedLoading,
+            neededSegments: [],
+        });
     }
 }