rx-player 4.0.0-dev.2023102700 → 4.0.0-dev.2023110700

package/dist/es2017/core/init/utils/initialize_content_decryption.d.ts

@@ -0,0 +1,80 @@
+import { IKeySystemOption, IPlayerError } from "../../../public_types";
+import SharedReference, { IReadOnlySharedReference } from "../../../utils/reference";
+import { CancellationSignal } from "../../../utils/task_canceller";
+import { IContentProtection } from "../../decrypt";
+/**
+ * Initialize content decryption capabilities on the given `HTMLMediaElement`.
+ *
+ * You can call this function even if you don't want decrytpion capabilities, in
+ * which case you can just set the `keySystems` option as an empty array.
+ * In this situation, the returned object will directly correspond to an
+ * "`initialized`" state and the `onError` callback will be triggered as soon
+ * as protection information is received.
+ *
+ * @param {HTMLMediaElement} mediaElement - `HTMLMediaElement` on which content
+ * decryption may be wanted.
+ * @param {Array.<Object>} keySystems - Key system configuration(s) wanted
+ * Empty array if no content decryption capability is wanted.
+ * @param {Object} protectionRef - Reference through which content
+ * protection initialization data will be sent through.
+ * @param {Object} callbacks - Callbacks called at various decryption-related
+ * events.
+ * @param {Object} cancelSignal - When that signal emits, this function will
+ * stop listening to various events as well as items sent through the
+ * `protectionRef` parameter.
+ * @returns {Object} - Reference emitting the current status regarding DRM
+ * initialization.
+ */
+export default function initializeContentDecryption(mediaElement: HTMLMediaElement, keySystems: IKeySystemOption[], protectionRef: IReadOnlySharedReference<null | IContentProtection>, callbacks: {
+    onWarning: (err: IPlayerError) => void;
+    onError: (err: Error) => void;
+}, cancelSignal: CancellationSignal): IReadOnlySharedReference<IDrmInitializationStatus>;
+/** Status of content decryption initialization. */
+interface IDrmInitializationStatus {
+    /** Current initialization state the decryption logic is in. */
+    initializationState: IDecryptionInitializationState;
+    /**
+     * If set, corresponds to the hex string describing the current key system
+     * used.
+     * `undefined` if unknown or if it does not apply.
+     */
+    drmSystemId: string | undefined;
+}
+/** Initialization steps to add decryption capabilities to an `HTMLMediaElement`. */
+type IDecryptionInitializationState = 
+/**
+ * Decryption capabilities have not been initialized yet.
+ * You should wait before performing any action on the concerned
+ * `HTMLMediaElement` (such as linking a content / `MediaSource` to it).
+ */
+{
+    type: "uninitialized";
+    value: null;
+} | 
+/**
+ * The `MediaSource` or media url has to be linked to the `HTMLMediaElement`
+ * before continuing.
+ * Once it has been linked with success (e.g. the `MediaSource` has "opened"),
+ * the `isMediaLinked` `SharedReference` should be set to `true`.
+ *
+ * In the `MediaSource` case, you should wait until the `"initialized"`
+ * state before pushing segment.
+ *
+ * Note that the `"awaiting-media-link"` is an optional state. It can be
+ * skipped to directly `"initialized"` instead.
+ */
+{
+    type: "awaiting-media-link";
+    value: {
+        isMediaLinked: SharedReference<boolean>;
+    };
+} | 
+/**
+ * The `MediaSource` or media url can be linked AND segments can be pushed to
+ * the `HTMLMediaElement` on which decryption capabilities were wanted.
+ */
+{
+    type: "initialized";
+    value: null;
+};
+export {};

package/dist/es2017/core/init/utils/initialize_content_decryption.js

