rx-player 4.4.1 → 4.5.0-dev.2026012301

package/dist/es2017/core/stream/representation/utils/get_needed_segments.js

@@ -1,450 +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 config from "../../../../config";
-import log from "../../../../log";
-import { areSameContent } from "../../../../manifest";
-import objectAssign from "../../../../utils/object_assign";
-/**
- * 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, }) {
-    const { adaptation, representation } = content;
-    let availableBufferSize = getAvailableBufferSize(bufferedSegments, segmentsBeingPushed, maxBufferSize);
-    const availableSegmentsForRange = representation.index.getSegments(neededRange.start, neededRange.end - neededRange.start);
-    // Remove from `bufferedSegments` any segments in the wrong track / bad quality
-    const segmentsToKeep = bufferedSegments.filter((bufferedSegment) => !shouldContentBeReplaced(bufferedSegment.infos, content, currentPlaybackTime, fastSwitchThreshold));
-    // Remove any segments that are not usable because they have been garbage collected
-    const reusableSegments = filterOutGCedSegments(segmentsToKeep, neededRange, getBufferedHistory);
-    const { MINIMUM_SEGMENT_SIZE, MIN_BUFFER_AHEAD } = config.getCurrent();
-    let shouldStopLoadingSegments = false;
-    /**
-     * Epsilon compensating for rounding errors when comparing the start and end
-     * time of multiple segments.
-     */
-    const ROUNDING_ERROR = Math.min(1 / 60, MINIMUM_SEGMENT_SIZE);
-    let isBufferFull = false;
-    const segmentsOnHold = [];
-    const segmentsToLoad = availableSegmentsForRange.filter((segment) => {
-        const contentObject = objectAssign({ segment }, content);
-        // First, check that the segment is not already being pushed
-        if (segmentsBeingPushed.length > 0) {
-            const isAlreadyBeingPushed = segmentsBeingPushed.some((pendingSegment) => areSameContent(contentObject, pendingSegment));
-            if (isAlreadyBeingPushed) {
-                return false;
-            }
-        }
-        const { duration, time, end } = segment;
-        if (segment.isInit) {
-            return true; // never skip initialization segments
-        }
-        if (shouldStopLoadingSegments) {
-            segmentsOnHold.push(segment);
-            return false;
-        }
-        if (segment.complete && duration < MINIMUM_SEGMENT_SIZE) {
-            return false; // too small, don't download
-        }
-        // Check if the same segment from another Representation is not already
-        // being pushed.
-        if (segmentsBeingPushed.length > 0) {
-            const waitForPushedSegment = segmentsBeingPushed.some((pendingSegment) => {
-                if (pendingSegment.period.id !== content.period.id ||
-                    pendingSegment.adaptation.id !== content.adaptation.id) {
-                    return false;
-                }
-                const { segment: oldSegment } = pendingSegment;
-                if (oldSegment.time - ROUNDING_ERROR > time) {
-                    return false;
-                }
-                if (oldSegment.complete) {
-                    if (oldSegment.end + ROUNDING_ERROR < end) {
-                        return false;
-                    }
-                }
-                else if (Math.abs(time - oldSegment.time) > time) {
-                    return false;
-                }
-                return !shouldContentBeReplaced(pendingSegment, contentObject, currentPlaybackTime, fastSwitchThreshold);
-            });
-            if (waitForPushedSegment) {
-                return false;
-            }
-        }
-        // check if the segment is already downloaded
-        for (const completeSeg of reusableSegments) {
-            const areFromSamePeriod = completeSeg.infos.period.id === content.period.id;
-            // Check if content are from same period, as there can't be overlapping
-            // periods, we should consider a segment as already downloaded if
-            // it is from same period (but can be from different adaptation or
-            // representation)
-            if (completeSeg.status === 1 /* ChunkStatus.FullyLoaded */ && areFromSamePeriod) {
-                const completeSegInfos = completeSeg.infos.segment;
-                if (time - completeSegInfos.time > -ROUNDING_ERROR) {
-                    if (completeSegInfos.complete) {
-                        if (completeSegInfos.end - end > -ROUNDING_ERROR) {
-                            return false; // Same segment's characteristics: already downloaded
-                        }
-                    }
-                    else if (Math.abs(time - completeSegInfos.time) < ROUNDING_ERROR) {
-                        // same start (special case for non-complete segments): already downloaded
-                        return false;
-                    }
-                }
-            }
-        }
-        const estimatedSegmentSize = duration * content.representation.bitrate; // in bits
-        if (availableBufferSize - estimatedSegmentSize < 0) {
-            isBufferFull = true;
-            if (time > neededRange.start + MIN_BUFFER_AHEAD) {
-                shouldStopLoadingSegments = true;
-                segmentsOnHold.push(segment);
-                return false;
-            }
-        }
-        // check if the browser is not just garbage collecting it
-        const segmentHistory = getBufferedHistory(contentObject);
-        if (segmentHistory.length > 1) {
-            const lastTimeItWasPushed = segmentHistory[segmentHistory.length - 1];
-            const beforeLastTimeItWasPushed = segmentHistory[segmentHistory.length - 2];
-            if (lastTimeItWasPushed.buffered === null &&
-                beforeLastTimeItWasPushed.buffered === null) {
-                log.warn("Stream", "Segment GCed multiple times in a row, ignoring it.", "If this happens a lot and lead to unpleasant experience, please " +
-                    " check your device's available memory. If it's low when this message " +
-                    "is emitted, you might want to update the RxPlayer's settings (" +
-                    "`maxBufferAhead`, `maxVideoBufferSize` etc.) so less memory is used " +
-                    "by regular media data buffering.", {
-                    bufferType: adaptation.type,
-                    representationId: representation.id,
-                    segmentTime: segment.time,
-                });
-                return false;
-            }
-        }
-        // check if there is an hole in place of the segment currently
-        for (let i = 0; i < reusableSegments.length; i++) {
-            const completeSeg = reusableSegments[i];
-            // For the first already-loaded segment, take the first one ending after
-            // this one' s start
-            if (completeSeg.end + ROUNDING_ERROR > time) {
-                const shouldLoad = completeSeg.start > time + ROUNDING_ERROR ||
-                    getLastContiguousSegment(reusableSegments, i).end < end - ROUNDING_ERROR;
-                if (shouldLoad) {
-                    availableBufferSize -= estimatedSegmentSize;
-                }
-                return shouldLoad;
-            }
-        }
-        availableBufferSize -= estimatedSegmentSize;
-        return true;
-    });
-    return { segmentsToLoad, segmentsOnHold, isBufferFull };
-}
-/**
- * Compute the estimated available buffer size in memory in kilobytes
- * @param bufferedSegments
- * @param segmentsBeingPushed
- * @param maxVideoBufferSize
- * @returns availableBufferSize in bits
- */
-function getAvailableBufferSize(bufferedSegments, segmentsBeingPushed, maxVideoBufferSize) {
-    let availableBufferSize = maxVideoBufferSize * 8000; // in bits
-    availableBufferSize -= segmentsBeingPushed.reduce((size, segment) => {
-        const { bitrate } = segment.representation;
-        // Not taking into account the fact that the segment
-        // can still be generated and the duration not fully exact
-        const { duration } = segment.segment;
-        return size + bitrate * duration;
-    }, 0);
-    return bufferedSegments.reduce((size, chunk) => {
-        if (chunk.chunkSize !== undefined) {
-            return size - chunk.chunkSize * 8; // in bits
-        }
-        else {
-            return size;
-        }
-    }, availableBufferSize);
-}
-/**
- * From the given array of buffered chunks (`bufferedSegments`) returns the last
- * buffered chunk contiguous with the one at the `startIndex` index given.
- * @param {Array.<Object>}
- * @param {number} startIndex
- * @returns {Object}
- */
-function getLastContiguousSegment(bufferedSegments, startIndex) {
-    let j = startIndex + 1;
-    const { MINIMUM_SEGMENT_SIZE } = config.getCurrent();
-    /**
-     * Epsilon compensating for rounding errors when comparing the start and end
-     * time of multiple segments.
-     */
-    const ROUNDING_ERROR = Math.min(1 / 60, MINIMUM_SEGMENT_SIZE);
-    // go through all contiguous segments and take the last one
-    while (j < bufferedSegments.length - 1 &&
-        bufferedSegments[j - 1].end + ROUNDING_ERROR > bufferedSegments[j].start) {
-        j++;
-    }
-    j--; // index of last contiguous segment
-    return bufferedSegments[j];
-}
-/**
- * Returns `true` if segments linked to the given `oldContent` currently present
- * in the buffer should be replaced by segments coming from `currentContent`.
- * @param {Object} oldContent
- * @param {Object} currentContent
- * @param {number} currentPlaybackTime
- * @param {number} [fastSwitchThreshold]
- * @returns {boolean}
- */
-function shouldContentBeReplaced(oldContent, currentContent, currentPlaybackTime, fastSwitchThreshold) {
-    const { CONTENT_REPLACEMENT_PADDING } = config.getCurrent();
-    if (oldContent.period.id !== currentContent.period.id) {
-        return false; // keep segments from another Period by default.
-    }
-    const { segment } = oldContent;
-    if (segment.time < currentPlaybackTime + CONTENT_REPLACEMENT_PADDING) {
-        return false;
-    }
-    if (oldContent.adaptation.id !== currentContent.adaptation.id) {
-        return true; // replace segments from another Adaptation
-    }
-    return canFastSwitch(oldContent.representation, currentContent.representation, fastSwitchThreshold);
-}
-/**
- * Returns `true` if segments from the new Representation can replace
- * previously-loaded segments from the old Representation given.
- *
- * This behavior is called "fast-switching".
- * @param {Object} oldSegmentRepresentation
- * @param {Object} newSegmentRepresentation
- * @param {number|undefined} fastSwitchThreshold
- * @returns {boolean}
- */
-function canFastSwitch(oldSegmentRepresentation, newSegmentRepresentation, fastSwitchThreshold) {
-    const oldContentBitrate = oldSegmentRepresentation.bitrate;
-    const { BITRATE_REBUFFERING_RATIO } = config.getCurrent();
-    if (fastSwitchThreshold === undefined) {
-        // only re-load comparatively-poor bitrates for the same Adaptation.
-        const bitrateCeil = oldContentBitrate * BITRATE_REBUFFERING_RATIO;
-        return newSegmentRepresentation.bitrate > bitrateCeil;
-    }
-    return (oldContentBitrate < fastSwitchThreshold &&
-        newSegmentRepresentation.bitrate > oldContentBitrate);
-}
-/**
- * From buffered segment information, return `true` if the given `currentSeg`
- * might have been garbage collected at the start.
- * Return `false` if the segment is complete at least from `maximumStartTime`.
- * @param {Object} currentSeg - The segment information for the segment in
- * question.
- * @param {Object|null} prevSeg - The segment information for the previous
- * buffered segment, if one (`null` if none).
- * @param {number} maximumStartTime - Only consider the data after that time.
- * If `currentSeg` has only been garbage collected for some data which is before
- * that time, we will return `false`.
- */
-function doesStartSeemGarbageCollected(currentSeg, prevSeg, maximumStartTime) {
-    const { MAX_TIME_MISSING_FROM_COMPLETE_SEGMENT } = config.getCurrent();
-    if (currentSeg.bufferedStart === undefined) {
-        return false;
-    }
-    if (prevSeg !== null &&
-        prevSeg.bufferedEnd !== undefined &&
-        currentSeg.bufferedStart - prevSeg.bufferedEnd < 0.1) {
-        return false;
-    }
-    if (maximumStartTime < currentSeg.bufferedStart &&
-        currentSeg.bufferedStart - currentSeg.start > MAX_TIME_MISSING_FROM_COMPLETE_SEGMENT) {
-        log.info("Stream", "The start of the wanted segment has been garbage collected", {
-            segmentStart: currentSeg.start,
-            currentStartInBuffer: currentSeg.bufferedStart,
-        });
-        return true;
-    }
-    return false;
-}
-/**
- * From buffered segment information, return `true` if the given `currentSeg`
- * might have been garbage collected at the end.
- * Return `false` if the segment is complete at least until `minimumEndTime`.
- * @param {Object} currentSeg - The segment information for the segment in
- * question.
- * @param {Object|null} nextSeg - The segment information for the next buffered
- * segment, if one (`null` if none).
- * @param {number} minimumEndTime - Only consider the data before that time.
- * If `currentSeg` has only been garbage collected for some data which is after
- * that time, we will return `false`.
- */
-function doesEndSeemGarbageCollected(currentSeg, nextSeg, minimumEndTime) {
-    const { MAX_TIME_MISSING_FROM_COMPLETE_SEGMENT } = config.getCurrent();
-    if (currentSeg.bufferedEnd === undefined) {
-        return false;
-    }
-    if (nextSeg !== null &&
-        nextSeg.bufferedStart !== undefined &&
-        nextSeg.bufferedStart - currentSeg.bufferedEnd < 0.1) {
-        return false;
-    }
-    if (minimumEndTime > currentSeg.bufferedEnd &&
-        currentSeg.end - currentSeg.bufferedEnd > MAX_TIME_MISSING_FROM_COMPLETE_SEGMENT) {
-        log.info("Stream", "The end of the wanted segment has been garbage collected", {
-            segmentEnd: currentSeg.end,
-            currentEndInBuffer: currentSeg.bufferedEnd,
-        });
-        return true;
-    }
-    return false;
-}
-/**
- * Returns `true` if a segment that has been garbage-collected at the start
- * might profit from being re-loaded.
- *
- * Returns `false` if we have a high chance of staying in the same situation
- * after re-loading the segment.
- *
- * This function takes in argument the entries of a SegmentSink's history
- * related to the corresponding segment and check if the segment appeared
- * garbage-collected at the start directly after the last few times it was
- * pushed, indicating that the issue might be sourced at a browser issue instead
- * of classical garbage collection.
- *
- * @param {Array.<Object>} segmentEntries
- * @param {number|undefined} currentBufferedStart
- * @returns {boolean}
- */
-function shouldReloadSegmentGCedAtTheStart(segmentEntries, currentBufferedStart) {
-    var _a, _b;
-    if (segmentEntries.length < 2) {
-        return true;
-    }
-    const lastEntry = segmentEntries[segmentEntries.length - 1];
-    const lastBufferedStart = (_a = lastEntry.buffered) === null || _a === void 0 ? void 0 : _a.start;
-    // If the current segment's buffered start is much higher than what it
-    // initially was when we pushed it, the segment has a very high chance of
-    // having been truly garbage-collected.
-    if (currentBufferedStart !== undefined &&
-        lastBufferedStart !== undefined &&
-        currentBufferedStart - lastBufferedStart > 0.05) {
-        return true;
-    }
-    const prevEntry = segmentEntries[segmentEntries.length - 2];
-    const prevBufferedStart = (_b = prevEntry.buffered) === null || _b === void 0 ? void 0 : _b.start;
-    if (prevBufferedStart === undefined || lastBufferedStart === undefined) {
-        return true;
-    }
-    // Compare `bufferedStart` from the last time this segment was pushed
-    // (`entry.bufferedStart`) to the previous time it was pushed
-    // (`prevSegEntry.bufferedStart`).
-    //
-    // If in both cases, we notice that their initial `bufferedStart` are close,
-    // it means that in recent history the same segment has been accused to be
-    // garbage collected two times at roughly the same positions just after being
-    // pushed.
-    // This is very unlikely and might be linked to either a content or browser
-    // issue. In that case, don't try to reload.
-    return Math.abs(prevBufferedStart - lastBufferedStart) > 0.01;
-}
-/**
- * Returns `true` if a segment that has been garbage-collected at the end
- * might profit from being re-loaded.
- *
- * Returns `false` if we have a high chance of staying in the same situation
- * after re-loading the segment.
- *
- * This function takes in argument the entries of a SegmentSink's history
- * related to the corresponding segment and check if the segment appeared
- * garbage-collected at the end directly after the last few times it was
- * pushed, indicating that the issue might be sourced at a browser issue instead
- * of classical garbage collection.
- *
- * @param {Array.<Object>} segmentEntries
- * @param {number|undefined} currentBufferedEnd
- * @returns {boolean}
- */
-function shouldReloadSegmentGCedAtTheEnd(segmentEntries, currentBufferedEnd) {
-    var _a, _b;
-    if (segmentEntries.length < 2) {
-        return true;
-    }
-    const lastEntry = segmentEntries[segmentEntries.length - 1];
-    const lastBufferedEnd = (_a = lastEntry.buffered) === null || _a === void 0 ? void 0 : _a.end;
-    // If the current segment's buffered end is much lower than what it
-    // initially was when we pushed it, the segment has a very high chance of
-    // having been truly garbage-collected.
-    if (currentBufferedEnd !== undefined &&
-        lastBufferedEnd !== undefined &&
-        lastBufferedEnd - currentBufferedEnd > 0.05) {
-        return true;
-    }
-    const prevEntry = segmentEntries[segmentEntries.length - 2];
-    const prevBufferedEnd = (_b = prevEntry.buffered) === null || _b === void 0 ? void 0 : _b.end;
-    if (prevBufferedEnd === undefined || lastBufferedEnd === undefined) {
-        return true;
-    }
-    // Compare `bufferedEnd` from the last time this segment was pushed
-    // (`entry.bufferedEnd`) to the previous time it was pushed
-    // (`prevSegEntry.bufferedEnd`).
-    //
-    // If in both cases, we notice that their initial `bufferedEnd` are close,
-    // it means that in recent history the same segment has been accused to be
-    // garbage collected two times at roughly the same positions just after being
-    // pushed.
-    // This is very unlikely and might be linked to either a content or browser
-    // issue. In that case, don't try to reload.
-    return Math.abs(prevBufferedEnd - lastBufferedEnd) > 0.01;
-}
-/**
- * Returns the list of segments, minus those that have been garbage collected.
- * @param {IBufferedChunk[]} segments - The segments list to filter.
- * @param {Object} neededRange - The range we want to fill with segments.
- * @param getBufferedHistory - Callback allowing to retrieve a segment's history in the buffer
- * @returns The segments list including only reusable segments.
- */
-function filterOutGCedSegments(segments, neededRange, getBufferedHistory) {
-    return segments.filter((currentSeg, i, consideredSegments) => {
-        const prevSeg = i === 0 ? null : consideredSegments[i - 1];
-        const nextSeg = i >= consideredSegments.length - 1 ? null : consideredSegments[i + 1];
-        let lazySegmentHistory = null;
-        if (doesStartSeemGarbageCollected(currentSeg, prevSeg, neededRange.start)) {
-            lazySegmentHistory = getBufferedHistory(currentSeg.infos);
-            if (shouldReloadSegmentGCedAtTheStart(lazySegmentHistory, currentSeg.bufferedStart)) {
-                return false;
-            }
-            log.debug("Stream", "skipping segment gc-ed at the start", {
-                segmentStart: currentSeg.start,
-                currentStartInBuffer: currentSeg.bufferedStart,
-            });
-        }
-        if (doesEndSeemGarbageCollected(currentSeg, nextSeg, neededRange.end)) {
-            lazySegmentHistory = lazySegmentHistory !== null && lazySegmentHistory !== void 0 ? lazySegmentHistory : getBufferedHistory(currentSeg.infos);
-            if (shouldReloadSegmentGCedAtTheEnd(lazySegmentHistory, currentSeg.bufferedEnd)) {
-                return false;
-            }
-            log.debug("Stream", "skipping segment gc-ed at the end", {
-                segmentEnd: currentSeg.end,
-                currentEndInBuffer: currentSeg.bufferedEnd,
-            });
-        }
-        return true;
-    });
-}

