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

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

@@ -0,0 +1,319 @@
+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;
+    /**
+     * Human-readable string describing the reason for the change.
+     * This is useful when debugging.
+     */
+    reason: string;
+}
+/** 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

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

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

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

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

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

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

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

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