rx-player 3.25.2 → 3.26.3-dev.2022021400

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

@@ -13,15 +13,14 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { map, scan, withLatestFrom, } from "rxjs/operators";
-import { isPlaybackStuck } from "../../compat";
+import { ignoreElements, map, merge as observableMerge, scan, tap, withLatestFrom, } from "rxjs";
 import isSeekingApproximate from "../../compat/is_seeking_approximate";
 import config from "../../config";
 import { MediaError } from "../../errors";
 import log from "../../log";
 import { getNextRangeGap } from "../../utils/ranges";
 import EVENTS from "../stream/events_generators";
-var BUFFER_DISCONTINUITY_THRESHOLD = config.BUFFER_DISCONTINUITY_THRESHOLD, FORCE_DISCONTINUITY_SEEK_DELAY = config.FORCE_DISCONTINUITY_SEEK_DELAY;
+var BUFFER_DISCONTINUITY_THRESHOLD = config.BUFFER_DISCONTINUITY_THRESHOLD, FORCE_DISCONTINUITY_SEEK_DELAY = config.FORCE_DISCONTINUITY_SEEK_DELAY, FREEZING_STALLED_DELAY = config.FREEZING_STALLED_DELAY, UNFREEZING_SEEK_DELAY = config.UNFREEZING_SEEK_DELAY, UNFREEZING_DELTA_POSITION = config.UNFREEZING_DELTA_POSITION;
 /**
  * Work-around rounding errors with floating points by setting an acceptable,
  * very short, deviation when checking equalities.
@@ -29,27 +28,24 @@ var BUFFER_DISCONTINUITY_THRESHOLD = config.BUFFER_DISCONTINUITY_THRESHOLD, FORC
 var EPSILON = 1 / 60;
 /**
  * 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$, mediaElement, manifest, discontinuityUpdate$, setCurrentTime) {
+export default function StallAvoider(playbackObserver, manifest, lockedStream$, discontinuityUpdate$) {
     var initialDiscontinuitiesStore = [];
     /**
      * Emit every known audio and video buffer discontinuities in chronological
      * order (first ordered by Period's start, then by bufferType in any order.
      */
