rx-player 3.25.2 → 3.26.3-dev.2022021400

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

@@ -13,8 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { combineLatest as observableCombineLatest, EMPTY, merge as observableMerge, of as observableOf, Subject, } from "rxjs";
-import { exhaustMap, filter, finalize, ignoreElements, map, mapTo, mergeMap, mergeScan, share, shareReplay, startWith, switchMap, take, takeUntil, tap, } from "rxjs/operators";
+import { combineLatest as observableCombineLatest, EMPTY, exhaustMap, filter, finalize, ignoreElements, map, merge as observableMerge, mergeMap, mergeScan, of as observableOf, share, shareReplay, startWith, Subject, switchMap, take, takeUntil, tap, } from "rxjs";
 import { shouldReloadMediaSourceOnDecipherabilityUpdate } from "../../compat";
 import config from "../../config";
 import log from "../../log";
@@ -64,7 +63,7 @@ var OUT_OF_SYNC_MANIFEST_REFRESH_DELAY = config.OUT_OF_SYNC_MANIFEST_REFRESH_DEL
  * @returns {Observable}
  */
 export default function InitializeOnMediaSource(_a) {
-    var adaptiveOptions = _a.adaptiveOptions, autoPlay = _a.autoPlay, bufferOptions = _a.bufferOptions, clock$ = _a.clock$, keySystems = _a.keySystems, lowLatencyMode = _a.lowLatencyMode, manifest$ = _a.manifest$, manifestFetcher = _a.manifestFetcher, mediaElement = _a.mediaElement, minimumManifestUpdateInterval = _a.minimumManifestUpdateInterval, segmentFetcherCreator = _a.segmentFetcherCreator, setCurrentTime = _a.setCurrentTime, speed$ = _a.speed$, startAt = _a.startAt, textTrackOptions = _a.textTrackOptions;
+    var adaptiveOptions = _a.adaptiveOptions, autoPlay = _a.autoPlay, bufferOptions = _a.bufferOptions, keySystems = _a.keySystems, lowLatencyMode = _a.lowLatencyMode, manifest$ = _a.manifest$, manifestFetcher = _a.manifestFetcher, mediaElement = _a.mediaElement, minimumManifestUpdateInterval = _a.minimumManifestUpdateInterval, playbackObserver = _a.playbackObserver, segmentFetcherCreator = _a.segmentFetcherCreator, speed = _a.speed, startAt = _a.startAt, textTrackOptions = _a.textTrackOptions;
     /** Choose the right "Representation" for a given "Adaptation". */
     var abrManager = new ABRManager(adaptiveOptions);
     /**
@@ -115,14 +114,15 @@ export default function InitializeOnMediaSource(_a) {
                 return openMediaSource$.pipe(mergeMap(function () {
                     // Now that the MediaSource has been opened and linked to the media
                     // element we can attach the MediaKeys instance to the latter.
-                    evt.value.attachMediaKeys$.next();
+                    evt.value.canAttachMediaKeys.setValue(true);
                     // If the `disableMediaKeysAttachmentLock` option has been set to
                     // `true`, we should not wait until the MediaKeys instance has been
                     // attached to start loading the content.
+                    // TODO we may want to keep keySystems option knowledge in the EME
+                    // code
                     var shouldDisableLock = evt.value.options
                         .disableMediaKeysAttachmentLock === true;
-                    return shouldDisableLock ? observableOf({ isEmeReady: true,
-                        drmSystemId: drmSystemId_1 }) :
+                    return shouldDisableLock ? observableOf({ isEmeReady: true, drmSystemId: drmSystemId_1 }) :
                         EMPTY;
                 }), startWith({ isEmeReady: false, drmSystemId: drmSystemId_1 }));
             default:
@@ -148,23 +148,19 @@ export default function InitializeOnMediaSource(_a) {
         var mediaSourceLoader = createMediaSourceLoader({
             abrManager: abrManager,
             bufferOptions: objectAssign({ textTrackOptions: textTrackOptions, drmSystemId: drmSystemId }, bufferOptions),
-            clock$: clock$,
             manifest: manifest,
             mediaElement: mediaElement,
+            playbackObserver: playbackObserver,
             segmentFetcherCreator: segmentFetcherCreator,
-            speed$: speed$,
-            setCurrentTime: setCurrentTime,
+            speed: speed,
         });
         // handle initial load and reloads
         var recursiveLoad$ = recursivelyLoadOnMediaSource(initialMediaSource, initialTime, autoPlay);
         // Emit when we want to manually update the manifest.
         var scheduleRefresh$ = new Subject();
-        var manifestUpdate$ = manifestUpdateScheduler({ initialManifest: manifestEvt,
-            manifestFetcher: manifestFetcher,
-            minimumManifestUpdateInterval: minimumManifestUpdateInterval,
-            scheduleRefresh$: scheduleRefresh$ });
+        var manifestUpdate$ = manifestUpdateScheduler({ initialManifest: manifestEvt, manifestFetcher: manifestFetcher, minimumManifestUpdateInterval: minimumManifestUpdateInterval, scheduleRefresh$: scheduleRefresh$ });
         var manifestEvents$ = observableMerge(fromEvent(manifest, "manifestUpdate")
-            .pipe(mapTo(EVENTS.manifestUpdate())), fromEvent(manifest, "decipherabilityUpdate")
+            .pipe(map(function () { return EVENTS.manifestUpdate(); })), fromEvent(manifest, "decipherabilityUpdate")
             .pipe(map(EVENTS.decipherabilityUpdate)));
         var setUndecipherableRepresentations$ = emeManager$.pipe(tap(function (evt) {
             if (evt.type === "keys-update") {
@@ -174,7 +170,13 @@ export default function InitializeOnMediaSource(_a) {
                 log.info("Init: blacklisting Representations based on protection data.");
                 manifest.addUndecipherableProtectionData(evt.value);
             }
-        }), ignoreElements());
+        }), 
+        // 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 */
+        ignoreElements());
         return observableMerge(manifestEvents$, manifestUpdate$, setUndecipherableRepresentations$, recursiveLoad$)
             .pipe(startWith(EVENTS.manifestReady(manifest)), finalize(function () { scheduleRefresh$.complete(); }));
         /**
@@ -216,17 +218,17 @@ export default function InitializeOnMediaSource(_a) {
                         // to flush the buffers
                         var position = evt.value.position;
                         if (position + 0.001 < evt.value.duration) {
-                            setCurrentTime(mediaElement.currentTime + 0.001);
+                            playbackObserver.setCurrentTime(mediaElement.currentTime + 0.001);
                         }
                         else {
-                            setCurrentTime(position);
+                            playbackObserver.setCurrentTime(position);
                         }
                         return null;
                     case "encryption-data-encountered":
                         protectedSegments$.next(evt.value);
                         return null;
                     case "needs-buffer-flush":
-                        setCurrentTime(mediaElement.currentTime + 0.001);
+                        playbackObserver.setCurrentTime(mediaElement.currentTime + 0.001);
                         return null;
                 }
                 return evt;

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

@@ -15,30 +15,27 @@
  */
 import { Observable } from "rxjs";
 import Manifest from "../../manifest";
