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

package/dist/es2017/core/entry/content_preparer.d.ts

@@ -0,0 +1,194 @@
+import type { IContentInitializationData } from "../../main_thread/types";
+import type { IManifest } from "../../manifest";
+import type { IMediaSourceInterface } from "../../mse";
+import type { IRepresentationFilter, ISegmentLoader, IManifestLoader } from "../../public_types";
+import type { IRepresentationEstimator } from "../adaptive";
+import type { IRepresentationEstimatorThrottlers } from "../adaptive/adaptive_representation_selector";
+import CmcdDataBuilder from "../cmcd";
+import type { IManifestRefreshSettings } from "../fetchers";
+import { ManifestFetcher, SegmentQueueCreator } from "../fetchers";
+import type { IThumbnailFetcher } from "../fetchers/thumbnails/thumbnail_fetcher";
+import SegmentSinksStore from "../segment_sinks";
+import type { ICoreMessage } from "../types";
+import CoreTextDisplayerInterface from "./core_text_displayer_interface";
+import FreezeResolver from "./FreezeResolver";
+import TrackChoiceSetter from "./track_choice_setter";
+/**
+ * Class facilitating the workflows behind loading a new content for the
+ * RxPlayer Core:
+ *
+ *   - Handle Manifest fetching and Manifest updates.
+ *
+ *   - Handle the `MediaSource`'s creation and indirectly of its `SourceBuffer`s
+ *     as well as handling "MediaSource reloading".
+ *
+ *   - initialize various modules (`segmentQueueCreator`, CmcdDataBuilder`,
+ *     `RepresentationEstimator`) linked to the initialized content.
+ *
+ * You can start loading a content through the `initializeNewContent` method.
+ *
+ * When a content is linked to the `ContentPreparer` you can inspect the
+ * different initialized modules by calling its `getCurrentContent` method.
+ *
+ * @class ContentPreparer
+ */
+export default class ContentPreparer {
+    /**
+     * Information on the content linked to that `ContentPreparer` through its
+     * `initializeNewContent` method.
+     * `null` if no content is initialized.
+     */
+    private _currentContent;
+    /**
+     * TaskCanceller which is triggered when the currently-initialized content is
+     * not needed anymore, because we stopped it since or switched to a new content.
+     */
+    private _contentCanceller;
+    /**
+     * TaskCanceller which is triggered when the currently-created MediaSource is
+     * not needed anymore, either because the content has changed or because we
+     * had to reload.
+     */
+    private _currentMediaSourceCanceller;
+    /** @see constructor */
+    private _hasVideo;
+    /**
+     * @param {Object} capabilities
+     * @param {boolean} capabilities.hasVideo - If `true`, we're playing on an
+     * element which has video capabilities.
+     * If `false`, we're only able to play audio, optionally with subtitles.
+     *
+     * Typically this boolean is `true` for `<video>` HTMLElement and `false` for
+     * `<audio>` HTMLElement.
+     */
+    constructor({ hasVideo }: {
+        hasVideo: boolean;
+    });
+    /**
+     * Start fetching the wanted content's Manifest and initializing the various
+     * modules stored by the `ContentPreparer` linked to that content.
+     *
+     * The returned Promise resolves with the parsed Manifest when those modules
+     * are all ready and you can thus begin to load the content.
+     *
+     * Reject if it failed to do so.
+     * @param {Object} context - Information on the content that should be
+     * initialized.
+     * @param {Object} corePlugins - Callbacks that may have been registered by
+     * the application if it loaded the core independently as a worker.
+     * @returns {Promise.<Object>}
+     */
+    initializeNewContent(sendMessage: (msg: ICoreMessage, transferables?: Transferable[]) => void, context: IContentInitializationData, 
+    /** Allows to filter which Representations can be choosen. */
+    throttlers: IRepresentationEstimatorThrottlers, corePlugins: ICorePlugins): Promise<IManifest>;
+    /**
+     * Get information on the current content prepared through the
+     * `initializeNewContent` method, or `null` if no content is currently
+     * prepared.
+     * @returns {Object|null}
+     */
+    getCurrentContent(): IPreparedContentData | null;
+    /**
+     * Schedule an update for the Manifest file,
+     *
+     * Do nothing if no content is currently prepared.
+     * @param {Object} settings - Various settings to configure the ways and
+     * moment at which the Manifest will be refreshed.
+     */
+    scheduleManifestRefresh(settings: IManifestRefreshSettings): void;
+    /**
+     * Change the MediaSource attached for the current content.
+     * It is assumed that main thread is already notified that such a reload is
+     * happening.
+     *
+     * The returned Promise resolves when it restarts being ready.
+     * @param {Function} sendMessage
+     * @returns {Promise}
+     */
+    reloadMediaSource(sendMessage: (msg: ICoreMessage, transferables?: Transferable[]) => void): Promise<void>;
+    /**
+     * Dispose all resources linked to the currently preopared content if one and
+     * stop linking it to this `ContentPreparer`.
+     * @param {string | undefined} reason - Human-inspectable reason behind the
+     * dispose. Used for debugging matters, especially for debug log
+     * inspection.
+     */
+    disposeCurrentContent(reason: string | undefined): void;
+}
+/**
+ * Modules and Metadata associated to the current "prepared" content.
+ */
+export interface IPreparedContentData {
+    /**
+     * Identifier uniquely identifying a specific content.
+     *
+     * Protects against all kind of race conditions or asynchronous issues.
+     */
+    contentId: string;
+    /**
+     * Perform data collection and retrieval for the "Common Media Client Data"
+     * scheme, which is a specification allowing to communicate about playback
+     * conditions with a CDN.
+     */
+    cmcdDataBuilder: CmcdDataBuilder | null;
+    /**
+     * If `true`, the RxPlayer can enable its "Representation avoidance"
+     * mechanism, where it avoid loading Representation that it suspect
+     * have issues being decoded on the current device.
+     */
+    enableRepresentationAvoidance: boolean;
+    /**
+     * Interface to the MediaSource implementation, allowing to buffer audio
+     * and video media segments.
+     */
+    mediaSource: IMediaSourceInterface;
+    /** Class abstracting Manifest fetching and refreshing. */
+    manifestFetcher: ManifestFetcher;
+    /**
+     * Manifest instance.
+     *
+     * `null` when not fetched yet.
+     */
+    manifest: IManifest | null;
+    /**
+     * Specific module detecting freezing issues and trying to work-around
+     * them.
+     */
+    freezeResolver: FreezeResolver;
+    /**
+     * Perform the adaptive logic, allowing to choose the best Representation for
+     * the different types of media to load.
+     */
+    representationEstimator: IRepresentationEstimator;
+    /**
+     * Allows to create a "SegmentSink" (powerful abstraction over media
+     * buffering API) for each type of media.
+     */
+    segmentSinksStore: SegmentSinksStore;
+    /** Allows to send timed text media data so it can be rendered. */
+    coreTextSender: CoreTextDisplayerInterface | null;
+    /**
+     * Allows to create `SegmentQueue` which simplifies complex media segment
+     * fetching.
+     */
+    segmentQueueCreator: SegmentQueueCreator;
+    /** Allows to load image thumbnails. */
+    fetchThumbnailData: IThumbnailFetcher;
+    /**
+     * Allows to store and update the wanted tracks and Representation inside that
+     * track.
+     */
+    trackChoiceSetter: TrackChoiceSetter;
+    /**
+     * If `true`, MSE API should be used in the core part of the RxPlayer (in the
+     * WebWorker).
+     * If `false`, they should be relied on on main thread.
+     */
+    useMseInWorker: boolean;
+}
+export interface ICorePlugins {
+    representationFilters: Map<string, IRepresentationFilter>;
+    segmentLoaders: Map<string, ISegmentLoader>;
+    manifestLoaders: Map<string, IManifestLoader>;
+}
+//# sourceMappingURL=content_preparer.d.ts.map

