rx-player 4.4.1 → 4.5.0-dev.2026012301

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

@@ -1,314 +0,0 @@
-import type { IContentProtection } from "../../../main_thread/types";
-import type { IManifest, IAdaptation, ISegment, IPeriod, IRepresentation } from "../../../manifest";
-import type { IEMSG } from "../../../parsers/containers/isobmff";
-import type { ObservationPosition, IReadOnlyPlaybackObserver } from "../../../playback_observer";
-import type { IAudioRepresentationsSwitchingMode, IPlayerError, IVideoRepresentationsSwitchingMode } from "../../../public_types";
-import type { IRange } from "../../../utils/ranges";
-import type { IReadOnlySharedReference } from "../../../utils/reference";
-import type { SegmentQueue } from "../../fetchers";
-import type { IBufferType, SegmentSink } from "../../segment_sinks";
-/** Callbacks called by the `RepresentationStream` on various events. */
-export interface IRepresentationStreamCallbacks {
-    /**
-     * Called to announce the current status regarding the buffer for its
-     * associated Period and type (e.g. "audio", "video", "text" etc.).
-     *
-     * Each new `IStreamStatusPayload` event replace the precedent one for the
-     * same Period and type.
-     */
-    streamStatusUpdate(payload: IStreamStatusPayload): void;
-    /** Called after a new segment has been succesfully added to the SegmentSink */
-    addedSegment(payload: IStreamEventAddedSegmentPayload): void;
-    /** Called when a segment with protection information has been encountered. */
-    encryptionDataEncountered(payload: IContentProtection[]): void;
-    /**
-     * Called when the Manifest is possibly out-of-sync and needs to be refreshed
-     * completely.
-     *
-     * The Stream made that guess because a segment that should have been available
-     * is not and because it suspects this is due to a synchronization problem.
-     */
-    manifestMightBeOufOfSync(): void;
-    /**
-     * Callback called when a `RepresentationStream` is being terminated:
-     *
-     *   - it has finished all its segment requests and won't do new ones.
-     *
-     *   - it has stopped regularly checking for its current status.
-     *
-     *   - it only waits until all the segments it has loaded have been pushed to the
-     *     SegmentSink before actually stopping everything it does.
-     *
-     * You can use this call as a hint that a new `RepresentationStream` can be
-     * created for the same `Period` and type (e.g. to switch quality).
-     */
-    terminating(): void;
-    /**
-     * Called when the Manifest needs to be refreshed.
-     * Note that segment might still be loaded and pushed even after calling
-     * this callback.
-     */
-    needsManifestRefresh(): void;
-    /**
-     * Called when an "inband" event, as found in a media segment, has been
-     * encountered.
-     */
-    inbandEvent(payload: IInbandEvent[]): void;
-    /**
-     * Called when a minor error has been encountered, that does not interrupt
-     * the segment loading and pushing operations.
-     */
-    warning(payload: IPlayerError): void;
-    /**
-     * Called when a fatal error has been encountered.
-     * Such errors have led to all the Stream's operations to be stopped.
-     */
-    error(payload: unknown): void;
-}
-/** Payload for the `streamStatusUpdate` callback. */
-export interface IStreamStatusPayload {
-    /** Period concerned. */
-    period: IPeriod;
-    /** Buffer type concerned. */
-    bufferType: IBufferType;
-    /**
-     * Present or future "hole" in the SegmentSink's buffer that will not be
-     * filled by a segment, despite being part of the time period indicated by
-     * the associated Period.
-     *
-     * This value is set to the most imminent of such "discontinuity", which
-     * can be either:
-     *
-     *   - current (no segment available at `position` but future segments are
-     *     available), in which case this discontinuity's true beginning might
-     *     be unknown.
-     *
-     *   - a future hole between two segments in that Period.
-     *
-     *   - missing media data at the end of the time period associated to that
-     *     Period.
-     *
-     * The presence or absence of a discontinuity can evolve during playback
-     * (because new tracks or qualities might not have the same ones).
-     * As such, it is advised to only consider the last discontinuity sent
-     * through a `"stream-status"` event.
-     */
-    imminentDiscontinuity: IBufferDiscontinuity | null;
-    /**
-     * If `true`, no segment are left to be loaded to be able to play until the
-     * end of the Period.
-     */
-    hasFinishedLoading: boolean;
-    /**
-     * If `true`, this stream is a placeholder stream which will never load any
-     * segment.
-     */
-    isEmptyStream: boolean;
-    /**
-     * Segments that will be scheduled for download to fill the buffer until
-     * the buffer goal (first element of that list might already be loading).
-     */
-    neededSegments: IQueuedSegment[];
-    /** Position in the content in seconds from which this status was done.  */
-    position: number;
-}
-/** Payload for the `addedSegment` callback. */
-export interface IStreamEventAddedSegmentPayload {
-    /** Context about the content that has been added. */
-    content: {
-        period: IPeriod;
-        adaptation: IAdaptation;
-        representation: IRepresentation;
-    };
-    /** The concerned Segment. */
-    segment: ISegment;
-    /** Ranges of the concerned SegmentSink after the segment was pushed. */
-    buffered: IRange[];
-}
-/** Structure describing an "inband" event, as found in a media segment. */
-export interface IInbandEvent {
-    /** Type when the event was foud inside a "emsg` ISOBMFF box */
-    type: "emsg";
-    /** Value when the event was foud inside a "emsg` ISOBMFF box */
-    value: IEMSG;
-}
-/** Information about a Segment waiting to be loaded by the Stream. */
-export interface IQueuedSegment {
-    /** Priority of the segment request (lower number = higher priority). */
-    priority: number;
-    /** Segment wanted. */
-    segment: ISegment;
-}
-/** Describe an encountered hole in the buffer, called a "discontinuity". */
-export interface IBufferDiscontinuity {
-    /**
-     * Start time, in seconds, at which the discontinuity starts.
-     *
-     * if set to `undefined`, its true start time is unknown but the current
-     * position is part of it.  It is thus a discontinuity that is currently
-     * encountered.
-     */
-    start: number | undefined;
-    /**
-     * End time, in seconds at which the discontinuity ends (and thus where
-     * new segments are encountered).
-     *
-     * If `null`, no new media segment is available for that Period and
-     * buffer type until the end of the Period.
-     */
-    end: number | null;
-}
-/** Object that should be emitted by the given `IReadOnlyPlaybackObserver`. */
-export interface IRepresentationStreamPlaybackObservation {
-    /**
-     * Information on the current media position in seconds at the time of a
-     * Playback Observation.
-     */
-    position: ObservationPosition;
-    /**
-     * Information on whether the media element was paused at the time of the
-     * Observation.
-     */
-    paused: IPausedPlaybackObservation;
-    /** Last "playback rate" asked by the user. */
-    speed: number;
-    /**
-     * 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;
-}
-/** Pause-related information linked to an emitted Playback observation. */
-export interface IPausedPlaybackObservation {
-    /**
-     * Known paused state at the time the Observation was emitted.
-     *
-     * `true` indicating that the HTMLMediaElement was in a paused state.
-     *
-     * Note that it might have changed since. If you want truly precize
-     * information, you should recuperate it from the HTMLMediaElement directly
-     * through another mean.
-     */
-    last: boolean;
-    /**
-     * Actually wanted paused state not yet reached.
-     * This might for example be set to `false` when the content is currently
-     * loading (and thus paused) but with autoPlay enabled.
-     */
-    pending: boolean | undefined;
-}
-/** Position-related information linked to an emitted Playback observation. */
-export interface IPositionPlaybackObservation {
-    /**
-     * Known position at the time the Observation was emitted, in seconds.
-     *
-     * Note that it might have changed since. If you want truly precize
-     * information, you should recuperate it from the HTMLMediaElement directly
-     * through another mean.
-     */
-    last: number;
-    /**
-     * Actually wanted position in seconds that is not yet reached.
-     *
-     * This might for example be set to the initial position when the content is
-     * loading (and thus potentially at a `0` position) but which will be seeked
-     * to a given position once possible.
-     */
-    pending: number | undefined;
-}
-/** Item emitted by the `terminate` reference given to a RepresentationStream. */
-export interface ITerminationOrder {
-    urgent: boolean;
-}
-/** Arguments to give to the RepresentationStream. */
-export interface IRepresentationStreamArguments<TSegmentDataType> {
-    /** The context of the Representation you want to load. */
-    content: {
-        adaptation: IAdaptation;
-        manifest: IManifest;
-        period: IPeriod;
-        representation: IRepresentation;
-    };
-    /** The `SegmentSink` on which segments will be pushed. */
-    segmentSink: SegmentSink;
-    /** Interface used to load new segments. */
-    segmentQueue: SegmentQueue<TSegmentDataType>;
-    /**
-     * Reference emitting when the RepresentationStream should "terminate".
-     *
-     * When this Reference emits an object, the RepresentationStream will begin a
-     * "termination process": it will, depending on the type of termination
-     * wanted, either stop immediately pending segment requests or wait until they
-     * are finished before fully terminating (calling the `terminating` callback
-     * and stopping all `RepresentationStream` current tasks).
-     */
-    terminate: IReadOnlySharedReference<null | ITerminationOrder>;
-    /** Periodically emits the current playback conditions. */
-    playbackObserver: IReadOnlyPlaybackObserver<IRepresentationStreamPlaybackObservation>;
-    /** Supplementary arguments which configure the RepresentationStream's behavior. */
-    options: IRepresentationStreamOptions;
-}
-/**
- * Various specific stream "options" which tweak the behavior of the
- * RepresentationStream.
- */
-export interface IRepresentationStreamOptions {
-    /**
-     * The buffer size we have to reach in seconds (compared to the current
-     * position. When that size is reached, no segments will be loaded until it
-     * goes below that size again.
-     */
-    bufferGoal: IReadOnlySharedReference<number>;
-    /**
-     *  The buffer size limit in memory that we can reach.
-     *  Once reached, no segments will be loaded until it
-     *  goes below that size again
-     */
-    maxBufferSize: IReadOnlySharedReference<number>;
-    /**
-     * Hex-encoded DRM "system ID" as found in:
-     * https://dashif.org/identifiers/content_protection/
-     *
-     * Allows to identify which DRM system is currently used, to allow potential
-     * optimizations.
-     *
-     * Set to `undefined` in two cases:
-     *   - no DRM system is used (e.g. the content is unencrypted).
-     *   - We don't know which DRM system is currently used.
-     */
-    drmSystemId: string | undefined;
-    /**
-     * Bitrate threshold from which no "fast-switching" should occur on a segment.
-     *
-     * Fast-switching is an optimization allowing to replace segments from a
-     * low-bitrate Representation by segments from a higher-bitrate
-     * Representation. This allows the user to see/hear an improvement in quality
-     * faster, hence "fast-switching".
-     *
-     * This Reference allows to limit this behavior to only allow the replacement
-     * of segments with a bitrate lower than a specific value - the number emitted
-     * by that Reference.
-     *
-     * If set to `undefined`, no threshold is active and any segment can be
-     * replaced by higher quality segment(s).
-     *
-     * `0` can be emitted to disable any kind of fast-switching.
-     */
-    fastSwitchThreshold: IReadOnlySharedReference<undefined | number>;
-}
-/** Object indicating a choice of allowed Representations made by the user. */
-export interface IRepresentationsChoice {
-    /** `Representation`s wanted by the user. */
-    representationIds: string[];
-    /**
-     * How the Streams should react if another, not currently authorized,
-     * Representation was previously playing.
-     */
-    switchingMode: IVideoRepresentationsSwitchingMode | IAudioRepresentationsSwitchingMode;
-}
-//# sourceMappingURL=types.d.ts.map

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

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

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

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

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

@@ -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 type { IReadOnlyPlaybackObserver } from "../../../../playback_observer";
-import type { IRange } from "../../../../utils/ranges";
-import type { IReadOnlySharedReference } from "../../../../utils/reference";
-import type { CancellationSignal } from "../../../../utils/task_canceller";
-import type { IInsertedChunkInfos, IPushChunkInfos, SegmentSink } from "../../../segment_sinks";
-import type { IRepresentationStreamPlaybackObservation } from "../types";
-/**
- * Append a segment to the given segmentSink.
- * If it leads to an Error due to a full buffer, try to run our custom range
- * _garbage collector_ then retry.
- * @param {Object} playbackObserver
- * @param {Object} segmentSink
- * @param {Object} dataInfos
- * @param {number} bufferGoal
- * @param {Object} cancellationSignal
- * @returns {Promise}
- */
-export default function appendSegmentToBuffer<T>(playbackObserver: IReadOnlyPlaybackObserver<IRepresentationStreamPlaybackObservation>, segmentSink: SegmentSink, dataInfos: IPushChunkInfos<T> & {
-    inventoryInfos: IInsertedChunkInfos;
-}, bufferGoal: IReadOnlySharedReference<number>, cancellationSignal: CancellationSignal): Promise<IRange[]>;
-//# sourceMappingURL=append_segment_to_buffer.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"append_segment_to_buffer.d.ts","sourceRoot":"","sources":["../../../../../../src/core/stream/representation/utils/append_segment_to_buffer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AASH,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,+BAA+B,CAAC;AAC/E,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,0BAA0B,CAAC;AACvD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,6BAA6B,CAAC;AAE5E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AAE3E,OAAO,KAAK,EACV,mBAAmB,EACnB,eAAe,EACf,WAAW,EACZ,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,wCAAwC,EAAE,MAAM,UAAU,CAAC;AAEzE;;;;;;;;;;GAUG;AACH,wBAA8B,qBAAqB,CAAC,CAAC,EACnD,gBAAgB,EAAE,yBAAyB,CAAC,wCAAwC,CAAC,EACrF,WAAW,EAAE,WAAW,EACxB,SAAS,EAAE,eAAe,CAAC,CAAC,CAAC,GAAG;IAAE,cAAc,EAAE,mBAAmB,CAAA;CAAE,EACvE,UAAU,EAAE,wBAAwB,CAAC,MAAM,CAAC,EAC5C,kBAAkB,EAAE,kBAAkB,GACrC,OAAO,CAAC,MAAM,EAAE,CAAC,CA4CnB"}

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

@@ -1,79 +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.
- */
-/**
- * This file allows any Stream to push data to a SegmentSink.
- */
-import { MediaError, SourceBufferError } from "../../../../errors";
-import log from "../../../../log";
-import { toTaggedTrack } from "../../../../manifest";
-import sleep from "../../../../utils/sleep";
-import { CancellationError } from "../../../../utils/task_canceller";
-/**
- * Append a segment to the given segmentSink.
- * If it leads to an Error due to a full buffer, try to run our custom range
- * _garbage collector_ then retry.
- * @param {Object} playbackObserver
- * @param {Object} segmentSink
- * @param {Object} dataInfos
- * @param {number} bufferGoal
- * @param {Object} cancellationSignal
- * @returns {Promise}
- */
-export default async function appendSegmentToBuffer(playbackObserver, segmentSink, dataInfos, bufferGoal, cancellationSignal) {
-    try {
-        return await segmentSink.pushChunk(dataInfos);
-    }
-    catch (appendError) {
-        if (cancellationSignal.isCancelled() && appendError instanceof CancellationError) {
-            throw appendError;
-        }
-        else if (!(appendError instanceof SourceBufferError) || !appendError.isBufferFull) {
-            const reason = appendError instanceof Error
-                ? appendError.toString()
-                : "An unknown error happened when pushing content";
-            throw new MediaError("BUFFER_APPEND_ERROR", reason, {
-                tracks: [toTaggedTrack(dataInfos.inventoryInfos.adaptation)],
-            });
-        }
-        const { position } = playbackObserver.getReference().getValue();
-        const currentPos = position.getWanted();
-        try {
-            log.warn("Stream", "Running garbage collector");
-            const start = Math.max(currentPos - 5, 0);
-            const end = currentPos + bufferGoal.getValue() + 12;
-            if (start > 0) {
-                await segmentSink.removeBuffer(0, start);
-            }
-            if (end < Number.MAX_VALUE) {
-                await segmentSink.removeBuffer(end, Number.MAX_VALUE);
-            }
-            await sleep(200);
-            if (cancellationSignal.cancellationError !== null) {
-                throw cancellationSignal.cancellationError;
-            }
-            return await segmentSink.pushChunk(dataInfos);
-        }
-        catch (err2) {
-            if (err2 instanceof CancellationError) {
-                throw err2;
-            }
-            const reason = err2 instanceof Error ? err2.toString() : "Could not clean the buffer";
-            throw new MediaError("BUFFER_FULL_ERROR", reason, {
-                tracks: [toTaggedTrack(dataInfos.inventoryInfos.adaptation)],
-            });
-        }
-    }
-}

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

@@ -1,54 +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 { IBufferedChunk } from "../../../segment_sinks";
-import type { IBufferDiscontinuity } from "../types";
-/**
- * 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.
- */
-export default function checkForDiscontinuity(content: {
-    adaptation: IAdaptation;
-    manifest: IManifest;
-    period: IPeriod;
-    representation: IRepresentation;
-}, checkedRange: {
-    start: number;
-    end: number;
-}, nextSegmentStart: number | null, hasFinishedLoading: boolean, bufferedSegments: IBufferedChunk[]): IBufferDiscontinuity | null;
-//# sourceMappingURL=check_for_discontinuity.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"check_for_discontinuity.d.ts","sourceRoot":"","sources":["../../../../../../src/core/stream/representation/utils/check_for_discontinuity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,KAAK,EACV,SAAS,EACT,WAAW,EACX,OAAO,EACP,eAAe,EAChB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,CAAC,OAAO,UAAU,qBAAqB,CAC3C,OAAO,EAAE;IACP,UAAU,EAAE,WAAW,CAAC;IACxB,QAAQ,EAAE,SAAS,CAAC;IACpB,MAAM,EAAE,OAAO,CAAC;IAChB,cAAc,EAAE,eAAe,CAAC;CACjC,EACD,YAAY,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,EAC5C,gBAAgB,EAAE,MAAM,GAAG,IAAI,EAC/B,kBAAkB,EAAE,OAAO,EAC3B,gBAAgB,EAAE,cAAc,EAAE,GACjC,oBAAoB,GAAG,IAAI,CAqK7B"}