rx-player 4.4.1 → 4.5.0-dev.2026012301

package/dist/es2017/core/stream/period/period_stream.js

@@ -1,432 +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 { formatError, MediaError } from "../../../errors";
-import log from "../../../log";
-import { toTaggedTrack } from "../../../manifest";
-import arrayFind from "../../../utils/array_find";
-import objectAssign from "../../../utils/object_assign";
-import queueMicrotask from "../../../utils/queue_microtask";
-import { getLeftSizeOfRange } from "../../../utils/ranges";
-import SharedReference from "../../../utils/reference";
-import TaskCanceller, { CancellationError } from "../../../utils/task_canceller";
-import SegmentSinksStore from "../../segment_sinks";
-import AdaptationStream from "../adaptation";
-import getAdaptationSwitchStrategy from "./utils/get_adaptation_switch_strategy";
-/**
- * Create a single PeriodStream:
- *   - Lazily create (or reuse) a SegmentSink for the given type.
- *   - Create a Stream linked to an Adaptation each time it changes, to
- *     download and append the corresponding segments to the SegmentSink.
- *   - Announce when the Stream is full or is awaiting new Segments through
- *     events
- *
- * @param {Object} args - Various arguments allowing the `PeriodStream` to
- * determine which Adaptation and which Representation to choose, as well as
- * which segments to load from it.
- * You can check the corresponding type for more information.
- * @param {Object} callbacks - The `PeriodStream` relies on a system of
- * callbacks that it will call on various events.
- *
- * Depending on the event, the caller may be supposed to perform actions to
- * react upon some of them.
- *
- * This approach is taken instead of a more classical EventEmitter pattern to:
- *   - Allow callbacks to be called synchronously after the
- *     `AdaptationStream` is called.
- *   - Simplify bubbling events up, by just passing through callbacks
- *   - Force the caller to explicitely handle or not the different events.
- *
- * Callbacks may start being called immediately after the `AdaptationStream`
- * call and may be called until either the `parentCancelSignal` argument is
- * triggered, or until the `error` callback is called, whichever comes first.
- * @param {Object} parentCancelSignal - `CancellationSignal` allowing, when
- * triggered, to immediately stop all operations the `PeriodStream` is
- * doing.
- */
-export default function PeriodStream({ bufferType, content, garbageCollectors, playbackObserver, representationEstimator, segmentQueueCreator, segmentSinksStore, options, wantedBufferAhead, maxVideoBufferSize, }, callbacks, parentCancelSignal) {
-    const { manifest, period } = content;
-    /**
-     * Emits the chosen Adaptation and Representations for the current type.
-     * `null` when no Adaptation is chosen (e.g. no subtitles)
-     * `undefined` at the beginning (it can be ignored.).
-     */
-    const adaptationRef = new SharedReference(undefined, parentCancelSignal);
-    callbacks.periodStreamReady({
-        type: bufferType,
-        manifest,
-        period,
-        adaptationRef,
-    });
-    if (parentCancelSignal.isCancelled()) {
-        return;
-    }
-    let currentStreamCanceller;
-    let isFirstAdaptationSwitch = true;
-    adaptationRef.onUpdate((choice) => {
-        // As an IIFE to profit from async/await while respecting onUpdate's signature
-        (async () => {
-            var _a;
-            if (choice === undefined) {
-                return;
-            }
-            const streamCanceller = new TaskCanceller();
-            streamCanceller.linkToSignal(parentCancelSignal);
-            currentStreamCanceller === null || currentStreamCanceller === void 0 ? void 0 : currentStreamCanceller.cancel(); // Cancel previously created stream if one
-            currentStreamCanceller = streamCanceller;
-            if (choice === null) {
-                // Current type is disabled for that Period
-                log.info(`Stream`, `Set no Adaptation`, {
-                    periodStart: period.start,
-                    bufferType,
-                });
-                const segmentSinkStatus = segmentSinksStore.getStatus(bufferType);
-                if (segmentSinkStatus.type === "initialized") {
-                    log.info(`Stream`, `Clearing previous SegmentSink`, {
-                        periodStart: period.start,
-                        bufferType,
-                    });
-                    if (SegmentSinksStore.isNative(bufferType)) {
-                        return askForMediaSourceReload(0, true, streamCanceller.signal);
-                    }
-                    else {
-                        const periodEnd = (_a = period.end) !== null && _a !== void 0 ? _a : Infinity;
-                        if (period.start > periodEnd) {
-                            log.warn("Stream", "Can't free buffer: period's start is after its end", {
-                                periodStart: period.start,
-                                periodEnd,
-                                bufferType,
-                            });
-                        }
-                        else {
-                            await segmentSinkStatus.value.removeBuffer(period.start, periodEnd);
-                            if (streamCanceller.isUsed()) {
-                                return; // The stream has been cancelled
-                            }
-                        }
-                    }
-                }
-                else if (segmentSinkStatus.type === "uninitialized") {
-                    segmentSinksStore.disableSegmentSink(bufferType);
-                    if (streamCanceller.isUsed()) {
-                        return; // The stream has been cancelled
-                    }
-                }
-                callbacks.adaptationChange({
-                    type: bufferType,
-                    adaptation: null,
-                    period,
-                });
-                if (streamCanceller.isUsed()) {
-                    return; // Previous call has provoken Stream cancellation by side-effect
-                }
-                return createEmptyAdaptationStream(playbackObserver, wantedBufferAhead, bufferType, { period }, callbacks, streamCanceller.signal);
-            }
-            const adaptations = period.adaptations[bufferType];
-            const adaptation = arrayFind(adaptations !== null && adaptations !== void 0 ? adaptations : [], (a) => a.id === choice.adaptationId);
-            if (adaptation === undefined) {
-                currentStreamCanceller.cancel();
-                log.warn("Stream", "Unfound chosen Adaptation choice", {
-                    adaptationId: choice.adaptationId,
-                });
-                return;
-            }
-            /**
-             * If this is not the first Adaptation choice, we might want to apply a
-             * delta to the current position so we can re-play back some media in the
-             * new Adaptation to give some context back.
-             * This value contains this relative position, in seconds.
-             * @see createMediaSourceReloadRequester
-             */
-            const { DELTA_POSITION_AFTER_RELOAD } = config.getCurrent();
-            let relativePosHasBeenDefaulted = false;
-            let relativePosAfterSwitch;
-            if (isFirstAdaptationSwitch) {
-                relativePosAfterSwitch = 0;
-            }
-            else if (choice.relativeResumingPosition !== undefined) {
-                relativePosAfterSwitch = choice.relativeResumingPosition;
-            }
-            else {
-                relativePosHasBeenDefaulted = true;
-                switch (bufferType) {
-                    case "audio":
-                        relativePosAfterSwitch = DELTA_POSITION_AFTER_RELOAD.trackSwitch.audio;
-                        break;
-                    case "video":
-                        relativePosAfterSwitch = DELTA_POSITION_AFTER_RELOAD.trackSwitch.video;
-                        break;
-                    default:
-                        relativePosAfterSwitch = DELTA_POSITION_AFTER_RELOAD.trackSwitch.other;
-                        break;
-                }
-            }
-            isFirstAdaptationSwitch = false;
-            if (SegmentSinksStore.isNative(bufferType) &&
-                segmentSinksStore.getStatus(bufferType).type === "disabled") {
-                return askForMediaSourceReload(relativePosAfterSwitch, true, streamCanceller.signal);
-            }
-            // Reload if the Adaptation disappears from the manifest
-            manifest.addEventListener("manifestUpdate", (updates) => {
-                // If current period has been unexpectedly removed, ask to reload
-                for (const element of updates.updatedPeriods) {
-                    if (element.period.id === period.id) {
-                        for (const adap of element.result.removedAdaptations) {
-                            if (adap.id === adaptation.id) {
-                                return askForMediaSourceReload(relativePosAfterSwitch, true, streamCanceller.signal);
-                            }
-                        }
-                    }
-                    else if (element.period.start > period.start) {
-                        break;
-                    }
-                }
-            }, currentStreamCanceller.signal);
-            const { representations } = choice;
-            log.info(`Stream`, `Updating adaptation`, {
-                bufferType: adaptation.type,
-                periodStart: period.start,
-                adaptationId: adaptation.id,
-            });
-            callbacks.adaptationChange({ type: bufferType, adaptation, period });
-            if (streamCanceller.isUsed()) {
-                return; // Previous call has provoken cancellation by side-effect
-            }
-            const segmentSink = createOrReuseSegmentSink(segmentSinksStore, bufferType, adaptation);
-            const strategy = getAdaptationSwitchStrategy(segmentSink, period, adaptation, choice.switchingMode, playbackObserver, options);
-            if (strategy.type === "needs-reload") {
-                return askForMediaSourceReload(relativePosAfterSwitch, true, streamCanceller.signal);
-            }
-            await segmentSinksStore.waitForUsableBuffers(streamCanceller.signal);
-            if (streamCanceller.isUsed()) {
-                return; // The Stream has since been cancelled
-            }
-            if (strategy.type === "flush-buffer" || strategy.type === "clean-buffer") {
-                for (const { start, end } of strategy.value) {
-                    await segmentSink.removeBuffer(start, end);
-                    if (streamCanceller.isUsed()) {
-                        return; // The Stream has since been cancelled
-                    }
-                }
-                if (strategy.type === "flush-buffer") {
-                    // The seek to `relativePosAfterSwitch` is only performed if strategy.type
-                    // is "flush-buffer" because there should be no interuption when playing in
-                    // with `clean-buffer` strategy
-                    callbacks.needsBufferFlush({
-                        relativeResumingPosition: relativePosAfterSwitch,
-                        relativePosHasBeenDefaulted,
-                    });
-                    if (streamCanceller.isUsed()) {
-                        return; // Previous callback cancelled the Stream by side-effect
-                    }
-                }
-            }
-            garbageCollectors.get(segmentSink)(streamCanceller.signal);
-            createAdaptationStream(adaptation, representations, segmentSink, streamCanceller.signal);
-        })().catch((err) => {
-            if (err instanceof CancellationError) {
-                return;
-            }
-            currentStreamCanceller === null || currentStreamCanceller === void 0 ? void 0 : currentStreamCanceller.cancel();
-            callbacks.error(err);
-        });
-    }, { clearSignal: parentCancelSignal, emitCurrentValue: true });
-    /**
-     * @param {Object} adaptation
-     * @param {Object} representations
-     * @param {Object} segmentSink
-     * @param {Object} cancelSignal
-     */
-    function createAdaptationStream(adaptation, representations, segmentSink, cancelSignal) {
-        const adaptationPlaybackObserver = createAdaptationStreamPlaybackObserver(playbackObserver, adaptation.type);
-        AdaptationStream({
-            content: { manifest, period, adaptation, representations },
-            options,
-            playbackObserver: adaptationPlaybackObserver,
-            representationEstimator,
-            segmentSink,
-            segmentQueueCreator,
-            wantedBufferAhead,
-            maxVideoBufferSize,
-        }, Object.assign(Object.assign({}, callbacks), { error: onAdaptationStreamError }), cancelSignal);
-        function onAdaptationStreamError(error) {
-            // Stream linked to a non-native media buffer should not impact the
-            // stability of the player. ie: if a text buffer sends an error, we want
-            // to continue playing without any subtitles
-            if (!SegmentSinksStore.isNative(bufferType)) {
-                log.error(`Stream`, `${bufferType} Stream crashed. Aborting it.`, error instanceof Error ? error : "");
-                segmentSinksStore.disposeSegmentSink(bufferType);
-                const formattedError = formatError(error, {
-                    defaultCode: "NONE",
-                    defaultReason: "Unknown `AdaptationStream` error",
-                });
-                callbacks.warning(formattedError);
-                if (cancelSignal.isCancelled()) {
-                    return; // Previous callback cancelled the Stream by side-effect
-                }
-                return createEmptyAdaptationStream(playbackObserver, wantedBufferAhead, bufferType, { period }, callbacks, cancelSignal);
-            }
-            log.error(`Stream`, `${bufferType} Stream crashed. Stopping playback.`, error instanceof Error ? error : "");
-            callbacks.error(error);
-        }
-    }
-    /**
-     * Regularly ask to reload the MediaSource on each playback observation
-     * performed by the playback observer.
-     *
-     * @param {number} timeOffset - Relative position, compared to the current
-     * playhead, at which we should restart playback after reloading.
-     * For example `-2` will reload 2 seconds before the current position.
-     * @param {boolean} stayInPeriod - If `true`, we will control that the position
-     * we reload at, after applying `timeOffset`, is still part of the Period
-     * `period`.
-     *
-     * If it isn't we will re-calculate that reloaded position to be:
-     *   - either the Period's start if the calculated position is before the
-     *     Period's start.
-     *   - either the Period'end start if the calculated position is after the
-     *     Period's end.
-     * @param {Object} cancelSignal
-     */
-    function askForMediaSourceReload(timeOffset, stayInPeriod, cancelSignal) {
-        // We begin by scheduling a micro-task to reduce the possibility of race
-        // conditions where `askForMediaSourceReload` would be called synchronously before
-        // the next observation (which may reflect very different playback conditions)
-        // is actually received.
-        // It can happen when `askForMediaSourceReload` is called as a side-effect of
-        // the same event that triggers the playback observation to be emitted.
-        queueMicrotask(() => {
-            playbackObserver.listen(() => {
-                if (cancelSignal.isCancelled()) {
-                    return;
-                }
-                callbacks.waitingMediaSourceReload({
-                    bufferType,
-                    period,
-                    timeOffset,
-                    stayInPeriod,
-                });
-            }, { includeLastObservation: true, clearSignal: cancelSignal });
-        });
-    }
-}
-/**
- * @param {string} bufferType
- * @param {Object} adaptation
- * @returns {Object}
- */
-function createOrReuseSegmentSink(segmentSinksStore, bufferType, adaptation) {
-    const segmentSinkStatus = segmentSinksStore.getStatus(bufferType);
-    if (segmentSinkStatus.type === "initialized") {
-        log.info("Stream", "Reusing a previous SegmentSink for the type", { bufferType });
-        return segmentSinkStatus.value;
-    }
-    const codec = getFirstDeclaredMimeType(adaptation);
-    return segmentSinksStore.createSegmentSink(bufferType, codec);
-}
-/**
- * Get mime-type string of the first representation declared in the given
- * adaptation.
- * @param {Adaptation} adaptation
- * @returns {string}
- */
-function getFirstDeclaredMimeType(adaptation) {
-    const representations = adaptation.representations.filter((r) => r.isPlayable() !== false);
-    if (representations.length > 0) {
-        return representations[0].getMimeTypeString();
-    }
-    else if (adaptation.representations.length > 0) {
-        return adaptation.representations[0].getMimeTypeString();
-    }
-    else {
-        const noRepErr = new MediaError("NO_PLAYABLE_REPRESENTATION", "No Representation in the chosen " + adaptation.type + " Adaptation can be played", { tracks: [toTaggedTrack(adaptation)] });
-        throw noRepErr;
-    }
-}
-/**
- * Create AdaptationStream's version of a playback observer.
- * @param {Object} initialPlaybackObserver
- * @param {string} trackType
- * @returns {Object}
- */
-function createAdaptationStreamPlaybackObserver(initialPlaybackObserver, trackType) {
-    return initialPlaybackObserver.deriveReadOnlyObserver(function transform(observationRef, cancellationSignal) {
-        const newRef = new SharedReference(constructAdaptationStreamPlaybackObservation(), cancellationSignal);
-        observationRef.onUpdate(emitAdaptationStreamPlaybackObservation, {
-            clearSignal: cancellationSignal,
-            emitCurrentValue: false,
-        });
-        return newRef;
-        function constructAdaptationStreamPlaybackObservation() {
-            const baseObservation = observationRef.getValue();
-            const buffered = baseObservation.buffered[trackType];
-            const bufferGap = buffered !== null
-                ? getLeftSizeOfRange(buffered, baseObservation.position.getWanted())
-                : 0;
-            return objectAssign({}, baseObservation, { bufferGap, buffered });
-        }
-        function emitAdaptationStreamPlaybackObservation() {
-            newRef.setValue(constructAdaptationStreamPlaybackObservation());
-        }
-    });
-}
-/**
- * Create empty AdaptationStream, linked to a Period.
- * This AdaptationStream will never download any segment and just emit a "full"
- * event when reaching the end.
- * @param {Object} playbackObserver
- * @param {Object} wantedBufferAhead
- * @param {string} bufferType
- * @param {Object} content
- * @param {Object} callbacks
- * @param {Object} cancelSignal
- */
-function createEmptyAdaptationStream(playbackObserver, wantedBufferAhead, bufferType, content, callbacks, cancelSignal) {
-    const { period } = content;
-    let hasFinishedLoading = false;
-    wantedBufferAhead.onUpdate(sendStatus, {
-        emitCurrentValue: false,
-        clearSignal: cancelSignal,
-    });
-    playbackObserver.listen(sendStatus, {
-        includeLastObservation: false,
-        clearSignal: cancelSignal,
-    });
-    sendStatus();
-    function sendStatus() {
-        const observation = playbackObserver.getReference().getValue();
-        const wba = wantedBufferAhead.getValue();
-        const position = observation.position.getWanted();
-        if (period.end !== undefined && position + wba >= period.end) {
-            log.debug("Stream", 'full "empty" AdaptationStream', {
-                bufferType,
-                periodEnd: period.end,
-                position,
-                wantedBufferAhead: wba,
-            });
-            hasFinishedLoading = true;
-        }
-        callbacks.streamStatusUpdate({
-            period,
-            bufferType,
-            imminentDiscontinuity: null,
-            position,
-            isEmptyStream: true,
-            hasFinishedLoading,
-            neededSegments: [],
-        });
-    }
-}

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