package/dist/es2017/core/entry/content_preparer.d.ts.map

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

package/dist/es2017/core/entry/content_preparer.js

@@ -0,0 +1,375 @@
+import { MediaSource_ } from "../../compat/browser_compatibility_types";
+import features from "../../features";
+import log from "../../log";
+import { createRepresentationFilterFromFnString } from "../../manifest";
+import MainMediaSourceInterface from "../../mse/main_media_source_interface";
+import WorkerMediaSourceInterface from "../../mse/worker_media_source_interface";
+import idGenerator from "../../utils/id_generator";
+import isNullOrUndefined from "../../utils/is_null_or_undefined";
+import TaskCanceller from "../../utils/task_canceller";
+import createAdaptiveRepresentationSelector from "../adaptive";
+import CmcdDataBuilder from "../cmcd";
+import { ManifestFetcher, SegmentQueueCreator } from "../fetchers";
+import CdnPrioritizer from "../fetchers/cdn_prioritizer";
+import createThumbnailFetcher from "../fetchers/thumbnails/thumbnail_fetcher";
+import SegmentSinksStore from "../segment_sinks";
+import CoreTextDisplayerInterface from "./core_text_displayer_interface";
+import FreezeResolver from "./FreezeResolver";
+import TrackChoiceSetter from "./track_choice_setter";
+import { formatErrorForSender } from "./utils";
+/** Function allowing to associate a unique identifier to all created `MediaSource` */
+const generateMediaSourceId = idGenerator();
+/**
+ * Class facilitating the workflows behind loading a new content for the
+ * RxPlayer Core:
+ *
+ *   - Handle Manifest fetching and Manifest updates.
+ *
+ *   - Handle the `MediaSource`'s creation and indirectly of its `SourceBuffer`s
+ *     as well as handling "MediaSource reloading".
+ *
+ *   - initialize various modules (`segmentQueueCreator`, CmcdDataBuilder`,
+ *     `RepresentationEstimator`) linked to the initialized content.
+ *
+ * You can start loading a content through the `initializeNewContent` method.
+ *
+ * When a content is linked to the `ContentPreparer` you can inspect the
+ * different initialized modules by calling its `getCurrentContent` method.
+ *
+ * @class ContentPreparer
+ */
+export default class ContentPreparer {
+    /**
+     * @param {Object} capabilities
+     * @param {boolean} capabilities.hasVideo - If `true`, we're playing on an
+     * element which has video capabilities.
+     * If `false`, we're only able to play audio, optionally with subtitles.
+     *
+     * Typically this boolean is `true` for `<video>` HTMLElement and `false` for
+     * `<audio>` HTMLElement.
+     */
+    constructor({ hasVideo }) {
+        this._currentContent = null;
+        this._currentMediaSourceCanceller = new TaskCanceller("ContentPreparer MediaSource");
+        this._hasVideo = hasVideo;
+        const contentCanceller = new TaskCanceller("ContentPreparer");
+        this._contentCanceller = contentCanceller;
+    }
+    /**
+     * Start fetching the wanted content's Manifest and initializing the various
+     * modules stored by the `ContentPreparer` linked to that content.
+     *
+     * The returned Promise resolves with the parsed Manifest when those modules
+     * are all ready and you can thus begin to load the content.
+     *
+     * Reject if it failed to do so.
+     * @param {Object} context - Information on the content that should be
+     * initialized.
+     * @param {Object} corePlugins - Callbacks that may have been registered by
+     * the application if it loaded the core independently as a worker.
+     * @returns {Promise.<Object>}
+     */
+    initializeNewContent(sendMessage, context, 
+    /** Allows to filter which Representations can be choosen. */
+    throttlers, corePlugins) {
+        return new Promise((res, rej) => {
+            var _a, _b;
+            this.disposeCurrentContent("new init");
+            const contentCanceller = this._contentCanceller;
+            const currentMediaSourceCanceller = new TaskCanceller("ContentPreparer MediaSource");
+            this._currentMediaSourceCanceller = currentMediaSourceCanceller;
+            currentMediaSourceCanceller.linkToSignal(contentCanceller.signal);
+            const { contentId, url, hasText, transportOptions, useMseInWorker, enableRepresentationAvoidance, transport, } = context;
+            let manifest = null;
+            const transportFn = features.transports[transport];
+            if (typeof transportFn !== "function") {
+                rej(new Error(`transport "${transport}" not supported. ` +
+                    "Did you add the corresponding feature?"));
+                return;
+            }
+            const transportPipelines = transportFn(Object.assign(Object.assign({}, transportOptions), extractExternalPlugins(transportOptions, corePlugins)));
+            const cmcdDataBuilder = context.cmcd === undefined ? null : new CmcdDataBuilder(context.cmcd);
+            const manifestFetcher = new ManifestFetcher(url === undefined ? undefined : [url], transportPipelines, Object.assign({ cmcdDataBuilder }, context.manifestRetryOptions));
+            const representationEstimator = createAdaptiveRepresentationSelector({
+                initialBitrates: {
+                    audio: (_a = context.initialAudioBitrate) !== null && _a !== void 0 ? _a : 0,
+                    video: (_b = context.initialVideoBitrate) !== null && _b !== void 0 ? _b : 0,
+                },
+                lowLatencyMode: transportOptions.lowLatencyMode,
+                throttlers,
+            });
+            const unbindRejectOnCancellation = currentMediaSourceCanceller.signal.register((error) => {
+                rej(error);
+            });
+            const cdnPrioritizer = new CdnPrioritizer(contentCanceller.signal);
+            const segmentQueueCreator = new SegmentQueueCreator(transportPipelines, cdnPrioritizer, cmcdDataBuilder, context.segmentRetryOptions);
+            const fetchThumbnailData = createThumbnailFetcher(transportPipelines.thumbnails, cdnPrioritizer);
+            const trackChoiceSetter = new TrackChoiceSetter();
+            const [mediaSource, segmentSinksStore, coreTextSender] = createMediaSourceInterfaceAndSegmentSinksStore(sendMessage, contentId, {
+                useMseInWorker,
+                hasVideo: this._hasVideo,
+                hasText,
+            }, currentMediaSourceCanceller.signal);
+            const freezeResolver = new FreezeResolver(segmentSinksStore);
+            this._currentContent = {
+                cmcdDataBuilder,
+                contentId,
+                enableRepresentationAvoidance,
+                freezeResolver,
+                mediaSource,
+                manifest: null,
+                manifestFetcher,
+                representationEstimator,
+                segmentSinksStore,
+                segmentQueueCreator,
+                fetchThumbnailData,
+                coreTextSender,
+                trackChoiceSetter,
+                useMseInWorker,
+            };
+            mediaSource.addEventListener("mediaSourceOpen", function () {
+                checkIfReadyAndValidate();
+            }, currentMediaSourceCanceller.signal);
+            contentCanceller.signal.register((err) => {
+                manifestFetcher.dispose(err.reason);
+            });
+            manifestFetcher.addEventListener("warning", (err) => {
+                sendMessage({
+                    type: "warning" /* CoreMessageType.Warning */,
+                    contentId,
+                    value: formatErrorForSender(err),
+                });
+            }, contentCanceller.signal);
+            manifestFetcher.addEventListener("manifestReady", (man) => {
+                if (manifest !== null) {
+                    log.warn("Core", "Multiple `manifestReady` events, ignoring");
+                    return;
+                }
+                manifest = man;
+                if (this._currentContent !== null) {
+                    this._currentContent.manifest = manifest;
+                }
+                checkIfReadyAndValidate();
+            }, currentMediaSourceCanceller.signal);
+            manifestFetcher.addEventListener("error", (err) => {
+                sendMessage({
+                    type: "error" /* CoreMessageType.Error */,
+                    contentId,
+                    value: formatErrorForSender(err),
+                });
+                rej(err);
+            }, contentCanceller.signal);
+            manifestFetcher.start();
+            function checkIfReadyAndValidate() {
+                if (manifest === null ||
+                    mediaSource.readyState === "closed" ||
+                    currentMediaSourceCanceller.isUsed()) {
+                    return;
+                }
+                updateCodecSupportInWorkerMode(manifest);
+                manifest.addEventListener("manifestUpdate", (updates) => {
+                    if (manifest === null) {
+                        // TODO log warn?
+                        return;
+                    }
+                    sendMessage({
+                        type: "manifest-update" /* CoreMessageType.ManifestUpdate */,
+                        contentId,
+                        value: { manifest, updates },
+                    });
+                }, contentCanceller.signal);
+                unbindRejectOnCancellation();
+                res(manifest);
+            }
+        });
+    }
+    /**
+     * Get information on the current content prepared through the
+     * `initializeNewContent` method, or `null` if no content is currently
+     * prepared.
+     * @returns {Object|null}
+     */
+    getCurrentContent() {
+        return this._currentContent;
+    }
+    /**
+     * Schedule an update for the Manifest file,
+     *
+     * Do nothing if no content is currently prepared.
+     * @param {Object} settings - Various settings to configure the ways and
+     * moment at which the Manifest will be refreshed.
+     */
+    scheduleManifestRefresh(settings) {
+        var _a;
+        (_a = this._currentContent) === null || _a === void 0 ? void 0 : _a.manifestFetcher.scheduleManualRefresh(settings);
+    }
+    /**
+     * Change the MediaSource attached for the current content.
+     * It is assumed that main thread is already notified that such a reload is
+     * happening.
+     *
+     * The returned Promise resolves when it restarts being ready.
+     * @param {Function} sendMessage
+     * @returns {Promise}
+     */
+    reloadMediaSource(sendMessage) {
+        this._currentMediaSourceCanceller.cancel("ContentPreparer MediaSource reload");
+        if (this._currentContent === null) {
+            return Promise.reject(new Error("CP: No content anymore"));
+        }
+        this._currentContent.trackChoiceSetter.reset();
+        this._currentMediaSourceCanceller = new TaskCanceller("ContentPreparer MediaSource");
+        const [mediaSourceInterface, segmentSinksStore, coreTextSender] = createMediaSourceInterfaceAndSegmentSinksStore(sendMessage, this._currentContent.contentId, {
+            useMseInWorker: this._currentContent.useMseInWorker,
+            hasVideo: this._hasVideo,
+            hasText: this._currentContent.coreTextSender !== null,
+        }, this._currentMediaSourceCanceller.signal);
+        this._currentContent.mediaSource = mediaSourceInterface;
+        this._currentContent.segmentSinksStore = segmentSinksStore;
+        this._currentContent.freezeResolver = new FreezeResolver(segmentSinksStore);
+        this._currentContent.coreTextSender = coreTextSender;
+        return new Promise((res, rej) => {
+            mediaSourceInterface.addEventListener("mediaSourceOpen", function () {
+                res();
+            }, this._currentMediaSourceCanceller.signal);
+            mediaSourceInterface.addEventListener("mediaSourceClose", function () {
+                rej(new Error("MediaSource ReadyState changed to close during init."));
+            }, this._currentMediaSourceCanceller.signal);
+            this._currentMediaSourceCanceller.signal.register((error) => {
+                rej(error);
+            });
+        });
+    }
+    /**
+     * Dispose all resources linked to the currently preopared content if one and
+     * stop linking it to this `ContentPreparer`.
+     * @param {string | undefined} reason - Human-inspectable reason behind the
+     * dispose. Used for debugging matters, especially for debug log
+     * inspection.
+     */
+    disposeCurrentContent(reason) {
+        this._contentCanceller.cancel(reason);
+        this._contentCanceller = new TaskCanceller("ContentPreparer");
+    }
+}
+/**
+ * @param {Function} sendMessage
+ * @param {string} contentId
+ * @param {Object} capabilities
+ * @param {boolean} capabilities.useMseInWorker
+ * @param {boolean} capabilities.hasVideo
+ * @param {boolean} capabilities.hasText
+ * @param {Object} cancelSignal
+ * @returns {Array.<Object>}
+ */
+function createMediaSourceInterfaceAndSegmentSinksStore(sendMessage, contentId, capabilities, cancelSignal) {
+    let mediaSourceInterface;
+    if (capabilities.useMseInWorker) {
+        const mainMediaSource = new MainMediaSourceInterface(generateMediaSourceId());
+        mediaSourceInterface = mainMediaSource;
+        let sentMediaSourceLink;
+        const handle = mainMediaSource.handle;
+        if (handle.type === "handle") {
+            sentMediaSourceLink = { type: "handle", value: handle.value };
+        }
+        else {
+            const url = URL.createObjectURL(handle.value);
+            sentMediaSourceLink = { type: "url", value: url };
+            cancelSignal.register(() => {
+                URL.revokeObjectURL(url);
+            });
+        }
+        sendMessage({
+            type: "attach-media-source" /* CoreMessageType.AttachMediaSource */,
+            contentId,
+            value: sentMediaSourceLink,
+            mediaSourceId: mediaSourceInterface.id,
+        }, [handle.value]);
+    }
+    else {
+        mediaSourceInterface = new WorkerMediaSourceInterface(generateMediaSourceId(), contentId, sendMessage);
+    }
+    const textSender = capabilities.hasText
+        ? new CoreTextDisplayerInterface(contentId, sendMessage)
+        : null;
+    const { hasVideo } = capabilities;
+    const segmentSinksStore = new SegmentSinksStore(mediaSourceInterface, hasVideo, textSender);
+    cancelSignal.register((err) => {
+        segmentSinksStore.disposeAll(err.reason);
+        textSender === null || textSender === void 0 ? void 0 : textSender.stop(err.reason);
+        mediaSourceInterface.dispose(err.reason);
+    });
+    return [mediaSourceInterface, segmentSinksStore, textSender];
+}
+/**
+ * Set Representation.isCodecSupportedInWebWorker to true or false
+ * If the codec is supported in the current context.
+ * If MSE in worker is not available, the attribute is not set.
+ */
+function updateCodecSupportInWorkerMode(manifestToUpdate) {
+    var _a, _b;
+    if (isNullOrUndefined(MediaSource_)) {
+        return;
+    }
+    const codecsMap = new Map();
+    for (const period of manifestToUpdate.periods) {
+        const checkedAdaptations = [
+            ...((_a = period.adaptations.video) !== null && _a !== void 0 ? _a : []),
+            ...((_b = period.adaptations.audio) !== null && _b !== void 0 ? _b : []),
+        ];
+        for (const adaptation of checkedAdaptations) {
+            for (const representation of adaptation.representations) {
+                const codec = `${representation.mimeType};codecs="${representation.codecs[0]}"`;
+                if (codecsMap.has(codec)) {
+                    representation.isCodecSupportedInWebWorker = codecsMap.get(codec);
+                }
+                else {
+                    const supported = MediaSource_.isTypeSupported(codec);
+                    representation.isCodecSupportedInWebWorker = supported;
+                    codecsMap.set(codec, supported);
+                }
+            }
+        }
+    }
+}
+/**
+ * Some functions may be defined by the API, we call those "plugins".
+ * This function parses and extract the actual function from the different
+ * ways an application can provide it to us.
+ * @param {Object} input - The API input
+ * @param {Object} corePlugins - Context on what identified functions are
+ * defined right now.
+ * @returns {Function}
+ */
+function extractExternalPlugins(input, corePlugins) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    let manifestLoader;
+    let segmentLoader;
+    let representationFilter;
+    if (typeof ((_a = input.representationFilter) === null || _a === void 0 ? void 0 : _a.fn) === "function") {
+        representationFilter = input.representationFilter.fn;
+    }
+    else if (typeof ((_b = input.representationFilter) === null || _b === void 0 ? void 0 : _b.eval) === "string") {
+        representationFilter = createRepresentationFilterFromFnString(input.representationFilter.eval);
+    }
+    else if (typeof ((_c = input.representationFilter) === null || _c === void 0 ? void 0 : _c.workerId) === "string") {
+        representationFilter = corePlugins.representationFilters.get(input.representationFilter.workerId);
+    }
+    if (typeof ((_d = input.manifestLoader) === null || _d === void 0 ? void 0 : _d.fn) === "function") {
+        manifestLoader = input.manifestLoader.fn;
+    }
+    else if (typeof ((_e = input.manifestLoader) === null || _e === void 0 ? void 0 : _e.workerId) === "string") {
+        manifestLoader = corePlugins.manifestLoaders.get(input.manifestLoader.workerId);
+    }
+    if (typeof ((_f = input.segmentLoader) === null || _f === void 0 ? void 0 : _f.fn) === "function") {
+        segmentLoader = input.segmentLoader.fn;
+    }
+    else if (typeof ((_g = input.segmentLoader) === null || _g === void 0 ? void 0 : _g.workerId) === "string") {
+        segmentLoader = corePlugins.segmentLoaders.get(input.segmentLoader.workerId);
+    }
+    return {
+        manifestLoader,
+        segmentLoader,
+        representationFilter,
+    };
+}