rx-player 3.25.2 → 3.26.3-dev.2022021400

package/src/core/init/initialize_directfile.ts

@@ -21,36 +21,32 @@
 
 import {
   EMPTY,
-  merge as observableMerge,
-  Observable,
-  of as observableOf,
-} from "rxjs";
-import {
   filter,
   ignoreElements,
-  map,
+  merge as observableMerge,
   mergeMap,
-  mergeMapTo,
+  switchMap,
+  Observable,
+  of as observableOf,
   share,
   take,
-} from "rxjs/operators";
+} from "rxjs";
 import {
   clearElementSrc,
   setElementSrc$,
 } from "../../compat";
-import { MediaError } from "../../errors";
 import log from "../../log";
 import deferSubscriptions from "../../utils/defer_subscriptions";
+import { IReadOnlySharedReference } from "../../utils/reference";
+import { PlaybackObserver } from "../api";
 import { IKeySystemOption } from "../eme";
 import createEMEManager from "./create_eme_manager";
-import EVENTS from "./events_generators";
+import emitLoadedEvent from "./emit_loaded_event";
 import { IInitialTimeOptions } from "./get_initial_time";
-import seekAndLoadOnMediaEvents from "./initial_seek_and_play";
+import initialSeekAndPlay from "./initial_seek_and_play";
+import StallAvoider from "./stall_avoider";
 import throwOnMediaError from "./throw_on_media_error";