@@ -0,0 +1,104 @@
+import { EncryptedMediaError } from "../../../errors";
+import features from "../../../features";
+import log from "../../../log";
+import SharedReference from "../../../utils/reference";
+import TaskCanceller from "../../../utils/task_canceller";
+import { ContentDecryptorState, } from "../../decrypt";
+/**
+ * Initialize content decryption capabilities on the given `HTMLMediaElement`.
+ *
+ * You can call this function even if you don't want decrytpion capabilities, in
+ * which case you can just set the `keySystems` option as an empty array.
+ * In this situation, the returned object will directly correspond to an
+ * "`initialized`" state and the `onError` callback will be triggered as soon
+ * as protection information is received.
+ *
+ * @param {HTMLMediaElement} mediaElement - `HTMLMediaElement` on which content
+ * decryption may be wanted.
+ * @param {Array.<Object>} keySystems - Key system configuration(s) wanted
+ * Empty array if no content decryption capability is wanted.
+ * @param {Object} protectionRef - Reference through which content
+ * protection initialization data will be sent through.
+ * @param {Object} callbacks - Callbacks called at various decryption-related
+ * events.
+ * @param {Object} cancelSignal - When that signal emits, this function will
+ * stop listening to various events as well as items sent through the
+ * `protectionRef` parameter.
+ * @returns {Object} - Reference emitting the current status regarding DRM
+ * initialization.
+ */
+export default function initializeContentDecryption(mediaElement, keySystems, protectionRef, callbacks, cancelSignal) {
+    if (keySystems.length === 0) {
+        return createEmeDisabledReference("No `keySystems` option given.");
+    }
+    else if (features.decrypt === null) {
+        return createEmeDisabledReference("EME feature not activated.");
+    }
+    const decryptorCanceller = new TaskCanceller();
+    decryptorCanceller.linkToSignal(cancelSignal);
+    const drmStatusRef = new SharedReference({
+        initializationState: { type: "uninitialized", value: null },
+        drmSystemId: undefined,
+    }, cancelSignal);
+    const ContentDecryptor = features.decrypt;
+    if (!ContentDecryptor.hasEmeApis()) {
+        return createEmeDisabledReference("EME API not available on the current page.");
+    }
+    log.debug("Init: Creating ContentDecryptor");
+    const contentDecryptor = new ContentDecryptor(mediaElement, keySystems);
+    contentDecryptor.addEventListener("stateChange", (state) => {
+        if (state === ContentDecryptorState.WaitingForAttachment) {
+            const isMediaLinked = new SharedReference(false);
+            isMediaLinked.onUpdate((isAttached, stopListening) => {
+                if (isAttached) {
+                    stopListening();
+                    if (state === ContentDecryptorState.WaitingForAttachment) {
+                        contentDecryptor.attach();
+                    }
+                }
+            }, { clearSignal: decryptorCanceller.signal });
+            drmStatusRef.setValue({ initializationState: { type: "awaiting-media-link",
+                    value: { isMediaLinked } },
+                drmSystemId: contentDecryptor.systemId });
+        }
+        else if (state === ContentDecryptorState.ReadyForContent) {
+            drmStatusRef.setValue({ initializationState: { type: "initialized",
+                    value: null },
+                drmSystemId: contentDecryptor.systemId });
+            contentDecryptor.removeEventListener("stateChange");
+        }
+    });
+    contentDecryptor.addEventListener("error", (error) => {
+        decryptorCanceller.cancel();
+        callbacks.onError(error);
+    });
+    contentDecryptor.addEventListener("warning", (error) => {
+        callbacks.onWarning(error);
+    });
+    protectionRef.onUpdate((data) => {
+        if (data === null) {
+            return;
+        }
+        contentDecryptor.onInitializationData(data);
+    }, { clearSignal: decryptorCanceller.signal });
+    decryptorCanceller.signal.register(() => {
+        contentDecryptor.dispose();
+    });
+    return drmStatusRef;
+    function createEmeDisabledReference(errMsg) {
+        protectionRef.onUpdate((data, stopListening) => {
+            if (data === null) { // initial value
+                return;
+            }
+            stopListening();
+            const err = new EncryptedMediaError("MEDIA_IS_ENCRYPTED_ERROR", errMsg);
+            callbacks.onError(err);
+        }, { clearSignal: cancelSignal });
+        const ref = new SharedReference({
+            initializationState: { type: "initialized", value: null },
+            drmSystemId: undefined
+        });
+        ref.finish(); // We know that no new value will be triggered
+        return ref;
+    }
+}

package/dist/es2017/core/init/utils/media_source_duration_updater.d.ts