package/dist/es2017/core/stream/representation/utils/get_segment_priority.d.ts

@@ -1,29 +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.
- */
-/**
- * Calculate the priority number for a given segment start time, in function of
- * the distance with the wanted starting timestamp.
- *
- * The lower is this number, the higher should be the priority of the request.
- *
- * Note that a `segmentTime` given behind the current time will always have the
- * highest priority.
- * @param {number} segmentTime
- * @param {Object} wantedStartTimestamp
- * @returns {number}
- */
-export default function getSegmentPriority(segmentTime: number, wantedStartTimestamp: number): number;
-//# sourceMappingURL=get_segment_priority.d.ts.map

package/dist/es2017/core/stream/representation/utils/get_segment_priority.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"get_segment_priority.d.ts","sourceRoot":"","sources":["../../../../../../src/core/stream/representation/utils/get_segment_priority.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAIH;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,OAAO,UAAU,kBAAkB,CACxC,WAAW,EAAE,MAAM,EACnB,oBAAoB,EAAE,MAAM,GAC3B,MAAM,CASR"}

package/dist/es2017/core/stream/representation/utils/get_segment_priority.js

@@ -1,38 +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 config from "../../../../config";
-/**
- * Calculate the priority number for a given segment start time, in function of
- * the distance with the wanted starting timestamp.
- *
- * The lower is this number, the higher should be the priority of the request.
- *
- * Note that a `segmentTime` given behind the current time will always have the
- * highest priority.
- * @param {number} segmentTime
- * @param {Object} wantedStartTimestamp
- * @returns {number}
- */
-export default function getSegmentPriority(segmentTime, wantedStartTimestamp) {
-    const distance = segmentTime - wantedStartTimestamp;
-    const { SEGMENT_PRIORITIES_STEPS } = config.getCurrent();
-    for (let priority = 0; priority < SEGMENT_PRIORITIES_STEPS.length; priority++) {
-        if (distance < SEGMENT_PRIORITIES_STEPS[priority]) {
-            return priority;
-        }
-    }
-    return SEGMENT_PRIORITIES_STEPS.length;
-}