@@ -1,120 +0,0 @@
-import type { IManifest, IAdaptation, IPeriod } from "../../../manifest";
-import type { ObservationPosition, IReadOnlyPlaybackObserver } from "../../../playback_observer";
-import type { ITrackType } from "../../../public_types";
-import type { IRange } from "../../../utils/ranges";
-import type { IReadOnlySharedReference } from "../../../utils/reference";
-import type SharedReference from "../../../utils/reference";
-import type { CancellationSignal } from "../../../utils/task_canceller";
-import type WeakMapMemory from "../../../utils/weak_map_memory";
-import type { IRepresentationEstimator } from "../../adaptive";
-import type { SegmentQueueCreator } from "../../fetchers";
-import type { IBufferType, SegmentSink } from "../../segment_sinks";
-import type SegmentSinksStore from "../../segment_sinks";
-import type { IAdaptationChoice, IAdaptationStreamCallbacks, IAdaptationStreamOptions } from "../adaptation";
-import type { IPausedPlaybackObservation } from "../representation";
-export type { IPausedPlaybackObservation };
-/** Callbacks called by the `AdaptationStream` on various events. */
-export interface IPeriodStreamCallbacks extends IAdaptationStreamCallbacks {
-    /**
-     * Called when a new `PeriodStream` is ready to start but needs an Adaptation
-     * (i.e. track) to be chosen first.
-     */
-    periodStreamReady(payload: IPeriodStreamReadyPayload): void;
-    /**
-     * Called when a new `AdaptationStream` is created to load segments from an
-     * `Adaptation`.
-     */
-    adaptationChange(payload: IAdaptationChangePayload): void;
-}
-/** Payload for the `adaptationChange` callback. */
-export interface IAdaptationChangePayload {
-    /** The type of buffer for which the Representation is changing. */
-    type: IBufferType;
-    /** The `Period` linked to the `RepresentationStream` we're creating. */
-    period: IPeriod;
-    /**
-     * The `Adaptation` linked to the `AdaptationStream` we're creating.
-     * `null` when we're choosing no Adaptation at all.
-     */
-    adaptation: IAdaptation | null;
-}
-/** Payload for the `periodStreamReady` callback. */
-export interface IPeriodStreamReadyPayload {
-    /** The type of buffer linked to the `PeriodStream` we want to create. */
-    type: IBufferType;
-    /** The `Manifest` linked to the `PeriodStream` we have created. */
-    manifest: IManifest;
-    /** The `Period` linked to the `PeriodStream` we have created. */
-    period: IPeriod;
-    /**
-     * The reference through which any Adaptation (i.e. track) choice should be
-     * emitted for that `PeriodStream`.
-     *
-     * The `PeriodStream` will not do anything until this Reference has emitted
-     * at least one to give its initial choice.
-     * You can send `null` through it to tell this `PeriodStream` that you don't
-     * want any `Adaptation` for now.
-     * It is set to `undefined` by default, you SHOULD NOT set it to `undefined`
-     * yourself.
-     */
-    adaptationRef: SharedReference<IAdaptationChoice | null | undefined>;
-}
-/** Playback observation required by the `PeriodStream`. */
-export interface IPeriodStreamPlaybackObservation {
-    /**
-     * Information on whether the media element was paused at the time of the
-     * Observation.
-     */
-    paused: IPausedPlaybackObservation;
-    /**
-     * Information on the current media position in seconds at the time of the
-     * Observation.
-     */
-    position: ObservationPosition;
-    /** `duration` property of the HTMLMediaElement. */
-    duration: number;
-    /** `readyState` property of the HTMLMediaElement. */
-    readyState: number;
-    /** Target playback rate at which we want to play the content. */
-    speed: number;
-    /** Theoretical maximum position on the content that can currently be played. */
-    maximumPosition: number;
-    /**
-     * Ranges of buffered data per type of media.
-     * `null` if no buffer exists for that type of media.
-     */
-    buffered: Record<ITrackType, IRange[] | null>;
-    /**
-     * Indicates whether the user agent believes it has enough buffered data to ensure
-     * uninterrupted playback for a meaningful period or needs more data.
-     * It also reflects whether the user agent can retrieve and buffer data in an
-     * energy-efficient manner while maintaining the desired memory usage.
-     * `true` indicates that the buffer is low, and more data should be buffered.
-     * `false` indicates that there is enough buffered data, and no additional data needs
-     *  to be buffered at this time.
-     */
-    canStream: boolean;
-}
-/** Arguments required by the `PeriodStream`. */
-export interface IPeriodStreamArguments {
-    bufferType: IBufferType;
-    content: {
-        manifest: IManifest;
-        period: IPeriod;
-    };
-    garbageCollectors: WeakMapMemory<SegmentSink, (cancelSignal: CancellationSignal) => void>;
-    segmentQueueCreator: SegmentQueueCreator;
-    segmentSinksStore: SegmentSinksStore;
-    playbackObserver: IReadOnlyPlaybackObserver<IPeriodStreamPlaybackObservation>;
-    options: IPeriodStreamOptions;
-    representationEstimator: IRepresentationEstimator;
-    wantedBufferAhead: IReadOnlySharedReference<number>;
-    maxVideoBufferSize: IReadOnlySharedReference<number>;
-}
-/** Options tweaking the behavior of the PeriodStream. */
-export type IPeriodStreamOptions = IAdaptationStreamOptions & {
-    /** Behavior when a new video and/or audio codec is encountered. */
-    onCodecSwitch: "continue" | "reload";
-};
-export type { IAudioTrackSwitchingMode } from "../../../public_types";
-//# sourceMappingURL=types.d.ts.map

