rx-player 4.0.0 → 4.1.0-dev.2024031100

package/dist/commonjs/main_thread/decrypt/utils/server_certificate_store.js

@@ -0,0 +1,123 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+var hash_buffer_1 = require("../../../utils/hash_buffer");
+/**
+ * Keep track of server certificate which have been set for a MediaKeys.
+ * As it is impossible for a MediaKeys to have his server certificate reset
+ * or updated, we consider that once it has been set, it will remain set until
+ * the MediaKeys instance is killed.
+ *
+ * So, a WeakMap helps keeping a trace of which server certificate (identified
+ * with a unique hash) is set on a MediaKeys.
+ * `null` indicate that we don't know (and not `undefined`, because this is the
+ * default value for when a WeakMap has no value for a key) which server
+ * certificate is attached to a MediaKeys instance (most likely because related
+ * EME APIs failed or had an unexpected behavior).
+ */
+var serverCertificateHashesMap = new WeakMap();
+/** ServerCertificateStore */
+exports.default = {
+    /**
+     * Tells the ServerCertificateStore that you begin to call the APIs to set a
+     * ServerCertificate on `mediaKeys`.
+     *
+     * Calling this function is necessary due to how server certificate work
+     * currently in EME APIs:
+     * Because right now, it is impossible to tell if a MediaKeys instance has an
+     * attached ServerCertificate or not when the corresponding API fails or if it
+     * never answers, we prefer to announce through this function that the current
+     * server certificate attached to this MediaKeys is for now invalid.
+     * @param {MediaKeys | Object} mediaKeys
+     */
+    prepare: function (mediaKeys) {
+        serverCertificateHashesMap.set(mediaKeys, null);
+    },
+    /**
+     * Attach a new server certificate to a MediaKeys in the
+     * ServerCertificateStore.
+     *
+     * Only one server certificate should ever be attached to a MediaKeys
+     * instance and the `prepare` function should have been called before any
+     * action to update the server certificate took place (this function does not
+     * enforce either of those behaviors).
+     * @param {MediaKeys | Object} mediaKeys
+     * @param {ArrayBufferView | BufferSource} serverCertificate
+     */
+    set: function (mediaKeys, serverCertificate) {
+        var formattedServerCertificate = serverCertificate instanceof Uint8Array
+            ? serverCertificate
+            : new Uint8Array(serverCertificate instanceof ArrayBuffer
+                ? serverCertificate
+                : serverCertificate.buffer);
+        var hash = (0, hash_buffer_1.default)(formattedServerCertificate);
+        serverCertificateHashesMap.set(mediaKeys, {
+            hash: hash,
+            serverCertificate: formattedServerCertificate,
+        });
+    },
+    /**
+     * Returns `true` if the MediaKeys instance has an attached ServerCertificate.
+     * Returns `false` if it doesn't.
+     *
+     * Returns `undefined` if we cannot know, most likely because related EME APIs
+     * failed or had an unexpected behavior.
+     * @param {MediaKeys} mediaKeys
+     * @returns {Boolean|undefined}
+     */
+    hasOne: function (mediaKeys) {
+        var currentServerCertificate = serverCertificateHashesMap.get(mediaKeys);
+        if (currentServerCertificate === undefined) {
+            return false;
+        }
+        if (currentServerCertificate === null) {
+            return undefined;
+        }
+        return true;
+    },
+    /**
+     * Returns `true` if the given `mediaKeys` has `serverCertificate` attached to
+     * it.
+     * Returns `false` either if it doesn't of if we doesn't know if it does.
+     * @param {MediaKeys | Object} mediaKeys
+     * @param {ArrayBufferView | BufferSource} serverCertificate
+     * @returns {boolean}
+     */
+    has: function (mediaKeys, serverCertificate) {
+        var serverCertificateHash = serverCertificateHashesMap.get(mediaKeys);
+        if (serverCertificateHash === undefined || serverCertificateHash === null) {
+            return false;
+        }
+        var oldHash = serverCertificateHash.hash, oldServerCertificate = serverCertificateHash.serverCertificate;
+        var newServerCertificate = serverCertificate instanceof Uint8Array
+            ? serverCertificate
+            : new Uint8Array(serverCertificate instanceof ArrayBuffer
+                ? serverCertificate
+                : serverCertificate.buffer);
+        var newHash = (0, hash_buffer_1.default)(newServerCertificate);
+        if (newHash !== oldHash ||
+            oldServerCertificate.length !== newServerCertificate.length) {
+            return false;
+        }
+        for (var i = 0; i < oldServerCertificate.length; i++) {
+            if (oldServerCertificate[i] !== newServerCertificate[i]) {
+                return false;
+            }
+        }
+        return true;
+    },
+};

