rx-player 3.25.2 → 3.26.3-dev.2022021400

package/dist/_esm5.processed/core/init/events_generators.d.ts

@@ -15,10 +15,9 @@
  */
 import { ICustomError } from "../../errors";
 import Manifest, { Adaptation, Period, Representation } from "../../manifest";
-import { IStalledStatus } from "../api";
 import SegmentBuffersStore, { IBufferType } from "../segment_buffers";
 import { IRepresentationChangeEvent } from "../stream";
-import { IDecipherabilityUpdateEvent, ILoadedEvent, IManifestReadyEvent, IManifestUpdateEvent, IReloadingMediaSourceEvent, IStalledEvent, IUnstalledEvent, IWarningEvent } from "./types";
+import { IDecipherabilityUpdateEvent, ILoadedEvent, IManifestReadyEvent, IManifestUpdateEvent, IReloadingMediaSourceEvent, IStalledEvent, IStallingSituation, IUnstalledEvent, IWarningEvent } from "./types";
 /**
  * Construct a "loaded" event.
  * @returns {Object}
@@ -26,13 +25,12 @@ import { IDecipherabilityUpdateEvent, ILoadedEvent, IManifestReadyEvent, IManife
 declare function loaded(segmentBuffersStore: SegmentBuffersStore | null): ILoadedEvent;
 /**
  * Construct a "stalled" event.
- * @param {Object|null} stalling
+ * @param {Object|null} rebuffering
  * @returns {Object}
  */
-declare function stalled(stalling: IStalledStatus): IStalledEvent;
+declare function stalled(rebuffering: IStallingSituation): IStalledEvent;
 /**
  * Construct a "stalled" event.
- * @param {Object|null} stalling
  * @returns {Object}
  */
 declare function unstalled(): IUnstalledEvent;

package/dist/_esm5.processed/core/init/events_generators.js

@@ -22,15 +22,14 @@ function loaded(segmentBuffersStore) {
 }
 /**
  * Construct a "stalled" event.
- * @param {Object|null} stalling
+ * @param {Object|null} rebuffering
  * @returns {Object}
  */
