rx-player 4.0.0 → 4.1.0-dev.2024031100

package/dist/es2017/core/stream/adaptation/adaptation_stream.js

@@ -7,7 +7,7 @@ import cancellableSleep from "../../../utils/cancellable_sleep";
 import noop from "../../../utils/noop";
 import objectAssign from "../../../utils/object_assign";
 import queueMicrotask from "../../../utils/queue_microtask";
-import SharedReference, { createMappedReference, } from "../../../utils/reference";
+import SharedReference, { createMappedReference } from "../../../utils/reference";
 import TaskCanceller from "../../../utils/task_canceller";
 import RepresentationStream from "../representation";
 import getRepresentationsSwitchingStrategy from "./get_representations_switch_strategy";
@@ -17,7 +17,7 @@ import getRepresentationsSwitchingStrategy from "./get_representations_switch_st
  *
  * It will rely on the IRepresentationEstimator to choose at any time the
  * best Representation for this Adaptation and then run the logic to download
- * and push the corresponding segments in the SegmentBuffer.
+ * and push the corresponding segments in the SegmentSink.
  *
  * @param {Object} args - Various arguments allowing the `AdaptationStream` to
  * determine which Representation to choose and which segments to load from it.
@@ -41,7 +41,7 @@ import getRepresentationsSwitchingStrategy from "./get_representations_switch_st
  * triggered, to immediately stop all operations the `AdaptationStream` is
  * doing.
  */
