rx-player 3.26.1 → 3.26.2

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. */
@@ -127,10 +124,8 @@ export interface IInitializeArguments {
   minimumManifestUpdateInterval : number;
   /** Interface allowing to load segments */
   segmentFetcherCreator : SegmentFetcherCreator;
-  /** Perform an internal seek */
-  setCurrentTime: (time: number) => void;
   /** Emit the playback rate (speed) set by the user. */
-  speed$ : Observable<number>;
+  speed : IReadOnlySharedReference<number>;
   /** The configured starting position. */
   startAt? : IInitialTimeOptions;
   /** Configuration specific to the text track. */
@@ -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> {
@@ -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,30 +16,30 @@
 
 import {
   EMPTY,
-  merge as observableMerge,
-  Observable,
-  of as observableOf,
-  Subject,
-  throwError,
-} from "rxjs";
-import {
   filter,
   finalize,
   ignoreElements,
+  merge as observableMerge,
   mergeMap,
+  Observable,
+  of as observableOf,
+  Subject,
   switchMap,
   takeUntil,
-} from "rxjs/operators";
+  throwError,
+} from "rxjs";
 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";
@@ -49,33 +49,31 @@ import StallAvoider, {
   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;
-  /**
-   * 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;
+  /** Last wanted playback rate. */
+  speed : IReadOnlySharedReference<number>;
 }
 
 /**
@@ -87,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> {
   /**
@@ -117,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$, play$ } = initialSeekAndPlay({ clock$,
-                                                  mediaElement,
-                                                  startTime: initialTime,
-                                                  mustAutoPlay: autoPlay,
-                                                  setCurrentTime,
-                                                  isDirectfile: false });
-
-    const playDone$ = play$.pipe(filter((evt) => evt.type !== "warning"));
-
-    const streamEvents$ = playDone$.pipe(
-      mergeMap(() => streamEventsEmitter(manifest, mediaElement, clock$))
-    );
-
-    const streamClock$ = createStreamClock(clock$, { autoPlay,
-                                                     initialPlay$: playDone$,
-                                                     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>();
@@ -151,7 +148,7 @@ export default function createMediaSourceLoader(
 
     // Creates Observable which will manage every Stream for the given Content.
     const streams$ = StreamOrchestrator({ manifest, initialPeriod },
-                                        streamClock$,
+                                        streamObserver,
                                         abrManager,
                                         segmentBuffersStore,
                                         segmentFetcherCreator,
@@ -190,31 +187,27 @@ 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$,
                                        lockedStream$,
-                                       setCurrentTime);
+                                       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$ = play$.pipe(switchMap((evt) => {
-      if (evt.type === "warning") {
-        return observableOf(evt);
-      }
-      return emitLoadedEvent(clock$, mediaElement, segmentBuffersStore, false);
-    }));
+    const loadingEvts$ = seekAndPlay$.pipe(switchMap((evt) =>
+      evt.type === "warning" ?
+        observableOf(evt) :
+        emitLoadedEvent(observation$, mediaElement, segmentBuffersStore, false)));
 
     return observableMerge(durationUpdater$,
                            loadingEvts$,

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";
@@ -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 })));
     }
   }