-    var discontinuitiesStore$ = discontinuityUpdate$.pipe(withLatestFrom(clock$), // listen to clock to clean-up old discontinuities
-    scan(function (discontinuitiesStore, _a) {
-        var evt = _a[0], tick = _a[1];
-        return updateDiscontinuitiesStore(discontinuitiesStore, evt, tick);
+    var discontinuitiesStore$ = discontinuityUpdate$.pipe(withLatestFrom(playbackObserver.observe(true)), scan(function (discontinuitiesStore, _a) {
+        var evt = _a[0], observation = _a[1];
+        return updateDiscontinuitiesStore(discontinuitiesStore, evt, observation);
     }, initialDiscontinuitiesStore));
     /**
      * On some devices (right now only seen on Tizen), seeking through the
@@ -76,15 +72,83 @@ export default function StallAvoider(clock$, mediaElement, manifest, discontinui
      * to be ignored.
      */
     var ignoredStallTimeStamp = null;
-    return clock$.pipe(withLatestFrom(discontinuitiesStore$), map(function (_a) {
-        var tick = _a[0], discontinuitiesStore = _a[1];
-        var buffered = tick.buffered, currentRange = tick.currentRange, position = tick.position, event = tick.event, stalled = tick.stalled;
-        if (stalled === null) {
+    var prevFreezingState;
+    /**
+     * If we're rebuffering waiting on data of a "locked stream", seek into the
+     * Period handled by that stream to unlock the situation.
+     */
+    var unlock$ = lockedStream$.pipe(withLatestFrom(playbackObserver.observe(true)), tap(function (_a) {
+        var _b;
+        var lockedStreamEvt = _a[0], observation = _a[1];
+        // TODO(PaulB) also skip when the user's wanted speed is set to `0`, as we
+        // might not want to seek in that case?
+        if (!observation.rebuffering ||
+            observation.paused || (lockedStreamEvt.bufferType !== "audio" &&
+            lockedStreamEvt.bufferType !== "video")) {
+            return;
+        }
+        var currPos = observation.position;
+        var rebufferingPos = (_b = observation.rebuffering.position) !== null && _b !== void 0 ? _b : currPos;
+        var lockedPeriodStart = lockedStreamEvt.period.start;
+        if (currPos < lockedPeriodStart &&
+            Math.abs(rebufferingPos - lockedPeriodStart) < 1) {
+            log.warn("Init: rebuffering because of a future locked stream.\n" +
+                "Trying to unlock by seeking to the next Period");
+            playbackObserver.setCurrentTime(lockedPeriodStart + 0.001);
+        }
+    }), 
+    // 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());
+    var stall$ = playbackObserver.observe(true).pipe(withLatestFrom(discontinuitiesStore$), map(function (_a) {
+        var observation = _a[0], discontinuitiesStore = _a[1];
+        var buffered = observation.buffered, position = observation.position, readyState = observation.readyState, rebuffering = observation.rebuffering, freezing = observation.freezing;
+        if (freezing !== null) {
+            var now = performance.now();
+            var referenceTimestamp = prevFreezingState === null ?
+                freezing.timestamp :
+                prevFreezingState.attemptTimestamp;
+            if (now - referenceTimestamp > UNFREEZING_SEEK_DELAY) {
+                log.warn("Init: trying to seek to un-freeze player");
+                playbackObserver.setCurrentTime(playbackObserver.getCurrentTime() + UNFREEZING_DELTA_POSITION);
+                prevFreezingState = { attemptTimestamp: now };
+            }
+            if (now - freezing.timestamp > FREEZING_STALLED_DELAY) {
+                return { type: "stalled",
+                    value: "freezing" };
+            }
+        }
+        else {
+            prevFreezingState = null;
+        }
+        if (rebuffering === null) {
+            if (readyState === 1) {
+                // With a readyState set to 1, we should still not be able to play:
+                // Return that we're stalled
+                var reason = void 0;
+                if (observation.seeking) {
+                    reason = observation.internalSeeking ? "internal-seek" :
+                        "seeking";
+                }
+                else {
+                    reason = "not-ready";
+                }
+                return { type: "stalled",
+                    value: reason };
+            }
             return { type: "unstalled",
                 value: null };
         }
-        if (tick.seeking) {
-            lastSeekingPosition = tick.position;
+        // We want to separate a stall situation when a seek is due to a seek done
+        // internally by the player to when its due to a regular user seek.
+        var stalledReason = rebuffering.reason === "seeking" &&
+            observation.internalSeeking ? "internal-seek" :
+            rebuffering.reason;
+        if (observation.seeking) {
+            lastSeekingPosition = observation.position;
         }
         else if (lastSeekingPosition !== null) {
             var now = performance.now();
@@ -92,36 +156,34 @@ export default function StallAvoider(clock$, mediaElement, manifest, discontinui
                 ignoredStallTimeStamp = now;
             }
             if (isSeekingApproximate &&
-                tick.position < lastSeekingPosition &&
+                observation.position < lastSeekingPosition &&
                 now - ignoredStallTimeStamp < FORCE_DISCONTINUITY_SEEK_DELAY) {
                 return { type: "stalled",
-                    value: stalled };
+                    value: stalledReason };
             }
             lastSeekingPosition = null;
         }
         ignoredStallTimeStamp = null;
+        if (manifest === null) {
+            return { type: "stalled",
+                value: stalledReason };
+        }
         /** Position at which data is awaited. */
-        var stalledPosition = stalled.position;
+        var stalledPosition = rebuffering.position;
         if (stalledPosition !== null) {
             var skippableDiscontinuity = findSeekableDiscontinuity(discontinuitiesStore, manifest, stalledPosition);
             if (skippableDiscontinuity !== null) {
                 var realSeekTime = skippableDiscontinuity + 0.001;
-                if (realSeekTime <= mediaElement.currentTime) {
-                    log.info("Init: position to seek already reached, no seeking", mediaElement.currentTime, realSeekTime);
+                if (realSeekTime <= playbackObserver.getCurrentTime()) {
+                    log.info("Init: position to seek already reached, no seeking", playbackObserver.getCurrentTime(), realSeekTime);
                 }
                 else {
                     log.warn("SA: skippable discontinuity found in the stream", position, realSeekTime);
-                    setCurrentTime(realSeekTime);
+                    playbackObserver.setCurrentTime(realSeekTime);
                     return EVENTS.warning(generateDiscontinuityError(stalledPosition, realSeekTime));
                 }
             }
         }
-        // Is it a browser bug? -> force seek at the same current time
-        if (isPlaybackStuck(position, currentRange, event, stalled !== null)) {
-            log.warn("Init: After freeze seek", position, currentRange);
-            setCurrentTime(position);
-            return EVENTS.warning(generateDiscontinuityError(position, position));
-        }
         var freezePosition = stalledPosition !== null && stalledPosition !== void 0 ? stalledPosition : position;
         // Is it a very short discontinuity in buffer ? -> Seek at the beginning of the
         //                                                 next range
@@ -133,9 +195,9 @@ export default function StallAvoider(clock$, mediaElement, manifest, discontinui
         var nextBufferRangeGap = getNextRangeGap(buffered, freezePosition);
         if (nextBufferRangeGap < BUFFER_DISCONTINUITY_THRESHOLD) {
             var seekTo = (freezePosition + nextBufferRangeGap + EPSILON);
-            if (mediaElement.currentTime < seekTo) {
+            if (playbackObserver.getCurrentTime() < seekTo) {
                 log.warn("Init: discontinuity encountered inferior to the threshold", freezePosition, seekTo, BUFFER_DISCONTINUITY_THRESHOLD);
-                setCurrentTime(seekTo);
+                playbackObserver.setCurrentTime(seekTo);
                 return EVENTS.warning(generateDiscontinuityError(freezePosition, seekTo));
             }
         }
@@ -145,17 +207,18 @@ export default function StallAvoider(clock$, mediaElement, manifest, discontinui
             var period = manifest.periods[i];
             if (period.end !== undefined && period.end <= freezePosition) {
                 if (manifest.periods[i + 1].start > freezePosition &&
-                    manifest.periods[i + 1].start > mediaElement.currentTime) {
+                    manifest.periods[i + 1].start > playbackObserver.getCurrentTime()) {
                     var nextPeriod = manifest.periods[i + 1];
-                    setCurrentTime(nextPeriod.start);
+                    playbackObserver.setCurrentTime(nextPeriod.start);
                     return EVENTS.warning(generateDiscontinuityError(freezePosition, nextPeriod.start));
                 }
                 break;
             }
         }
         return { type: "stalled",
-            value: stalled };
+            value: stalledReason };
     }));
+    return observableMerge(unlock$, stall$);
 }
 /**
  * @param {Array.<Object>} discontinuitiesStore
@@ -223,14 +286,14 @@ function eventContainsDiscontinuity(evt) {
  *     store it in Period's chronological order in the Array.
  * @param {Array.<Object>} discontinuitiesStore
  * @param {Object} evt
- * @param {Object} tick
+ * @param {Object} observation
  * @returns {Array.<Object>}
  */
-function updateDiscontinuitiesStore(discontinuitiesStore, evt, tick) {
+function updateDiscontinuitiesStore(discontinuitiesStore, evt, observation) {
     // First, perform clean-up of old discontinuities
     while (discontinuitiesStore.length > 0 &&
         discontinuitiesStore[0].period.end !== undefined &&
-        discontinuitiesStore[0].period.end + 10 < tick.position) {
+        discontinuitiesStore[0].period.end + 10 < observation.position) {
         discontinuitiesStore.shift();
     }
     var period = evt.period, bufferType = evt.bufferType;

package/dist/_esm5.processed/core/init/stream_events_emitter/are_same_stream_events.d.ts

@@ -28,12 +28,12 @@
  * @returns {Boolean}
  */
 declare function areSameStreamEvents(evt1: {
-    id?: string;
+    id?: string | undefined;
     start: number;
-    end?: number;
+    end?: number | undefined;
 }, evt2: {
-    id?: string;
+    id?: string | undefined;
     start: number;
-    end?: number;
+    end?: number | undefined;
 }): boolean;
 export default areSameStreamEvents;

package/dist/_esm5.processed/core/init/stream_events_emitter/refresh_scheduled_events_list.js

@@ -36,21 +36,11 @@ function refreshScheduledEventsList(oldScheduledEvents, manifest) {
                 }
             }
             if (end === undefined) {
-                var newScheduledEvent = { start: start,
-                    id: id,
-                    data: data,
-                    publicEvent: { start: start,
-                        data: data } };
+                var newScheduledEvent = { start: start, id: id, data: data, publicEvent: { start: start, data: data } };
                 scheduledEvents.push(newScheduledEvent);
             }
             else {
-                var newScheduledEvent = { start: start,
-                    end: end,
-                    id: id,
-                    data: data,
-                    publicEvent: { start: start,
-                        end: end,
-                        data: data } };
+                var newScheduledEvent = { start: start, end: end, id: id, data: data, publicEvent: { start: start, end: end, data: data } };
                 scheduledEvents.push(newScheduledEvent);
             }
         });

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

@@ -15,7 +15,7 @@
  */
 import { Observable } from "rxjs";
 import Manifest from "../../../manifest";
-import { IInitClockTick } from "../types";
+import { IPlaybackObservation } from "../../api";
 import { IStreamEvent } from "./types";
 /**
  * Get events from manifest and emit each time an event has to be emitted
@@ -23,5 +23,5 @@ import { IStreamEvent } from "./types";
  * @param {HTMLMediaElement} mediaElement
  * @returns {Observable}
  */
-declare function streamEventsEmitter(manifest: Manifest, mediaElement: HTMLMediaElement, clock$: Observable<IInitClockTick>): Observable<IStreamEvent>;
+declare function streamEventsEmitter(manifest: Manifest, mediaElement: HTMLMediaElement, observation$: Observable<IPlaybackObservation>): Observable<IStreamEvent>;
 export default streamEventsEmitter;

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

@@ -13,8 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { combineLatest as observableCombineLatest, concat as observableConcat, EMPTY, interval, of as observableOf, } from "rxjs";
-import { distinctUntilChanged, ignoreElements, map, mergeMap, pairwise, scan, startWith, switchMap, tap, } from "rxjs/operators";
+import { combineLatest as observableCombineLatest, concat as observableConcat, distinctUntilChanged, EMPTY, ignoreElements, interval, map, mergeMap, pairwise, scan, startWith, switchMap, tap, of as observableOf, } from "rxjs";
 import config from "../../../config";
 import { fromEvent } from "../../../utils/event_emitter";
 import refreshScheduledEventsList from "./refresh_scheduled_events_list";
@@ -33,23 +32,23 @@ function isFiniteStreamEvent(evt) {
  * @param {HTMLMediaElement} mediaElement
  * @returns {Observable}
  */
-function streamEventsEmitter(manifest, mediaElement, clock$) {
+function streamEventsEmitter(manifest, mediaElement, observation$) {
     var eventsBeingPlayed = new WeakMap();
     var lastScheduledEvents = [];
     var scheduledEvents$ = fromEvent(manifest, "manifestUpdate").pipe(startWith(null), scan(function (oldScheduledEvents) {
         return refreshScheduledEventsList(oldScheduledEvents, manifest);
     }, []));
     /**
-     * Examine playback situation from clock ticks to emit stream events and
+     * Examine playback situation from playback observations to emit stream events and
      * prepare set onExit callbacks if needed.
      * @param {Array.<Object>} scheduledEvents
-     * @param {Object} oldTick
-     * @param {Object} newTick
+     * @param {Object} oldObservation
+     * @param {Object} newObservation
      * @returns {Observable}
      */
-    function emitStreamEvents$(scheduledEvents, oldClockTick, newClockTick) {
-        var previousTime = oldClockTick.currentTime;
-        var isSeeking = newClockTick.isSeeking, currentTime = newClockTick.currentTime;
+    function emitStreamEvents$(scheduledEvents, oldObservation, newObservation) {
+        var previousTime = oldObservation.currentTime;
+        var isSeeking = newObservation.isSeeking, currentTime = newObservation.currentTime;
         var eventsToSend = [];
         var eventsToExit = [];
         for (var i = 0; i < scheduledEvents.length; i++) {
@@ -94,7 +93,13 @@ function streamEventsEmitter(manifest, mediaElement, clock$) {
             if (typeof evt.onExit === "function") {
                 evt.onExit();
             }
-        }), ignoreElements()) : EMPTY);
+        }), 
+        // 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()) : EMPTY);
     }
     /**
      * This pipe allows to control wether the polling should occur, if there
@@ -106,15 +111,15 @@ function streamEventsEmitter(manifest, mediaElement, clock$) {
         }
         return observableCombineLatest([
             interval(STREAM_EVENT_EMITTER_POLL_INTERVAL).pipe(startWith(null)),
-            clock$,
+            observation$,
         ]).pipe(map(function (_a) {
-            var _ = _a[0], clockTick = _a[1];
-            var seeking = clockTick.seeking;
+            var _ = _a[0], observation = _a[1];
+            var seeking = observation.seeking;
             return { isSeeking: seeking,
                 currentTime: mediaElement.currentTime };
         }), pairwise(), mergeMap(function (_a) {
-            var oldTick = _a[0], newTick = _a[1];
-            return emitStreamEvents$(lastScheduledEvents, oldTick, newTick);
+            var oldObservation = _a[0], newObservation = _a[1];
+            return emitStreamEvents$(lastScheduledEvents, oldObservation, newObservation);
         }));
     }));
 }

package/dist/_esm5.processed/core/init/stream_events_emitter/types.d.ts

@@ -22,14 +22,14 @@ export interface IStreamEventData {
     };
 }
 export interface IStreamEventPayload {
-    id?: string;
+    id?: string | undefined;
     start: number;
     end: number;
     data: IStreamEventData;
     publicEvent: IPublicStreamEvent;
 }
 export interface INonFiniteStreamEventPayload {
-    id?: string;
+    id?: string | undefined;
     start: number;
     data: IStreamEventData;
     publicEvent: IPublicNonFiniteStreamEvent;

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

@@ -13,8 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { fromEvent as observableFromEvent, } from "rxjs";
-import { mergeMap } from "rxjs/operators";
+import { fromEvent as observableFromEvent, mergeMap, } from "rxjs";
 import { MediaError } from "../../errors";
 /**
  * Returns an observable which throws the right MediaError as soon an "error"

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

@@ -15,30 +15,11 @@
  */
 import { ICustomError } from "../../errors";
 import Manifest, { Adaptation, Period, Representation } from "../../manifest";
-import { IClockMediaEventType, IStalledStatus } from "../api";
 import { IAttachedMediaKeysEvent, IBlacklistProtectionDataEvent, ICreatedMediaKeysEvent, IEncryptedEvent, IInitDataIgnoredEvent, IKeysUpdateEvent, INoUpdateEvent, ISessionMessageEvent, ISessionUpdatedEvent } from "../eme";
 import SegmentBuffersStore from "../segment_buffers";
-import { IActivePeriodChangedEvent, IAdaptationChangeEvent, IBitrateEstimationChangeEvent, ICompletedStreamEvent, IEncryptionDataEncounteredEvent, IInbandEventsEvent, INeedsDecipherabilityFlush, INeedsMediaSourceReload, IPeriodStreamClearedEvent, IPeriodStreamReadyEvent, IRepresentationChangeEvent, IStreamEventAddedSegment, IStreamManifestMightBeOutOfSync, IStreamNeedsManifestRefresh } from "../stream";
+import { IActivePeriodChangedEvent, IAdaptationChangeEvent, IBitrateEstimationChangeEvent, ICompletedStreamEvent, IEncryptionDataEncounteredEvent, IInbandEventsEvent, INeedsBufferFlushEvent, INeedsDecipherabilityFlush, INeedsMediaSourceReload, IPeriodStreamClearedEvent, IPeriodStreamReadyEvent, IRepresentationChangeEvent, IStreamEventAddedSegment, IStreamManifestMightBeOutOfSync, IStreamNeedsManifestRefresh } from "../stream";
 import { IEMEDisabledEvent } from "./create_eme_manager";
 import { IStreamEventEvent, IStreamEventSkipEvent } from "./stream_events_emitter";
-/** Object awaited by the `Init` on each clock tick. */
-export interface IInitClockTick {
-    position: number;
-    getCurrentTime: () => number;
-    buffered: TimeRanges;
-    duration: number;
-    bufferGap: number;
-    event: IClockMediaEventType;
-    playbackRate: number;
-    currentRange: {
-        start: number;
-        end: number;
-    } | null;
-    readyState: number;
-    paused: boolean;
-    stalled: IStalledStatus | null;
-    seeking: boolean;
-}
 /** Event sent after the Manifest has been loaded and parsed for the first time. */
 export interface IManifestReadyEvent {
     type: "manifestReady";
@@ -80,15 +61,17 @@ export interface IReloadingMediaSourceEvent {
     type: "reloading-media-source";
     value: undefined;
 }
-export interface INeedsBufferFlush {
-    type: "needs-buffer-flush";
-    value: undefined;
-}
-/** Event sent after the player stalled, leading to buffering. */
+/** Event sent after the player stalled. */
 export interface IStalledEvent {
     type: "stalled";
-    value: IStalledStatus;
+    /** The reason behind the stall */
+    value: IStallingSituation;
 }
+export declare type IStallingSituation = "seeking" | // Rebuffering after seeking
+"not-ready" | // Rebuffering after low ready state
+"internal-seek" | // Rebuffering after a seek happened inside the player
+"buffering" | // Other rebuffering cases
+"freezing";
 /** Event sent when the player goes out of a stalling situation. */
 export interface IUnstalledEvent {
     type: "unstalled";
@@ -106,8 +89,8 @@ export interface ILoadedEvent {
 }
 export { IRepresentationChangeEvent };
 /** Events emitted by a `MediaSourceLoader`. */
-export declare type IMediaSourceLoaderEvent = IStalledEvent | IUnstalledEvent | ILoadedEvent | IWarningEvent | IStreamEventEvent | IStreamEventSkipEvent | IActivePeriodChangedEvent | IPeriodStreamClearedEvent | ICompletedStreamEvent | IPeriodStreamReadyEvent | INeedsMediaSourceReload | INeedsBufferFlush | IAdaptationChangeEvent | IBitrateEstimationChangeEvent | INeedsDecipherabilityFlush | IRepresentationChangeEvent | IStreamEventAddedSegment<unknown> | IEncryptionDataEncounteredEvent | IStreamManifestMightBeOutOfSync | IStreamNeedsManifestRefresh | IInbandEventsEvent;
+export declare type IMediaSourceLoaderEvent = IStalledEvent | IUnstalledEvent | ILoadedEvent | IWarningEvent | IStreamEventEvent | IStreamEventSkipEvent | IActivePeriodChangedEvent | IPeriodStreamClearedEvent | ICompletedStreamEvent | IPeriodStreamReadyEvent | INeedsMediaSourceReload | INeedsBufferFlushEvent | IAdaptationChangeEvent | IBitrateEstimationChangeEvent | INeedsDecipherabilityFlush | IRepresentationChangeEvent | IStreamEventAddedSegment<unknown> | IEncryptionDataEncounteredEvent | IStreamManifestMightBeOutOfSync | IStreamNeedsManifestRefresh | IInbandEventsEvent;
 /** Every events emitted by the `Init` module. */
-export declare type IInitEvent = IManifestReadyEvent | IManifestUpdateEvent | IReloadingMediaSourceEvent | INeedsBufferFlush | IDecipherabilityUpdateEvent | IWarningEvent | IEMEDisabledEvent | IEncryptedEvent | ICreatedMediaKeysEvent | IAttachedMediaKeysEvent | IInitDataIgnoredEvent | ISessionMessageEvent | IKeysUpdateEvent | INoUpdateEvent | ISessionUpdatedEvent | IBlacklistProtectionDataEvent | IStalledEvent | IUnstalledEvent | ILoadedEvent | IStreamEventEvent | IStreamEventSkipEvent | IActivePeriodChangedEvent | IPeriodStreamClearedEvent | ICompletedStreamEvent | IPeriodStreamReadyEvent | IAdaptationChangeEvent | IBitrateEstimationChangeEvent | IRepresentationChangeEvent | IStreamEventAddedSegment<unknown> | IInbandEventsEvent;
+export declare type IInitEvent = IManifestReadyEvent | IManifestUpdateEvent | IReloadingMediaSourceEvent | IDecipherabilityUpdateEvent | IWarningEvent | IEMEDisabledEvent | IEncryptedEvent | ICreatedMediaKeysEvent | IAttachedMediaKeysEvent | IInitDataIgnoredEvent | ISessionMessageEvent | IKeysUpdateEvent | INoUpdateEvent | ISessionUpdatedEvent | IBlacklistProtectionDataEvent | IStalledEvent | IUnstalledEvent | ILoadedEvent | IStreamEventEvent | IStreamEventSkipEvent | IActivePeriodChangedEvent | IPeriodStreamClearedEvent | ICompletedStreamEvent | IPeriodStreamReadyEvent | IAdaptationChangeEvent | IBitrateEstimationChangeEvent | IRepresentationChangeEvent | IStreamEventAddedSegment<unknown> | IInbandEventsEvent;
 /** Events emitted by the `Init` module for directfile contents. */
 export declare type IDirectfileEvent = IStalledEvent | IUnstalledEvent | ILoadedEvent | IWarningEvent | IEMEDisabledEvent | IEncryptedEvent | ICreatedMediaKeysEvent | IAttachedMediaKeysEvent | IInitDataIgnoredEvent | ISessionMessageEvent | IKeysUpdateEvent | INoUpdateEvent | ISessionUpdatedEvent | IBlacklistProtectionDataEvent;

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

@@ -14,18 +14,19 @@
  * limitations under the License.
  */
 import { Observable } from "rxjs";
-import { IInitClockTick } from "./types";
+import { IReadOnlySharedReference } from "../../utils/reference";
+import { IPlaybackObservation } from "../api";
 export interface IPlaybackRateOptions {
-    pauseWhenStalled?: boolean;
+    pauseWhenRebuffering?: boolean;
 }
 /**
  * Manage playback speed.
  * Set playback rate set by the user, pause playback when the player appear to
- * stall and restore the speed once it appears to un-stall.
+ * rebuffering and restore the speed once it appears to exit rebuffering status.
  *
  * @param {HTMLMediaElement} mediaElement
- * @param {Observable} speed$ - emit speed set by the user
- * @param {Observable} clock$ - Current playback conditions
+ * @param {Observable} speed - last speed set by the user
+ * @param {Observable} observation$ - Current playback conditions
  * @returns {Observable}
  */
-export default function updatePlaybackRate(mediaElement: HTMLMediaElement, speed$: Observable<number>, clock$: Observable<IInitClockTick>): Observable<number>;
+export default function updatePlaybackRate(mediaElement: HTMLMediaElement, speed: IReadOnlySharedReference<number>, observation$: Observable<IPlaybackObservation>): Observable<number>;

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

@@ -13,22 +13,21 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { defer as observableDefer, of as observableOf, } from "rxjs";
-import { distinctUntilChanged, map, startWith, switchMap, tap, } from "rxjs/operators";
+import { defer as observableDefer, distinctUntilChanged, map, of as observableOf, startWith, switchMap, tap, } from "rxjs";
 import log from "../../log";
 /**
  * Manage playback speed.
  * Set playback rate set by the user, pause playback when the player appear to
- * stall and restore the speed once it appears to un-stall.
+ * rebuffering and restore the speed once it appears to exit rebuffering status.
  *
  * @param {HTMLMediaElement} mediaElement
- * @param {Observable} speed$ - emit speed set by the user
- * @param {Observable} clock$ - Current playback conditions
+ * @param {Observable} speed - last speed set by the user
+ * @param {Observable} observation$ - Current playback conditions
  * @returns {Observable}
  */
-export default function updatePlaybackRate(mediaElement, speed$, clock$) {
-    var forcePause$ = clock$
-        .pipe(map(function (timing) { return timing.stalled !== null; }), startWith(false), distinctUntilChanged());
+export default function updatePlaybackRate(mediaElement, speed, observation$) {
+    var forcePause$ = observation$
+        .pipe(map(function (observation) { return observation.rebuffering !== null; }), startWith(false), distinctUntilChanged());
     return forcePause$
         .pipe(switchMap(function (shouldForcePause) {
         if (shouldForcePause) {
@@ -38,10 +37,10 @@ export default function updatePlaybackRate(mediaElement, speed$, clock$) {
                 return observableOf(0);
             });
         }
-        return speed$
-            .pipe(tap(function (speed) {
-            log.info("Init: Resume playback speed", speed);
-            mediaElement.playbackRate = speed;
+        return speed.asObservable()
+            .pipe(tap(function (lastSpeed) {
+            log.info("Init: Resume playback speed", lastSpeed);
+            mediaElement.playbackRate = lastSpeed;
         }));
     }));
 }

package/dist/_esm5.processed/core/segment_buffers/garbage_collector.d.ts

@@ -17,9 +17,9 @@ import { Observable } from "rxjs";
 import { SegmentBuffer } from "./implementations";
 export interface IGarbageCollectorArgument {
     /** SegmentBuffer implementation */
-    segmentBuffer: SegmentBuffer<unknown>;
+    segmentBuffer: SegmentBuffer;
     /** Emit current position in seconds regularly */
-    clock$: Observable<number>;
+    currentTime$: Observable<number>;
     /** Maximum time to keep behind current time position, in seconds */
     maxBufferBehind$: Observable<number>;
     /** Minimum time to keep behind current time position, in seconds */
@@ -27,10 +27,10 @@ export interface IGarbageCollectorArgument {
 }
 /**
  * Perform cleaning of the buffer according to the values set by the user
- * at each clock tick and each times the maxBufferBehind/maxBufferAhead values
- * change.
+ * each time `currentTime$` emits and each times the
+ * maxBufferBehind/maxBufferAhead values change.
  *
  * @param {Object} opt
  * @returns {Observable}
  */
-export default function BufferGarbageCollector({ segmentBuffer, clock$, maxBufferBehind$, maxBufferAhead$, }: IGarbageCollectorArgument): Observable<never>;
+export default function BufferGarbageCollector({ segmentBuffer, currentTime$, maxBufferBehind$, maxBufferAhead$, }: IGarbageCollectorArgument): Observable<never>;

package/dist/_esm5.processed/core/segment_buffers/garbage_collector.js

@@ -13,21 +13,20 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { combineLatest as observableCombineLatest, EMPTY, from as observableFrom, } from "rxjs";
-import { concatAll, ignoreElements, mergeMap, } from "rxjs/operators";
+import { combineLatest as observableCombineLatest, concatAll, EMPTY, from as observableFrom, ignoreElements, mergeMap, } from "rxjs";
 import log from "../../log";
 import { getInnerAndOuterTimeRanges } from "../../utils/ranges";
 /**
  * Perform cleaning of the buffer according to the values set by the user
- * at each clock tick and each times the maxBufferBehind/maxBufferAhead values
- * change.
+ * each time `currentTime$` emits and each times the
+ * maxBufferBehind/maxBufferAhead values change.
  *
  * @param {Object} opt
  * @returns {Observable}
  */
 export default function BufferGarbageCollector(_a) {
-    var segmentBuffer = _a.segmentBuffer, clock$ = _a.clock$, maxBufferBehind$ = _a.maxBufferBehind$, maxBufferAhead$ = _a.maxBufferAhead$;
-    return observableCombineLatest([clock$, maxBufferBehind$, maxBufferAhead$]).pipe(mergeMap(function (_a) {
+    var segmentBuffer = _a.segmentBuffer, currentTime$ = _a.currentTime$, maxBufferBehind$ = _a.maxBufferBehind$, maxBufferAhead$ = _a.maxBufferAhead$;
+    return observableCombineLatest([currentTime$, maxBufferBehind$, maxBufferAhead$]).pipe(mergeMap(function (_a) {
         var currentTime = _a[0], maxBufferBehind = _a[1], maxBufferAhead = _a[2];
         return clearBuffer(segmentBuffer, currentTime, maxBufferBehind, maxBufferAhead);
     }));
@@ -107,6 +106,12 @@ function clearBuffer(segmentBuffer, position, maxBufferBehind, maxBufferAhead) {
     var clean$ = observableFrom(cleanedupRanges.map(function (range) {
         log.debug("GC: cleaning range from SegmentBuffer", range);
         return segmentBuffer.removeBuffer(range.start, range.end);
-    })).pipe(concatAll(), ignoreElements());
+    })).pipe(concatAll(), 
+    // 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 clean$;
 }

package/dist/_esm5.processed/core/segment_buffers/implementations/audio_video/audio_video_segment_buffer.d.ts

@@ -25,7 +25,7 @@ import { IEndOfSegmentInfos, IPushChunkInfos, ISBOperation, SegmentBuffer } from
  *
  * @class AudioVideoSegmentBuffer
  */
-export default class AudioVideoSegmentBuffer extends SegmentBuffer<BufferSource> {
+export default class AudioVideoSegmentBuffer extends SegmentBuffer {
     /** "Type" of the buffer concerned. */
     readonly bufferType: "audio" | "video";
     /** SourceBuffer implementation. */
@@ -93,7 +93,7 @@ export default class AudioVideoSegmentBuffer extends SegmentBuffer<BufferSource>
      * @param {Object} infos
      * @returns {Observable}
      */
-    pushChunk(infos: IPushChunkInfos<BufferSource>): Observable<void>;
+    pushChunk(infos: IPushChunkInfos<unknown>): Observable<void>;
     /**
      * Remove buffered data (added to the same FIFO queue than `pushChunk`).
      * @param {number} start - start position, in seconds