rx-player 4.4.1 → 4.5.0-dev.2026012301

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

@@ -1,248 +0,0 @@
-"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

@@ -1,73 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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

@@ -1,228 +0,0 @@
-"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

@@ -1,92 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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"}