@@ -0,0 +1,58 @@
+/**
+ * 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.
+ */
+/**
+ * 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: MediaSource);
+    /**
+     * 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.
+     */
+    stopUpdating(): void;
+}

package/dist/es2017/core/init/utils/media_source_duration_updater.js

@@ -0,0 +1,263 @@
+/**
+ * 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 { onSourceOpen, onSourceEnded, onSourceClose, } from "../../../compat/event_listeners";
+/* eslint-disable-next-line max-len */
+import hasIssuesWithHighMediaSourceDuration from "../../../compat/has_issues_with_high_media_source_duration";
+import log from "../../../log";
+import SharedReference from "../../../utils/reference";
+import TaskCanceller from "../../../utils/task_canceller";
+/** Number of seconds in a regular year. */
+const YEAR_IN_SECONDS = 365 * 24 * 3600;
+/**
+ * Keep the MediaSource's `duration` attribute up-to-date with the duration of
+ * the content played on it.
+ * @class MediaSourceDurationUpdater
+ */
+export default class MediaSourceDurationUpdater {
+    /**
+     * Create a new `MediaSourceDurationUpdater`,
+     * @param {MediaSource} mediaSource - The MediaSource on which the content is
+     * played.
+     */
+    constructor(mediaSource) {
+        this._mediaSource = mediaSource;
+        this._currentMediaSourceDurationUpdateCanceller = null;
+    }
+    /**
+     * 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, isRealEndKnown) {
+        if (this._currentMediaSourceDurationUpdateCanceller !== null) {
+            this._currentMediaSourceDurationUpdateCanceller.cancel();
+        }
+        this._currentMediaSourceDurationUpdateCanceller = new TaskCanceller();
+        const mediaSource = this._mediaSource;
+        const currentSignal = this._currentMediaSourceDurationUpdateCanceller.signal;
+        const isMediaSourceOpened = createMediaSourceOpenReference(mediaSource, currentSignal);
+        /** TaskCanceller triggered each time the MediaSource switches to and from "open". */
+        let msOpenStatusCanceller = new TaskCanceller();
+        msOpenStatusCanceller.linkToSignal(currentSignal);
+        isMediaSourceOpened.onUpdate(onMediaSourceOpenedStatusChanged, { emitCurrentValue: true,
+            clearSignal: currentSignal });
+        function onMediaSourceOpenedStatusChanged() {
+            msOpenStatusCanceller.cancel();
+            if (!isMediaSourceOpened.getValue()) {
+                return;
+            }
+            msOpenStatusCanceller = new TaskCanceller();
+            msOpenStatusCanceller.linkToSignal(currentSignal);
+            const areSourceBuffersUpdating = createSourceBuffersUpdatingReference(mediaSource.sourceBuffers, msOpenStatusCanceller.signal);
+            /** TaskCanceller triggered each time SourceBuffers' updating status changes */
+            let sourceBuffersUpdatingCanceller = new TaskCanceller();
+            sourceBuffersUpdatingCanceller.linkToSignal(msOpenStatusCanceller.signal);
+            return areSourceBuffersUpdating.onUpdate((areUpdating) => {
+                sourceBuffersUpdatingCanceller.cancel();
+                sourceBuffersUpdatingCanceller = new TaskCanceller();
+                sourceBuffersUpdatingCanceller.linkToSignal(msOpenStatusCanceller.signal);
+                if (areUpdating) {
+                    return;
+                }
+                recursivelyForceDurationUpdate(mediaSource, newDuration, isRealEndKnown, sourceBuffersUpdatingCanceller.signal);
+            }, { clearSignal: msOpenStatusCanceller.signal, emitCurrentValue: true });
+        }
+    }
+    /**
+     * Abort the last duration-setting operation and free its resources.
+     */
+    stopUpdating() {
+        if (this._currentMediaSourceDurationUpdateCanceller !== null) {
+            this._currentMediaSourceDurationUpdateCanceller.cancel();
+            this._currentMediaSourceDurationUpdateCanceller = null;
+        }
+    }
+}
+/**
+ * Checks that duration can be updated on the MediaSource, and then
+ * sets it.
+ *
+ * Returns either:
+ *   - the new duration it has been updated to if it has
+ *   - `null` if it hasn'nt been updated
+ *
+ * @param {MediaSource} mediaSource
+ * @param {number} duration
+ * @param {boolean} isRealEndKnown
+ * @returns {string}
+ */
+function setMediaSourceDuration(mediaSource, duration, isRealEndKnown) {
+    let newDuration = duration;
+    if (!isRealEndKnown) {
+        newDuration = hasIssuesWithHighMediaSourceDuration() ?
+            Infinity :
+            getMaximumLiveSeekablePosition(duration);
+    }
+    let maxBufferedEnd = 0;
+    for (let i = 0; i < mediaSource.sourceBuffers.length; i++) {
+        const sourceBuffer = mediaSource.sourceBuffers[i];
+        const sbBufferedLen = sourceBuffer.buffered.length;
+        if (sbBufferedLen > 0) {
+            maxBufferedEnd = Math.max(sourceBuffer.buffered.end(sbBufferedLen - 1));
+        }
+    }
+    if (newDuration === mediaSource.duration) {
+        return "success" /* MediaSourceDurationUpdateStatus.Success */;
+    }
+    else if (maxBufferedEnd > newDuration) {
+        // We already buffered further than the duration we want to set.
+        // Keep the duration that was set at that time as a security.
+        if (maxBufferedEnd < mediaSource.duration) {
+            try {
+                log.info("Init: Updating duration to what is currently buffered", maxBufferedEnd);
+                mediaSource.duration = maxBufferedEnd;
+            }
+            catch (err) {
+                log.warn("Duration Updater: Can't update duration on the MediaSource.", err instanceof Error ? err : "");
+                return "failed" /* MediaSourceDurationUpdateStatus.Failed */;
+            }
+        }
+        return "partial" /* MediaSourceDurationUpdateStatus.Partial */;
+    }
+    else {
+        const oldDuration = mediaSource.duration;
+        try {
+            log.info("Init: Updating duration", newDuration);
+            mediaSource.duration = newDuration;
+            if (mediaSource.readyState === "open" && !isFinite(newDuration)) {
+                const maxSeekable = getMaximumLiveSeekablePosition(duration);
+                log.info("Init: calling `mediaSource.setLiveSeekableRange`", maxSeekable);
+                mediaSource.setLiveSeekableRange(0, maxSeekable);
+            }
+        }
+        catch (err) {
+            log.warn("Duration Updater: Can't update duration on the MediaSource.", err instanceof Error ? err : "");
+            return "failed" /* MediaSourceDurationUpdateStatus.Failed */;
+        }
+        const deltaToExpected = Math.abs(mediaSource.duration - newDuration);
+        if (deltaToExpected >= 0.1) {
+            const deltaToBefore = Math.abs(mediaSource.duration - oldDuration);
+            return deltaToExpected < deltaToBefore ? "partial" /* MediaSourceDurationUpdateStatus.Partial */ :
+                "failed" /* MediaSourceDurationUpdateStatus.Failed */;
+        }
+        return "success" /* MediaSourceDurationUpdateStatus.Success */;
+    }
+}
+/**
+ * Returns a `SharedReference` wrapping a boolean that tells if all the
+ * SourceBuffers ended all pending updates.
+ * @param {SourceBufferList} sourceBuffers
+ * @param {Object} cancelSignal
+ * @returns {Object}
+ */
+function createSourceBuffersUpdatingReference(sourceBuffers, cancelSignal) {
+    if (sourceBuffers.length === 0) {
+        const notOpenedRef = new SharedReference(false);
+        notOpenedRef.finish();
+        return notOpenedRef;
+    }
+    const areUpdatingRef = new SharedReference(false, cancelSignal);
+    reCheck();
+    for (let i = 0; i < sourceBuffers.length; i++) {
+        const sourceBuffer = sourceBuffers[i];
+        sourceBuffer.addEventListener("updatestart", reCheck);
+        sourceBuffer.addEventListener("update", reCheck);
+        cancelSignal.register(() => {
+            sourceBuffer.removeEventListener("updatestart", reCheck);
+            sourceBuffer.removeEventListener("update", reCheck);
+        });
+    }
+    return areUpdatingRef;
+    function reCheck() {
+        for (let i = 0; i < sourceBuffers.length; i++) {
+            const sourceBuffer = sourceBuffers[i];
+            if (sourceBuffer.updating) {
+                areUpdatingRef.setValueIfChanged(true);
+                return;
+            }
+        }
+        areUpdatingRef.setValueIfChanged(false);
+    }
+}
+/**
+ * Returns a `SharedReference` wrapping a boolean that tells if the media
+ * source is opened or not.
+ * @param {MediaSource} mediaSource
+ * @param {Object} cancelSignal
+ * @returns {Object}
+ */
+function createMediaSourceOpenReference(mediaSource, cancelSignal) {
+    const isMediaSourceOpen = new SharedReference(mediaSource.readyState === "open", cancelSignal);
+    onSourceOpen(mediaSource, () => {
+        log.debug("Init: Reacting to MediaSource open in duration updater");
+        isMediaSourceOpen.setValueIfChanged(true);
+    }, cancelSignal);
+    onSourceEnded(mediaSource, () => {
+        log.debug("Init: Reacting to MediaSource ended in duration updater");
+        isMediaSourceOpen.setValueIfChanged(false);
+    }, cancelSignal);
+    onSourceClose(mediaSource, () => {
+        log.debug("Init: Reacting to MediaSource close in duration updater");
+        isMediaSourceOpen.setValueIfChanged(false);
+    }, cancelSignal);
+    return isMediaSourceOpen;
+}
+/**
+ * Immediately tries to set the MediaSource's duration to the most appropriate
+ * one.
+ *
+ * If it fails, wait 2 seconds and retries.
+ *
+ * @param {MediaSource} mediaSource
+ * @param {number} duration
+ * @param {boolean} isRealEndKnown
+ * @param {Object} cancelSignal
+ */
+function recursivelyForceDurationUpdate(mediaSource, duration, isRealEndKnown, cancelSignal) {
+    const res = setMediaSourceDuration(mediaSource, duration, isRealEndKnown);
+    if (res === "success" /* MediaSourceDurationUpdateStatus.Success */) {
+        return;
+    }
+    const timeoutId = setTimeout(() => {
+        unregisterClear();
+        recursivelyForceDurationUpdate(mediaSource, duration, isRealEndKnown, cancelSignal);
+    }, 2000);
+    const unregisterClear = cancelSignal.register(() => {
+        clearTimeout(timeoutId);
+    });
+}
+function getMaximumLiveSeekablePosition(contentLastPosition) {
+    // Some targets poorly support setting a very high number for seekable
+    // ranges.
+    // Yet, in contents whose end is not yet known (e.g. live contents), we
+    // would prefer setting a value as high as possible to still be able to
+    // seek anywhere we want to (even ahead of the Manifest if we want to).
+    // As such, we put it at a safe default value of 2^32 excepted when the
+    // maximum position is already relatively close to that value, where we
+    // authorize exceptionally going over it.
+    return Math.max(Math.pow(2, 32), contentLastPosition + YEAR_IN_SECONDS);
+}