package/dist/commonjs/main_thread/init/directfile_content_initializer.d.ts

@@ -0,0 +1,97 @@
+/**
+ * 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 { IMediaElementPlaybackObserver } from "../../playback_observer";
+import type { IKeySystemOption } from "../../public_types";
+import type { IReadOnlySharedReference } from "../../utils/reference";
+import { ContentInitializer } from "./types";
+import type { IInitialTimeOptions } from "./utils/get_initial_time";
+/**
+ * `ContentIntializer` which will load contents by putting their URL in the
+ * `src` attribute of the given HTMLMediaElement.
+ *
+ * Because such contents are mainly loaded by the browser, those (called
+ * "directfile" contents in the RxPlayer) needs a simpler logic in-JS when
+ * compared to a content that relies on the MSE API.
+ *
+ * @class DirectFileContentInitializer
+ */
+export default class DirectFileContentInitializer extends ContentInitializer {
+    /**
+     * Initial options given to the `DirectFileContentInitializer`.
+     */
+    private _settings;
+    /**
+     * Allows to abort and clean everything the `DirectFileContentInitializer` is
+     * doing.
+     */
+    private _initCanceller;
+    /**
+     * Creates a new `DirectFileContentInitializer` linked to the given settings.
+     * @param {Object} settings
+     */
+    constructor(settings: IDirectFileOptions);
+    /**
+     * "Prepare" content so it can later be played by calling `start`.
+     */
+    prepare(): void;
+    /**
+     * Start playback of the content linked to this `DirectFileContentInitializer`
+     * on the given `HTMLMediaElement` and its associated `PlaybackObserver`.
+     * @param {HTMLMediaElement} mediaElement - HTMLMediaElement on which the
+     * content will be played.
+     * @param {Object} playbackObserver - Object regularly emitting playback
+     * information.
+     */
+    start(mediaElement: HTMLMediaElement, playbackObserver: IMediaElementPlaybackObserver): void;
+    /**
+     * Update URL this `ContentIntializer` depends on.
+     * @param {Array.<string>|undefined} _urls
+     * @param {boolean} _refreshNow
+     */
+    updateContentUrls(_urls: string[] | undefined, _refreshNow: boolean): void;
+    /**
+     * Stop content and free all resources linked to this `ContentIntializer`.
+     */
+    dispose(): void;
+    /**
+     * Logic performed when a fatal error was triggered.
+     * @param {*} err - The fatal error in question.
+     */
+    private _onFatalError;
+    /**
+     * Perform the initial seek (to begin playback at an initially-calculated
+     * position based on settings) and auto-play if needed when loaded.
+     * @param {HTMLMediaElement} mediaElement
+     * @param {Object} playbackObserver
+     */
+    private _seekAndPlay;
+}
+/** Options used by the `DirectFileContentInitializer` */
+export interface IDirectFileOptions {
+    /** If `true` we will play right after the content is considered "loaded". */
+    autoPlay: boolean;
+    /**
+     * Encryption-related settings. Can be left as an empty array if the content
+     * isn't encrypted.
+     */
+    keySystems: IKeySystemOption[];
+    /** Communicate the playback rate wanted by the user. */
+    speed: IReadOnlySharedReference<number>;
+    /** Optional initial position to start at. */
+    startAt?: IInitialTimeOptions | undefined;
+    /** URL that should be played. */
+    url: string;
+}

package/dist/commonjs/main_thread/init/directfile_content_initializer.js

