rx-player 4.5.0-dev.2026012301 → 4.5.0-dev.2026012302

package/dist/commonjs/core/stream/representation/utils/check_for_discontinuity.js

@@ -0,0 +1,248 @@
+"use strict";
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = checkForDiscontinuity;
+var log_1 = require("../../../../log");
+/**
+ * Check if there is a soon-to-be-encountered discontinuity in the buffer that
+ * won't be filled by any future segment.
+ * This function will only check discontinuities for the given `checkedRange`.
+ *
+ * @param {Object} content - The content we are currently loading.
+ * @param {Object} checkedRange - The time range that will be checked for
+ * discontinuities.
+ * Both `nextSegmentStart` and `bufferedSegments` arguments can only refer to
+ * that range.
+ * @param {number|null} nextSegmentStart - The start time in seconds of the next
+ * not-yet-pushed segment that can be pushed, in the limits of `checkedRange`.
+ * This includes segments which have not been loaded or pushed yet, but also
+ * segments which might be re-downloaded because currently incomplete in the
+ * buffer, the point being to know what is the earliest time in the buffer where
+ * a segment might be pushed in the future.
+ * `null` if no segment in `checkedRange` will be pushed under current buffer's
+ * conditions.
+ * @param {boolean} hasFinishedLoading - if `true`, all segments for the current
+ * Period have been loaded and none will be loaded in the future under the
+ * current buffer's state.
+ * @param {Array.<Object>} bufferedSegments - Information about every segments
+ * currently in the buffer, in chronological order.
+ * Only segments overlapping with the given `checkedRange` will be looked at,
+ * though the array given can be larger.
+ */
+function checkForDiscontinuity(content, checkedRange, nextSegmentStart, hasFinishedLoading, bufferedSegments) {
+    var period = content.period, adaptation = content.adaptation, representation = content.representation;
+    // `bufferedSegments` might also contains segments which are before
+    // `checkedRange`.
+    // Here we want the first one that goes over `checkedRange.start`, to  see
+    // if there's a discontinuity at the beginning in the buffer
+    var nextBufferedInRangeIdx = getIndexOfFirstChunkInRange(bufferedSegments, checkedRange);
+    if (nextBufferedInRangeIdx === null) {
+        // There's no segment currently buffered for the current range.
+        if (nextSegmentStart === null) {
+            // No segment to load in that range
+            // Check if we are in a discontinuity at the end of the current Period
+            if (hasFinishedLoading &&
+                period.end !== undefined &&
+                checkedRange.end >= period.end) {
+                return { start: undefined, end: null }; // discontinuity to Period's end
+            }
+            // Check that there is a discontinuity announced in the Manifest there
+            var discontinuityEnd = representation.index.checkDiscontinuity(checkedRange.start);
+            if (discontinuityEnd !== null) {
+                return { start: undefined, end: discontinuityEnd };
+            }
+        }
+        return null;
+    }
+    var nextBufferedSegment = bufferedSegments[nextBufferedInRangeIdx];
+    // Check if there is a hole that won't be filled before `nextSegmentStart`
+    if (
+    // Next buffered segment starts after the start of the current range
+    nextBufferedSegment.bufferedStart !== undefined &&
+        nextBufferedSegment.bufferedStart > checkedRange.start &&
+        // and no segment will fill in that hole
+        (nextSegmentStart === null ||
+            nextBufferedSegment.infos.segment.end <= nextSegmentStart)) {
+        var discontinuityEnd = nextBufferedSegment.bufferedStart;
+        if (!hasFinishedLoading &&
+            representation.index.awaitSegmentBetween(checkedRange.start, discontinuityEnd) !==
+                false) {
+            return null;
+        }
+        log_1.default.debug("Stream", "current discontinuity encountered", {
+            bufferType: adaptation.type,
+            nextSegmentTime: nextBufferedSegment.bufferedStart,
+            checkStartTime: checkedRange.start,
+        });
+        return { start: undefined, end: discontinuityEnd };
+    }
+    // Check if there's a discontinuity BETWEEN segments of the current range
+    var nextHoleIdx = getIndexOfFirstDiscontinuityBetweenChunks(bufferedSegments, checkedRange, nextBufferedInRangeIdx + 1);
+    // If there was a hole between two consecutives segments, and if this hole
+    // comes before the next segment to load, there is a discontinuity (that hole!)
+    if (nextHoleIdx !== null) {
+        var segmentInfoBeforeHole = bufferedSegments[nextHoleIdx - 1];
+        var segmentInfoAfterHole = bufferedSegments[nextHoleIdx];
+        if (nextSegmentStart === null ||
+            segmentInfoAfterHole.infos.segment.end <= nextSegmentStart) {
+            if (!hasFinishedLoading &&
+                representation.index.awaitSegmentBetween(segmentInfoBeforeHole.infos.segment.end, segmentInfoAfterHole.infos.segment.time) !== false) {
+                return null;
+            }
+            var start = segmentInfoBeforeHole.bufferedEnd;
+            var end = segmentInfoAfterHole.bufferedStart;
+            log_1.default.debug("Stream", "future discontinuity encountered", {
+                bufferType: adaptation.type,
+                discontinuityStart: start,
+                discontinuityEnd: end,
+            });
+            return { start: start, end: end };
+        }
+    }
+    if (nextSegmentStart === null) {
+        // If no hole between segments and no segment to load, check for a
+        // discontinuity at the end of the Period
+        if (hasFinishedLoading && period.end !== undefined) {
+            // Period is finished
+            if (checkedRange.end < period.end) {
+                // We've not reached the Period's end yet
+                return null;
+            }
+            // Check if the last buffered segment ends before this Period's end
+            // In which case there is a discontinuity between those
+            var lastBufferedInPeriodIdx = getIndexOfLastChunkInPeriod(bufferedSegments, period.end);
+            if (lastBufferedInPeriodIdx !== null) {
+                var lastSegment = bufferedSegments[lastBufferedInPeriodIdx];
+                if (lastSegment.bufferedEnd !== undefined &&
+                    lastSegment.bufferedEnd < period.end) {
+                    log_1.default.debug("Stream", "discontinuity encountered at the end of the current period", {
+                        bufferType: adaptation.type,
+                        segmentsEndTimeFromPeriod: lastSegment.bufferedEnd,
+                        periodEnd: period.end,
+                    });
+                    return { start: lastSegment.bufferedEnd, end: null };
+                }
+            }
+        }
+        // At last, check if we don't have a discontinuity at the end of the current
+        // range, announced in the Manifest, that is too big to be detected through
+        // the previous checks.
+        if (period.end !== undefined && checkedRange.end >= period.end) {
+            return null; // The previous checks should have taken care of those
+        }
+        for (var bufIdx = bufferedSegments.length - 1; bufIdx >= 0; bufIdx--) {
+            var bufSeg = bufferedSegments[bufIdx];
+            if (bufSeg.bufferedStart === undefined) {
+                break;
+            }
+            if (bufSeg.bufferedStart < checkedRange.end) {
+                if (bufSeg.bufferedEnd !== undefined && bufSeg.bufferedEnd < checkedRange.end) {
+                    var discontinuityEnd = representation.index.checkDiscontinuity(checkedRange.end);
+                    if (discontinuityEnd !== null) {
+                        return { start: bufSeg.bufferedEnd, end: discontinuityEnd };
+                    }
+                }
+                return null;
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Returns the index of the first element in `bufferedChunks` that is part of
+ * `range` (starts before it ends and ends after it starts).
+ *
+ * Returns `null` if no element is found in that range or if we cannot know the
+ * index of the first element in it.
+ * @param {Array.<Object>} bufferedChunks
+ * @param {Object} range
+ * @returns {number|null}
+ */
+function getIndexOfFirstChunkInRange(bufferedChunks, range) {
+    for (var bufIdx = 0; bufIdx < bufferedChunks.length; bufIdx++) {
+        var bufSeg = bufferedChunks[bufIdx];
+        if (bufSeg.bufferedStart === undefined ||
+            bufSeg.bufferedEnd === undefined ||
+            bufSeg.bufferedStart >= range.end) {
+            return null;
+        }
+        if (bufSeg.bufferedEnd > range.start) {
+            return bufIdx;
+        }
+    }
+    return null;
+}
+/**
+ * Returns the index of the first element in `bufferedChunks` which is not
+ * immediately consecutive to the one before it.
+ *
+ * `startFromIndex` is the index of the first segment that will be checked with
+ * the element coming before it. As such, it has to be superior to 0.
+ *
+ * If the element at `startFromIndex` comes immediately after the one before it,
+ * the element at `startFromIndex + 1` will be checked instead and so on until a
+ * segment completely out of `checkedRange` (which starts after it) is detected.
+ *
+ * If no hole between elements is found, `null` is returned.
+ * @param {Array.<Object>} bufferedChunks
+ * @param {Object} range
+ * @param {number} startFromIndex
+ * @returns {number|null}
+ */
+function getIndexOfFirstDiscontinuityBetweenChunks(bufferedChunks, range, startFromIndex) {
+    if (startFromIndex <= 0) {
+        log_1.default.error("Stream", "Asked to check a discontinuity before the first chunk.");
+        return null;
+    }
+    for (var bufIdx = startFromIndex; bufIdx < bufferedChunks.length; bufIdx++) {
+        var currSegment = bufferedChunks[bufIdx];
+        var prevSegment = bufferedChunks[bufIdx - 1];
+        // Exit as soon we miss information or when we go further than `checkedRange`
+        if (currSegment.bufferedStart === undefined ||
+            prevSegment.bufferedEnd === undefined ||
+            currSegment.bufferedStart >= range.end) {
+            return null;
+        }
+        // If there is a hole between two consecutive buffered segment
+        if (currSegment.bufferedStart - prevSegment.bufferedEnd > 0) {
+            return bufIdx;
+        }
+    }
+    return null;
+}
+/**
+ * Returns the index of the last element in `bufferedChunks` that is part of
+ * `range` (starts before it ends and ends after it starts).
+ *
+ * Returns `null` if no element is found in that range or if we cannot know the
+ * index of the last element in it.
+ * @param {Array.<Object>} bufferedChunks
+ * @param {number} periodEnd
+ * @returns {number|null}
+ */
+function getIndexOfLastChunkInPeriod(bufferedChunks, periodEnd) {
+    for (var bufIdx = bufferedChunks.length - 1; bufIdx >= 0; bufIdx--) {
+        var bufSeg = bufferedChunks[bufIdx];
+        if (bufSeg.bufferedStart === undefined) {
+            return null;
+        }
+        if (bufSeg.bufferedStart < periodEnd) {
+            return bufIdx;
+        }
+    }
+    return null;
+}

package/dist/commonjs/core/stream/representation/utils/get_buffer_status.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type { IManifest, IAdaptation, IPeriod, IRepresentation } from "../../../../manifest";
+import type { IReadOnlyPlaybackObserver } from "../../../../playback_observer";
+import type { SegmentSink } from "../../../segment_sinks";
+import type { IBufferDiscontinuity, IRepresentationStreamPlaybackObservation, IQueuedSegment } from "../types";
+/** Analysis of the current buffer's status. */
+export interface IBufferStatus {
+    /**
+     * Future discontinuity found in the SegmentSink's buffer: hole that won't
+     * be filled by a segment.
+     * `null` if no such discontinuity is found in the near future.
+     */
+    imminentDiscontinuity: IBufferDiscontinuity | null;
+    /**
+     * If `true`, no segment need to be loaded to be able to play until the end of
+     * the Period.
+     * Some segments might still be in the process of being pushed.
+     */
+    hasFinishedLoading: boolean;
+    /**
+     * Segments that have to be scheduled for download to fill the buffer at least
+     * until the given buffer goal.
+     * The first element of that list might already be currently downloading.
+     */
+    neededSegments: IQueuedSegment[];
+    /**
+     * If `true`, the Manifest has to be reloaded to obtain more information
+     * on which segments should be loaded.
+     */
+    shouldRefreshManifest: boolean;
+    /**
+     * If 'true', the buffer memory is saturated, thus we may have issues loading
+     * new segments.
+     */
+    isBufferFull: boolean;
+}
+/**
+ * Checks on the current buffered data for the given type and Period
+ * and returns what should be done to fill the buffer according to the buffer
+ * goal, the Representation chosen, etc.
+ * Also emits discontinuities if found, which are parts of the buffer that won't
+ * be filled by any segment, even in the future.
+ *
+ * @param {Object} content
+ * @param {number} initialWantedTime
+ * @param {Object} playbackObserver
+ * @param {number|undefined} fastSwitchThreshold
+ * @param {number} bufferGoal
+ * @param {number} maxBufferSize
+ * @param {Object} segmentSink
+ * @returns {Object}
+ */
+export default function getBufferStatus(content: {
+    adaptation: IAdaptation;
+    manifest: IManifest;
+    period: IPeriod;
+    representation: IRepresentation;
+}, initialWantedTime: number, playbackObserver: IReadOnlyPlaybackObserver<IRepresentationStreamPlaybackObservation>, fastSwitchThreshold: number | undefined, bufferGoal: number, maxBufferSize: number, segmentSink: SegmentSink): IBufferStatus;
+//# sourceMappingURL=get_buffer_status.d.ts.map

package/dist/commonjs/core/stream/representation/utils/get_buffer_status.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get_buffer_status.d.ts","sourceRoot":"","sources":["../../../../../../src/core/stream/representation/utils/get_buffer_status.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EACV,SAAS,EACT,WAAW,EACX,OAAO,EACP,eAAe,EAChB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,+BAA+B,CAAC;AAE/E,OAAO,KAAK,EAEV,WAAW,EACZ,MAAM,wBAAwB,CAAC;AAEhC,OAAO,KAAK,EACV,oBAAoB,EACpB,wCAAwC,EACxC,cAAc,EACf,MAAM,UAAU,CAAC;AAKlB,+CAA+C;AAC/C,MAAM,WAAW,aAAa;IAC5B;;;;OAIG;IACH,qBAAqB,EAAE,oBAAoB,GAAG,IAAI,CAAC;IACnD;;;;OAIG;IACH,kBAAkB,EAAE,OAAO,CAAC;IAC5B;;;;OAIG;IACH,cAAc,EAAE,cAAc,EAAE,CAAC;IACjC;;;OAGG;IACH,qBAAqB,EAAE,OAAO,CAAC;IAC/B;;;OAGG;IACH,YAAY,EAAE,OAAO,CAAC;CACvB;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,OAAO,UAAU,eAAe,CACrC,OAAO,EAAE;IACP,UAAU,EAAE,WAAW,CAAC;IACxB,QAAQ,EAAE,SAAS,CAAC;IACpB,MAAM,EAAE,OAAO,CAAC;IAChB,cAAc,EAAE,eAAe,CAAC;CACjC,EACD,iBAAiB,EAAE,MAAM,EACzB,gBAAgB,EAAE,yBAAyB,CAAC,wCAAwC,CAAC,EACrF,mBAAmB,EAAE,MAAM,GAAG,SAAS,EACvC,UAAU,EAAE,MAAM,EAClB,aAAa,EAAE,MAAM,EACrB,WAAW,EAAE,WAAW,GACvB,aAAa,CA+Gf"}

package/dist/commonjs/core/stream/representation/utils/get_buffer_status.js

@@ -0,0 +1,228 @@
+"use strict";
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = getBufferStatus;
+var is_null_or_undefined_1 = require("../../../../utils/is_null_or_undefined");
+var segment_sinks_1 = require("../../../segment_sinks");
+var check_for_discontinuity_1 = require("./check_for_discontinuity");
+var get_needed_segments_1 = require("./get_needed_segments");
+var get_segment_priority_1 = require("./get_segment_priority");
+/**
+ * Checks on the current buffered data for the given type and Period
+ * and returns what should be done to fill the buffer according to the buffer
+ * goal, the Representation chosen, etc.
+ * Also emits discontinuities if found, which are parts of the buffer that won't
+ * be filled by any segment, even in the future.
+ *
+ * @param {Object} content
+ * @param {number} initialWantedTime
+ * @param {Object} playbackObserver
+ * @param {number|undefined} fastSwitchThreshold
+ * @param {number} bufferGoal
+ * @param {number} maxBufferSize
+ * @param {Object} segmentSink
+ * @returns {Object}
+ */
+function getBufferStatus(content, initialWantedTime, playbackObserver, fastSwitchThreshold, bufferGoal, maxBufferSize, segmentSink) {
+    var _a, _b, _c;
+    var representation = content.representation;
+    var isPaused = (_b = (_a = playbackObserver.getIsPaused()) !== null && _a !== void 0 ? _a : playbackObserver.getReference().getValue().paused.pending) !== null && _b !== void 0 ? _b : playbackObserver.getReference().getValue().paused.last;
+    var playbackRate = (_c = playbackObserver.getPlaybackRate()) !== null && _c !== void 0 ? _c : playbackObserver.getReference().getValue().speed;
+    var askedStart = initialWantedTime;
+    if (isPaused === undefined ||
+        playbackRate === undefined ||
+        isPaused ||
+        playbackRate <= 0) {
+        askedStart -= 0.1;
+    }
+    var neededRange = getRangeOfNeededSegments(content, askedStart, bufferGoal);
+    var shouldRefreshManifest = representation.index.shouldRefresh(neededRange.start, neededRange.end);
+    /**
+     * Every segment awaiting an "SignalSegmentComplete" operation, which
+     * indicates that a completely-loaded segment is still being pushed to the
+     * SegmentSink.
+     */
+    var segmentsBeingPushed = segmentSink
+        .getPendingOperations()
+        .filter(function (operation) {
+        return operation.type === segment_sinks_1.SegmentSinkOperation.SignalSegmentComplete;
+    })
+        .map(function (operation) { return operation.value; });
+    /** Data on every segments buffered around `neededRange`. */
+    var bufferedSegments = segmentSink.getLastKnownInventory();
+    var currentPlaybackTime = playbackObserver.getCurrentTime();
+    if (currentPlaybackTime === undefined) {
+        // We're in a WebWorker, just consider the last known position
+        currentPlaybackTime = playbackObserver.getReference().getValue().position.getWanted();
+    }
+    /** Callback allowing to retrieve a segment's history in the buffer. */
+    var getBufferedHistory = segmentSink.getSegmentHistory.bind(segmentSink);
+    /** List of segments we will need to download. */
+    var _d = (0, get_needed_segments_1.default)({
+        content: content,
+        bufferedSegments: bufferedSegments,
+        currentPlaybackTime: currentPlaybackTime,
+        fastSwitchThreshold: fastSwitchThreshold,
+        getBufferedHistory: getBufferedHistory,
+        neededRange: neededRange,
+        segmentsBeingPushed: segmentsBeingPushed,
+        maxBufferSize: maxBufferSize,
+    }), segmentsToLoad = _d.segmentsToLoad, segmentsOnHold = _d.segmentsOnHold, isBufferFull = _d.isBufferFull;
+    var prioritizedNeededSegments = segmentsToLoad.map(function (segment) { return ({
+        priority: (0, get_segment_priority_1.default)(segment.time, askedStart),
+        segment: segment,
+    }); });
+    /**
+     * `true` if the current `RepresentationStream` has loaded all the
+     * needed segments for this Representation until the end of the Period.
+     */
+    var hasFinishedLoading = representation.index.isInitialized() &&
+        !representation.index.isStillAwaitingFutureSegments() &&
+        neededRange.hasReachedPeriodEnd &&
+        prioritizedNeededSegments.length === 0 &&
+        segmentsOnHold.length === 0;
+    /**
+     * Start time in seconds of the next available not-yet pushed segment.
+     * `null` if no segment is wanted for the current wanted range.
+     */
+    var nextSegmentStart = null;
+    if (segmentsBeingPushed.length > 0) {
+        nextSegmentStart = Math.min.apply(Math, __spreadArray([], __read(segmentsBeingPushed.map(function (info) { return info.segment.time; })), false));
+    }
+    if (segmentsOnHold.length > 0) {
+        nextSegmentStart =
+            nextSegmentStart !== null
+                ? Math.min(nextSegmentStart, segmentsOnHold[0].time)
+                : segmentsOnHold[0].time;
+    }
+    if (prioritizedNeededSegments.length > 0) {
+        nextSegmentStart =
+            nextSegmentStart !== null
+                ? Math.min(nextSegmentStart, prioritizedNeededSegments[0].segment.time)
+                : prioritizedNeededSegments[0].segment.time;
+    }
+    var imminentDiscontinuity = (0, check_for_discontinuity_1.default)(content, neededRange, nextSegmentStart, hasFinishedLoading, bufferedSegments);
+    return {
+        imminentDiscontinuity: imminentDiscontinuity,
+        hasFinishedLoading: hasFinishedLoading,
+        neededSegments: prioritizedNeededSegments,
+        isBufferFull: isBufferFull,
+        shouldRefreshManifest: shouldRefreshManifest,
+    };
+}
+/**
+ * Returns both the time range of segments that should be loaded (from a
+ * starting position to an ending position) and whether the end of the Period is
+ * reached by that range.
+ * @param {Object} content
+ * @param {number} initialWantedTime
+ * @param {number} bufferGoal
+ * @returns {Object}
+ */
+function getRangeOfNeededSegments(content, initialWantedTime, bufferGoal) {
+    var _a;
+    var wantedStartPosition;
+    var manifest = content.manifest, period = content.period, representation = content.representation;
+    var lastIndexPosition = representation.index.getLastAvailablePosition();
+    var representationIndex = representation.index;
+    // There is an exception for when the current initially wanted time is already
+    // after the last position with segments AND when we're playing the absolute
+    // last Period in the Manifest.
+    // In that case, we want to actually request at least the last segment to
+    // avoid ending the last Period - and by extension the content - with a
+    // segment which isn't the last one.
+    if (!(0, is_null_or_undefined_1.default)(lastIndexPosition) &&
+        segment_sinks_1.default.isNative(content.adaptation.type) &&
+        initialWantedTime >= lastIndexPosition &&
+        representationIndex.isInitialized() &&
+        !representationIndex.isStillAwaitingFutureSegments() &&
+        isPeriodTheCurrentAndLastOne(manifest, period, initialWantedTime)) {
+        wantedStartPosition = lastIndexPosition - 1;
+    }
+    else {
+        wantedStartPosition = initialWantedTime - 0.1;
+    }
+    var wantedEndPosition = wantedStartPosition + bufferGoal;
+    var hasReachedPeriodEnd;
+    if (!representation.index.isInitialized() ||
+        representation.index.isStillAwaitingFutureSegments() ||
+        period.end === undefined) {
+        hasReachedPeriodEnd = false;
+    }
+    else if (lastIndexPosition === undefined) {
+        // We do not know the end of this index.
+        hasReachedPeriodEnd = wantedEndPosition >= period.end;
+    }
+    else if (lastIndexPosition === null) {
+        // There is no available segment in the index currently.
+        hasReachedPeriodEnd = true;
+    }
+    else {
+        // We have a declared end. Check that our range went until the last
+        // position available in the index. If that's the case and we're left
+        // with no segments after filtering them, it means we already have
+        // downloaded the last segments and have nothing left to do: full.
+        hasReachedPeriodEnd = wantedEndPosition >= lastIndexPosition;
+    }
+    return {
+        start: Math.max(wantedStartPosition, period.start),
+        end: Math.min(wantedEndPosition, (_a = period.end) !== null && _a !== void 0 ? _a : Infinity),
+        hasReachedPeriodEnd: hasReachedPeriodEnd,
+    };
+}
+/**
+ * Returns `true` if the given Period is both:
+ *   - the one being played (the current position is known from `time`)
+ *   - the absolute last one in the Manifest (that is, there will never be a
+ *     Period after it).
+ * @param {Object} manifest
+ * @param {Object} period
+ * @param {number} time
+ * @returns {boolean}
+ */
+function isPeriodTheCurrentAndLastOne(manifest, period, time) {
+    var _a;
+    var nextPeriod = manifest.getPeriodAfter(period);
+    return (period.containsTime(time, nextPeriod) &&
+        manifest.isLastPeriodKnown &&
+        period.id === ((_a = manifest.periods[manifest.periods.length - 1]) === null || _a === void 0 ? void 0 : _a.id));
+}

package/dist/commonjs/core/stream/representation/utils/get_needed_segments.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type { IManifest, IAdaptation, ISegment, IPeriod, IRepresentation } from "../../../../manifest";
+import type { IBufferedChunk, ICompleteSegmentInfo, IBufferedHistoryEntry, IChunkContext } from "../../../segment_sinks";
+interface IContentContext {
+    adaptation: IAdaptation;
+    manifest: IManifest;
+    period: IPeriod;
+    representation: IRepresentation;
+}
+/** Arguments for `getNeededSegments`. */
+export interface IGetNeededSegmentsArguments {
+    /** The content we want to load segments for */
+    content: IContentContext;
+    /**
+     * The current playing position.
+     * Important to avoid asking for segments on the same exact position, which
+     * can be problematic in some browsers.
+     */
+    currentPlaybackTime: number;
+    /**
+     * This threshold defines a bitrate from which "fast-switching" is disabled.
+     * For example with a fastSwitchThreshold set to `100`, segments with a
+     * bitrate of `90` can be replaced. But segments with a bitrate of `100`
+     * onward won't be replaced by higher quality segments.
+     * Set to `undefined` to indicate that there's no threshold (anything can be
+     * replaced by higher-quality segments).
+     */
+    fastSwitchThreshold: number | undefined;
+    /** The range we want to fill with segments. */
+    neededRange: {
+        start: number;
+        end: number;
+    };
+    /** The list of segments that are already in the process of being pushed. */
+    segmentsBeingPushed: ICompleteSegmentInfo[];
+    /**
+     * Information on the segments already in the buffer, in chronological order.
+     *
+     * The data for the whole buffer is not necessary, as only data around the
+     * current range will be looked at.
+     * It is important to include segments close to - though not in - that range
+     * (let's say around 5 seconds) however to avoid some segments being
+     * re-requested.
+     */
+    bufferedSegments: IBufferedChunk[];
+    /**
+     * maxBufferSize is the maximum memory in kilobytes that the buffer should take
+     */
+    maxBufferSize: number;
+    getBufferedHistory: (context: IChunkContext) => IBufferedHistoryEntry[];
+}
+interface INeededSegments {
+    /** Segments that should be loaded right now, by chronological order. */
+    segmentsToLoad: ISegment[];
+    /**
+     * Segments that should be loaded, but not right now, due to some other
+     * constraints, such as memory limitations.
+     */
+    segmentsOnHold: ISegment[];
+    /**
+     * If `true` the buffer is currently full according to the given limits.
+     * Memory should be freed if possible, for example by cleaning the buffers.
+     */
+    isBufferFull: boolean;
+}
+/**
+ * Return the list of segments that can currently be downloaded to fill holes
+ * in the buffer in the given range, including already-pushed segments currently
+ * incomplete in the buffer.
+ * This list might also include already-loaded segments in a higher bitrate,
+ * according to the given configuration.
+ * Excludes segment that are already being pushed.
+ * @param {Object} args
+ * @returns {Array.<Object>}
+ */
+export default function getNeededSegments({ bufferedSegments, content, currentPlaybackTime, fastSwitchThreshold, getBufferedHistory, neededRange, segmentsBeingPushed, maxBufferSize, }: IGetNeededSegmentsArguments): INeededSegments;
+export {};
+//# sourceMappingURL=get_needed_segments.d.ts.map

package/dist/commonjs/core/stream/representation/utils/get_needed_segments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get_needed_segments.d.ts","sourceRoot":"","sources":["../../../../../../src/core/stream/representation/utils/get_needed_segments.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAIH,OAAO,KAAK,EACV,SAAS,EACT,WAAW,EACX,QAAQ,EACR,OAAO,EACP,eAAe,EAChB,MAAM,sBAAsB,CAAC;AAG9B,OAAO,KAAK,EACV,cAAc,EACd,oBAAoB,EACpB,qBAAqB,EACrB,aAAa,EACd,MAAM,wBAAwB,CAAC;AAGhC,UAAU,eAAe;IACvB,UAAU,EAAE,WAAW,CAAC;IACxB,QAAQ,EAAE,SAAS,CAAC;IACpB,MAAM,EAAE,OAAO,CAAC;IAChB,cAAc,EAAE,eAAe,CAAC;CACjC;AAED,yCAAyC;AACzC,MAAM,WAAW,2BAA2B;IAC1C,+CAA+C;IAC/C,OAAO,EAAE,eAAe,CAAC;IACzB;;;;OAIG;IACH,mBAAmB,EAAE,MAAM,CAAC;IAC5B;;;;;;;OAOG;IACH,mBAAmB,EAAE,MAAM,GAAG,SAAS,CAAC;IACxC,+CAA+C;IAC/C,WAAW,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC;IAC5C,4EAA4E;IAC5E,mBAAmB,EAAE,oBAAoB,EAAE,CAAC;IAC5C;;;;;;;;OAQG;IACH,gBAAgB,EAAE,cAAc,EAAE,CAAC;IAEnC;;OAEG;IACH,aAAa,EAAE,MAAM,CAAC;IAEtB,kBAAkB,EAAE,CAAC,OAAO,EAAE,aAAa,KAAK,qBAAqB,EAAE,CAAC;CACzE;AAED,UAAU,eAAe;IACvB,wEAAwE;IACxE,cAAc,EAAE,QAAQ,EAAE,CAAC;IAC3B;;;OAGG;IACH,cAAc,EAAE,QAAQ,EAAE,CAAC;IAC3B;;;OAGG;IACH,YAAY,EAAE,OAAO,CAAC;CACvB;AACD;;;;;;;;;GASG;AACH,MAAM,CAAC,OAAO,UAAU,iBAAiB,CAAC,EACxC,gBAAgB,EAChB,OAAO,EACP,mBAAmB,EACnB,mBAAmB,EACnB,kBAAkB,EAClB,WAAW,EACX,mBAAmB,EACnB,aAAa,GACd,EAAE,2BAA2B,GAAG,eAAe,CAkL/C"}