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

package/dist/es2017/mse/types.d.ts

@@ -0,0 +1,303 @@
+import type { ISerializedSourceBufferError } from "../errors/source_buffer_error";
+import type EventEmitter from "../utils/event_emitter";
+import type { IRange } from "../utils/ranges";
+/**
+ * Categorize a type of media associated to a `SourceBuffer` (the Media Source
+ * Extensions Object).
+ */
+export declare const enum SourceBufferType {
+    /** `SourceBuffer` for audio data only. */
+    Audio = "audio",
+    /** `SourceBuffer` for either video data only or both audio and video. */
+    Video = "video"
+}
+/** Parameters associated to a chunk that should be pushed. */
+export interface ISourceBufferInterfaceAppendBufferParameters {
+    /** Mime-type + codec combination linked to that chunk. */
+    codec?: string | undefined;
+    /**
+     * Tuple of:
+     *   1. The `appendWindowStart` (the Media Source Extensions concept)
+     *   2. The `appendWindowEnd` (the Media Source Extensions concept)
+     *
+     * `undefined` for each when no such value is set.
+     */
+    appendWindow?: [number | undefined, number | undefined] | undefined;
+    /**
+     * `timestampOffset` (the Media Source Extensions concept) that should be
+     * associated that chunk.
+     */
+    timestampOffset?: number | undefined;
+}
+/**
+ * Provide a more portable (as in both main thread and WebWorker compatible) and
+ * more usable (Promise-based, no need to queue calls) abstraction over a
+ * `SourceBuffer` Object from the Media Source Extensions.
+ */
+export interface ISourceBufferInterface {
+    /** Mime-type + codec combination currently linked to that `ISourceBufferInterface`. */
+    codec: string;
+    /**
+     * Type of media buffered by the underlying `SourceBuffer`.
+     */
+    type: SourceBufferType;
+    /**
+     * Append media data referenced by `data` to the `ISourceBufferInterface` with
+     * the corresponding associated parameters.
+     *
+     * Returns a promise which resolves once the data has been pushed with success
+     * with the new updated buffered range associated to the underlying
+     * `SourceBuffer`.
+     * Reject when either:
+     *
+     *   - The operation fails.
+     *     In which case the value rejected should preferably be a
+     *     `SourceBufferError`.
+     *
+     *   - The operation was aborted (due to an `abort` or `dispose` call).
+     *     In which case the value rejected should be a `CancellationError`.
+     *
+     * @param {BufferSource} data
+     * @param {Object} params
+     * @returns {Promise.<Array.<Object>>}
+     */
+    appendBuffer(data: BufferSource, params: ISourceBufferInterfaceAppendBufferParameters): Promise<IRange[]>;
+    /**
+     * Remove media data present between the given start time in seconds and the
+     * given end time in seconds.
+     *
+     * Returns a promise which resolves once the data has been removed with success
+     * with the new updated buffered range associated to the underlying
+     * `SourceBuffer`.
+     * Reject when either:
+     *
+     *   - The operation fails.
+     *     In which case the value rejected should preferably be a
+     *     `SourceBufferError`.
+     *
+     *   - The operation was aborted (due to an `abort` or `dispose` call).
+     *     In which case the value rejected should be a `CancellationError`.
+     *
+     * @param {number} start
+     * @param {number} end
+     * @returns {Promise.<Array.<Object>>}
+     */
+    remove(start: number, end: number): Promise<IRange[]>;
+    /**
+     * Abort all operations pending on the `SourceBuffer`.
+     * @param {string | undefined} reason - Human-inspectable reason behind the
+     * abort. Used for debugging matters, especially for debug log
+     * inspection.
+     */
+    abort(reason: string | undefined): void;
+    /**
+     * Abort all operations pending on the `SourceBuffer` AND free up all
+     * resources taken by the `ISourceBufferInterface`.
+     *
+     * The `ISourceBufferInterface` implementation might not be usable after
+     * this call, it should mostly be called for clean-up.
+     * @param {string | undefined} reason - Human-inspectable reason behind the
+     * dispose. Used for debugging matters, especially for debug log
+     * inspection.
+     */
+    dispose(reason: string | undefined): void;
+    /**
+     * Returns the current range of buffered data, or `undefined` if this is not
+     * obtainable synchronously.
+     * @returns {Array.<Object> | undefined}
+     */
+    getBuffered(): IRange[] | undefined;
+    /**
+     * Only set for `ISourceBufferInterface` objects which cannot rely on
+     * MediaSource API directly.
+     *
+     * This callback allows to communicate to the `ISourceBufferInterface` that
+     * an operation it has performed previously has suceeded.
+     *
+     * @param {string} operationId - Identifier for the operation that
+     * succeeded. The same one should have been used when initially running
+     * the operation.
+     * @param {Array.<Object>} ranges - The new contiguous buffered range
+     * linked to the MSE SourceBuffer once the operation succeeded.
+     */
+    onOperationSuccess?: (operationId: string, ranges: IRange[]) => void;
+    /**
+     * Only set for `ISourceBufferInterface` objects which cannot rely on
+     * MediaSource API directly.
+     *
+     * This callback allows to communicate to the `ISourceBufferInterface` that
+     * an operation it has performed previously has failed.
+     *
+     * @param {string} operationId - Identifier for the operation that
+     * succeeded. The same one should have been used when initially running
+     * the operation.
+     * @param {Array.<Object>} error - Categorization on the error encountered
+     * while doing the operation.
+     */
+    onOperationFailure?: (operationId: string, error: ISerializedSourceBufferError | {
+        errorName: "CancellationError";
+    }) => void;
+}
+/**
+ * Object allowing to link a MSE's `MediaSource` instance to an
+ * `HTMLMediaElement`.
+ */
+export type IMediaSourceHandle = {
+    type: "handle";
+    /**
+     * This is a `MediaSourceHandle` which can be sent through a `postMessage` - if
+     * cross-thread communication is needed - in which case it should be transfered
+     * through that call (see `postMessage` browser API documentation).
+     */
+    value: MediaProvider;
+} | {
+    type: "media-source";
+    /**
+     * This is the `MediaSource` instance itself directly, you may want to create
+     * an object URL to it before linking it through an `src` attribute.
+     *
+     * To create an object URL, you can use browser API such as
+     * `URL.createObjectURL`.
+     * Do not forget to revoke such URL (e.g. through `URL.revokeObjectURL`) when
+     * you're done.
+     */
+    value: MediaSource;
+};
+/**
+ * Interface to the Media Source Extension (or MSE) API, that is supposed to
+ * work regardless of if those API are available in the current environment
+ * (e.g. we're currently in a WebWorker where the MSE-in-worker feature is
+ * not available).
+ *
+ * The procedure creating a new `IMediaSourceInterface` object should also
+ * trigger the creation of a linked `MediaSource` MSE object.
+ */
+export interface IMediaSourceInterface extends EventEmitter<IMediaSourceInterfaceEvents> {
+    /** `id` uniquely identifying this `IMediaSourceInterface`. */
+    id: string;
+    /**
+     * Last known `ReadyState` the underlying MSE `MediaSource` was at.
+     *
+     * /!\ May be known asynchronously after it is updated. You can rely on events
+     * to be notified of its change.
+     */
+    readyState: ReadyState;
+    /**
+     * Mean to link the underlying `MediaSource` to an `HTMLMediaElement`.
+     *
+     * `undefined` if this `IMediaSourceInterface` cannot rely on MSE API
+     * directly to create a `MediaSource`, in which case it will have sent
+     * message by itself to the main thread for MediaSource creation.
+     */
+    handle: IMediaSourceHandle | undefined;
+    /**
+     * List `ISourceBufferInterface` objects linked to this
+     * `IMediaSourceInterface`.
+     *
+     * It can be noted that only one `ISourceBufferInterface` per
+     * `SourceBufferType` can be created at most, making that info on
+     * `ISourceBufferInterface` useful as a discriminant for that array.
+     */
+    sourceBuffers: ISourceBufferInterface[];
+    /**
+     * 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.
+     * The value can be `undefined` if the user agent does not provide this indicator.
+     * `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.
+     */
+    streaming?: boolean;
+    /**
+     * Add a new `ISourceBufferInterface` (and its corresponding underlying MSE
+     * `SourceBuffer` object) linked to the given `SourceBufferType`.
+     *
+     * This allows to then push media data of the corresponding media type so it
+     * can be decoded.
+     *
+     * Note that only one `ISourceBufferInterface` for a given `SourceBufferType`
+     * can be created at most per-`IMediaSourceInterface`.
+     */
+    addSourceBuffer(sbType: SourceBufferType, codec: string): ISourceBufferInterface;
+    /**
+     * Update `duration` property (which in reality means more the "maximum
+     * reachable position") in seconds linked to the `MediaSource` (which itself
+     * is used by the browser to determine the `HTMLMediaElement`'s `duration`
+     * property and various linked browser behavior).
+     *
+     * Note that this operation acts as a long-running background task that
+     * ensures the duration is set on the `MediaSource`.
+     * If you want to cancel the duration update operation, you should call
+     * `interruptDurationSetting`.
+     */
+    setDuration(newDuration: number, isRealEndKnown: boolean): void;
+    /**
+     * Interrupt a duration update background task previously started through
+     * a `setDuration` call.
+     * @param {string | undefined} reason - Human-inspectable reason behind the
+     * interrupt. Used for debugging matters, especially for debug log
+     * inspection.
+     */
+    interruptDurationSetting(reason: string | undefined): void;
+    /**
+     * Signal to the `IMediaSourceInterface` that all media segments until the
+     * end of the current content has been pushed through its
+     * `ISourceBufferInterface`, so it can call the `endOfStream` MSE API at
+     * the right time, allowing to properly end the content (e.g. this is
+     * necessary so the `HTMLMediaElement` can set its `ended` property to
+     * `true` when the end is reached).
+     *
+     * The `endOfStream` operation keeps running until a `stopEndOfStream` is
+     * done. If you want to cancel an `endOfStream` operation, for example because
+     * new future content is now available, you should call `stopEndOfStream`.
+     */
+    maintainEndOfStream(): void;
+    /**
+     * Interrupt an `endOfStream` operation started with `maintainEndOfStream`.
+     */
+    stopEndOfStream(): void;
+    /**
+     * Free all resources taken by the `IMediaSourceInterface`, including all its
+     * inner `ISourceBufferInterface` objects.
+     * @param {string | undefined} reason - Human-inspectable reason behind the
+     * dispose. Used for debugging matters, especially for debug log
+     * inspection.
+     */
+    dispose(reason: string | undefined): void;
+    /**
+     * Only set for `IMediaSourceInterface` objects which cannot rely on
+     * MediaSource API directly.
+     *
+     * This callback allows to communicate that the `ReadyState` of the underlying
+     * MSE `MediaSource` has changed.
+     *
+     * @param {string} readyState - The new `MediaSource` readyState.
+     */
+    onMediaSourceReadyStateChanged?: (readyState: ReadyState) => void;
+}
+/** Events that should be sent by an `IMediaSourceInterface`. */
+export interface IMediaSourceInterfaceEvents {
+    /**
+     * Indicate that the `IMediaSourceInterface`'s `readyState` property just
+     * changed to `"open"`.
+     */
+    mediaSourceOpen: null;
+    /**
+     * Indicate that the `IMediaSourceInterface`'s `readyState` property just
+     * changed to `"ended"`.
+     */
+    mediaSourceEnded: null;
+    /**
+     * Indicate that the `IMediaSourceInterface`'s `readyState` property just
+     * changed to `"close"`.
+     */
+    mediaSourceClose: null;
+    /**
+     * Indicate that the `IMediaSourceInterface`'s `streaming` property just
+     * changed.
+     */
+    streamingChanged: null;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/es2017/mse/types.d.ts.map

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

package/dist/es2017/mse/types.js

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

package/dist/es2017/mse/utils/end_of_stream.d.ts

@@ -0,0 +1,35 @@
+/**
+ * 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 { IMediaSource } from "../../compat/browser_compatibility_types";
+import type { CancellationSignal } from "../../utils/task_canceller";
+/**
+ * Trigger the `endOfStream` method of a MediaSource.
+ *
+ * If the MediaSource is ended/closed, do not call this method.
+ * If SourceBuffers are updating, wait for them to be updated before closing
+ * it.
+ * @param {MediaSource} mediaSource
+ * @param {Object} cancelSignal
+ */
+export default function triggerEndOfStream(mediaSource: IMediaSource, cancelSignal: CancellationSignal): void;
+/**
+ * Trigger the `endOfStream` method of a MediaSource each times it opens.
+ * @see triggerEndOfStream
+ * @param {MediaSource} mediaSource
+ * @param {Object} cancelSignal
+ */
+export declare function maintainEndOfStream(mediaSource: IMediaSource, cancelSignal: CancellationSignal): void;
+//# sourceMappingURL=end_of_stream.d.ts.map

package/dist/es2017/mse/utils/end_of_stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"end_of_stream.d.ts","sourceRoot":"","sources":["../../../../src/mse/utils/end_of_stream.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EACV,YAAY,EAGb,MAAM,0CAA0C,CAAC;AAOlD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAmBrE;;;;;;;;GAQG;AACH,MAAM,CAAC,OAAO,UAAU,kBAAkB,CACxC,WAAW,EAAE,YAAY,EACzB,YAAY,EAAE,kBAAkB,GAC/B,IAAI,CA+CN;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,WAAW,EAAE,YAAY,EACzB,YAAY,EAAE,kBAAkB,GAC/B,IAAI,CAeN"}

package/dist/es2017/mse/utils/end_of_stream.js

@@ -0,0 +1,92 @@
+/**
+ * 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 { onRemoveSourceBuffers, onSourceOpen, onSourceBufferUpdate, } from "../../compat/event_listeners";
+import log from "../../log";
+import TaskCanceller from "../../utils/task_canceller";
+/**
+ * Get "updating" SourceBuffers from a SourceBufferList.
+ * @param {SourceBufferList} sourceBuffers
+ * @returns {Array.<SourceBuffer>}
+ */
+function getUpdatingSourceBuffers(sourceBuffers) {
+    const updatingSourceBuffers = [];
+    for (let i = 0; i < sourceBuffers.length; i++) {
+        const SourceBuffer = sourceBuffers[i];
+        if (SourceBuffer.updating) {
+            updatingSourceBuffers.push(SourceBuffer);
+        }
+    }
+    return updatingSourceBuffers;
+}
+/**
+ * Trigger the `endOfStream` method of a MediaSource.
+ *
+ * If the MediaSource is ended/closed, do not call this method.
+ * If SourceBuffers are updating, wait for them to be updated before closing
+ * it.
+ * @param {MediaSource} mediaSource
+ * @param {Object} cancelSignal
+ */
+export default function triggerEndOfStream(mediaSource, cancelSignal) {
+    log.debug("mse", "Trying to call endOfStream");
+    if (mediaSource.readyState !== "open") {
+        log.debug("mse", "MediaSource not open, cancel endOfStream");
+        return;
+    }
+    const { sourceBuffers } = mediaSource;
+    const updatingSourceBuffers = getUpdatingSourceBuffers(sourceBuffers);
+    if (updatingSourceBuffers.length === 0) {
+        log.info("mse", "Triggering end of stream");
+        try {
+            mediaSource.endOfStream();
+        }
+        catch (err) {
+            log.error("mse", "Unable to call endOfStream", err instanceof Error ? err : new Error("Unknown error"));
+        }
+        return;
+    }
+    log.debug("mse", "Waiting SourceBuffers to be updated before calling endOfStream.");
+    const innerCanceller = new TaskCanceller("EndOfStream current iteration");
+    innerCanceller.linkToSignal(cancelSignal);
+    for (const sourceBuffer of updatingSourceBuffers) {
+        onSourceBufferUpdate(sourceBuffer, () => {
+            innerCanceller.cancel("SourceBuffer update");
+            triggerEndOfStream(mediaSource, cancelSignal);
+        }, innerCanceller.signal);
+    }
+    onRemoveSourceBuffers(sourceBuffers, () => {
+        innerCanceller.cancel("SourceBuffer remove");
+        triggerEndOfStream(mediaSource, cancelSignal);
+    }, innerCanceller.signal);
+}
+/**
+ * Trigger the `endOfStream` method of a MediaSource each times it opens.
+ * @see triggerEndOfStream
+ * @param {MediaSource} mediaSource
+ * @param {Object} cancelSignal
+ */
+export function maintainEndOfStream(mediaSource, cancelSignal) {
+    let endOfStreamCanceller = new TaskCanceller("EndOfStream");
+    endOfStreamCanceller.linkToSignal(cancelSignal);
+    onSourceOpen(mediaSource, () => {
+        log.debug("mse", "MediaSource re-opened while end-of-stream is active");
+        endOfStreamCanceller.cancel("MediaSource re-opened");
+        endOfStreamCanceller = new TaskCanceller("EndOfStream");
+        endOfStreamCanceller.linkToSignal(cancelSignal);
+        triggerEndOfStream(mediaSource, endOfStreamCanceller.signal);
+    }, cancelSignal);
+    triggerEndOfStream(mediaSource, endOfStreamCanceller.signal);
+}

package/dist/es2017/mse/utils/media_source_duration_updater.d.ts

@@ -0,0 +1,63 @@
+/**
+ * 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 { IMediaSource } from "../../compat/browser_compatibility_types";
+/**
+ * Keep the MediaSource's `duration` attribute up-to-date with the duration of
+ * the content played on it.
+ * @class MediaSourceDurationUpdater
+ */
+export default class MediaSourceDurationUpdater {
+    /**
+     * `MediaSource` on which we're going to update the `duration` attribute.
+     */
+    private _mediaSource;
+    /**
+     * Abort the current duration-setting logic.
+     * `null` if no such logic is pending.
+     */
+    private _currentMediaSourceDurationUpdateCanceller;
+    /**
+     * Create a new `MediaSourceDurationUpdater`,
+     * @param {MediaSource} mediaSource - The MediaSource on which the content is
+     * played.
+     */
+    constructor(mediaSource: IMediaSource);
+    /**
+     * Indicate to the `MediaSourceDurationUpdater` the currently known duration
+     * of the content.
+     *
+     * The `MediaSourceDurationUpdater` will then use that value to determine
+     * which `duration` attribute should be set on the `MediaSource` associated
+     *
+     * @param {number} newDuration
+     * @param {boolean} isRealEndKnown - If set to `false`, the current content is
+     * a dynamic content (it might evolve in the future) and the `newDuration`
+     * communicated might be greater still. In effect the
+     * `MediaSourceDurationUpdater` will actually set a much higher value to the
+     * `MediaSource`'s duration to prevent being annoyed by the HTML-related
+     * side-effects of having a too low duration (such as the impossibility to
+     * seek over that value).
+     */
+    updateDuration(newDuration: number, isRealEndKnown: boolean): void;
+    /**
+     * Abort the last duration-setting operation and free its resources.
+     * @param {string | undefined} reason - Human-inspectable reason behind the
+     * stop. Used for debugging matters, especially for debug log
+     * inspection.
+     */
+    stopUpdating(reason: string | undefined): void;
+}
+//# sourceMappingURL=media_source_duration_updater.d.ts.map

package/dist/es2017/mse/utils/media_source_duration_updater.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"media_source_duration_updater.d.ts","sourceRoot":"","sources":["../../../../src/mse/utils/media_source_duration_updater.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EACV,YAAY,EAEb,MAAM,0CAA0C,CAAC;AAYlD;;;;GAIG;AACH,MAAM,CAAC,OAAO,OAAO,0BAA0B;IAC7C;;OAEG;IACH,OAAO,CAAC,YAAY,CAAe;IAEnC;;;OAGG;IACH,OAAO,CAAC,0CAA0C,CAAuB;IAEzE;;;;OAIG;gBACS,WAAW,EAAE,YAAY;IAKrC;;;;;;;;;;;;;;;OAeG;IACI,cAAc,CAAC,WAAW,EAAE,MAAM,EAAE,cAAc,EAAE,OAAO,GAAG,IAAI;IA+DzE;;;;;OAKG;IACI,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS;CAM/C"}