@@ -0,0 +1,264 @@
+"use strict";
+/**
+ * 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.
+ */
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * /!\ This file is feature-switchable.
+ * It always should be imported through the `features` object.
+ */
+var clear_element_src_1 = require("../../compat/clear_element_src");
+var log_1 = require("../../log");
+var assert_1 = require("../../utils/assert");
+var is_null_or_undefined_1 = require("../../utils/is_null_or_undefined");
+var noop_1 = require("../../utils/noop");
+var reference_1 = require("../../utils/reference");
+var task_canceller_1 = require("../../utils/task_canceller");
+var types_1 = require("./types");
+var get_loaded_reference_1 = require("./utils/get_loaded_reference");
+var initial_seek_and_play_1 = require("./utils/initial_seek_and_play");
+var initialize_content_decryption_1 = require("./utils/initialize_content_decryption");
+var rebuffering_controller_1 = require("./utils/rebuffering_controller");
+var throw_on_media_error_1 = require("./utils/throw_on_media_error");
+/**
+ * `ContentIntializer` which will load contents by putting their URL in the
+ * `src` attribute of the given HTMLMediaElement.
+ *
+ * Because such contents are mainly loaded by the browser, those (called
+ * "directfile" contents in the RxPlayer) needs a simpler logic in-JS when
+ * compared to a content that relies on the MSE API.
+ *
+ * @class DirectFileContentInitializer
+ */
+var DirectFileContentInitializer = /** @class */ (function (_super) {
+    __extends(DirectFileContentInitializer, _super);
+    /**
+     * Creates a new `DirectFileContentInitializer` linked to the given settings.
+     * @param {Object} settings
+     */
+    function DirectFileContentInitializer(settings) {
+        var _this = _super.call(this) || this;
+        _this._settings = settings;
+        _this._initCanceller = new task_canceller_1.default();
+        return _this;
+    }
+    /**
+     * "Prepare" content so it can later be played by calling `start`.
+     */
+    DirectFileContentInitializer.prototype.prepare = function () {
+        return; // Directfile contents do not have any preparation
+    };
+    /**
+     * Start playback of the content linked to this `DirectFileContentInitializer`
+     * on the given `HTMLMediaElement` and its associated `PlaybackObserver`.
+     * @param {HTMLMediaElement} mediaElement - HTMLMediaElement on which the
+     * content will be played.
+     * @param {Object} playbackObserver - Object regularly emitting playback
+     * information.
+     */
+    DirectFileContentInitializer.prototype.start = function (mediaElement, playbackObserver) {
+        var _this = this;
+        var cancelSignal = this._initCanceller.signal;
+        var _a = this._settings, keySystems = _a.keySystems, speed = _a.speed, url = _a.url;
+        (0, clear_element_src_1.default)(mediaElement);
+        /**
+         * Create dummy encryption data emitter, as those are not sent from the
+         * RxPlayer for directfile contents.
+         */
+        var decryptionRef = new reference_1.default(null);
+        decryptionRef.finish();
+        var drmInitRef = (0, initialize_content_decryption_1.default)(mediaElement, keySystems, decryptionRef, {
+            onError: function (err) { return _this._onFatalError(err); },
+            onWarning: function (err) { return _this.trigger("warning", err); },
+            onBlackListProtectionData: noop_1.default,
+            onKeyIdsCompatibilityUpdate: noop_1.default,
+        }, cancelSignal);
+        /** Translate errors coming from the media element into RxPlayer errors. */
+        (0, throw_on_media_error_1.default)(mediaElement, function (error) { return _this._onFatalError(error); }, cancelSignal);
+        /**
+         * Class trying to avoid various stalling situations, emitting "stalled"
+         * events when it cannot, as well as "unstalled" events when it get out of one.
+         */
+        var rebufferingController = new rebuffering_controller_1.default(playbackObserver, null, speed);
+        rebufferingController.addEventListener("stalled", function (evt) {
+            return _this.trigger("stalled", evt);
+        });
+        rebufferingController.addEventListener("unstalled", function () {
+            return _this.trigger("unstalled", null);
+        });
+        rebufferingController.addEventListener("warning", function (err) {
+            return _this.trigger("warning", err);
+        });
+        cancelSignal.register(function () {
+            rebufferingController.destroy();
+        });
+        rebufferingController.start();
+        drmInitRef.onUpdate(function (evt, stopListeningToDrmUpdates) {
+            if (evt.initializationState.type === "uninitialized") {
+                return; // nothing done yet
+            }
+            stopListeningToDrmUpdates();
+            // Start everything! (Just put the URL in the element's src).
+            log_1.default.info("Setting URL to HTMLMediaElement", url);
+            mediaElement.src = url;
+            cancelSignal.register(function () {
+                log_1.default.info("Init: Removing directfile src from media element", mediaElement.src);
+                (0, clear_element_src_1.default)(mediaElement);
+            });
+            if (evt.initializationState.type === "awaiting-media-link") {
+                evt.initializationState.value.isMediaLinked.setValue(true);
+                drmInitRef.onUpdate(function (newDrmStatus, stopListeningToDrmUpdatesAgain) {
+                    if (newDrmStatus.initializationState.type === "initialized") {
+                        stopListeningToDrmUpdatesAgain();
+                        _this._seekAndPlay(mediaElement, playbackObserver);
+                    }
+                }, { emitCurrentValue: true, clearSignal: cancelSignal });
+            }
+            else {
+                (0, assert_1.default)(evt.initializationState.type === "initialized");
+                _this._seekAndPlay(mediaElement, playbackObserver);
+            }
+        }, { emitCurrentValue: true, clearSignal: cancelSignal });
+    };
+    /**
+     * Update URL this `ContentIntializer` depends on.
+     * @param {Array.<string>|undefined} _urls
+     * @param {boolean} _refreshNow
+     */
+    DirectFileContentInitializer.prototype.updateContentUrls = function (_urls, _refreshNow) {
+        throw new Error("Cannot update content URL of directfile contents");
+    };
+    /**
+     * Stop content and free all resources linked to this `ContentIntializer`.
+     */
+    DirectFileContentInitializer.prototype.dispose = function () {
+        this._initCanceller.cancel();
+    };
+    /**
+     * Logic performed when a fatal error was triggered.
+     * @param {*} err - The fatal error in question.
+     */
+    DirectFileContentInitializer.prototype._onFatalError = function (err) {
+        this._initCanceller.cancel();
+        this.trigger("error", err);
+    };
+    /**
+     * Perform the initial seek (to begin playback at an initially-calculated
+     * position based on settings) and auto-play if needed when loaded.
+     * @param {HTMLMediaElement} mediaElement
+     * @param {Object} playbackObserver
+     */
+    DirectFileContentInitializer.prototype._seekAndPlay = function (mediaElement, playbackObserver) {
+        var _this = this;
+        var cancelSignal = this._initCanceller.signal;
+        var _a = this._settings, autoPlay = _a.autoPlay, startAt = _a.startAt;
+        var initialTime = function () {
+            log_1.default.debug("Init: Calculating initial time");
+            var initTime = getDirectFileInitialTime(mediaElement, startAt);
+            log_1.default.debug("Init: Initial time calculated:", initTime);
+            return initTime;
+        };
+        (0, initial_seek_and_play_1.default)({
+            mediaElement: mediaElement,
+            playbackObserver: playbackObserver,
+            startTime: initialTime,
+            mustAutoPlay: autoPlay,
+            onWarning: function (err) { return _this.trigger("warning", err); },
+            isDirectfile: true,
+        }, cancelSignal)
+            .autoPlayResult.then(function () {
+            return (0, get_loaded_reference_1.default)(playbackObserver, mediaElement, true, cancelSignal).onUpdate(function (isLoaded, stopListening) {
+                if (isLoaded) {
+                    stopListening();
+                    _this.trigger("loaded", { segmentSinksStore: null });
+                }
+            }, { emitCurrentValue: true, clearSignal: cancelSignal });
+        })
+            .catch(function (err) {
+            if (!cancelSignal.isCancelled()) {
+                _this._onFatalError(err);
+            }
+        });
+    };
+    return DirectFileContentInitializer;
+}(types_1.ContentInitializer));
+exports.default = DirectFileContentInitializer;
+/**
+ * calculate initial time as a position in seconds.
+ * @param {HTMLMediaElement} mediaElement
+ * @param {Object|undefined} [startAt]
+ * @returns {number}
+ */
+function getDirectFileInitialTime(mediaElement, startAt) {
+    if ((0, is_null_or_undefined_1.default)(startAt)) {
+        return 0;
+    }
+    if (!(0, is_null_or_undefined_1.default)(startAt.position)) {
+        return startAt.position;
+    }
+    else if (!(0, is_null_or_undefined_1.default)(startAt.wallClockTime)) {
+        return startAt.wallClockTime;
+    }
+    else if (!(0, is_null_or_undefined_1.default)(startAt.fromFirstPosition)) {
+        return startAt.fromFirstPosition;
+    }
+    var duration = mediaElement.duration;
+    if (typeof startAt.fromLastPosition === "number") {
+        if ((0, is_null_or_undefined_1.default)(duration) || !isFinite(duration)) {
+            log_1.default.warn("startAt.fromLastPosition set but no known duration, " + "beginning at 0.");
+            return 0;
+        }
+        return Math.max(0, duration + startAt.fromLastPosition);
+    }
+    else if (typeof startAt.fromLivePosition === "number") {
+        var livePosition = mediaElement.seekable.length > 0 ? mediaElement.seekable.end(0) : duration;
+        if ((0, is_null_or_undefined_1.default)(livePosition)) {
+            log_1.default.warn("startAt.fromLivePosition set but no known live position, " + "beginning at 0.");
+            return 0;
+        }
+        return Math.max(0, livePosition + startAt.fromLivePosition);
+    }
+    else if (!(0, is_null_or_undefined_1.default)(startAt.percentage)) {
+        if ((0, is_null_or_undefined_1.default)(duration) || !isFinite(duration)) {
+            log_1.default.warn("startAt.percentage set but no known duration, " + "beginning at 0.");
+            return 0;
+        }
+        var percentage = startAt.percentage;
+        if (percentage >= 100) {
+            return duration;
+        }
+        else if (percentage <= 0) {
+            return 0;
+        }
+        var ratio = +percentage / 100;
+        return duration * ratio;
+    }
+    return 0;
+}