package/dist/es2017/core/stream/representation/utils/push_init_segment.d.ts

@@ -1,42 +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 { IReadOnlyPlaybackObserver } from "../../../../playback_observer";
-import type { IReadOnlySharedReference } from "../../../../utils/reference";
-import type { CancellationSignal } from "../../../../utils/task_canceller";
-import type { SegmentSink } from "../../../segment_sinks";
-import type { IRepresentationStreamPlaybackObservation, IStreamEventAddedSegmentPayload } from "../types";
-/**
- * Push the initialization segment to the SegmentSink.
- * @param {Object} args
- * @param {Object} cancelSignal
- * @returns {Promise}
- */
-export default function pushInitSegment<T>({ playbackObserver, content, initSegmentUniqueId, segment, segmentSink, bufferGoal, }: {
-    playbackObserver: IReadOnlyPlaybackObserver<IRepresentationStreamPlaybackObservation>;
-    content: {
-        adaptation: IAdaptation;
-        manifest: IManifest;
-        period: IPeriod;
-        representation: IRepresentation;
-    };
-    initSegmentUniqueId: string;
-    segmentData: T;
-    segment: ISegment;
-    segmentSink: SegmentSink;
-    bufferGoal: IReadOnlySharedReference<number>;
-}, cancelSignal: CancellationSignal): Promise<IStreamEventAddedSegmentPayload | null>;
-//# sourceMappingURL=push_init_segment.d.ts.map