-function stalled(stalling) {
-    return { type: "stalled", value: stalling };
+function stalled(rebuffering) {
+    return { type: "stalled", value: rebuffering };
 }
 /**
  * Construct a "stalled" event.
- * @param {Object|null} stalling
  * @returns {Object}
  */
 function unstalled() {
@@ -67,9 +66,7 @@ function manifestUpdate() {
  */
 function nullRepresentation(type, period) {
     return { type: "representationChange",
-        value: { type: type,
-            representation: null,
-            period: period } };
+        value: { type: type, representation: null, period: period } };
 }
 /**
  * construct a "warning" event.
@@ -86,13 +83,5 @@ function warning(value) {
 function reloadingMediaSource() {
     return { type: "reloading-media-source", value: undefined };
 }
-var INIT_EVENTS = { loaded: loaded,
-    decipherabilityUpdate: decipherabilityUpdate,
-    manifestReady: manifestReady,
-    manifestUpdate: manifestUpdate,
-    nullRepresentation: nullRepresentation,
-    reloadingMediaSource: reloadingMediaSource,
-    stalled: stalled,
-    unstalled: unstalled,
-    warning: warning };
+var INIT_EVENTS = { loaded: loaded, decipherabilityUpdate: decipherabilityUpdate, manifestReady: manifestReady, manifestUpdate: manifestUpdate, nullRepresentation: nullRepresentation, reloadingMediaSource: reloadingMediaSource, stalled: stalled, unstalled: unstalled, warning: warning };
 export default INIT_EVENTS;

package/dist/_esm5.processed/core/init/get_initial_time.js

@@ -30,7 +30,6 @@ var DEFAULT_LIVE_GAP = config.DEFAULT_LIVE_GAP;
  * @returns {Number}
  */
 export default function getInitialTime(manifest, lowLatencyMode, startAt) {
-    log.debug("Init: calculating initial time");
     if (startAt != null) {
         var min = manifest.getMinimumPosition();
         var max = manifest.getMaximumPosition();
@@ -94,8 +93,8 @@ export default function getInitialTime(manifest, lowLatencyMode, startAt) {
         var diffFromLiveTime = suggestedPresentationDelay !== undefined ? suggestedPresentationDelay :
             lowLatencyMode ? DEFAULT_LIVE_GAP.LOW_LATENCY :
                 DEFAULT_LIVE_GAP.DEFAULT;
-        log.debug("Init: " + liveTime + " defined as the live time, applying a live gap" +
-            (" of " + diffFromLiveTime));
+        log.debug("Init: ".concat(liveTime, " defined as the live time, applying a live gap") +
+            " of ".concat(diffFromLiveTime));
         return Math.max(liveTime - diffFromLiveTime, minimumPosition);
     }
     log.info("Init: starting at the minimum available position:", minimumPosition);

package/dist/_esm5.processed/core/init/initial_seek_and_play.d.ts

@@ -14,34 +14,68 @@
  * limitations under the License.
  */
 import { Observable } from "rxjs";
-import { IInitClockTick } from "./types";
-export declare type ILoadEvents = "not-loaded-metadata" | // metadata are not loaded. Manual action required
-"autoplay-blocked" | // loaded but autoplay is blocked by the browser
-"autoplay" | // loaded and autoplayed succesfully
-"loaded";
+import { IReadOnlySharedReference } from "../../utils/reference";
+import { IPlaybackObservation, PlaybackObserver } from "../api";
+import { IWarningEvent } from "./types";
+/** Event emitted when trying to perform the initial `play`. */
+export declare type IInitialPlayEvent = 
+/** Autoplay is not enabled, but all required steps to do so are there. */
+{
+    type: "skipped";
+} | 
 /**
- * Returns two Observables:
- *
- *   - seek$: when subscribed, will seek to the wanted started time as soon as
- *     it can. Emit and complete when done.
+ * Tried to play, but autoplay is blocked by the browser.
+ * A corresponding warning should have already been sent.
+ */
+{
+    type: "autoplay-blocked";
+} | 
+/** Autoplay was done with success. */
+{
+    type: "autoplay";
+} | 
+/** Warnings preventing the initial play from happening normally. */
+IWarningEvent;
+/**
+ * Emit once as soon as the playback observation announces that the content can
+ * begin to be played by calling the `play` method.
  *
- *   - load$: when subscribed, will play if and only if the `mustAutoPlay`
- *     option is set as soon as it can. Emit and complete when done.
- *     When this observable emits, it also means that the content is `loaded`
- *     and can begin to play the current content.
+ * This depends on browser-defined criteria (e.g. the readyState status) as well
+ * as RxPlayer-defined ones (e.g.) not rebuffering.
  *
+ * @param {Observable} observation$
+ * @returns {Observable.<undefined>}
+ */
+export declare function waitUntilPlayable(observation$: Observable<IPlaybackObservation>): Observable<undefined>;
+/** Object returned by `initialSeekAndPlay`. */
+export interface IInitialSeekAndPlayObject {
+    /**
+     * Observable which, when subscribed, will try to seek at the initial position
+     * then play if needed as soon as the HTMLMediaElement's properties are right.
+     *
+     * Emits various events relative to the status of this operation.
+     */
+    seekAndPlay$: Observable<IInitialPlayEvent>;
+    /**
+     * Shared reference whose value becomes `true` once the initial seek has
+     * been considered / has been done by `seekAndPlay$`.
+     */
+    initialSeekPerformed: IReadOnlySharedReference<boolean>;
+    /**
+     * Shared reference whose value becomes `true` once the initial play has
+     * been considered / has been done by `seekAndPlay$`.
+     */
+    initialPlayPerformed: IReadOnlySharedReference<boolean>;
+}
+/**
+ * Creates an Observable allowing to seek at the initially wanted position and
+ * to play if autoPlay is wanted.
  * @param {Object} args
  * @returns {Object}
  */
-export default function seekAndLoadOnMediaEvents({ clock$, mediaElement, startTime, mustAutoPlay, setCurrentTime, isDirectfile }: {
-    clock$: Observable<IInitClockTick>;
-    isDirectfile: boolean;
+export default function initialSeekAndPlay({ mediaElement, playbackObserver, startTime, mustAutoPlay }: {
+    playbackObserver: PlaybackObserver;
     mediaElement: HTMLMediaElement;
     mustAutoPlay: boolean;
-    /** Perform an internal seek. */
-    setCurrentTime: (nb: number) => void;
     startTime: number | (() => number);
-}): {
-    seek$: Observable<unknown>;
-    load$: Observable<ILoadEvents>;
-};
+}): IInitialSeekAndPlayObject;

package/dist/_esm5.processed/core/init/initial_seek_and_play.js

@@ -13,46 +13,37 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { concat as observableConcat, of as observableOf, } from "rxjs";
-import { catchError, filter, mapTo, mergeMap, shareReplay, take, tap, } from "rxjs/operators";
-import { play$, shouldValidateMetadata, shouldWaitForDataBeforeLoaded, whenLoadedMetadata$, } from "../../compat";
+import { catchError, concat as observableConcat, filter, map, mergeMap, of as observableOf, shareReplay, startWith, take, tap, } from "rxjs";
+import { play, shouldValidateMetadata, whenLoadedMetadata$, } from "../../compat";
+import { MediaError } from "../../errors";
 import log from "../../log";
+import { createSharedReference, } from "../../utils/reference";
+import EVENTS from "./events_generators";
 /**
- * Emit once a "can-play" message as soon as the clock$ announce that the content
- * can begin to be played.
+ * Emit once as soon as the playback observation announces that the content can
+ * begin to be played by calling the `play` method.
  *
- * Warn you if the metadata is not yet loaded metadata by emitting a
- * "not-loaded-metadata" message first.
- * @param {Observable} clock$
- * @returns {Observable}
+ * This depends on browser-defined criteria (e.g. the readyState status) as well
+ * as RxPlayer-defined ones (e.g.) not rebuffering.
+ *
+ * @param {Observable} observation$
+ * @returns {Observable.<undefined>}
  */
-function canPlay(clock$, mediaElement, isDirectfile) {
-    var isLoaded$ = clock$.pipe(filter(function (tick) {
-        var seeking = tick.seeking, stalled = tick.stalled, readyState = tick.readyState, currentRange = tick.currentRange;
-        if (seeking || stalled !== null) {
-            return false;
-        }
-        if (!shouldWaitForDataBeforeLoaded(isDirectfile, mediaElement.hasAttribute("playsinline"))) {
-            return readyState >= 1 && mediaElement.duration > 0;
-        }
-        if (readyState >= 4 || (readyState === 3 && currentRange !== null)) {
-            return shouldValidateMetadata() ? mediaElement.duration > 0 :
-                true;
-        }
-        return false;
-    }), take(1), mapTo("can-play"));
-    if (shouldValidateMetadata() && mediaElement.duration === 0) {
-        return observableConcat(observableOf("not-loaded-metadata"), isLoaded$);
-    }
-    return isLoaded$;
+export function waitUntilPlayable(observation$) {
+    return observation$.pipe(filter(function (_a) {
+        var seeking = _a.seeking, rebuffering = _a.rebuffering, readyState = _a.readyState;
+        return !seeking &&
+            rebuffering === null &&
+            readyState >= 1;
+    }), take(1), map(function () { return undefined; }));
 }
 /**
  * Try to play content then handle autoplay errors.
  * @param {HTMLMediaElement} - mediaElement
  * @returns {Observable}
  */
-function autoPlay$(mediaElement) {
-    return play$(mediaElement).pipe(mapTo("autoplay"), catchError(function (error) {
+function autoPlay(mediaElement) {
+    return play(mediaElement).pipe(map(function () { return "autoplay"; }), catchError(function (error) {
         if (error instanceof Error && error.name === "NotAllowedError") {
             // auto-play was probably prevented.
             log.warn("Init: Media element can't play." +
@@ -65,41 +56,59 @@ function autoPlay$(mediaElement) {
     }));
 }
 /**
- * Returns two Observables:
- *
- *   - seek$: when subscribed, will seek to the wanted started time as soon as
- *     it can. Emit and complete when done.
- *
- *   - load$: when subscribed, will play if and only if the `mustAutoPlay`
- *     option is set as soon as it can. Emit and complete when done.
- *     When this observable emits, it also means that the content is `loaded`
- *     and can begin to play the current content.
- *
+ * Creates an Observable allowing to seek at the initially wanted position and
+ * to play if autoPlay is wanted.
  * @param {Object} args
  * @returns {Object}
  */
-export default function seekAndLoadOnMediaEvents(_a) {
-    var clock$ = _a.clock$, mediaElement = _a.mediaElement, startTime = _a.startTime, mustAutoPlay = _a.mustAutoPlay, setCurrentTime = _a.setCurrentTime, isDirectfile = _a.isDirectfile;
+export default function initialSeekAndPlay(_a) {
+    var mediaElement = _a.mediaElement, playbackObserver = _a.playbackObserver, startTime = _a.startTime, mustAutoPlay = _a.mustAutoPlay;
+    var initialSeekPerformed = createSharedReference(false);
+    var initialPlayPerformed = createSharedReference(false);
     var seek$ = whenLoadedMetadata$(mediaElement).pipe(take(1), tap(function () {
         log.info("Init: Set initial time", startTime);
         var initialTime = typeof startTime === "function" ? startTime() :
             startTime;
-        setCurrentTime(initialTime);
+        playbackObserver.setCurrentTime(initialTime);
+        initialSeekPerformed.setValue(true);
+        initialSeekPerformed.finish();
     }), shareReplay({ refCount: true }));
-    var load$ = seek$.pipe(mergeMap(function () {
-        return canPlay(clock$, mediaElement, isDirectfile).pipe(tap(function () { return log.info("Init: Can begin to play content"); }), mergeMap(function (evt) {
-            if (evt === "can-play") {
-                if (!mustAutoPlay) {
-                    if (mediaElement.autoplay) {
-                        log.warn("Init: autoplay is enabled on HTML media element. " +
-                            "Media will play as soon as possible.");
-                    }
-                    return observableOf("loaded");
-                }
-                return autoPlay$(mediaElement);
-            }
+    var seekAndPlay$ = seek$.pipe(mergeMap(function () {
+        if (!shouldValidateMetadata() || mediaElement.duration > 0) {
+            return waitUntilPlayable(playbackObserver.observe(true));
+        }
+        else {
+            var error = new MediaError("MEDIA_ERR_NOT_LOADED_METADATA", "Cannot load automatically: your browser " +
+                "falsely announced having loaded the content.");
+            return waitUntilPlayable(playbackObserver.observe(true))
+                .pipe(startWith(EVENTS.warning(error)));
+        }
+    }), mergeMap(function (evt) {
+        if (evt !== undefined) {
             return observableOf(evt);
+        }
+        log.info("Init: Can begin to play content");
+        if (!mustAutoPlay) {
+            if (mediaElement.autoplay) {
+                log.warn("Init: autoplay is enabled on HTML media element. " +
+                    "Media will play as soon as possible.");
+            }
+            initialPlayPerformed.setValue(true);
+            initialPlayPerformed.finish();
+            return observableOf({ type: "skipped" });
+        }
+        return autoPlay(mediaElement).pipe(mergeMap(function (autoplayEvt) {
+            initialPlayPerformed.setValue(true);
+            initialPlayPerformed.finish();
+            if (autoplayEvt === "autoplay") {
+                return observableOf({ type: "autoplay" });
+            }
+            else {
+                var error = new MediaError("MEDIA_ERR_BLOCKED_AUTOPLAY", "Cannot trigger auto-play automatically: " +
+                    "your browser does not allow it.");
+                return observableConcat(observableOf(EVENTS.warning(error)), observableOf({ type: "autoplay-blocked" }));
+            }
         }));
     }), shareReplay({ refCount: true }));
-    return { seek$: seek$, load$: load$ };
+    return { seekAndPlay$: seekAndPlay$, initialPlayPerformed: initialPlayPerformed, initialSeekPerformed: initialSeekPerformed };
 }

package/dist/_esm5.processed/core/init/initialize_directfile.d.ts

@@ -18,23 +18,24 @@
  * It always should be imported through the `features` object.
  */
 import { Observable } from "rxjs";
+import { IReadOnlySharedReference } from "../../utils/reference";
+import { PlaybackObserver } from "../api";
 import { IKeySystemOption } from "../eme";
 import { IInitialTimeOptions } from "./get_initial_time";
-import { IDirectfileEvent, IInitClockTick } from "./types";
+import { IDirectfileEvent } from "./types";
 export interface IDirectFileOptions {
     autoPlay: boolean;
-    clock$: Observable<IInitClockTick>;
     keySystems: IKeySystemOption[];
     mediaElement: HTMLMediaElement;
-    speed$: Observable<number>;
-    setCurrentTime: (nb: number) => void;
-    startAt?: IInitialTimeOptions;
-    url?: string;
+    playbackObserver: PlaybackObserver;
+    speed: IReadOnlySharedReference<number>;
+    startAt?: IInitialTimeOptions | undefined;
+    url?: string | undefined;
 }
 /**
  * Launch a content in "Directfile mode".
  * @param {Object} directfileOptions
  * @returns {Observable}
  */
-export default function initializeDirectfileContent({ autoPlay, clock$, keySystems, mediaElement, speed$, setCurrentTime, startAt, url, }: IDirectFileOptions): Observable<IDirectfileEvent>;
+export default function initializeDirectfileContent({ autoPlay, keySystems, mediaElement, playbackObserver, speed, startAt, url, }: IDirectFileOptions): Observable<IDirectfileEvent>;
 export { IDirectfileEvent };

package/dist/_esm5.processed/core/init/initialize_directfile.js

@@ -17,15 +17,14 @@
  * /!\ This file is feature-switchable.
  * It always should be imported through the `features` object.
  */
-import { EMPTY, merge as observableMerge, of as observableOf, } from "rxjs";
-import { filter, ignoreElements, map, mergeMap, mergeMapTo, share, take, } from "rxjs/operators";
+import { EMPTY, filter, ignoreElements, merge as observableMerge, mergeMap, switchMap, of as observableOf, share, take, } from "rxjs";
 import { clearElementSrc, setElementSrc$, } from "../../compat";
-import { MediaError } from "../../errors";
 import log from "../../log";
 import deferSubscriptions from "../../utils/defer_subscriptions";
 import createEMEManager from "./create_eme_manager";
-import EVENTS from "./events_generators";
-import seekAndLoadOnMediaEvents from "./initial_seek_and_play";
+import emitLoadedEvent from "./emit_loaded_event";
+import initialSeekAndPlay from "./initial_seek_and_play";
+import StallAvoider from "./stall_avoider";
 import throwOnMediaError from "./throw_on_media_error";
 import updatePlaybackRate from "./update_playback_rate";
 /**
@@ -75,7 +74,7 @@ function getDirectFileInitialTime(mediaElement, startAt) {
  * @returns {Observable}
  */
 export default function initializeDirectfileContent(_a) {
-    var autoPlay = _a.autoPlay, clock$ = _a.clock$, keySystems = _a.keySystems, mediaElement = _a.mediaElement, speed$ = _a.speed$, setCurrentTime = _a.setCurrentTime, startAt = _a.startAt, url = _a.url;
+    var autoPlay = _a.autoPlay, keySystems = _a.keySystems, mediaElement = _a.mediaElement, playbackObserver = _a.playbackObserver, speed = _a.speed, startAt = _a.startAt, url = _a.url;
     clearElementSrc(mediaElement);
     if (url == null) {
         throw new Error("No URL for a DirectFile content");
@@ -85,46 +84,45 @@ export default function initializeDirectfileContent(_a) {
     log.debug("Init: Calculating initial time");
     var initialTime = function () { return getDirectFileInitialTime(mediaElement, startAt); };
     log.debug("Init: Initial time calculated:", initialTime);
-    var _b = seekAndLoadOnMediaEvents({ clock$: clock$,
-        mediaElement: mediaElement,
-        startTime: initialTime,
-        mustAutoPlay: autoPlay,
-        setCurrentTime: setCurrentTime,
-        isDirectfile: true }), seek$ = _b.seek$, load$ = _b.load$;
+    var seekAndPlay$ = initialSeekAndPlay({ mediaElement: mediaElement, playbackObserver: playbackObserver, startTime: initialTime,
+        mustAutoPlay: autoPlay }).seekAndPlay$;
     // Create EME Manager, an observable which will manage every EME-related
     // issue.
     var emeManager$ = linkURL$.pipe(mergeMap(function () { return createEMEManager(mediaElement, keySystems, EMPTY); }), deferSubscriptions(), share());
     // Translate errors coming from the media element into RxPlayer errors
     // through a throwing Observable.
     var mediaError$ = throwOnMediaError(mediaElement);
+    var observation$ = playbackObserver.observe(true);
     // Set the speed set by the user on the media element while pausing a
     // little longer while the buffer is empty.
-    var playbackRate$ = updatePlaybackRate(mediaElement, speed$, clock$)
+    var playbackRate$ = updatePlaybackRate(mediaElement, speed, observation$)
+        // NOTE As of now (RxJS 7.4.0), RxJS defines `ignoreElements` default
+        // first type parameter as `any` instead of the perfectly fine `unknown`,
+        // leading to linter issues, as it forbids the usage of `any`.
+        // This is why we're disabling the eslint rule.
+        /* eslint-disable-next-line @typescript-eslint/no-unsafe-argument */
         .pipe(ignoreElements());
-    // Create Stalling Manager, an observable which will try to get out of
-    // various infinite stalling issues
-    var stalled$ = clock$.pipe(map(function (tick) { return tick.stalled === null ? EVENTS.unstalled() :
-        EVENTS.stalled(tick.stalled); }));
-    // Manage "loaded" event and warn if autoplay is blocked on the current browser
-    var loadedEvent$ = emeManager$.pipe(filter(function isEMEReady(evt) {
+    /**
+     * Observable trying to avoid various stalling situations, emitting "stalled"
+     * events when it cannot, as well as "unstalled" events when it get out of one.
+     */
+    var stallAvoider$ = StallAvoider(playbackObserver, null, EMPTY, EMPTY);
+    /**
+     * Emit a "loaded" events once the initial play has been performed and the
+     * media can begin playback.
+     * Also emits warning events if issues arise when doing so.
+     */
+    var loadingEvts$ = emeManager$.pipe(filter(function isEMEReady(evt) {
         if (evt.type === "created-media-keys") {
-            evt.value.attachMediaKeys$.next();
+            evt.value.canAttachMediaKeys.setValue(true);
             return true;
         }
         return evt.type === "eme-disabled" || evt.type === "attached-media-keys";
-    }), take(1), mergeMapTo(load$), mergeMap(function (evt) {
-        if (evt === "autoplay-blocked") {
-            var error = new MediaError("MEDIA_ERR_BLOCKED_AUTOPLAY", "Cannot trigger auto-play automatically: " +
-                "your browser does not allow it.");
-            return observableOf(EVENTS.warning(error), EVENTS.loaded(null));
+    }), take(1), mergeMap(function () { return seekAndPlay$; }), switchMap(function (evt) {
+        if (evt.type === "warning") {
+            return observableOf(evt);
         }
-        else if (evt === "not-loaded-metadata") {
-            var error = new MediaError("MEDIA_ERR_NOT_LOADED_METADATA", "Cannot load automatically: your browser " +
-                "falsely announced having loaded the content.");
-            return observableOf(EVENTS.warning(error));
-        }
-        return observableOf(EVENTS.loaded(null));
+        return emitLoadedEvent(observation$, mediaElement, null, true);
     }));
-    var initialSeek$ = seek$.pipe(ignoreElements());
-    return observableMerge(loadedEvent$, initialSeek$, emeManager$, mediaError$, playbackRate$, stalled$);
+    return observableMerge(loadingEvts$, emeManager$, mediaError$, playbackRate$, stallAvoider$);
 }

package/dist/_esm5.processed/core/init/initialize_media_source.d.ts

@@ -13,13 +13,15 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { BehaviorSubject, Observable } from "rxjs";
+import { Observable } from "rxjs";
+import { IReadOnlySharedReference } from "../../utils/reference";
 import { IABRManagerArguments } from "../abr";
+import { PlaybackObserver } from "../api";
 import { IKeySystemOption } from "../eme";
 import { IManifestFetcherParsedResult, IManifestFetcherWarningEvent, ManifestFetcher, SegmentFetcherCreator } from "../fetchers";
 import { ITextTrackSegmentBufferOptions } from "../segment_buffers";
 import { IInitialTimeOptions } from "./get_initial_time";
-import { IInitClockTick, IInitEvent } from "./types";
+import { IInitEvent } from "./types";
 /** Arguments to give to the `InitializeOnMediaSource` function. */
 export interface IInitializeArguments {
     /** Options concerning the ABR logic. */
@@ -29,11 +31,11 @@ export interface IInitializeArguments {
     /** Options concerning the media buffers. */
     bufferOptions: {
         /** Buffer "goal" at which we stop downloading new segments. */
-        wantedBufferAhead$: BehaviorSubject<number>;
+        wantedBufferAhead: IReadOnlySharedReference<number>;
         /** Max buffer size after the current position, in seconds (we GC further up). */
-        maxBufferAhead$: Observable<number>;
+        maxBufferAhead: IReadOnlySharedReference<number>;
         /** Max buffer size before the current position, in seconds (we GC further down). */
-        maxBufferBehind$: Observable<number>;
+        maxBufferBehind: IReadOnlySharedReference<number>;
         /** Strategy when switching the current bitrate manually (smooth vs reload). */
         manualBitrateSwitchingMode: "seamless" | "direct";
         /**
@@ -47,7 +49,7 @@ export interface IInitializeArguments {
         onCodecSwitch: "continue" | "reload";
     };
     /** Regularly emit current playback conditions. */
-    clock$: Observable<IInitClockTick>;
+    playbackObserver: PlaybackObserver;
     /** Every encryption configuration set. */
     keySystems: IKeySystemOption[];
     /** `true` to play low-latency contents optimally. */
@@ -61,13 +63,11 @@ export interface IInitializeArguments {
     /** Limit the frequency of Manifest updates. */
     minimumManifestUpdateInterval: number;
     /** Interface allowing to load segments */
-    segmentFetcherCreator: SegmentFetcherCreator<any>;
-    /** Perform an internal seek */
-    setCurrentTime: (time: number) => void;
+    segmentFetcherCreator: SegmentFetcherCreator;
     /** Emit the playback rate (speed) set by the user. */
-    speed$: Observable<number>;
+    speed: IReadOnlySharedReference<number>;
     /** The configured starting position. */
-    startAt?: IInitialTimeOptions;
+    startAt?: IInitialTimeOptions | undefined;
     /** Configuration specific to the text track. */
     textTrackOptions: ITextTrackSegmentBufferOptions;
 }
@@ -102,4 +102,4 @@ export interface IInitializeArguments {
  * @param {Object} args
  * @returns {Observable}
  */
-export default function InitializeOnMediaSource({ adaptiveOptions, autoPlay, bufferOptions, clock$, keySystems, lowLatencyMode, manifest$, manifestFetcher, mediaElement, minimumManifestUpdateInterval, segmentFetcherCreator, setCurrentTime, speed$, startAt, textTrackOptions }: IInitializeArguments): Observable<IInitEvent>;
+export default function InitializeOnMediaSource({ adaptiveOptions, autoPlay, bufferOptions, keySystems, lowLatencyMode, manifest$, manifestFetcher, mediaElement, minimumManifestUpdateInterval, playbackObserver, segmentFetcherCreator, speed, startAt, textTrackOptions }: IInitializeArguments): Observable<IInitEvent>;