package/dist/commonjs/main_thread/init/media_source_content_initializer.d.ts

@@ -0,0 +1,166 @@
+/**
+ * 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 { IAdaptiveRepresentationSelectorArguments } from "../../core/adaptive";
+import type { IManifestFetcherSettings } from "../../core/fetchers";
+import type { IMediaElementPlaybackObserver } from "../../playback_observer";
+import type { IKeySystemOption } from "../../public_types";
+import type { ITransportPipelines } from "../../transports";
+import type { IReadOnlySharedReference } from "../../utils/reference";
+import type { ITextDisplayerOptions } from "./types";
+import { ContentInitializer } from "./types";
+import type { IInitialTimeOptions } from "./utils/get_initial_time";
+/**
+ * Allows to load a new content thanks to the MediaSource Extensions (a.k.a. MSE)
+ * Web APIs.
+ *
+ * Through this `ContentInitializer`, a Manifest will be fetched (and depending
+ * on the situation, refreshed), a `MediaSource` instance will be linked to the
+ * wanted `HTMLMediaElement` and chunks of media data, called segments, will be
+ * pushed on buffers associated to this `MediaSource` instance.
+ *
+ * @class MediaSourceContentInitializer
+ */
+export default class MediaSourceContentInitializer extends ContentInitializer {
+    /** Constructor settings associated to this `MediaSourceContentInitializer`. */
+    private _settings;
+    /**
+     * `TaskCanceller` allowing to abort everything that the
+     * `MediaSourceContentInitializer` is doing.
+     */
+    private _initCanceller;
+    /** Interface allowing to fetch and refresh the Manifest. */
+    private _manifestFetcher;
+    /**
+     * Reference to the `Manifest` Object:
+     *   - as an asynchronous value if it is still in the process of being loaded.
+     *   - as an synchronous value if it has been loaded
+     *   - `null` if the load task has not started yet.
+     */
+    private _manifest;
+    /**
+     * Create a new `MediaSourceContentInitializer`, associated to the given
+     * settings.
+     * @param {Object} settings
+     */
+    constructor(settings: IInitializeArguments);
+    /**
+     * Perform non-destructive preparation steps, to prepare a future content.
+     * For now, this mainly mean loading the Manifest document.
+     */
+    prepare(): void;
+    /**
+     * @param {HTMLMediaElement} mediaElement
+     * @param {Object} playbackObserver
+     */
+    start(mediaElement: HTMLMediaElement, playbackObserver: IMediaElementPlaybackObserver): void;
+    /**
+     * Update URL of the Manifest.
+     * @param {Array.<string>|undefined} urls - URLs to reach that Manifest from
+     * the most prioritized URL to the least prioritized URL.
+     * @param {boolean} refreshNow - If `true` the resource in question (e.g.
+     * DASH's MPD) will be refreshed immediately.
+     */
+    updateContentUrls(urls: string[] | undefined, refreshNow: boolean): void;
+    dispose(): void;
+    private _onFatalError;
+    private _initializeMediaSourceAndDecryption;
+    private _onInitialMediaSourceReady;
+    /**
+     * Buffer the content on the given MediaSource.
+     * @param {Object} args
+     * @param {function} onReloadOrder
+     * @param {Object} cancelSignal
+     */
+    private _startBufferingOnMediaSource;
+    /**
+     * Creates a `RebufferingController`, a class trying to avoid various stalling
+     * situations (such as rebuffering periods), and returns it.
+     *
+     * Various methods from that class need then to be called at various events
+     * (see `RebufferingController` definition).
+     *
+     * This function also handles the `RebufferingController`'s events:
+     *   - emit "stalled" events when stalling situations cannot be prevented,
+     *   - emit "unstalled" events when we could get out of one,
+     *   - emit "warning" on various rebuffering-related minor issues
+     *     like discontinuity skipping.
+     * @param {Object} playbackObserver
+     * @param {Object} manifest
+     * @param {Object} speed
+     * @param {Object} cancelSignal
+     * @returns {Object}
+     */
+    private _createRebufferingController;
+}
+/** Arguments to give to the `InitializeOnMediaSource` function. */
+export interface IInitializeArguments {
+    /** Options concerning the ABR logic. */
+    adaptiveOptions: IAdaptiveRepresentationSelectorArguments;
+    /** `true` if we should play when loaded. */
+    autoPlay: boolean;
+    /** Options concerning the media buffers. */
+    bufferOptions: {
+        /** Buffer "goal" at which we stop downloading new segments. */
+        wantedBufferAhead: IReadOnlySharedReference<number>;
+        /** Buffer maximum size in kiloBytes at which we stop downloading */
+        maxVideoBufferSize: IReadOnlySharedReference<number>;
+        /** Max buffer size after the current position, in seconds (we GC further up). */
+        maxBufferAhead: IReadOnlySharedReference<number>;
+        /** Max buffer size before the current position, in seconds (we GC further down). */
+        maxBufferBehind: IReadOnlySharedReference<number>;
+        /**
+         * Enable/Disable fastSwitching: allow to replace lower-quality segments by
+         * higher-quality ones to have a faster transition.
+         */
+        enableFastSwitching: boolean;
+        /** Behavior when a new video and/or audio codec is encountered. */
+        onCodecSwitch: "continue" | "reload";
+    };
+    /** Every encryption configuration set. */
+    keySystems: IKeySystemOption[];
+    /** `true` to play low-latency contents optimally. */
+    lowLatencyMode: boolean;
+    /** Settings linked to Manifest requests. */
+    manifestRequestSettings: IManifestFetcherSettings;
+    /** Logic linked Manifest and segment loading and parsing. */
+    transport: ITransportPipelines;
+    /** Configuration for the segment requesting logic. */
+    segmentRequestOptions: {
+        lowLatencyMode: boolean;
+        /**
+         * Amount of time after which a request should be aborted.
+         * `undefined` indicates that a default value is wanted.
+         * `-1` indicates no timeout.
+         */
+        requestTimeout: number | undefined;
+        /**
+         * Amount of time, in milliseconds, after which a request that hasn't receive
+         * the headers and status code should be aborted and optionnaly retried,
+         * depending on the maxRetry configuration.
+         */
+        connectionTimeout: number | undefined;
+        /** Maximum number of time a request on error will be retried. */
+        maxRetry: number | undefined;
+    };
+    /** Emit the playback rate (speed) set by the user. */
+    speed: IReadOnlySharedReference<number>;
+    /** The configured starting position. */
+    startAt?: IInitialTimeOptions | undefined;
+    /** Configuration specific to the text track. */
+    textTrackOptions: ITextDisplayerOptions;
+    /** URL of the Manifest. `undefined` if unknown or not pertinent. */
+    url: string | undefined;
+}