package/dist/es2017/core/stream/representation/utils/push_init_segment.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"push_init_segment.d.ts","sourceRoot":"","sources":["../../../../../../src/core/stream/representation/utils/push_init_segment.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EACV,SAAS,EACT,WAAW,EACX,QAAQ,EACR,OAAO,EACP,eAAe,EAChB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,+BAA+B,CAAC;AAE/E,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,6BAA6B,CAAC;AAC5E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AAC3E,OAAO,KAAK,EAAoB,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAC5E,OAAO,KAAK,EACV,wCAAwC,EACxC,+BAA+B,EAChC,MAAM,UAAU,CAAC;AAGlB;;;;;GAKG;AACH,wBAA8B,eAAe,CAAC,CAAC,EAC7C,EACE,gBAAgB,EAChB,OAAO,EACP,mBAAmB,EACnB,OAAO,EACP,WAAW,EACX,UAAU,GACX,EAAE;IACD,gBAAgB,EAAE,yBAAyB,CAAC,wCAAwC,CAAC,CAAC;IACtF,OAAO,EAAE;QACP,UAAU,EAAE,WAAW,CAAC;QACxB,QAAQ,EAAE,SAAS,CAAC;QACpB,MAAM,EAAE,OAAO,CAAC;QAChB,cAAc,EAAE,eAAe,CAAC;KACjC,CAAC;IACF,mBAAmB,EAAE,MAAM,CAAC;IAC5B,WAAW,EAAE,CAAC,CAAC;IACf,OAAO,EAAE,QAAQ,CAAC;IAClB,WAAW,EAAE,WAAW,CAAC;IACzB,UAAU,EAAE,wBAAwB,CAAC,MAAM,CAAC,CAAC;CAC9C,EACD,YAAY,EAAE,kBAAkB,GAC/B,OAAO,CAAC,+BAA+B,GAAG,IAAI,CAAC,CAqBjD"}