+import { IReadOnlySharedReference } from "../../utils/reference";
 import ABRManager from "../abr";
+import { PlaybackObserver } from "../api";
 import { SegmentFetcherCreator } from "../fetchers";
 import { IStreamOrchestratorOptions } from "../stream";
-import { IInitClockTick, IMediaSourceLoaderEvent } from "./types";
+import { IMediaSourceLoaderEvent } from "./types";
 /** Arguments needed by `createMediaSourceLoader`. */
 export interface IMediaSourceLoaderArguments {
     /** Module helping to choose the right Representation. */
     abrManager: ABRManager;
     /** Various stream-related options. */
     bufferOptions: IStreamOrchestratorOptions;
-    /** Observable emitting playback conditions regularly. */
-    clock$: Observable<IInitClockTick>;
     manifest: Manifest;
     /** Media Element on which the content will be played. */
     mediaElement: HTMLMediaElement;
+    /** Emit playback conditions regularly. */
+    playbackObserver: PlaybackObserver;
     /** Module to facilitate segment fetching. */
-    segmentFetcherCreator: SegmentFetcherCreator<any>;
-    /**
-     * Observable emitting the wanted playback rate as it changes.
-     * Replay the last value on subscription.
-     */
-    speed$: Observable<number>;
-    /** Perform an internal seek */
-    setCurrentTime: (nb: number) => void;
+    segmentFetcherCreator: SegmentFetcherCreator;
+    /** Last wanted playback rate. */
+    speed: IReadOnlySharedReference<number>;
 }
 /**
  * Returns a function allowing to load or reload the content in arguments into
@@ -46,4 +43,4 @@ export interface IMediaSourceLoaderArguments {
  * @param {Object} args
  * @returns {Function}
  */