package/dist/es2017/core/stream/period/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/core/stream/period/types.ts"],"names":[],"mappings":"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"}

package/dist/es2017/core/stream/period/types.js

@@ -1 +0,0 @@
-export {};

package/dist/es2017/core/stream/period/utils/get_adaptation_switch_strategy.d.ts

@@ -1,68 +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 { IAdaptation, IPeriod } from "../../../../manifest";
-import type { IReadOnlyPlaybackObserver } from "../../../../playback_observer";
-import type { SegmentSink } from "../../../segment_sinks";
-import type { ITrackSwitchingMode } from "../../adaptation";
-import type { IPeriodStreamPlaybackObservation } from "../types";
-export type IAdaptationSwitchStrategy = 
-/** Do nothing special. */
-{
-    type: "continue";
-    value: undefined;
-}
-/**
- * Clean the given ranges of time from the buffer, preferably avoiding time
- * around the current position to continue playback smoothly.
- */
- | {
-    type: "clean-buffer";
-    value: Array<{
-        start: number;
-        end: number;
-    }>;
-}
-/**
- * Clean the given ranges of time from the buffer and try to flush the buffer
- * so that it is taken in account directly.
- */
- | {
-    type: "flush-buffer";
-    value: Array<{
-        start: number;
-        end: number;
-    }>;
-}
-/** Reload completely the media buffers. */
- | {
-    type: "needs-reload";
-    value: undefined;
-};
-export interface IAdaptationSwitchOptions {
-    /** Behavior when a new video and/or audio codec is encountered. */
-    onCodecSwitch: "continue" | "reload";
-}
-/**
- * Find out what to do when switching Adaptation, based on the current
- * situation.
- * @param {Object} segmentSink
- * @param {Object} period
- * @param {Object} adaptation
- * @param {Object} playbackObserver
- * @returns {Object}
- */
-export default function getAdaptationSwitchStrategy(segmentSink: SegmentSink, period: IPeriod, adaptation: IAdaptation, switchingMode: ITrackSwitchingMode, playbackObserver: IReadOnlyPlaybackObserver<IPeriodStreamPlaybackObservation>, options: IAdaptationSwitchOptions): IAdaptationSwitchStrategy;
-//# sourceMappingURL=get_adaptation_switch_strategy.d.ts.map