package/dist/es2017/core/stream/representation/utils/push_init_segment.js

@@ -1,36 +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 objectAssign from "../../../../utils/object_assign";
-import appendSegmentToBuffer from "./append_segment_to_buffer";
-/**
- * Push the initialization segment to the SegmentSink.
- * @param {Object} args
- * @param {Object} cancelSignal
- * @returns {Promise}
- */
-export default async function pushInitSegment({ playbackObserver, content, initSegmentUniqueId, segment, segmentSink, bufferGoal, }, cancelSignal) {
-    const codec = content.representation.getMimeTypeString();
-    const data = {
-        initSegmentUniqueId,
-        chunk: null,
-        timestampOffset: 0,
-        appendWindow: [undefined, undefined],
-        codec,
-    };
-    const inventoryInfos = objectAssign({ segment, chunkSize: undefined, start: 0, end: 0 }, content);
-    const buffered = await appendSegmentToBuffer(playbackObserver, segmentSink, { data, inventoryInfos }, bufferGoal, cancelSignal);
-    return { content, segment, buffered };
-}

package/dist/es2017/core/stream/representation/utils/push_media_segment.d.ts

@@ -1,43 +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 { IReadOnlyPlaybackObserver } from "../../../../playback_observer";
-import type { ISegmentParserParsedMediaChunk } from "../../../../transports";
-import type { IReadOnlySharedReference } from "../../../../utils/reference";
-import type { CancellationSignal } from "../../../../utils/task_canceller";
-import type { SegmentSink } from "../../../segment_sinks";
-import type { IRepresentationStreamPlaybackObservation, IStreamEventAddedSegmentPayload } from "../types";
-/**
- * Push a given media segment (non-init segment) to a SegmentSink.
- * @param {Object} args
- * @param {Object} cancelSignal
- * @returns {Promise}
- */
-export default function pushMediaSegment<T>({ playbackObserver, bufferGoal, content, initSegmentUniqueId, parsedSegment, segment, segmentSink, }: {
-    playbackObserver: IReadOnlyPlaybackObserver<IRepresentationStreamPlaybackObservation>;
-    content: {
-        adaptation: IAdaptation;
-        manifest: IManifest;
-        period: IPeriod;
-        representation: IRepresentation;
-    };
-    bufferGoal: IReadOnlySharedReference<number>;
-    initSegmentUniqueId: string | null;
-    parsedSegment: ISegmentParserParsedMediaChunk<T>;
-    segment: ISegment;
-    segmentSink: SegmentSink;
-}, cancelSignal: CancellationSignal): Promise<IStreamEventAddedSegmentPayload | null>;
-//# sourceMappingURL=push_media_segment.d.ts.map