-export default function AdaptationStream({ playbackObserver, content, options, representationEstimator, segmentBuffer, segmentFetcherCreator, wantedBufferAhead, maxVideoBufferSize }, callbacks, parentCancelSignal) {
+export default function AdaptationStream({ playbackObserver, content, options, representationEstimator, segmentSink, segmentFetcherCreator, wantedBufferAhead, maxVideoBufferSize, }, callbacks, parentCancelSignal) {
     const { manifest, period, adaptation } = content;
     /** Allows to cancel everything the `AdaptationStream` is doing. */
     const adapStreamCanceller = new TaskCanceller();
@@ -63,7 +63,7 @@ export default function AdaptationStream({ playbackObserver, content, options, r
     /** Stores the last emitted bitrate. */
     let previouslyEmittedBitrate;
     const initialRepIds = content.representations.getValue().representationIds;
-    const initialRepresentations = content.adaptation.representations.filter(r => arrayIncludes(initialRepIds, r.id) &&
+    const initialRepresentations = content.adaptation.representations.filter((r) => arrayIncludes(initialRepIds, r.id) &&
         r.decipherable !== false &&
         r.isSupported !== false);
     /** Emit the list of Representation for the adaptive logic. */
@@ -71,13 +71,14 @@ export default function AdaptationStream({ playbackObserver, content, options, r
     // Start-up Adaptive logic
     const { estimates: estimateRef, callbacks: abrCallbacks } = representationEstimator({ manifest, period, adaptation }, currentRepresentation, representationsList, playbackObserver, adapStreamCanceller.signal);
     /** Allows a `RepresentationStream` to easily fetch media segments. */
-    const segmentFetcher = segmentFetcherCreator
-        .createSegmentFetcher(adaptation.type, 
+    const segmentFetcher = segmentFetcherCreator.createSegmentFetcher(adaptation.type, 
     /* eslint-disable @typescript-eslint/unbound-method */
-    { onRequestBegin: abrCallbacks.requestBegin,
+    {
+        onRequestBegin: abrCallbacks.requestBegin,
         onRequestEnd: abrCallbacks.requestEnd,
         onProgress: abrCallbacks.requestProgress,
-        onMetrics: abrCallbacks.metrics });
+        onMetrics: abrCallbacks.metrics,
+    });
     /* eslint-enable @typescript-eslint/unbound-method */
     /** Used to determine when "fast-switching" is possible. */
     const fastSwitchThreshold = new SharedReference(0);
@@ -103,7 +104,7 @@ export default function AdaptationStream({ playbackObserver, content, options, r
             cancelCurrentStreams.cancel();
         }
         const newRepIds = content.representations.getValue().representationIds;
-        const newRepresentations = content.adaptation.representations.filter(r => arrayIncludes(newRepIds, r.id));
+        const newRepresentations = content.adaptation.representations.filter((r) => arrayIncludes(newRepIds, r.id));
         representationsList.setValueIfChanged(newRepresentations);
         cancelCurrentStreams = new TaskCanceller();
         cancelCurrentStreams.linkToSignal(adapStreamCanceller.signal);
@@ -131,7 +132,7 @@ export default function AdaptationStream({ playbackObserver, content, options, r
     async function onRepresentationsChoiceChange(choice, fnCancelSignal) {
         // First check if we should perform any action regarding what was previously
         // in the buffer
-        const switchStrat = getRepresentationsSwitchingStrategy(period, adaptation, choice, segmentBuffer, playbackObserver);
+        const switchStrat = getRepresentationsSwitchingStrategy(period, adaptation, choice, segmentSink, playbackObserver);
         switch (switchStrat.type) {
             case "continue":
                 break; // nothing to do
@@ -147,16 +148,18 @@ export default function AdaptationStream({ playbackObserver, content, options, r
                         }
                         const { DELTA_POSITION_AFTER_RELOAD } = config.getCurrent();
                         const timeOffset = DELTA_POSITION_AFTER_RELOAD.bitrateSwitch;
-                        return callbacks.waitingMediaSourceReload({ bufferType: adaptation.type,
+                        return callbacks.waitingMediaSourceReload({
+                            bufferType: adaptation.type,
                             period,
                             timeOffset,
-                            stayInPeriod: true });
+                            stayInPeriod: true,
+                        });
                     }, { includeLastObservation: true, clearSignal: fnCancelSignal });
                 });
             case "flush-buffer": // Clean + flush
             case "clean-buffer": // Just clean
                 for (const range of switchStrat.value) {
-                    await segmentBuffer.removeBuffer(range.start, range.end);
+                    await segmentSink.removeBuffer(range.start, range.end);
                     if (fnCancelSignal.isCancelled()) {
                         return;
                     }
@@ -213,8 +216,16 @@ export default function AdaptationStream({ playbackObserver, content, options, r
                 log.info("Stream: slow Representation switch", adaptation.type);
                 return terminateCurrentStream.setValue({ urgent: false });
             }
-        }, { clearSignal: repStreamTerminatingCanceller.signal, emitCurrentValue: true });
-        const repInfo = { type: adaptation.type, adaptation, period, representation };
+        }, {
+            clearSignal: repStreamTerminatingCanceller.signal,
+            emitCurrentValue: true,
+        });
+        const repInfo = {
+            type: adaptation.type,
+            adaptation,
+            period,
+            representation,
+        };
         currentRepresentation.setValue(representation);
         if (adapStreamCanceller.isUsed()) {
             return; // previous callback has stopped everything by side-effect
@@ -262,12 +273,10 @@ export default function AdaptationStream({ playbackObserver, content, options, r
     function createRepresentationStream(representation, terminateCurrentStream, representationStreamCallbacks, fnCancelSignal) {
         const bufferGoalCanceller = new TaskCanceller();
         bufferGoalCanceller.linkToSignal(fnCancelSignal);
-        const bufferGoal = createMappedReference(wantedBufferAhead, prev => {
+        const bufferGoal = createMappedReference(wantedBufferAhead, (prev) => {
             return prev * getBufferGoalRatio(representation);
         }, bufferGoalCanceller.signal);
-        const maxBufferSize = adaptation.type === "video" ?
-            maxVideoBufferSize :
-            new SharedReference(Infinity);
+        const maxBufferSize = adaptation.type === "video" ? maxVideoBufferSize : new SharedReference(Infinity);
         log.info("Stream: changing representation", adaptation.type, representation.id, representation.bitrate);
         const updatedCallbacks = objectAssign({}, representationStreamCallbacks, {
             error(err) {
@@ -290,9 +299,11 @@ export default function AdaptationStream({ playbackObserver, content, options, r
                     bufferGoalRatioMap.set(representation.id, newBufferGoalRatio);
                     // We wait 4 seconds to let the situation evolve by itself before
                     // retrying loading segments with a lower buffer goal
-                    cancellableSleep(4000, adapStreamCanceller.signal).then(() => {
+                    cancellableSleep(4000, adapStreamCanceller.signal)
+                        .then(() => {
                         return createRepresentationStream(representation, terminateCurrentStream, representationStreamCallbacks, fnCancelSignal);
-                    }).catch(noop);
+                    })
+                        .catch(noop);
                 }
             },
             terminating() {
@@ -300,20 +311,21 @@ export default function AdaptationStream({ playbackObserver, content, options, r
                 representationStreamCallbacks.terminating();
             },
         });
-        RepresentationStream({ playbackObserver,
-            content: { representation,
-                adaptation,
-                period,
-                manifest },
-            segmentBuffer,
+        RepresentationStream({
+            playbackObserver,
+            content: { representation, adaptation, period, manifest },
+            segmentSink,
             segmentFetcher,
             terminate: terminateCurrentStream,
-            options: { bufferGoal,
+            options: {
+                bufferGoal,
                 maxBufferSize,
                 drmSystemId: options.drmSystemId,
-                fastSwitchThreshold } }, updatedCallbacks, fnCancelSignal);
+                fastSwitchThreshold,
+            },
+        }, updatedCallbacks, fnCancelSignal);
         // reload if the Representation disappears from the Manifest
-        manifest.addEventListener("manifestUpdate", updates => {
+        manifest.addEventListener("manifestUpdate", (updates) => {
             for (const element of updates.updatedPeriods) {
                 if (element.period.id === period.id) {
                     for (const updated of element.result.updatedAdaptations) {
@@ -346,8 +358,7 @@ export default function AdaptationStream({ playbackObserver, content, options, r
      */
     function getBufferGoalRatio(representation) {
         const oldBufferGoalRatio = bufferGoalRatioMap.get(representation.id);
-        const bufferGoalRatio = oldBufferGoalRatio !== undefined ? oldBufferGoalRatio :
-            1;
+        const bufferGoalRatio = oldBufferGoalRatio !== undefined ? oldBufferGoalRatio : 1;
         if (oldBufferGoalRatio === undefined) {
             bufferGoalRatioMap.set(representation.id, bufferGoalRatio);
         }

package/dist/es2017/core/stream/adaptation/get_representations_switch_strategy.d.ts

@@ -13,41 +13,41 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Adaptation, Period } from "../../../manifest";
-import { IReadOnlyPlaybackObserver } from "../../api";
-import { SegmentBuffer } from "../../segment_buffers";
-import { IRepresentationsChoice, IRepresentationStreamPlaybackObservation } from "../representation";
-export default function getRepresentationsSwitchingStrategy(period: Period, adaptation: Adaptation, settings: IRepresentationsChoice, segmentBuffer: SegmentBuffer, playbackObserver: IReadOnlyPlaybackObserver<IRepresentationStreamPlaybackObservation>): IRepresentationSwitchStrategy;
+import type { IAdaptation, IPeriod } from "../../../manifest";
+import type { IReadOnlyPlaybackObserver } from "../../../playback_observer";
+import type { SegmentSink } from "../../segment_sinks";
+import type { IRepresentationsChoice, IRepresentationStreamPlaybackObservation } from "../representation";
+export default function getRepresentationsSwitchingStrategy(period: IPeriod, adaptation: IAdaptation, settings: IRepresentationsChoice, segmentSink: SegmentSink, playbackObserver: IReadOnlyPlaybackObserver<IRepresentationStreamPlaybackObservation>): IRepresentationSwitchStrategy;
 export type IRepresentationSwitchStrategy = 
 /** Do nothing special. */
 {
     type: "continue";
     value: undefined;
-} | 
+}
 /**
  * Clean the given ranges of time from the buffer, preferably avoiding time
  * around the current position to continue playback smoothly.
  */
-{
+ | {
     type: "clean-buffer";
     value: Array<{
         start: number;
         end: number;
     }>;
-} | 
+}
 /**
  * Clean the given ranges of time from the buffer and try to flush the buffer
  * so that it is taken in account directly.
  */
-{
+ | {
     type: "flush-buffer";
     value: Array<{
         start: number;
         end: number;
     }>;
-} | 
+}
 /** Reload completely the media buffers. */
-{
+ | {
     type: "needs-reload";
     value: undefined;
 };

package/dist/es2017/core/stream/adaptation/get_representations_switch_strategy.js

@@ -15,28 +15,32 @@
  */
 import config from "../../../config";
 import arrayIncludes from "../../../utils/array_includes";
-import { excludeFromRanges, insertInto, } from "../../../utils/ranges";
-import { getFirstSegmentAfterPeriod, getLastSegmentBeforePeriod, SegmentBufferOperation, } from "../../segment_buffers";
-export default function getRepresentationsSwitchingStrategy(period, adaptation, settings, segmentBuffer, playbackObserver) {
-    var _a, _b;
+import { excludeFromRanges, insertInto } from "../../../utils/ranges";
+import { getFirstSegmentAfterPeriod, getLastSegmentBeforePeriod, SegmentSinkOperation, } from "../../segment_sinks";
+export default function getRepresentationsSwitchingStrategy(period, adaptation, settings, segmentSink, playbackObserver) {
+    var _a, _b, _c, _d;
     if (settings.switchingMode === "lazy") {
         return { type: "continue", value: undefined };
     }
-    const inventory = segmentBuffer.getLastKnownInventory();
+    const inventory = segmentSink.getLastKnownInventory();
     const unwantedRange = [];
     for (const elt of inventory) {
-        if (elt.infos.period.id === period.id && (elt.infos.adaptation.id !== adaptation.id ||
-            !arrayIncludes(settings.representationIds, elt.infos.representation.id))) {
-            insertInto(unwantedRange, { start: (_a = elt.bufferedStart) !== null && _a !== void 0 ? _a : elt.start,
-                end: (_b = elt.bufferedEnd) !== null && _b !== void 0 ? _b : elt.end });
+        if (elt.infos.period.id === period.id &&
+            (elt.infos.adaptation.id !== adaptation.id ||
+                !arrayIncludes(settings.representationIds, elt.infos.representation.id))) {
+            insertInto(unwantedRange, {
+                start: (_a = elt.bufferedStart) !== null && _a !== void 0 ? _a : elt.start,
+                end: (_b = elt.bufferedEnd) !== null && _b !== void 0 ? _b : elt.end,
+            });
         }
     }
-    const pendingOperations = segmentBuffer.getPendingOperations();
+    const pendingOperations = segmentSink.getPendingOperations();
     for (const operation of pendingOperations) {
-        if (operation.type === SegmentBufferOperation.Push) {
+        if (operation.type === SegmentSinkOperation.Push) {
             const info = operation.value.inventoryInfos;
-            if (info.period.id === period.id && (info.adaptation.id !== adaptation.id ||
-                !arrayIncludes(settings.representationIds, info.representation.id))) {
+            if (info.period.id === period.id &&
+                (info.adaptation.id !== adaptation.id ||
+                    !arrayIncludes(settings.representationIds, info.representation.id))) {
                 const start = info.segment.time;
                 const end = start + info.segment.duration;
                 insertInto(unwantedRange, { start, end });
@@ -62,34 +66,29 @@ export default function getRepresentationsSwitchingStrategy(period, adaptation,
     const lastSegmentBefore = getLastSegmentBeforePeriod(inventory, period);
     if (lastSegmentBefore !== null &&
         (lastSegmentBefore.bufferedEnd === undefined ||
-            period.start - lastSegmentBefore.bufferedEnd < 1)) // Close to Period's start
-     {
+            period.start - lastSegmentBefore.bufferedEnd < 1)) {
+        // Close to Period's start
         // Exclude data close to the period's start to avoid cleaning
         // to much
-        rangesToExclude.push({ start: 0,
-            end: period.start + 1 });
+        rangesToExclude.push({ start: 0, end: period.start + 1 });
     }
     if (!shouldFlush) {
         // exclude data around current position to avoid decoding issues
         const { ADAP_REP_SWITCH_BUFFER_PADDINGS } = config.getCurrent();
         const bufferType = adaptation.type;
         /** Ranges that won't be cleaned from the current buffer. */
-        let paddingBefore = ADAP_REP_SWITCH_BUFFER_PADDINGS[bufferType].before;
-        if (paddingBefore == null) {
-            paddingBefore = 0;
-        }
-        let paddingAfter = ADAP_REP_SWITCH_BUFFER_PADDINGS[bufferType].after;
-        if (paddingAfter == null) {
-            paddingAfter = 0;
-        }
+        const paddingBefore = (_c = ADAP_REP_SWITCH_BUFFER_PADDINGS[bufferType].before) !== null && _c !== void 0 ? _c : 0;
+        const paddingAfter = (_d = ADAP_REP_SWITCH_BUFFER_PADDINGS[bufferType].after) !== null && _d !== void 0 ? _d : 0;
         let currentTime = playbackObserver.getCurrentTime();
         if (currentTime === undefined) {
             // TODO current position might be old. A better solution should be found.
             const lastObservation = playbackObserver.getReference().getValue();
             currentTime = lastObservation.position.getPolled();
         }
-        rangesToExclude.push({ start: currentTime - paddingBefore,
-            end: currentTime + paddingAfter });
+        rangesToExclude.push({
+            start: currentTime - paddingBefore,
+            end: currentTime + paddingAfter,
+        });
     }
     // Now remove possible small range from the end if there is a segment from the
     // next Period
@@ -99,15 +98,15 @@ export default function getRepresentationsSwitchingStrategy(period, adaptation,
         if (firstSegmentAfter !== null &&
             (firstSegmentAfter.bufferedStart === undefined ||
                 // Close to Period's end
-                (firstSegmentAfter.bufferedStart - period.end) < 1)) {
-            rangesToExclude.push({ start: period.end - 1,
-                end: Number.MAX_VALUE });
+                firstSegmentAfter.bufferedStart - period.end < 1)) {
+            rangesToExclude.push({ start: period.end - 1, end: Number.MAX_VALUE });
         }
     }
     const toRemove = excludeFromRanges(unwantedRange, rangesToExclude);
     if (toRemove.length === 0) {
         return { type: "continue", value: undefined };
     }
-    return shouldFlush ? { type: "flush-buffer", value: toRemove } :
-        { type: "clean-buffer", value: toRemove };
+    return shouldFlush
+        ? { type: "flush-buffer", value: toRemove }
+        : { type: "clean-buffer", value: toRemove };
 }

package/dist/es2017/core/stream/adaptation/types.d.ts

@@ -1,11 +1,11 @@
-import Manifest, { Adaptation, Period, Representation } from "../../../manifest";
-import { IAudioTrackSwitchingMode, IVideoTrackSwitchingMode } from "../../../public_types";
-import { IReadOnlySharedReference } from "../../../utils/reference";
-import { IRepresentationEstimator } from "../../adaptive";
-import { IReadOnlyPlaybackObserver } from "../../api";
-import { SegmentFetcherCreator } from "../../fetchers";
-import { IBufferType, SegmentBuffer } from "../../segment_buffers";
-import { IRepresentationsChoice, IRepresentationStreamCallbacks, IRepresentationStreamPlaybackObservation } from "../representation";
+import type { IManifest, IAdaptation, IPeriod, IRepresentation } from "../../../manifest";
+import type { IReadOnlyPlaybackObserver } from "../../../playback_observer";
+import type { IAudioTrackSwitchingMode, IVideoTrackSwitchingMode } from "../../../public_types";
+import type { IReadOnlySharedReference } from "../../../utils/reference";
+import type { IRepresentationEstimator } from "../../adaptive";
+import type { SegmentFetcherCreator } from "../../fetchers";
+import type { IBufferType, SegmentSink } from "../../segment_sinks";
+import type { IRepresentationsChoice, IRepresentationStreamCallbacks, IRepresentationStreamPlaybackObservation } from "../representation";
 /** Callbacks called by the `AdaptationStream` on various events. */
 export interface IAdaptationStreamCallbacks extends Omit<IRepresentationStreamCallbacks, "terminating" | "addedSegment"> {
     /** Called as new bitrate estimates are done. */
@@ -47,14 +47,14 @@ export interface IRepresentationChangePayload {
     /** The type of buffer linked to that `RepresentationStream`. */
     type: IBufferType;
     /** The `Period` linked to the `RepresentationStream` we're creating. */
-    period: Period;
+    period: IPeriod;
     /** The `Adaptation` linked to the `RepresentationStream` we're creating. */
-    adaptation: Adaptation;
+    adaptation: IAdaptation;
     /**
      * The `Representation` linked to the `RepresentationStream` we're creating.
      * `null` when we're choosing no Representation at all.
      */
-    representation: Representation | null;
+    representation: IRepresentation | null;
 }
 /** Payload for the `waitingMediaSourceReload` callback. */
 export interface IWaitingMediaSourceReloadPayload {
@@ -64,7 +64,7 @@ export interface IWaitingMediaSourceReloadPayload {
      * The MediaSource will only be reloaded if that Period becomes the current
      * one.
      */
-    period: Period;
+    period: IPeriod;
     /** Buffer type concerned. */
     bufferType: IBufferType;
     /**
@@ -99,7 +99,7 @@ export interface INeedsBufferFlushPayload {
 /** Regular playback information needed by the AdaptationStream. */
 export interface IAdaptationStreamPlaybackObservation extends IRepresentationStreamPlaybackObservation {
     /**
-     * For the current SegmentBuffer, difference in seconds between the next position
+     * For the current SegmentSink, difference in seconds between the next position
      * where no segment data is available and the current position.
      */
     bufferGap: number;
@@ -114,21 +114,21 @@ export interface IAdaptationStreamArguments {
     playbackObserver: IReadOnlyPlaybackObserver<IAdaptationStreamPlaybackObservation>;
     /** Content you want to create this Stream for. */
     content: {
-        manifest: Manifest;
-        period: Period;
-        adaptation: Adaptation;
+        manifest: IManifest;
+        period: IPeriod;
+        adaptation: IAdaptation;
         representations: IReadOnlySharedReference<IRepresentationsChoice>;
     };
     options: IAdaptationStreamOptions;
     /** Estimate the right Representation to play. */
     representationEstimator: IRepresentationEstimator;
     /** SourceBuffer wrapper - needed to push media segments. */
-    segmentBuffer: SegmentBuffer;
+    segmentSink: SegmentSink;
     /** Module used to fetch the wanted media segments. */
     segmentFetcherCreator: SegmentFetcherCreator;
     /**
      * "Buffer goal" wanted, or the ideal amount of time ahead of the current
-     * position in the current SegmentBuffer. When this amount has been reached
+     * position in the current SegmentSink. When this amount has been reached
      * this AdaptationStream won't try to download new segments.
      */
     wantedBufferAhead: IReadOnlySharedReference<number>;

package/dist/es2017/core/stream/index.d.ts

@@ -16,6 +16,6 @@
 import StreamOrchestrator, { INeedsMediaSourceReloadPayload, IStreamOrchestratorOptions, IStreamOrchestratorPlaybackObservation, IStreamOrchestratorCallbacks } from "./orchestrator";
 import { IPausedPlaybackObservation } from "./period";
 export { IRepresentationsChoice, IInbandEvent, IStreamStatusPayload, } from "./representation";
-export { IAdaptationChoice, ITrackSwitchingMode, IWaitingMediaSourceReloadPayload, } from "./adaptation";
+export { IAdaptationChoice, INeedsBufferFlushPayload, ITrackSwitchingMode, IWaitingMediaSourceReloadPayload, } from "./adaptation";
 export default StreamOrchestrator;
 export { IPausedPlaybackObservation, INeedsMediaSourceReloadPayload, IStreamOrchestratorPlaybackObservation, IStreamOrchestratorOptions, IStreamOrchestratorCallbacks, };

package/dist/es2017/core/stream/orchestrator/get_time_ranges_for_content.d.ts

@@ -13,17 +13,17 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { IAdaptationMetadata, IPeriodMetadata, IRepresentationMetadata } from "../../../manifest";
-import { IRange } from "../../../utils/ranges";
-import { SegmentBuffer } from "../../segment_buffers";
+import type { IAdaptationMetadata, IPeriodMetadata, IRepresentationMetadata } from "../../../manifest";
+import type { IRange } from "../../../utils/ranges";
+import type { SegmentSink } from "../../segment_sinks";
 /**
  * Returns the buffered ranges which hold the given content.
  * Returns the whole buffered ranges if some of it is unknown.
- * @param {Object} segmentBuffer
+ * @param {Object} segmentSink
  * @param {Array.<Object>} contents
  * @returns {Array.<Object>}
  */
-export default function getTimeRangesForContent(segmentBuffer: SegmentBuffer, contents: Array<{
+export default function getTimeRangesForContent(segmentSink: SegmentSink, contents: Array<{
     adaptation: IAdaptationMetadata;
     period: IPeriodMetadata;
     representation: IRepresentationMetadata;

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

@@ -17,22 +17,22 @@ import log from "../../../log";
 /**
  * Returns the buffered ranges which hold the given content.
  * Returns the whole buffered ranges if some of it is unknown.
- * @param {Object} segmentBuffer
+ * @param {Object} segmentSink
  * @param {Array.<Object>} contents
  * @returns {Array.<Object>}
  */
-export default function getTimeRangesForContent(segmentBuffer, contents) {
+export default function getTimeRangesForContent(segmentSink, contents) {
     if (contents.length === 0) {
         return [];
     }
     const accumulator = [];
-    const inventory = segmentBuffer.getLastKnownInventory();
+    const inventory = segmentSink.getLastKnownInventory();
     for (let i = 0; i < inventory.length; i++) {
         const chunk = inventory[i];
-        const hasContent = contents.some(content => {
-            return chunk.infos.period.id === content.period.id &&
+        const hasContent = contents.some((content) => {
+            return (chunk.infos.period.id === content.period.id &&
                 chunk.infos.adaptation.id === content.adaptation.id &&
-                chunk.infos.representation.id === content.representation.id;
+                chunk.infos.representation.id === content.representation.id);
         });
         if (hasContent) {
             const { bufferedStart, bufferedEnd } = chunk;

package/dist/es2017/core/stream/orchestrator/stream_orchestrator.d.ts

@@ -13,21 +13,22 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import Manifest, { Period } from "../../../manifest";
-import { IReadOnlySharedReference } from "../../../utils/reference";
-import { CancellationSignal } from "../../../utils/task_canceller";
-import { IRepresentationEstimator } from "../../adaptive";
-import type { IReadOnlyPlaybackObserver } from "../../api";
-import { SegmentFetcherCreator } from "../../fetchers";
-import SegmentBuffersStore, { IBufferType } from "../../segment_buffers";
-import { IPeriodStreamCallbacks, IPeriodStreamOptions, IPeriodStreamPlaybackObservation } from "../period";
+import type { IManifest, IPeriod } from "../../../manifest";
+import type { IReadOnlyPlaybackObserver } from "../../../playback_observer";
+import type { IReadOnlySharedReference } from "../../../utils/reference";
+import type { CancellationSignal } from "../../../utils/task_canceller";
+import type { IRepresentationEstimator } from "../../adaptive";
+import type { SegmentFetcherCreator } from "../../fetchers";
+import type { IBufferType } from "../../segment_sinks";
+import type SegmentSinksStore from "../../segment_sinks";
+import type { IPeriodStreamCallbacks, IPeriodStreamOptions, IPeriodStreamPlaybackObservation } from "../period";
 /**
  * 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...
  *
@@ -40,8 +41,8 @@ import { IPeriodStreamCallbacks, IPeriodStreamOptions, IPeriodStreamPlaybackObse
  * @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
@@ -64,9 +65,9 @@ import { IPeriodStreamCallbacks, IPeriodStreamOptions, IPeriodStreamPlaybackObse
  * doing.
  */
 export default function StreamOrchestrator(content: {
-    manifest: Manifest;
-    initialPeriod: Period;
-}, playbackObserver: IReadOnlyPlaybackObserver<IStreamOrchestratorPlaybackObservation>, representationEstimator: IRepresentationEstimator, segmentBuffersStore: SegmentBuffersStore, segmentFetcherCreator: SegmentFetcherCreator, options: IStreamOrchestratorOptions, callbacks: IStreamOrchestratorCallbacks, orchestratorCancelSignal: CancellationSignal): void;
+    manifest: IManifest;
+    initialPeriod: IPeriod;
+}, playbackObserver: IReadOnlyPlaybackObserver<IStreamOrchestratorPlaybackObservation>, representationEstimator: IRepresentationEstimator, segmentSinksStore: SegmentSinksStore, segmentFetcherCreator: SegmentFetcherCreator, options: IStreamOrchestratorOptions, callbacks: IStreamOrchestratorCallbacks, orchestratorCancelSignal: CancellationSignal): void;
 export type IStreamOrchestratorPlaybackObservation = IPeriodStreamPlaybackObservation;
 /** Options tweaking the behavior of the StreamOrchestrator. */
 export type IStreamOrchestratorOptions = IPeriodStreamOptions & {
@@ -114,7 +115,7 @@ export interface IStreamOrchestratorCallbacks extends Omit<IPeriodStreamCallback
      */
     lockedStream(payload: ILockedStreamPayload): void;
     /**
-     * Called after the SegmentBuffer have been "cleaned" to remove from it
+     * Called after the SegmentSink have been "cleaned" to remove from it
      * every non-decipherable segments - usually following an update of the
      * decipherability status of some `Representation`(s).
      *
@@ -135,14 +136,14 @@ export interface IPeriodStreamClearedPayload {
      */
     type: IBufferType;
     /** The `Manifest` linked to the `PeriodStream` we just cleared. */
-    manifest: Manifest;
+    manifest: IManifest;
     /**
      * The `Period` linked to the `PeriodStream` we just removed.
      *
      * The combination of this and `Period` should give you enough information
      * about which `PeriodStream` has been removed.
      */
-    period: Period;
+    period: IPeriod;
 }
 /** Payload for the `needsMediaSourceReload` callback. */
 export interface INeedsMediaSourceReloadPayload {
@@ -168,7 +169,7 @@ export interface INeedsMediaSourceReloadPayload {
 /** Payload for the `lockedStream` callback. */
 export interface ILockedStreamPayload {
     /** Period concerned. */
-    period: Period;
+    period: IPeriod;
     /** Buffer type concerned. */
     bufferType: IBufferType;
 }