-export default function createMediaSourceLoader({ mediaElement, manifest, clock$, speed$, bufferOptions, abrManager, segmentFetcherCreator, setCurrentTime }: IMediaSourceLoaderArguments): (mediaSource: MediaSource, initialTime: number, autoPlay: boolean) => Observable<IMediaSourceLoaderEvent>;
+export default function createMediaSourceLoader({ mediaElement, manifest, speed, bufferOptions, abrManager, playbackObserver, segmentFetcherCreator }: IMediaSourceLoaderArguments): (mediaSource: MediaSource, initialTime: number, autoPlay: boolean) => Observable<IMediaSourceLoaderEvent>;

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

@@ -13,17 +13,16 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { EMPTY, merge as observableMerge, of as observableOf, Subject, throwError, } from "rxjs";
-import { filter, finalize, ignoreElements, mergeMap, takeUntil, } from "rxjs/operators";
+import { EMPTY, filter, finalize, ignoreElements, merge as observableMerge, mergeMap, of as observableOf, Subject, switchMap, takeUntil, throwError, } from "rxjs";
 import { MediaError } from "../../errors";
 import log from "../../log";
 import SegmentBuffersStore from "../segment_buffers";
 import StreamOrchestrator from "../stream";
-import createStreamClock from "./create_stream_clock";
+import createStreamPlaybackObserver from "./create_stream_playback_observer";
 import DurationUpdater from "./duration_updater";
+import emitLoadedEvent from "./emit_loaded_event";
 import { maintainEndOfStream } from "./end_of_stream";
-import EVENTS from "./events_generators";
-import seekAndLoadOnMediaEvents from "./initial_seek_and_play";
+import initialSeekAndPlay from "./initial_seek_and_play";
 import StallAvoider from "./stall_avoider";
 import streamEventsEmitter from "./stream_events_emitter";
 import updatePlaybackRate from "./update_playback_rate";