package/dist/es2017/core/stream/representation/utils/push_media_segment.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"push_media_segment.d.ts","sourceRoot":"","sources":["../../../../../../src/core/stream/representation/utils/push_media_segment.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,KAAK,EACV,SAAS,EACT,WAAW,EACX,QAAQ,EACR,OAAO,EACP,eAAe,EAChB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,+BAA+B,CAAC;AAC/E,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,wBAAwB,CAAC;AAE7E,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,6BAA6B,CAAC;AAC5E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AAC3E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,KAAK,EACV,wCAAwC,EACxC,+BAA+B,EAChC,MAAM,UAAU,CAAC;AAGlB;;;;;GAKG;AACH,wBAA8B,gBAAgB,CAAC,CAAC,EAC9C,EACE,gBAAgB,EAChB,UAAU,EACV,OAAO,EACP,mBAAmB,EACnB,aAAa,EACb,OAAO,EACP,WAAW,GACZ,EAAE;IACD,gBAAgB,EAAE,yBAAyB,CAAC,wCAAwC,CAAC,CAAC;IACtF,OAAO,EAAE;QACP,UAAU,EAAE,WAAW,CAAC;QACxB,QAAQ,EAAE,SAAS,CAAC;QACpB,MAAM,EAAE,OAAO,CAAC;QAChB,cAAc,EAAE,eAAe,CAAC;KACjC,CAAC;IACF,UAAU,EAAE,wBAAwB,CAAC,MAAM,CAAC,CAAC;IAC7C,mBAAmB,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,aAAa,EAAE,8BAA8B,CAAC,CAAC,CAAC,CAAC;IACjD,OAAO,EAAE,QAAQ,CAAC;IAClB,WAAW,EAAE,WAAW,CAAC;CAC1B,EACD,YAAY,EAAE,kBAAkB,GAC/B,OAAO,CAAC,+BAA+B,GAAG,IAAI,CAAC,CAiDjD"}