rx-player 3.25.2 → 3.26.3-dev.2022021400

package/src/core/init/manifest_update_scheduler.ts

@@ -18,18 +18,15 @@ import {
   defer as observableDefer,
   EMPTY,
   from as observableFrom,
+  map,
   merge as observableMerge,
+  mergeMap,
   Observable,
   of as observableOf,
-  timer as observableTimer,
-} from "rxjs";
-import {
-  mapTo,
-  mergeMap,
-  mergeMapTo,
   share,
   take,
-} from "rxjs/operators";
+  timer as observableTimer,
+} from "rxjs";
 import config from "../../config";
 import log from "../../log";
 import Manifest from "../../manifest";
@@ -51,9 +48,9 @@ export interface IManifestUpdateSchedulerArguments {
   manifestFetcher : ManifestFetcher;
   /** 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;
   /** Allows the rest of the code to ask for a Manifest refresh */
@@ -77,7 +74,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
@@ -130,9 +127,9 @@ export default function manifestUpdateScheduler({
    * encountered.
    */
   function handleManifestRefresh$(
-    { sendingTime, parsingTime, updatingTime } : { sendingTime?: number;
-                                                   parsingTime? : number;
-                                                   updatingTime? : number; }
+    { sendingTime, parsingTime, updatingTime } : { sendingTime?: number | undefined;
+                                                   parsingTime? : number | undefined;
+                                                   updatingTime? : number | undefined; }
   ) : Observable<IWarningEvent> {
     /**
      * Total time taken to fully update the last Manifest, in milliseconds.
@@ -170,15 +167,17 @@ export default function manifestUpdateScheduler({
         return startManualRefreshTimer(delay ?? 0,
                                        minimumManifestUpdateInterval,
                                        sendingTime)
-          .pipe(mapTo({ completeRefresh, unsafeMode }));
+          .pipe(map(() => ({ completeRefresh, unsafeMode })));
       }));
 
     /** Emit when the Manifest tells us that it has "expired". */
     const expired$ = manifest.expired === null ?
       EMPTY :
-      observableTimer(minInterval)
-        .pipe(mergeMapTo(observableFrom(manifest.expired)),
-              mapTo({ completeRefresh: true, unsafeMode: unsafeModeEnabled }));
+      observableTimer(minInterval).pipe(
+        mergeMap(() =>
+          manifest.expired === null ? EMPTY :
+                                      observableFrom(manifest.expired)),
+        map(() => ({ completeRefresh: true, unsafeMode: unsafeModeEnabled })));
 
     /** Emit when the Manifest should normally be refreshed. */
     const autoRefresh$ = createAutoRefreshObservable();
@@ -257,7 +256,7 @@ export default function manifestUpdateScheduler({
         actualRefreshInterval = regularRefreshDelay;
       }
       return observableTimer(Math.max(actualRefreshInterval, minInterval))
-        .pipe(mapTo({ completeRefresh: false, unsafeMode: unsafeModeEnabled }));
+        .pipe(map(() => ({ completeRefresh: false, unsafeMode: unsafeModeEnabled })));
     }
   }
 

package/src/core/init/stall_avoider.ts

@@ -14,13 +14,15 @@
  * limitations under the License.
  */
 
-import { Observable } from "rxjs";
 import {
+  ignoreElements,
   map,
+  merge as observableMerge,
+  Observable,
   scan,
+  tap,
   withLatestFrom,
-} from "rxjs/operators";
-import { isPlaybackStuck } from "../../compat";
+} from "rxjs";
 import isSeekingApproximate from "../../compat/is_seeking_approximate";
 import config from "../../config";
 import { MediaError } from "../../errors";
@@ -29,17 +31,24 @@ import Manifest, {
   Period,
 } from "../../manifest";
 import { getNextRangeGap } from "../../utils/ranges";
+import {
+  IPlaybackObservation,
+  PlaybackObserver,
+} from "../api";
 import { IBufferType } from "../segment_buffers";
 import EVENTS from "../stream/events_generators";
 import {
-  IInitClockTick,
   IStalledEvent,
+  IStallingSituation,
   IUnstalledEvent,
   IWarningEvent,
 } from "./types";
 
 const { BUFFER_DISCONTINUITY_THRESHOLD,
-        FORCE_DISCONTINUITY_SEEK_DELAY } = config;
+        FORCE_DISCONTINUITY_SEEK_DELAY,
+        FREEZING_STALLED_DELAY,
+        UNFREEZING_SEEK_DELAY,
+        UNFREEZING_DELTA_POSITION } = config;
 
 /**
  * Work-around rounding errors with floating points by setting an acceptable,
@@ -47,6 +56,13 @@ const { BUFFER_DISCONTINUITY_THRESHOLD,
  */
 const EPSILON = 1 / 60;
 
+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
@@ -106,23 +122,20 @@ interface IDiscontinuityStoredInfo {
 
 /**
  * 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
+  playbackObserver : PlaybackObserver,
+  manifest: Manifest | null,
+  lockedStream$ : Observable<ILockedStreamEvent>,
+  discontinuityUpdate$: Observable<IDiscontinuityEvent>
 ) : Observable<IStalledEvent | IUnstalledEvent | IWarningEvent> {
   const initialDiscontinuitiesStore : IDiscontinuityStoredInfo[] = [];
 
@@ -131,10 +144,10 @@ export default function StallAvoider(
    * order (first ordered by Period's start, then by bufferType in any order.
    */
   const discontinuitiesStore$ = discontinuityUpdate$.pipe(
-    withLatestFrom(clock$), // listen to clock to clean-up old discontinuities
+    withLatestFrom(playbackObserver.observe(true)),
     scan(
-      (discontinuitiesStore, [evt, tick]) =>
-        updateDiscontinuitiesStore(discontinuitiesStore, evt, tick),
+      (discontinuitiesStore, [evt, observation]) =>
+        updateDiscontinuitiesStore(discontinuitiesStore, evt, observation),
       initialDiscontinuitiesStore));
 
   /**
@@ -164,36 +177,126 @@ export default function StallAvoider(
    */
   let ignoredStallTimeStamp : number | null = null;
 
-  return clock$.pipe(
+  let prevFreezingState : { attemptTimestamp : number } | null;
+
+  /**
+   * If we're rebuffering waiting on data of a "locked stream", seek into the
+   * Period handled by that stream to unlock the situation.
+   */
+  const unlock$ = lockedStream$.pipe(
+    withLatestFrom(playbackObserver.observe(true)),
+    tap(([lockedStreamEvt, observation]) => {
+      // 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;
+      }
+      const currPos = observation.position;
+      const rebufferingPos = observation.rebuffering.position ?? currPos;
+      const 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()
+  );
+
+  const stall$ = playbackObserver.observe(true).pipe(
     withLatestFrom(discontinuitiesStore$),
-    map(([tick, discontinuitiesStore]) => {
-      const { buffered, currentRange, position, event, stalled } = tick;
-      if (stalled === null) {
+    map(([observation, discontinuitiesStore]) => {
+      const { buffered,
+              position,
+              readyState,
+              rebuffering,
+              freezing } = observation;
+
+      if (freezing !== null) {
+        const now = performance.now();
+
+        const 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" as const,
+                   value: "freezing" as const };
+        }
+      } 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
+          let reason : IStallingSituation;
+          if (observation.seeking) {
+            reason = observation.internalSeeking ? "internal-seek" :
+                                                   "seeking";
+          } else {
+            reason = "not-ready";
+          }
+          return { type: "stalled" as const,
+                   value: reason };
+        }
         return { type: "unstalled" as const,
                  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.
+      const stalledReason = rebuffering.reason === "seeking" &&
+                            observation.internalSeeking ? "internal-seek" as const :
+                                                          rebuffering.reason;
+
+      if (observation.seeking) {
+        lastSeekingPosition = observation.position;
       } else if (lastSeekingPosition !== null) {
         const now = performance.now();
         if (ignoredStallTimeStamp === null) {
           ignoredStallTimeStamp = now;
         }
         if (isSeekingApproximate &&
-            tick.position < lastSeekingPosition &&
+            observation.position < lastSeekingPosition &&
             now - ignoredStallTimeStamp < FORCE_DISCONTINUITY_SEEK_DELAY)
         {
           return { type: "stalled" as const,
-                   value: stalled };
+                   value: stalledReason };
         }
         lastSeekingPosition = null;
       }
 
       ignoredStallTimeStamp = null;
 
+      if (manifest === null) {
+        return { type: "stalled" as const,
+                 value: stalledReason };
+      }
+
       /** Position at which data is awaited. */
-      const { position: stalledPosition } = stalled;
+      const { position: stalledPosition } = rebuffering;
 
       if (stalledPosition !== null) {
         const skippableDiscontinuity = findSeekableDiscontinuity(discontinuitiesStore,
@@ -201,32 +304,19 @@ export default function StallAvoider(
                                                                  stalledPosition);
         if (skippableDiscontinuity !== null) {
           const realSeekTime = skippableDiscontinuity + 0.001;
-          if (realSeekTime <= mediaElement.currentTime) {
+          if (realSeekTime <= playbackObserver.getCurrentTime()) {
             log.info("Init: position to seek already reached, no seeking",
-                     mediaElement.currentTime, realSeekTime);
+                     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));
-
-      }
-
       const freezePosition = stalledPosition ?? position;
 
       // Is it a very short discontinuity in buffer ? -> Seek at the beginning of the
@@ -239,10 +329,10 @@ export default function StallAvoider(
       const nextBufferRangeGap = getNextRangeGap(buffered, freezePosition);
       if (nextBufferRangeGap < BUFFER_DISCONTINUITY_THRESHOLD) {
         const 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));
         }
       }
@@ -253,10 +343,10 @@ export default function StallAvoider(
         const 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())
           {
             const nextPeriod = manifest.periods[i + 1];
-            setCurrentTime(nextPeriod.start);
+            playbackObserver.setCurrentTime(nextPeriod.start);
             return EVENTS.warning(generateDiscontinuityError(freezePosition,
                                                              nextPeriod.start));
 
@@ -266,8 +356,9 @@ export default function StallAvoider(
       }
 
       return { type: "stalled" as const,
-               value: stalled };
+               value: stalledReason };
     }));
+  return observableMerge(unlock$, stall$);
 }
 
 /**
@@ -344,18 +435,18 @@ function eventContainsDiscontinuity(
  *     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 : IDiscontinuityStoredInfo[],
   evt : IDiscontinuityEvent,
-  tick : IInitClockTick
+  observation : IPlaybackObservation
 ) : IDiscontinuityStoredInfo[] {
   // 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();
   }

package/src/core/init/stream_events_emitter/are_same_stream_events.ts

@@ -28,12 +28,12 @@
  * @param {Object} evt2
  * @returns {Boolean}
  */
-function areSameStreamEvents(evt1: { id?: string;
+function areSameStreamEvents(evt1: { id?: string | undefined;
                                      start: number;
-                                     end?: number; },
-                             evt2: { id?: string;
+                                     end?: number | undefined; },
+                             evt2: { id?: string | undefined;
                                      start: number;
-                                     end?: number; }): boolean {
+                                     end?: number | undefined; }): boolean {
   return evt1.id === evt2.id &&
          evt1.start === evt2.start &&
          evt1.end === evt2.end;

package/src/core/init/stream_events_emitter/stream_events_emitter.ts

@@ -17,26 +17,24 @@
 import {
   combineLatest as observableCombineLatest,
   concat as observableConcat,
-  EMPTY,
-  interval,
-  Observable,
-  of as observableOf,
-} from "rxjs";
-import {
   distinctUntilChanged,
+  EMPTY,
   ignoreElements,
+  interval,
   map,
   mergeMap,
+  Observable,
   pairwise,
   scan,
   startWith,
   switchMap,
   tap,
-} from "rxjs/operators";
+  of as observableOf,
+} from "rxjs";
 import config from "../../../config";
 import Manifest from "../../../manifest";
 import { fromEvent } from "../../../utils/event_emitter";
-import { IInitClockTick } from "../types";
+import { IPlaybackObservation } from "../../api";
 import refreshScheduledEventsList from "./refresh_scheduled_events_list";
 import {
   INonFiniteStreamEventPayload,
@@ -66,7 +64,7 @@ function isFiniteStreamEvent(
  */
 function streamEventsEmitter(manifest: Manifest,
                              mediaElement: HTMLMediaElement,
-                             clock$: Observable<IInitClockTick>
+                             observation$: Observable<IPlaybackObservation>
 ): Observable<IStreamEvent> {
   const eventsBeingPlayed =
     new WeakMap<IStreamEventPayload|INonFiniteStreamEventPayload, true>();
@@ -79,20 +77,20 @@ function streamEventsEmitter(manifest: 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: Array<IStreamEventPayload|INonFiniteStreamEventPayload>,
-    oldClockTick: { currentTime: number; isSeeking: boolean },
-    newClockTick: { currentTime: number; isSeeking: boolean }
+    oldObservation: { currentTime: number; isSeeking: boolean },
+    newObservation: { currentTime: number; isSeeking: boolean }
   ): Observable<IStreamEvent> {
-    const { currentTime: previousTime } = oldClockTick;
-    const { isSeeking, currentTime } = newClockTick;
+    const { currentTime: previousTime } = oldObservation;
+    const { isSeeking, currentTime } = newObservation;
     const eventsToSend: IStreamEvent[] = [];
     const eventsToExit: IPublicStreamEvent[] = [];
 
@@ -141,6 +139,11 @@ function streamEventsEmitter(manifest: Manifest,
             evt.onExit();
           }
         }),
+        // 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
     );
@@ -160,16 +163,16 @@ function streamEventsEmitter(manifest: Manifest,
       }
       return observableCombineLatest([
         interval(STREAM_EVENT_EMITTER_POLL_INTERVAL).pipe(startWith(null)),
-        clock$,
+        observation$,
       ]).pipe(
-        map(([_, clockTick]) => {
-          const { seeking } = clockTick;
+        map(([_, observation]) => {
+          const { seeking } = observation;
           return { isSeeking: seeking,
                    currentTime: mediaElement.currentTime };
         }),
         pairwise(),
-        mergeMap(([oldTick, newTick]) =>
-          emitStreamEvents$(lastScheduledEvents, oldTick, newTick))
+        mergeMap(([oldObservation, newObservation]) =>
+          emitStreamEvents$(lastScheduledEvents, oldObservation, newObservation))
       );
     })
   );

package/src/core/init/stream_events_emitter/types.ts

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

package/src/core/init/throw_on_media_error.ts

@@ -16,9 +16,9 @@
 
 import {
   fromEvent as observableFromEvent,
+  mergeMap,
   Observable,
 } from "rxjs";
-import { mergeMap } from "rxjs/operators";
 import { MediaError } from "../../errors";
 
 /**

package/src/core/init/types.ts

@@ -20,10 +20,6 @@ import Manifest, {
   Period,
   Representation,
 } from "../../manifest";
-import {
-  IClockMediaEventType,
-  IStalledStatus,
-} from "../api";
 import {
   IAttachedMediaKeysEvent,
   IBlacklistProtectionDataEvent,
@@ -43,6 +39,7 @@ import {
   ICompletedStreamEvent,
   IEncryptionDataEncounteredEvent,
   IInbandEventsEvent,
+  INeedsBufferFlushEvent,
   INeedsDecipherabilityFlush,
   INeedsMediaSourceReload,
   IPeriodStreamClearedEvent,
@@ -58,23 +55,6 @@ import {
   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";
@@ -112,12 +92,20 @@ export interface IWarningEvent { type : "warning";
 export interface IReloadingMediaSourceEvent { type: "reloading-media-source";
                                               value: undefined; }
 
-export interface INeedsBufferFlush { type: "needs-buffer-flush";
-                                     value: undefined; }
+/** Event sent after the player stalled. */
+export interface IStalledEvent {
+  type : "stalled";
+  /** The reason behind the stall */
+  value : IStallingSituation;
+}
 
-/** Event sent after the player stalled, leading to buffering. */
-export interface IStalledEvent { type : "stalled";
-                                 value : IStalledStatus; }
+export 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"; // stalled for an unknown reason (might be waiting for
+              // a decryption key)
 
 /** Event sent when the player goes out of a stalling situation. */
 export interface IUnstalledEvent { type : "unstalled";
@@ -149,7 +137,7 @@ export type IMediaSourceLoaderEvent = IStalledEvent |
                                       ICompletedStreamEvent |
                                       IPeriodStreamReadyEvent |
                                       INeedsMediaSourceReload |
-                                      INeedsBufferFlush |
+                                      INeedsBufferFlushEvent |
                                       IAdaptationChangeEvent |
                                       IBitrateEstimationChangeEvent |
                                       INeedsDecipherabilityFlush |
@@ -164,7 +152,6 @@ export type IMediaSourceLoaderEvent = IStalledEvent |
 export type IInitEvent = IManifestReadyEvent |
                          IManifestUpdateEvent |
                          IReloadingMediaSourceEvent |
-                         INeedsBufferFlush |
                          IDecipherabilityUpdateEvent |
                          IWarningEvent |
                          IEMEDisabledEvent |