package/dist/es2017/core/stream/period/utils/get_adaptation_switch_strategy.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"get_adaptation_switch_strategy.d.ts","sourceRoot":"","sources":["../../../../../../src/core/stream/period/utils/get_adaptation_switch_strategy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AACjE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,+BAA+B,CAAC;AAI/E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAM1D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAC5D,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,UAAU,CAAC;AAEjE,MAAM,MAAM,yBAAyB;AACnC,0BAA0B;AACxB;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,KAAK,EAAE,SAAS,CAAA;CAAE;AACxC;;;GAGG;GACD;IAAE,IAAI,EAAE,cAAc,CAAC;IAAC,KAAK,EAAE,KAAK,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAAE;AACxE;;;GAGG;GACD;IAAE,IAAI,EAAE,cAAc,CAAC;IAAC,KAAK,EAAE,KAAK,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAAE;AACxE,2CAA2C;GACzC;IAAE,IAAI,EAAE,cAAc,CAAC;IAAC,KAAK,EAAE,SAAS,CAAA;CAAE,CAAC;AAE/C,MAAM,WAAW,wBAAwB;IACvC,mEAAmE;IACnE,aAAa,EAAE,UAAU,GAAG,QAAQ,CAAC;CACtC;AAED;;;;;;;;GAQG;AACH,MAAM,CAAC,OAAO,UAAU,2BAA2B,CACjD,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,OAAO,EACf,UAAU,EAAE,WAAW,EACvB,aAAa,EAAE,mBAAmB,EAClC,gBAAgB,EAAE,yBAAyB,CAAC,gCAAgC,CAAC,EAC7E,OAAO,EAAE,wBAAwB,GAChC,yBAAyB,CA+G3B"}