rx-player 3.28.1-dev.2022083000 → 3.29.0-dev.2022090500

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "rx-player",
   "author": "Canal+",
-  "version": "3.28.1-dev.2022083000",
+  "version": "3.29.0-dev.2022090500",
   "description": "Canal+ HTML5 Video Player",
   "main": "./dist/rx-player.js",
   "keywords": [
@@ -88,17 +88,17 @@
     "@types/chai": "4.3.3",
     "@types/jest": "28.1.8",
     "@types/mocha": "9.1.1",
-    "@types/node": "18.7.13",
+    "@types/node": "18.7.14",
     "@types/sinon": "10.0.13",
-    "@typescript-eslint/eslint-plugin": "5.35.1",
-    "@typescript-eslint/eslint-plugin-tslint": "5.35.1",
-    "@typescript-eslint/parser": "5.35.1",
+    "@typescript-eslint/eslint-plugin": "5.36.1",
+    "@typescript-eslint/eslint-plugin-tslint": "5.36.1",
+    "@typescript-eslint/parser": "5.36.1",
     "arraybuffer-loader": "1.0.8",
     "babel-loader": "8.2.5",
     "chai": "4.3.6",
     "cheerio": "1.0.0-rc.12",
     "core-js": "3.25.0",
-    "esbuild": "0.15.5",
+    "esbuild": "0.15.6",
     "eslint": "8.23.0",
     "eslint-plugin-import": "2.26.0",
     "eslint-plugin-jsdoc": "39.3.6",
@@ -124,7 +124,7 @@
     "rimraf": "3.0.2",
     "semver": "7.3.7",
     "sinon": "14.0.0",
-    "terser-webpack-plugin": "5.3.5",
+    "terser-webpack-plugin": "5.3.6",
     "ts-jest": "28.0.8",
     "ts-loader": "9.3.1",
     "tslint": "6.1.3",

package/sonar-project.properties

@@ -1,7 +1,7 @@
 sonar.projectKey=rx-player
 sonar.organization=rx-player
 sonar.projectName=rx-player
-sonar.projectVersion=3.28.1-dev.2022083000
+sonar.projectVersion=3.29.0-dev.2022090500
 sonar.sources=./src,./demo,./tests
 sonar.exclusions=demo/full/bundle.js,demo/standalone/lib.js,demo/bundle.js
 sonar.host.url=https://sonarcloud.io

package/src/compat/event_listeners.ts

@@ -107,6 +107,69 @@ export type IEventTargetLike = HTMLElement |
                                IEventEmitterLike |
                                IEventEmitter<unknown>;
 
+/**
+ * Returns a function allowing to add event listeners for particular event(s)
+ * optionally automatically adding browser prefixes if needed.
+ * @param {Array.<string>} eventNames - The event(s) to listen to. If multiple
+ * events are set, the event listener will be triggered when any of them emits.
+ * @returns {Function} - Returns function allowing to easily add a callback to
+ * be triggered when that event is emitted on a given event target.
+ */
+function createCompatibleEventListener(
+  eventNames : string[]
+) :
+  (
+    element : IEventTargetLike,
+    listener : (event? : unknown) => void,
+    cancelSignal: CancellationSignal
+  ) => void
+{
+  let mem : string|undefined;
+  const prefixedEvents = eventPrefixed(eventNames);
+
+  return (
+    element : IEventTargetLike,
+    listener: (event? : unknown) => void,
+    cancelSignal: CancellationSignal
+  ) => {
+    if (cancelSignal.isCancelled) {
+      return;
+    }
+
+    // if the element is a HTMLElement we can detect
+    // the supported event, and memoize it in `mem`
+    if (element instanceof HTMLElement) {
+      if (typeof mem === "undefined") {
+        mem = findSupportedEvent(element, prefixedEvents);
+      }
+
+      if (isNonEmptyString(mem)) {
+        element.addEventListener(mem, listener);
+        cancelSignal.register(() => {
+          if (mem !== undefined) {
+            element.removeEventListener(mem, listener);
+          }
+        });
+      } else {
+        if (__ENVIRONMENT__.CURRENT_ENV === __ENVIRONMENT__.DEV as number) {
+          log.warn(`compat: element ${element.tagName}` +
+                   " does not support any of these events: " +
+                   prefixedEvents.join(", "));
+        }
+        return ;
+      }
+    }
+
+    prefixedEvents.forEach(eventName => {
+      (element as IEventEmitterLike).addEventListener(eventName, listener);
+      cancelSignal.register(() => {
+        (element as IEventEmitterLike).removeEventListener(eventName, listener);
+      });
+    });
+  };
+
+}
+
 /**
  * @param {Array.<string>} eventNames
  * @param {Array.<string>|undefined} prefixes
@@ -247,7 +310,8 @@ export interface IPictureInPictureEvent {
 
 /**
  * Emit when video enters and leaves Picture-In-Picture mode.
- * @param {HTMLMediaElement} mediaElement
+ * @param {HTMLMediaElement} elt
+ * @param {Object} stopListening
  * @returns {Observable}
  */
 function getPictureOnPictureStateRef(
@@ -505,6 +569,24 @@ const onKeyError$ = compatibleListener(["keyerror", "error"]);
  */
 const onKeyStatusesChange$ = compatibleListener(["keystatuseschange"]);
 
+/**
+ * @param {HTMLMediaElement} mediaElement
+ * @returns {Observable}
+ */
+const onSeeking = createCompatibleEventListener(["seeking"]);
+
+/**
+ * @param {HTMLMediaElement} mediaElement
+ * @returns {Observable}
+ */
+const onSeeked = createCompatibleEventListener(["seeked"]);
+
+/**
+ * @param {HTMLMediaElement} mediaElement
+ * @returns {Observable}
+ */
+const onEnded = createCompatibleEventListener(["ended"]);
+
 /**
  * Utilitary function allowing to add an event listener and remove it
  * automatically once the given `CancellationSignal` emits.
@@ -534,6 +616,7 @@ export {
   getVideoVisibilityRef,
   getVideoWidthRef,
   onEncrypted$,
+  onEnded,
   onEnded$,
   onFullscreenChange$,
   onKeyAdded$,
@@ -542,7 +625,9 @@ export {
   onKeyStatusesChange$,
   onLoadedMetadata$,
   onRemoveSourceBuffers$,
+  onSeeked,
   onSeeked$,
+  onSeeking,
   onSeeking$,
   onSourceClose$,
   onSourceEnded$,

package/src/compat/on_height_width_change.ts

@@ -14,16 +14,11 @@
  * limitations under the License.
  */
 
-import {
-  defer as observableDefer,
-  distinctUntilChanged,
-  interval as observableInterval,
-  map,
-  Observable,
-  Observer,
-  startWith,
-} from "rxjs";
 import log from "../log";
+import createSharedReference, {
+  IReadOnlySharedReference,
+} from "../utils/reference";
+import { CancellationSignal } from "../utils/task_canceller";
 import isNode from "./is_node";
 
 export interface IResolution { width : number;
@@ -63,8 +58,8 @@ const _ResizeObserver : IResizeObserverConstructor |
 /* eslint-enable @typescript-eslint/no-unsafe-assignment */
 
 /**
- * Emit the current height and width of the given `element` on subscribtion
- * and each time it changes.
+ * Emit the current height and width of the given `element` each time it
+ * changes.
  *
  * On some browsers, we might not be able to rely on a native API to know when
  * it changes, the `interval` argument allow us to provide us an inverval in
@@ -75,46 +70,50 @@ const _ResizeObserver : IResizeObserverConstructor |
  */
 export default function onHeightWidthChange(
   element : HTMLElement,
-  interval : number
-) : Observable<IResolution> {
-  return observableDefer(() : Observable<IResolution> => {
-    if (_ResizeObserver !== undefined) {
-      let lastHeight : number = -1;
-      let lastWidth : number = -1;
-
-      return new Observable((obs : Observer<IResolution>) => {
-        const resizeObserver = new _ResizeObserver(entries => {
-          if (entries.length === 0) {
-            log.error("Compat: Resized but no observed element.");
-            return;
-          }
+  interval : number,
+  cancellationSignal : CancellationSignal
+) : IReadOnlySharedReference<IResolution> {
+  const { height: initHeight, width: initWidth } = element.getBoundingClientRect();
+  const ref = createSharedReference<IResolution>({
+    height: initHeight,
+    width: initWidth,
+  });
+  let lastHeight : number = initHeight;
+  let lastWidth : number = initWidth;
 
-          const entry = entries[0];
-          const { height, width } = entry.contentRect;
+  if (_ResizeObserver !== undefined) {
+    const resizeObserver = new _ResizeObserver(entries => {
+      if (entries.length === 0) {
+        log.error("Compat: Resized but no observed element.");
+        return;
+      }
 
-          if (height !== lastHeight || width !== lastWidth) {
-            lastHeight = height;
-            lastWidth = width;
-            obs.next({ height, width });
-          }
-        });
+      const entry = entries[0];
+      const { height, width } = entry.contentRect;
 
-        resizeObserver.observe(element);
-        return () => {
-          resizeObserver.disconnect();
-        };
-      });
-    }
+      if (height !== lastHeight || width !== lastWidth) {
+        lastHeight = height;
+        lastWidth = width;
+        ref.setValue({ height, width });
+      }
+    });
 
-    return observableInterval(interval).pipe(
-      startWith(null),
-      map(() : IResolution => {
-        const { height, width } = element.getBoundingClientRect();
-        return { height, width };
-      }),
-      distinctUntilChanged((o, n) => {
-        return o.height === n.height && o.width === n.width;
-      })
-    );
-  });
+    resizeObserver.observe(element);
+    cancellationSignal.register(() => {
+      resizeObserver.disconnect();
+    });
+  } else {
+    const intervalId = setInterval(() => {
+      const { height, width } = element.getBoundingClientRect();
+      if (height !== lastHeight || width !== lastWidth) {
+        lastHeight = height;
+        lastWidth = width;
+        ref.setValue({ height, width });
+      }
+    }, interval);
+    cancellationSignal.register(() => {
+      clearInterval(intervalId);
+    });
+  }
+  return ref;
 }

package/src/core/api/playback_observer.ts

@@ -82,7 +82,7 @@ export default class PlaybackObserver {
    * This allows us to correctly characterize seeking events: if the counter is
    * superior to `0`, it is probably due to an internal "seek".
    */
-  private _internalSeekingEventsIncomingCounter : number;
+  private _internalSeeksIncoming : number[];
 
   /**
    * Stores the last playback observation produced by the `PlaybackObserver`.:
@@ -106,7 +106,7 @@ export default class PlaybackObserver {
    * @param {Object} options
    */
   constructor(mediaElement : HTMLMediaElement, options : IPlaybackObserverOptions) {
-    this._internalSeekingEventsIncomingCounter = 0;
+    this._internalSeeksIncoming = [];
     this._mediaElement = mediaElement;
     this._withMediaSource = options.withMediaSource;
     this._lowLatencyMode = options.lowLatencyMode;
@@ -137,6 +137,14 @@ export default class PlaybackObserver {
     return this._mediaElement.currentTime;
   }
 
+  /**
+   * Returns the current playback rate advertised by the `HTMLMediaElement`.
+   * @returns {number}
+   */
+  public getPlaybackRate() : number {
+    return this._mediaElement.playbackRate;
+  }
+
   /**
    * Returns the current `paused` status advertised by the `HTMLMediaElement`.
    *
@@ -159,7 +167,7 @@ export default class PlaybackObserver {
    * @param {number} time
    */
   public setCurrentTime(time: number) : void {
-    this._internalSeekingEventsIncomingCounter += 1;
+    this._internalSeeksIncoming.push(time);
     this._mediaElement.currentTime = time;
   }
 
@@ -250,17 +258,21 @@ export default class PlaybackObserver {
       event : IPlaybackObserverEventType
     ) : IPlaybackObservation => {
       let tmpEvt: IPlaybackObserverEventType = event;
-      if (tmpEvt === "seeking" && this._internalSeekingEventsIncomingCounter > 0) {
+      let startedInternalSeekTime : number | undefined;
+      if (tmpEvt === "seeking" && this._internalSeeksIncoming.length > 0) {
         tmpEvt = "internal-seeking";
-        this._internalSeekingEventsIncomingCounter -= 1;
+        startedInternalSeekTime = this._internalSeeksIncoming.shift();
       }
       const _lastObservation = lastObservation ?? this._generateInitialObservation();
       const mediaTimings = getMediaInfos(this._mediaElement, tmpEvt);
-      const internalSeeking = mediaTimings.seeking &&
-        // We've just received the event for internally seeking
-        (tmpEvt === "internal-seeking" ||
-          // or We're still waiting on the previous internal-seek
-          (_lastObservation.internalSeeking && tmpEvt !== "seeking"));
+      let pendingInternalSeek : number | null = null;
+      if (mediaTimings.seeking) {
+        if (typeof startedInternalSeekTime === "number") {
+          pendingInternalSeek = startedInternalSeekTime;
+        } else if (_lastObservation.pendingInternalSeek !== null && event !== "seeking") {
+          pendingInternalSeek = _lastObservation.pendingInternalSeek;
+        }
+      }
       const rebufferingStatus = getRebufferingStatus(
         _lastObservation,
         mediaTimings,
@@ -272,14 +284,14 @@ export default class PlaybackObserver {
         {},
         { rebuffering: rebufferingStatus,
           freezing: freezingStatus,
-          internalSeeking },
+          pendingInternalSeek },
         mediaTimings);
       if (log.hasLevel("DEBUG")) {
         log.debug("API: current media element state tick",
                   "event", timings.event,
                   "position", timings.position,
                   "seeking", timings.seeking,
-                  "internalSeeking", timings.internalSeeking,
+                  "internalSeek", timings.pendingInternalSeek,
                   "rebuffering", timings.rebuffering !== null,
                   "freezing", timings.freezing !== null,
                   "ended", timings.ended,
@@ -341,7 +353,7 @@ export default class PlaybackObserver {
     return objectAssign(getMediaInfos(this._mediaElement, "init"),
                         { rebuffering: null,
                           freezing: null,
-                          internalSeeking: false });
+                          pendingInternalSeek: null });
   }
 }
 
@@ -457,7 +469,7 @@ export interface IPlaybackObservation extends IMediaInfos {
    * If `true`, an "internal seek" (a seeking operation triggered by the
    * RxPlayer code) is currently pending.
    */
-  internalSeeking : boolean;
+  pendingInternalSeek : number | null;
 }
 
 /**
@@ -475,6 +487,11 @@ export interface IPlaybackObservation extends IMediaInfos {
 export interface IReadOnlyPlaybackObserver<TObservationType> {
   /** Get the current playing position, in seconds. */
   getCurrentTime() : number;
+  /**
+   * Returns the current playback rate advertised by the `HTMLMediaElement`.
+   * @returns {number}
+   */
+  getPlaybackRate() : number;
   /** Get the HTMLMediaElement's current `readyState`. */
   getReadyState() : number;
   /**
@@ -859,6 +876,9 @@ function generateReadOnlyObserver<TSource, TDest>(
     getReadyState() {
       return src.getReadyState();
     },
+    getPlaybackRate() : number {
+      return src.getPlaybackRate();
+    },
     getIsPaused() {
       return src.getIsPaused();
     },

package/src/core/api/public_api.ts

@@ -432,7 +432,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     // See: https://bugzilla.mozilla.org/show_bug.cgi?id=1194624
     videoElement.preload = "auto";
 
-    this.version = /* PLAYER_VERSION */"3.28.1-dev.2022083000";
+    this.version = /* PLAYER_VERSION */"3.29.0-dev.2022090500";
     this.log = log;
     this.state = "STOPPED";
     this.videoElement = videoElement;
@@ -741,21 +741,28 @@ class Player extends EventEmitter<IPublicAPIEvent> {
 
       const transportPipelines = transportFn(transportOptions);
 
-      const { offlineRetry, segmentRetry, manifestRetry } = networkConfig;
+      const { offlineRetry,
+              segmentRetry,
+              manifestRetry,
+              manifestRequestTimeout,
+              segmentRequestTimeout } = networkConfig;
 
       /** Interface used to load and refresh the Manifest. */
-      const manifestFetcher = new ManifestFetcher(url,
-                                                  transportPipelines,
-                                                  { lowLatencyMode,
-                                                    maxRetryRegular: manifestRetry,
-                                                    maxRetryOffline: offlineRetry });
+      const manifestFetcher = new ManifestFetcher(
+        url,
+        transportPipelines,
+        { lowLatencyMode,
+          maxRetryRegular: manifestRetry,
+          maxRetryOffline: offlineRetry,
+          requestTimeout:  manifestRequestTimeout });
 
       /** Interface used to download segments. */
       const segmentFetcherCreator = new SegmentFetcherCreator(
         transportPipelines,
         { lowLatencyMode,
           maxRetryOffline: offlineRetry,
-          maxRetryRegular: segmentRetry });
+          maxRetryRegular: segmentRetry,
+          requestTimeout: segmentRequestTimeout });
 
       /** Observable emitting the initial Manifest */
       let manifest$ : Observable<IManifestFetcherParsedResult |
@@ -1046,16 +1053,14 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     // Handle state updates
     playerState$
       .pipe(takeUntil(stoppedContent$))
-      .subscribe(x => this._priv_setPlayerState(x));
+      .subscribe(newState => {
+        this._priv_setPlayerState(newState);
 
-    const endedEvent$ = observation$.pipe(filter(o => {
-      return o.event === "ended";
-    }));
-    (this._priv_stopAtEnd ? endedEvent$ :
-                            EMPTY)
-      .pipe(takeUntil(stoppedContent$))
-      .subscribe(() => {
-        currentContentCanceller.cancel();
+        // Previous call could have performed all kind of side-effects, thus,
+        // we re-check the current state associated to the RxPlayer
+        if (this.state === "ENDED" && this._priv_stopAtEnd) {
+          currentContentCanceller.cancel();
+        }
       });
 
     // Link playback events to the corresponding callbacks
@@ -2943,7 +2948,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     return activeRepresentations[currentPeriod.id];
   }
 }
-Player.version = /* PLAYER_VERSION */"3.28.1-dev.2022083000";
+Player.version = /* PLAYER_VERSION */"3.29.0-dev.2022090500";
 
 /** Every events sent by the RxPlayer's public API. */
 interface IPublicAPIEvent {

package/src/core/fetchers/manifest/manifest_fetcher.ts

@@ -28,6 +28,7 @@ import {
   ITransportPipelines,
 } from "../../../transports";
 import assert from "../../../utils/assert";
+import isNullOrUndefined from "../../../utils/is_null_or_undefined";
 import TaskCanceller from "../../../utils/task_canceller";
 import errorSelector from "../utils/error_selector";
 import {
@@ -103,6 +104,13 @@ export interface IManifestFetcherSettings {
   maxRetryRegular : number | undefined;
   /** Maximum number of time a request be retried when the user is offline. */
   maxRetryOffline : number | undefined;
+  /**
+   * Timeout after which request are aborted and, depending on other options,
+   * retried.
+   * To set to `-1` for no timeout.
+   * `undefined` will lead to a default, large, timeout being used.
+   */
+  requestTimeout : number | undefined;
 }
 
 /**
@@ -164,6 +172,7 @@ export default class ManifestFetcher {
                                            IManifestFetcherWarningEvent>
   {
     return new Observable((obs) => {
+      const settings = this._settings;
       const pipelines = this._pipelines;
       const requestUrl = url ?? this._manifestUrl;
 
@@ -228,12 +237,21 @@ export default class ManifestFetcher {
        * Call the loader part of the pipeline, retrying if it fails according
        * to the current settings.
        * Returns the Promise of the last attempt.
-       * @param {string | undefined}  resolverUrl
+       * @param {string | undefined} manifestUrl
        * @returns {Promise}
        */
       function callLoaderWithRetries(manifestUrl : string | undefined) {
         const { loadManifest } = pipelines;
-        const callLoader = () => loadManifest(manifestUrl, canceller.signal);
+        let requestTimeout : number | undefined =
+          isNullOrUndefined(settings.requestTimeout) ?
+            config.getCurrent().DEFAULT_REQUEST_TIMEOUT :
+            settings.requestTimeout;
+        if (requestTimeout < 0) {
+          requestTimeout = undefined;
+        }
+        const callLoader = () => loadManifest(manifestUrl,
+                                              { timeout: requestTimeout },
+                                              canceller.signal);
         return tryRequestPromiseWithBackoff(callLoader,
                                             backoffSettings,
                                             canceller.signal);

package/src/core/fetchers/segment/segment_fetcher.ts

@@ -72,6 +72,11 @@ export default function createSegmentFetcher<TLoadedFormat, TSegmentDataType>(
   callbacks : ISegmentFetcherCreatorCallbacks,
   options : ISegmentFetcherOptions
 ) : ISegmentFetcher<TSegmentDataType> {
+  const requestOptions = {
+    timeout: options.requestTimeout < 0 ? undefined :
+                                          options.requestTimeout,
+  };
+
   /**
    * Cache audio and video initialization segments.
    * This allows to avoid doing too many requests for what are usually very
@@ -257,7 +262,11 @@ export default function createSegmentFetcher<TLoadedFormat, TSegmentDataType>(
         url : string | null,
         cancellationSignal: CancellationSignal
       ) {
-        return loadSegment(url, content, cancellationSignal, loaderCallbacks);
+        return loadSegment(url,
+                           content,
+                           requestOptions,
+                           cancellationSignal,
+                           loaderCallbacks);
       }
 
       /**
@@ -428,6 +437,12 @@ export interface ISegmentFetcherOptions {
    * currently offline.
    */
   maxRetryOffline : number;
+  /**
+   * Timeout after which request are aborted and, depending on other options,
+   * retried.
+   * To set to `-1` for no timeout.
+   */
+  requestTimeout : number;
 }
 
 /**
@@ -439,11 +454,14 @@ export function getSegmentFetcherOptions(
   bufferType : string,
   { maxRetryRegular,
     maxRetryOffline,
-    lowLatencyMode } : { maxRetryRegular? : number | undefined;
+    lowLatencyMode,
+    requestTimeout } : { maxRetryRegular? : number | undefined;
                          maxRetryOffline? : number | undefined;
+                         requestTimeout? : number | undefined;
                          lowLatencyMode : boolean; }
 ) : ISegmentFetcherOptions {
   const { DEFAULT_MAX_REQUESTS_RETRY_ON_ERROR,
+          DEFAULT_REQUEST_TIMEOUT,
           DEFAULT_MAX_REQUESTS_RETRY_ON_OFFLINE,
           INITIAL_BACKOFF_DELAY_BASE,
           MAX_BACKOFF_DELAY_BASE } = config.getCurrent();
@@ -453,5 +471,7 @@ export function getSegmentFetcherOptions(
            baseDelay: lowLatencyMode ? INITIAL_BACKOFF_DELAY_BASE.LOW_LATENCY :
                                        INITIAL_BACKOFF_DELAY_BASE.REGULAR,
            maxDelay: lowLatencyMode ? MAX_BACKOFF_DELAY_BASE.LOW_LATENCY :
-                                      MAX_BACKOFF_DELAY_BASE.REGULAR };
+                                      MAX_BACKOFF_DELAY_BASE.REGULAR,
+           requestTimeout: isNullOrUndefined(requestTimeout) ? DEFAULT_REQUEST_TIMEOUT :
+                                                               requestTimeout };
 }

package/src/core/fetchers/segment/segment_fetcher_creator.ts

@@ -135,4 +135,11 @@ export interface ISegmentFetcherCreatorBackoffOptions {
   maxRetryRegular : number | undefined;
   /** Maximum number of time a request be retried when the user is offline. */
   maxRetryOffline : number | undefined;
+  /**
+   * Timeout after which request are aborted and, depending on other options,
+   * retried.
+   * To set to `-1` for no timeout.
+   * `undefined` will lead to a default, large, timeout being used.
+   */
+  requestTimeout : number | undefined;
 }

package/src/core/init/initialize_directfile.ts

@@ -170,7 +170,7 @@ export default function initializeDirectfileContent({
    * 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);
+  const stallAvoider$ = StallAvoider(playbackObserver, null, speed, EMPTY, EMPTY);
 
   /**
    * Emit a "loaded" events once the initial play has been performed and the

package/src/core/init/load_on_media_source.ts

@@ -212,6 +212,7 @@ export default function createMediaSourceLoader(
      */
     const stallAvoider$ = StallAvoider(playbackObserver,
                                        manifest,
+                                       speed,
                                        lockedStream$,
                                        discontinuityUpdate$);