-import {
-  IDirectfileEvent,
-  IInitClockTick,
-} from "./types";
+import { IDirectfileEvent } from "./types";
 import updatePlaybackRate from "./update_playback_rate";
 
 /**
@@ -100,13 +96,12 @@ function getDirectFileInitialTime(
 
 // Argument used by `initializeDirectfileContent`
 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".
@@ -115,11 +110,10 @@ export interface IDirectFileOptions { autoPlay : boolean;
  */
 export default function initializeDirectfileContent({
   autoPlay,
-  clock$,
   keySystems,
   mediaElement,
-  speed$,
-  setCurrentTime,
+  playbackObserver,
+  speed,
   startAt,
   url,
 } : IDirectFileOptions) : Observable<IDirectfileEvent> {
@@ -137,12 +131,10 @@ export default function initializeDirectfileContent({
   const initialTime = () => getDirectFileInitialTime(mediaElement, startAt);
   log.debug("Init: Initial time calculated:", initialTime);
 
-  const { seek$, load$ } = seekAndLoadOnMediaEvents({ clock$,
-                                                      mediaElement,
-                                                      startTime: initialTime,
-                                                      mustAutoPlay: autoPlay,
-                                                      setCurrentTime,
-                                                      isDirectfile: true });
+  const { seekAndPlay$ } = initialSeekAndPlay({ mediaElement,
+                                                playbackObserver,
+                                                startTime: initialTime,
+                                                mustAutoPlay: autoPlay });
 
   // Create EME Manager, an observable which will manage every EME-related
   // issue.
@@ -156,52 +148,52 @@ export default function initializeDirectfileContent({
   // through a throwing Observable.
   const mediaError$ = throwOnMediaError(mediaElement);
 
+  const 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.
   const playbackRate$ =
-    updatePlaybackRate(mediaElement, speed$, clock$)
+    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
-  const stalled$ = clock$.pipe(
-    map(tick => tick.stalled === null ? EVENTS.unstalled() :
-                                        EVENTS.stalled(tick.stalled)));
-
-  // Manage "loaded" event and warn if autoplay is blocked on the current browser
-  const loadedEvent$ = emeManager$.pipe(
+  /**
+   * Observable trying to avoid various stalling situations, emitting "stalled"
+   * events when it cannot, as well as "unstalled" events when it get out of one.
+   */
+  const 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.
+   */
+  const 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((evt) => {
-      if (evt === "autoplay-blocked") {
-        const 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));
-      } else if (evt === "not-loaded-metadata") {
-        const error = new MediaError("MEDIA_ERR_NOT_LOADED_METADATA",
-                                     "Cannot load automatically: your browser " +
-                                     "falsely announced having loaded the content.");
-        return observableOf(EVENTS.warning(error));
+    mergeMap(() => seekAndPlay$),
+    switchMap((evt) => {
+      if (evt.type === "warning") {
+        return observableOf(evt);
       }
-      return observableOf(EVENTS.loaded(null));
+      return emitLoadedEvent(observation$, mediaElement, null, true);
     }));
 
-  const initialSeek$ = seek$.pipe(ignoreElements());
-
-  return observableMerge(loadedEvent$,
-                         initialSeek$,
+  return observableMerge(loadingEvts$,
                          emeManager$,
                          mediaError$,
                          playbackRate$,
-                         stalled$);
+                         stallAvoider$);
 }
 
 export { IDirectfileEvent };

package/src/core/init/initialize_media_source.ts

@@ -15,31 +15,27 @@
  */
 
 import {
-  BehaviorSubject,
   combineLatest as observableCombineLatest,
   EMPTY,
-  merge as observableMerge,
-  Observable,
-  of as observableOf,
-  Subject,
-} from "rxjs";
-import {
   exhaustMap,
   filter,
   finalize,
   ignoreElements,
   map,
-  mapTo,
+  merge as observableMerge,
   mergeMap,
   mergeScan,
+  Observable,
+  of as observableOf,
   share,
   shareReplay,
   startWith,
+  Subject,
   switchMap,
   take,
   takeUntil,
   tap,
-} from "rxjs/operators";
+} from "rxjs";
 import { shouldReloadMediaSourceOnDecipherabilityUpdate } from "../../compat";
 import config from "../../config";
 import log from "../../log";
@@ -47,9 +43,11 @@ import deferSubscriptions from "../../utils/defer_subscriptions";
 import { fromEvent } from "../../utils/event_emitter";
 import filterMap from "../../utils/filter_map";
 import objectAssign from "../../utils/object_assign";
+import { IReadOnlySharedReference } from "../../utils/reference";
 import ABRManager, {
   IABRManagerArguments,
 } from "../abr";
+import { PlaybackObserver } from "../api";
 import {
   getCurrentKeySystem,
   IContentProtection,
@@ -77,7 +75,6 @@ import manifestUpdateScheduler, {
 } from "./manifest_update_scheduler";
 import throwOnMediaError from "./throw_on_media_error";
 import {
-  IInitClockTick,
   IInitEvent,
   IMediaSourceLoaderEvent,
 } from "./types";
@@ -93,11 +90,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";
     /**
@@ -111,7 +108,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. */
@@ -126,13 +123,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;
 }
@@ -172,16 +167,15 @@ export default function InitializeOnMediaSource(
   { adaptiveOptions,
     autoPlay,
     bufferOptions,
-    clock$,
     keySystems,
     lowLatencyMode,
     manifest$,
     manifestFetcher,
     mediaElement,
     minimumManifestUpdateInterval,
+    playbackObserver,
     segmentFetcherCreator,
-    setCurrentTime,
-    speed$,
+    speed,
     startAt,
     textTrackOptions } : IInitializeArguments
 ) : Observable<IInitEvent> {
@@ -243,7 +237,7 @@ export default function InitializeOnMediaSource(
          * ID identifying the current MediaKeys' system ID. Can be used to only
          * send initialization data linked to that ID as an optimization measure.
          */
-        drmSystemId? : string;
+        drmSystemId? : string | undefined;
       },
       evt : IEMEManagerEvent | IEMEDisabledEvent
     ) => {
@@ -258,11 +252,13 @@ export default function InitializeOnMediaSource(
             mergeMap(() => {
               // 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
               const shouldDisableLock = evt.value.options
                 .disableMediaKeysAttachmentLock === true;
               return shouldDisableLock ? observableOf({ isEmeReady: true,
@@ -298,12 +294,11 @@ export default function InitializeOnMediaSource(
         abrManager,
         bufferOptions: objectAssign({ textTrackOptions, drmSystemId },
                                     bufferOptions),
-        clock$,
         manifest,
         mediaElement,
+        playbackObserver,
         segmentFetcherCreator,
-        speed$,
-        setCurrentTime,
+        speed,
       });
 
       // handle initial load and reloads
@@ -321,7 +316,7 @@ export default function InitializeOnMediaSource(
 
       const manifestEvents$ = observableMerge(
         fromEvent(manifest, "manifestUpdate")
-          .pipe(mapTo(EVENTS.manifestUpdate())),
+          .pipe(map(() => EVENTS.manifestUpdate())),
         fromEvent(manifest, "decipherabilityUpdate")
           .pipe(map(EVENTS.decipherabilityUpdate)));
 
@@ -334,6 +329,11 @@ export default function InitializeOnMediaSource(
             manifest.addUndecipherableProtectionData(evt.value);
           }
         }),
+        // 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$,
@@ -388,16 +388,16 @@ export default function InitializeOnMediaSource(
                 // to flush the buffers
                 const { position } = evt.value;
                 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/src/core/init/load_on_media_source.ts

@@ -16,64 +16,64 @@
 
 import {
   EMPTY,
+  filter,
+  finalize,
+  ignoreElements,
   merge as observableMerge,
+  mergeMap,
   Observable,
   of as observableOf,
   Subject,
+  switchMap,
+  takeUntil,
   throwError,
 } from "rxjs";
-import {
-  filter,
-  finalize,
-  ignoreElements,
-  mergeMap,
-  takeUntil,
-} from "rxjs/operators";
 import { MediaError } from "../../errors";
 import log from "../../log";
 import Manifest from "../../manifest";
+import { IReadOnlySharedReference } from "../../utils/reference";
 import ABRManager from "../abr";
+import { PlaybackObserver } from "../api";
 import { SegmentFetcherCreator } from "../fetchers";
 import SegmentBuffersStore from "../segment_buffers";
 import StreamOrchestrator, {
   IStreamOrchestratorOptions,
 } 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, {
   IDiscontinuityEvent,
+  ILockedStreamEvent,
 } from "./stall_avoider";
 import streamEventsEmitter from "./stream_events_emitter";
-import {
-  IInitClockTick,
-  IMediaSourceLoaderEvent,
-} from "./types";
+import { IMediaSourceLoaderEvent } from "./types";
 import updatePlaybackRate from "./update_playback_rate";
 
+// 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 @typescript-eslint/no-unsafe-argument */
+
 /** 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 of the content we want to play. */
   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>;
 }
 
 /**
@@ -85,12 +85,11 @@ export interface IMediaSourceLoaderArguments {
 export default function createMediaSourceLoader(
   { mediaElement,
     manifest,
-    clock$,
-    speed$,
+    speed,
     bufferOptions,
     abrManager,
-    segmentFetcherCreator,
-    setCurrentTime } : IMediaSourceLoaderArguments
+    playbackObserver,
+    segmentFetcherCreator } : IMediaSourceLoaderArguments
 ) : (mediaSource : MediaSource, initialTime : number, autoPlay : boolean) =>
   Observable<IMediaSourceLoaderEvent> {
   /**
@@ -103,7 +102,7 @@ export default function createMediaSourceLoader(
     mediaSource : MediaSource,
     initialTime : number,
     autoPlay : boolean
-  ) {
+  ) : Observable<IMediaSourceLoaderEvent> {
     /** Maintains the MediaSource's duration up-to-date with the Manifest */
     const durationUpdater$ = DurationUpdater(manifest, mediaSource);
 
@@ -115,28 +114,28 @@ export default function createMediaSourceLoader(
       return throwError(() => error);
     }
 
-    /** Interface to create media buffers for loaded segments. */
+    /** Interface to create media buffers. */
     const segmentBuffersStore = new SegmentBuffersStore(mediaElement, mediaSource);
 
-    const { seek$, load$ } = seekAndLoadOnMediaEvents({ clock$,
-                                                        mediaElement,
-                                                        startTime: initialTime,
-                                                        mustAutoPlay: autoPlay,
-                                                        setCurrentTime,
-                                                        isDirectfile: false });
-
-    const initialPlay$ = load$.pipe(filter((evt) => evt !== "not-loaded-metadata"));
-
-    const streamEvents$ = initialPlay$.pipe(
-      mergeMap(() => streamEventsEmitter(manifest, mediaElement, clock$))
-    );
-
-    const streamClock$ = createStreamClock(clock$, { autoPlay,
-                                                     initialPlay$,
-                                                     initialSeek$: seek$,
-                                                     manifest,
-                                                     speed$,
-                                                     startTime: initialTime });
+    const { seekAndPlay$,
+            initialPlayPerformed,
+            initialSeekPerformed } = initialSeekAndPlay({ mediaElement,
+                                                          playbackObserver,
+                                                          startTime: initialTime,
+                                                          mustAutoPlay: autoPlay });
+
+    const observation$ = playbackObserver.observe(true);
+    const streamEvents$ = initialPlayPerformed.asObservable().pipe(
+      filter((hasPlayed) => hasPlayed),
+      mergeMap(() => streamEventsEmitter(manifest, mediaElement, observation$)));
+
+    const streamObserver = createStreamPlaybackObserver(manifest,
+                                                        playbackObserver,
+                                                        { autoPlay,
+                                                          initialPlayPerformed,
+                                                          initialSeekPerformed,
+                                                          speed,
+                                                          startTime: initialTime });
 
     /** Cancel endOfStream calls when streams become active again. */
     const cancelEndOfStream$ = new Subject<null>();
@@ -144,9 +143,12 @@ export default function createMediaSourceLoader(
     /** Emits discontinuities detected by the StreamOrchestrator. */
     const discontinuityUpdate$ = new Subject<IDiscontinuityEvent>();
 
+    /** Emits event when streams are "locked", meaning they cannot load segments. */
+    const lockedStream$ = new Subject<ILockedStreamEvent>();
+
     // Creates Observable which will manage every Stream for the given Content.
     const streams$ = StreamOrchestrator({ manifest, initialPeriod },
-                                        streamClock$,
+                                        streamObserver,
                                         abrManager,
                                         segmentBuffersStore,
                                         segmentFetcherCreator,
@@ -170,6 +172,9 @@ export default function createMediaSourceLoader(
                                         discontinuity: imminentDiscontinuity,
                                         position });
             return EMPTY;
+          case "locked-stream":
+            lockedStream$.next(evt.value);
+            return EMPTY;
           default:
             return observableOf(evt);
         }
@@ -182,39 +187,30 @@ export default function createMediaSourceLoader(
      * empty, so it can build back buffer.
      */
     const playbackRate$ =
-      updatePlaybackRate(mediaElement, speed$, clock$)
+      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.
      */
-    const stallAvoider$ = StallAvoider(clock$,
-                                       mediaElement,
+    const stallAvoider$ = StallAvoider(playbackObserver,
                                        manifest,
-                                       discontinuityUpdate$,
-                                       setCurrentTime);
-
-    const loadedEvent$ = load$
-      .pipe(mergeMap((evt) => {
-        if (evt === "autoplay-blocked") {
-          const 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") {
-          const 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));
-      }));
+                                       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.
+     */
+    const loadingEvts$ = seekAndPlay$.pipe(switchMap((evt) =>
+      evt.type === "warning" ?
+        observableOf(evt) :
+        emitLoadedEvent(observation$, mediaElement, segmentBuffersStore, false)));
 
     return observableMerge(durationUpdater$,
-                           loadedEvent$,
+                           loadingEvts$,
                            playbackRate$,
                            stallAvoider$,
                            streams$,