package/dist/es2017/core/init/utils/rebuffering_controller.d.ts

@@ -0,0 +1,147 @@
+/**
+ * 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 Manifest, { Period } from "../../../manifest";
+import { IPlayerError } from "../../../public_types";
+import EventEmitter from "../../../utils/event_emitter";
+import { IReadOnlySharedReference } from "../../../utils/reference";
+import { PlaybackObserver } from "../../api";
+import SegmentBuffersStore, { IBufferType } from "../../segment_buffers";
+import { IStallingSituation } from "../types";
+/**
+ * Monitor playback, trying to avoid stalling situation.
+ * If stopping the player to build buffer is needed, temporarily set the
+ * playback rate (i.e. speed) at `0` until enough buffer is available again.
+ *
+ * Emit "stalled" then "unstalled" respectively when an unavoidable stall is
+ * encountered and exited.
+ */
+export default class RebufferingController extends EventEmitter<IRebufferingControllerEvent> {
+    /** Emit the current playback conditions */
+    private _playbackObserver;
+    private _manifest;
+    private _segmentBuffersStore;
+    private _speed;
+    private _isStarted;
+    /**
+     * Every known audio and video buffer discontinuities in chronological
+     * order (first ordered by Period's start, then by bufferType in any order.
+     */
+    private _discontinuitiesStore;
+    private _canceller;
+    /**
+     * If set to something else than `null`, this is the monotonically-raising
+     * timestamp when playback begin to seem to not start despite having
+     * decipherable data in the buffer(s).
+     *
+     * If enough time in that condition is spent, special considerations are
+     * taken at which point `_currentFreezeTimestamp` is reset to `null`.
+     *
+     * It is also reset to `null` when and if there is no such issue anymore.
+     */
+    private _currentFreezeTimestamp;
+    /**
+     * @param {object} playbackObserver - emit the current playback conditions.
+     * @param {Object} manifest - The Manifest of the currently-played content.
+     * @param {Object} speed - The last speed set by the user
+     */
+    constructor(playbackObserver: PlaybackObserver, manifest: Manifest | null, segmentBuffersStore: SegmentBuffersStore | null, speed: IReadOnlySharedReference<number>);
+    start(): void;
+    /**
+     * Update information on an upcoming discontinuity for a given buffer type and
+     * Period.
+     * Each new update for the same Period and type overwrites the previous one.
+     * @param {Object} evt
+     */
+    updateDiscontinuityInfo(evt: IDiscontinuityEvent): void;
+    /**
+     * Function to call when a Stream is currently locked, i.e. we cannot load
+     * segments for the corresponding Period and buffer type until it is seeked
+     * to.
+     * @param {string} bufferType - Buffer type for which no segment will
+     * currently load.
+     * @param {Object} period - Period for which no segment will currently load.
+     */
+    onLockedStream(bufferType: IBufferType, period: Period): void;
+    /**
+     * Stops the `RebufferingController` from montoring stalling situations,
+     * forever.
+     */
+    destroy(): void;
+    /**
+     * Support of contents with DRM on all the platforms out there is a pain in
+     * the *ss considering all the DRM-related bugs there are.
+     *
+     * We found out a frequent issue which is to be unable to play despite having
+     * all the decryption keys to play what is currently buffered.
+     * When this happens, re-creating the buffers from scratch, with a reload, is
+     * usually sufficient to unlock the situation.
+     *
+     * Although we prefer providing more targeted fixes or telling to platform
+     * developpers to fix their implementation, it's not always possible.
+     * We thus resorted to developping an heuristic which detects such situation
+     * and reload in that case.
+     *
+     * @param {Object} observation - The last playback observation produced, it
+     * has to be recent (just triggered for example).
+     * @returns {boolean} - Returns `true` if it seems to be such kind of
+     * decipherability freeze, in which case this method already performed the
+     * right handling steps.
+     */
+    private _checkDecipherabilityFreeze;
+}
+export interface IRebufferingControllerEvent {
+    stalled: IStallingSituation;
+    unstalled: null;
+    needsReload: null;
+    warning: IPlayerError;
+}
+/**
+ * Event indicating that a discontinuity has been found.
+ * Each event for a `bufferType` and `period` combination replaces the previous
+ * one.
+ */
+export interface IDiscontinuityEvent {
+    /** Buffer type concerned by the discontinuity. */
+    bufferType: IBufferType;
+    /** Period concerned by the discontinuity. */
+    period: Period;
+    /**
+     * Close discontinuity time information.
+     * `null` if no discontinuity has been detected currently for that buffer
+     * type and Period.
+     */
+    discontinuity: IDiscontinuityTimeInfo | null;
+    /**
+     * Position at which the discontinuity was found.
+     * Can be important for when a current discontinuity's start is unknown.
+     */
+    position: number;
+}
+/** Information on a found discontinuity. */
+export interface IDiscontinuityTimeInfo {
+    /**
+     * Start time of the discontinuity.
+     * `undefined` for when the start is unknown but the discontinuity was
+     * currently encountered at the position we were in when this event was
+     * created.
+     */
+    start: number | undefined;
+    /**
+     * End time of the discontinuity, in seconds.
+     * If `null`, no further segment can be loaded for the corresponding Period.
+     */
+    end: number | null;
+}