@@ -34,7 +33,7 @@ import updatePlaybackRate from "./update_playback_rate";
  * @returns {Function}
  */
 export default function createMediaSourceLoader(_a) {
-    var mediaElement = _a.mediaElement, manifest = _a.manifest, clock$ = _a.clock$, speed$ = _a.speed$, bufferOptions = _a.bufferOptions, abrManager = _a.abrManager, segmentFetcherCreator = _a.segmentFetcherCreator, setCurrentTime = _a.setCurrentTime;
+    var mediaElement = _a.mediaElement, manifest = _a.manifest, speed = _a.speed, bufferOptions = _a.bufferOptions, abrManager = _a.abrManager, playbackObserver = _a.playbackObserver, segmentFetcherCreator = _a.segmentFetcherCreator;
     /**
      * Load the content on the given MediaSource.
      * @param {MediaSource} mediaSource
@@ -50,28 +49,21 @@ export default function createMediaSourceLoader(_a) {
             var error_1 = new MediaError("MEDIA_STARTING_TIME_NOT_FOUND", "Wanted starting time not found in the Manifest.");
             return throwError(function () { return error_1; });
         }
-        /** Interface to create media buffers for loaded segments. */
+        /** Interface to create media buffers. */
         var segmentBuffersStore = new SegmentBuffersStore(mediaElement, mediaSource);
-        var _b = seekAndLoadOnMediaEvents({ clock$: clock$,
-            mediaElement: mediaElement,
-            startTime: initialTime,
-            mustAutoPlay: autoPlay,
-            setCurrentTime: setCurrentTime,
-            isDirectfile: false }), seek$ = _b.seek$, load$ = _b.load$;
-        var initialPlay$ = load$.pipe(filter(function (evt) { return evt !== "not-loaded-metadata"; }));
-        var streamEvents$ = initialPlay$.pipe(mergeMap(function () { return streamEventsEmitter(manifest, mediaElement, clock$); }));
-        var streamClock$ = createStreamClock(clock$, { autoPlay: autoPlay,
-            initialPlay$: initialPlay$,
-            initialSeek$: seek$,
-            manifest: manifest,
-            speed$: speed$,
-            startTime: initialTime });
+        var _b = initialSeekAndPlay({ mediaElement: mediaElement, playbackObserver: playbackObserver, startTime: initialTime,
+            mustAutoPlay: autoPlay }), seekAndPlay$ = _b.seekAndPlay$, initialPlayPerformed = _b.initialPlayPerformed, initialSeekPerformed = _b.initialSeekPerformed;
+        var observation$ = playbackObserver.observe(true);
+        var streamEvents$ = initialPlayPerformed.asObservable().pipe(filter(function (hasPlayed) { return hasPlayed; }), mergeMap(function () { return streamEventsEmitter(manifest, mediaElement, observation$); }));
+        var streamObserver = createStreamPlaybackObserver(manifest, playbackObserver, { autoPlay: autoPlay, initialPlayPerformed: initialPlayPerformed, initialSeekPerformed: initialSeekPerformed, speed: speed, startTime: initialTime });
         /** Cancel endOfStream calls when streams become active again. */
         var cancelEndOfStream$ = new Subject();
         /** Emits discontinuities detected by the StreamOrchestrator. */
         var discontinuityUpdate$ = new Subject();
+        /** Emits event when streams are "locked", meaning they cannot load segments. */
+        var lockedStream$ = new Subject();
         // Creates Observable which will manage every Stream for the given Content.
-        var streams$ = StreamOrchestrator({ manifest: manifest, initialPeriod: initialPeriod }, streamClock$, abrManager, segmentBuffersStore, segmentFetcherCreator, bufferOptions).pipe(mergeMap(function (evt) {
+        var streams$ = StreamOrchestrator({ manifest: manifest, initialPeriod: initialPeriod }, streamObserver, abrManager, segmentBuffersStore, segmentFetcherCreator, bufferOptions).pipe(mergeMap(function (evt) {
             switch (evt.type) {
                 case "end-of-stream":
                     log.debug("Init: end-of-stream order received.");
@@ -82,10 +74,10 @@ export default function createMediaSourceLoader(_a) {
                     return EMPTY;
                 case "stream-status":
                     var _a = evt.value, period = _a.period, bufferType = _a.bufferType, imminentDiscontinuity = _a.imminentDiscontinuity, position = _a.position;
-                    discontinuityUpdate$.next({ period: period,
-                        bufferType: bufferType,
-                        discontinuity: imminentDiscontinuity,
-                        position: position });
+                    discontinuityUpdate$.next({ period: period, bufferType: bufferType, discontinuity: imminentDiscontinuity, position: position });
+                    return EMPTY;
+                case "locked-stream":
+                    lockedStream$.next(evt.value);
                     return EMPTY;
                 default:
                     return observableOf(evt);
@@ -96,29 +88,24 @@ export default function createMediaSourceLoader(_a) {
          * the user on the media element and force a speed of `0` when the buffer is
          * empty, so it can build back buffer.
          */
-        var playbackRate$ = updatePlaybackRate(mediaElement, speed$, clock$)
+        var playbackRate$ = updatePlaybackRate(mediaElement, speed, observation$)
             .pipe(ignoreElements());
         /**
          * 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(clock$, mediaElement, manifest, discontinuityUpdate$, setCurrentTime);
-        var loadedEvent$ = load$
-            .pipe(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(segmentBuffersStore));
-            }
-            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));
-            }
-            log.debug("Init: The current content is loaded.");
-            return observableOf(EVENTS.loaded(segmentBuffersStore));
+        var stallAvoider$ = StallAvoider(playbackObserver, manifest, lockedStream$, discontinuityUpdate$);
+        /**
+         * 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$ = seekAndPlay$.pipe(switchMap(function (evt) {
+            return evt.type === "warning" ?
+                observableOf(evt) :
+                emitLoadedEvent(observation$, mediaElement, segmentBuffersStore, false);
         }));
-        return observableMerge(durationUpdater$, loadedEvent$, playbackRate$, stallAvoider$, streams$, streamEvents$).pipe(finalize(function () {
+        return observableMerge(durationUpdater$, loadingEvts$, playbackRate$, stallAvoider$, streams$, streamEvents$).pipe(finalize(function () {
             // clean-up every created SegmentBuffers
             segmentBuffersStore.disposeAll();
         }));

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

@@ -24,9 +24,9 @@ export interface IManifestUpdateSchedulerArguments {
     /** Information about the initial load of the manifest */
     initialManifest: {
         manifest: Manifest;
-        sendingTime?: number;
-        receivedTime?: number;
-        parsingTime?: number;
+        sendingTime?: number | undefined;
+        receivedTime?: number | undefined;
+        parsingTime?: number | undefined;
     };
     /** Minimum interval to keep between Manifest updates */
     minimumManifestUpdateInterval: number;
@@ -47,7 +47,7 @@ export interface IManifestRefreshSchedulerEvent {
      * Optional wanted refresh delay, which is the minimum time you want to wait
      * before updating the Manifest
      */
-    delay?: number;
+    delay?: number | undefined;
     /**
      * Whether the parsing can be done in the more efficient "unsafeMode".
      * This mode is extremely fast but can lead to de-synchronisation with the

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

@@ -13,8 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { defer as observableDefer, EMPTY, from as observableFrom, merge as observableMerge, of as observableOf, timer as observableTimer, } from "rxjs";
-import { mapTo, mergeMap, mergeMapTo, share, take, } from "rxjs/operators";
+import { defer as observableDefer, EMPTY, from as observableFrom, map, merge as observableMerge, mergeMap, of as observableOf, share, take, timer as observableTimer, } from "rxjs";
 import config from "../../config";
 import log from "../../log";
 import throttle from "../../utils/rx-throttle";
@@ -81,19 +80,20 @@ export default function manifestUpdateScheduler(_a) {
             var completeRefresh = _a.completeRefresh, delay = _a.delay, canUseUnsafeMode = _a.canUseUnsafeMode;
             var unsafeMode = canUseUnsafeMode && unsafeModeEnabled;
             return startManualRefreshTimer(delay !== null && delay !== void 0 ? delay : 0, minimumManifestUpdateInterval, sendingTime)
-                .pipe(mapTo({ completeRefresh: completeRefresh, unsafeMode: unsafeMode }));
+                .pipe(map(function () { return ({ completeRefresh: completeRefresh, unsafeMode: unsafeMode }); }));
         }));
         /** Emit when the Manifest tells us that it has "expired". */
         var expired$ = manifest.expired === null ?
             EMPTY :
-            observableTimer(minInterval)
-                .pipe(mergeMapTo(observableFrom(manifest.expired)), mapTo({ completeRefresh: true, unsafeMode: unsafeModeEnabled }));
+            observableTimer(minInterval).pipe(mergeMap(function () {
+                return manifest.expired === null ? EMPTY :
+                    observableFrom(manifest.expired);
+            }), map(function () { return ({ completeRefresh: true, unsafeMode: unsafeModeEnabled }); }));
         /** Emit when the Manifest should normally be refreshed. */
         var autoRefresh$ = createAutoRefreshObservable();
         return observableMerge(autoRefresh$, internalRefresh$, expired$).pipe(take(1), mergeMap(function (_a) {
             var completeRefresh = _a.completeRefresh, unsafeMode = _a.unsafeMode;
-            return refreshManifest({ completeRefresh: completeRefresh,
-                unsafeMode: unsafeMode });
+            return refreshManifest({ completeRefresh: completeRefresh, unsafeMode: unsafeMode });
         }), mergeMap(function (evt) {
             if (evt.type === "warning") {
                 return observableOf(evt);
@@ -150,7 +150,7 @@ export default function manifestUpdateScheduler(_a) {
                 actualRefreshInterval = regularRefreshDelay;
             }
             return observableTimer(Math.max(actualRefreshInterval, minInterval))
-                .pipe(mapTo({ completeRefresh: false, unsafeMode: unsafeModeEnabled }));
+                .pipe(map(function () { return ({ completeRefresh: false, unsafeMode: unsafeModeEnabled }); }));
         }
     }
     /**
@@ -176,9 +176,7 @@ export default function manifestUpdateScheduler(_a) {
                 String(consecutiveUnsafeMode) + " consecutive times.");
             consecutiveUnsafeMode = 0;
         }
-        return fetchManifest(refreshURL, { externalClockOffset: externalClockOffset,
-            previousManifest: manifest,
-            unsafeMode: unsafeMode })
+        return fetchManifest(refreshURL, { externalClockOffset: externalClockOffset, previousManifest: manifest, unsafeMode: unsafeMode })
             .pipe(mergeMap(function (value) {
             if (value.type === "warning") {
                 return observableOf(value);
@@ -195,19 +193,14 @@ export default function manifestUpdateScheduler(_a) {
                 catch (e) {
                     var message = e instanceof Error ? e.message :
                         "unknown error";
-                    log.warn("MUS: Attempt to update Manifest failed: " + message, "Re-downloading the Manifest fully");
+                    log.warn("MUS: Attempt to update Manifest failed: ".concat(message), "Re-downloading the Manifest fully");
                     return startManualRefreshTimer(FAILED_PARTIAL_UPDATE_MANIFEST_REFRESH_DELAY, minimumManifestUpdateInterval, newSendingTime)
                         .pipe(mergeMap(function () {
                         return refreshManifest({ completeRefresh: true, unsafeMode: false });
                     }));
                 }
             }
-            return observableOf({ type: "parsed",
-                manifest: manifest,
-                sendingTime: newSendingTime,
-                receivedTime: receivedTime,
-                parsingTime: parsingTime,
-                updatingTime: performance.now() - updateTimeStart });
+            return observableOf({ type: "parsed", manifest: manifest, sendingTime: newSendingTime, receivedTime: receivedTime, parsingTime: parsingTime, updatingTime: performance.now() - updateTimeStart });
         }));
     }
 }

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

@@ -15,8 +15,15 @@
  */
 import { Observable } from "rxjs";
 import Manifest, { Period } from "../../manifest";
+import { PlaybackObserver } from "../api";
 import { IBufferType } from "../segment_buffers";
-import { IInitClockTick, IStalledEvent, IUnstalledEvent, IWarningEvent } from "./types";
+import { IStalledEvent, IUnstalledEvent, IWarningEvent } from "./types";
+export interface ILockedStreamEvent {
+    /** Buffer type for which no segment will currently load. */
+    bufferType: IBufferType;
+    /** Period for which no segment will currently load. */
+    period: Period;
+}
 /**
  * Event indicating that a discontinuity has been found.
  * Each event for a `bufferType` and `period` combination replaces the previous
@@ -56,15 +63,13 @@ export interface IDiscontinuityTimeInfo {
 }
 /**
  * Monitor situations where playback is stalled and try to get out of those.
- * Emit "stalled" then "unstalled" respectably when an unavoidable stall is
+ * Emit "stalled" then "unstalled" respectively when an unavoidable stall is
  * encountered and exited.
- * @param {Observable} clock$ - Observable emitting the current playback
- * conditions.
- * @param {HTMLMediaElement} mediaElement - The HTMLMediaElement on which the
- * media is played.
+ * @param {object} playbackObserver - emit the current playback conditions.
  * @param {Object} manifest - The Manifest of the currently-played content.
  * @param {Observable} discontinuityUpdate$ - Observable emitting encountered
  * discontinuities for loaded Period and buffer types.
+ * @param {Function} setCurrentTime
  * @returns {Observable}
  */
-export default function StallAvoider(clock$: Observable<IInitClockTick>, mediaElement: HTMLMediaElement, manifest: Manifest, discontinuityUpdate$: Observable<IDiscontinuityEvent>, setCurrentTime: (nb: number) => void): Observable<IStalledEvent | IUnstalledEvent | IWarningEvent>;
+export default function StallAvoider(playbackObserver: PlaybackObserver, manifest: Manifest | null, lockedStream$: Observable<ILockedStreamEvent>, discontinuityUpdate$: Observable<IDiscontinuityEvent>): Observable<IStalledEvent | IUnstalledEvent | IWarningEvent>;