rx-player 3.25.2 → 3.26.3-dev.2022021400

package/src/core/stream/adaptation/create_representation_estimator.ts

@@ -15,16 +15,14 @@
  */
 
 import {
-  merge as observableMerge,
   Observable,
-  of as observableOf,
   Subject,
-} from "rxjs";
-import {
   distinctUntilChanged,
   map,
+  merge as observableMerge,
+  of as observableOf,
   switchMap,
-} from "rxjs/operators";
+} from "rxjs";
 import { MediaError } from "../../../errors";
 import Manifest, {
   Adaptation,
@@ -33,61 +31,36 @@ import Manifest, {
 import { fromEvent } from "../../../utils/event_emitter";
 import ABRManager, {
   IABREstimate,
-  IABRManagerClockTick,
-  IABRMetricsEvent,
-  IABRRequestBeginEvent,
-  IABRRequestEndEvent,
-  IABRRequestProgressEvent,
+  IABRManagerPlaybackObservation,
+  IABRStreamEvents,
 } from "../../abr";
-import {
-  IRepresentationChangeEvent,
-  IStreamEventAddedSegment,
-} from "../types";
 
 /**
  * Create an "estimator$" Observable which will emit which Representation (from
  * the given `Adaptation`) is the best fit (see `IABREstimate` type definition)
  * corresponding to the current network and playback conditions.
  *
- * This function also returns two subjects that should be used to add feedback
- * helping the estimator to make its choices:
- *
- *   - `requestFeedback$`: Subject through which information about new requests
- *     and network metrics should be emitted.
+ * This function also returns a subject that should be used to add feedback
+ * helping the estimator to make its choices.
  *
- *   - `streamFeedback$`: Subject through which stream-related events should be
- *      emitted.
- *
- * You can look at the types defined for both of those Subjects to have more
- * information on what data is expected. The idea is to provide as much data as
- * possible so the estimation is as adapted as possible.
+ * You can look at the types defined for this Subject to have more information
+ * on what data is expected. The idea is to provide as much data as possible so
+ * the estimation is as adapted as possible.
  *
  * @param {Object} content
  * @param {Object} abrManager
- * @param {Observable} clock$
+ * @param {Observable} observation$
  * @returns {Object}
  */
 export default function createRepresentationEstimator(
   { manifest, adaptation } : { manifest : Manifest;
                                adaptation : Adaptation; },
   abrManager : ABRManager,
-  clock$ : Observable<IABRManagerClockTick>
+  observation$ : Observable<IABRManagerPlaybackObservation>
 ) : { estimator$ : Observable<IABREstimate>;
-      streamFeedback$ : Subject<IStreamEventAddedSegment<unknown> |
-                                IRepresentationChangeEvent>;
-      requestFeedback$ : Subject<IABRMetricsEvent |
-                                 IABRRequestBeginEvent |
-                                 IABRRequestProgressEvent |
-                                 IABRRequestEndEvent>; }
+      abrFeedbacks$ : Subject<IABRStreamEvents>; }
 {
-  const streamFeedback$ = new Subject<IStreamEventAddedSegment<unknown> |
-                                      IRepresentationChangeEvent>();
-  const requestFeedback$ = new Subject<IABRMetricsEvent |
-                                       IABRRequestBeginEvent |
-                                       IABRRequestProgressEvent |
-                                       IABRRequestEndEvent>();
-  const abrEvents$ = observableMerge(streamFeedback$, requestFeedback$);
-
+  const abrFeedbacks$ = new Subject<IABRStreamEvents>();
   const estimator$ = observableMerge(
     // subscribe "first" (hack as it is a merge here) to event
     fromEvent(manifest, "decipherabilityUpdate"),
@@ -117,9 +90,10 @@ export default function createRepresentationEstimator(
       return true;
     }),
     switchMap((playableRepresentations) =>
-      abrManager.get$(adaptation.type, playableRepresentations, clock$, abrEvents$)));
+      abrManager.get$(adaptation.type,
+                      playableRepresentations,
+                      observation$,
+                      abrFeedbacks$)));
 
-  return { estimator$,
-           streamFeedback$,
-           requestFeedback$ };
+  return { estimator$, abrFeedbacks$ };
 }

package/src/core/stream/adaptation/index.ts

@@ -16,13 +16,13 @@
 
 import AdaptationStream, {
   IAdaptationStreamArguments,
-  IAdaptationStreamClockTick,
+  IAdaptationStreamPlaybackObservation,
   IAdaptationStreamOptions,
 } from "./adaptation_stream";
 
 export default AdaptationStream;
 export {
   IAdaptationStreamArguments,
-  IAdaptationStreamClockTick,
+  IAdaptationStreamPlaybackObservation,
   IAdaptationStreamOptions,
 };

package/src/core/stream/events_generators.ts

@@ -23,7 +23,6 @@ import {
   Representation,
 } from "../../manifest";
 import { IContentProtection } from "../eme";
-import { INeedsBufferFlush } from "../init";
 import { IBufferType } from "../segment_buffers";
 import {
   IActivePeriodChangedEvent,
@@ -32,6 +31,8 @@ import {
   ICompletedStreamEvent,
   IEncryptionDataEncounteredEvent,
   IEndOfStreamEvent,
+  ILockedStreamEvent,
+  INeedsBufferFlushEvent,
   INeedsDecipherabilityFlush,
   INeedsMediaSourceReload,
   IPeriodStreamClearedEvent,
@@ -43,6 +44,7 @@ import {
   IStreamNeedsManifestRefresh,
   IStreamTerminatingEvent,
   IStreamWarningEvent,
+  IWaitingMediaSourceReloadInternalEvent,
 } from "./types";
 
 const EVENTS = {
@@ -106,25 +108,37 @@ const EVENTS = {
   },
 
   /**
-   * @param {Object} period - The Period to which the stream logic asking for a
-   * media source reload is linked.
    * @param {number} reloadAt - Position at which we should reload
    * @param {boolean} reloadOnPause - If `false`, stay on pause after reloading.
    * if `true`, automatically play once reloaded.
    * @returns {Object}
    */
   needsMediaSourceReload(
-    period : Period,
     reloadAt : number,
     reloadOnPause : boolean
   ) : INeedsMediaSourceReload {
     return { type: "needs-media-source-reload",
              value: { position : reloadAt,
-                      autoPlay : reloadOnPause,
-                      period } };
+                      autoPlay : reloadOnPause } };
   },
 
-  needsBufferFlush(): INeedsBufferFlush {
+  /**
+   * @param {string} bufferType - The buffer type for which the stream cannot
+   * currently load segments.
+   * @param {Object} period - The Period for which the stream cannot
+   * currently load segments.
+   * media source reload is linked.
+   * @returns {Object}
+   */
+  lockedStream(
+    bufferType : IBufferType,
+    period : Period
+  ) : ILockedStreamEvent {
+    return { type: "locked-stream",
+             value: { bufferType, period } };
+  },
+
+  needsBufferFlush(): INeedsBufferFlushEvent {
     return { type: "needs-buffer-flush", value: undefined };
   },
 
@@ -183,6 +197,16 @@ const EVENTS = {
   warning(value : ICustomError) : IStreamWarningEvent {
     return { type: "warning", value };
   },
+
+  waitingMediaSourceReload(
+    bufferType : IBufferType,
+    period : Period,
+    position : number,
+    autoPlay : boolean
+  ) : IWaitingMediaSourceReloadInternalEvent {
+    return { type: "waiting-media-source-reload",
+             value: { bufferType, period, position, autoPlay } };
+  },
 };
 
 export default EVENTS;

package/src/core/stream/index.ts

@@ -15,13 +15,13 @@
  */
 
 import StreamOrchestrator, {
-  IStreamOrchestratorClockTick,
   IStreamOrchestratorOptions,
+  IStreamOrchestratorPlaybackObservation,
 } from "./orchestrator";
 export * from "./types";
 
 export default StreamOrchestrator;
 export {
-  IStreamOrchestratorClockTick,
+  IStreamOrchestratorPlaybackObservation,
   IStreamOrchestratorOptions,
 };

package/src/core/stream/orchestrator/active_period_emitter.ts

@@ -14,19 +14,17 @@
  * limitations under the License.
  */
 
-import {
-  merge as observableMerge,
-  Observable,
-} from "rxjs";
 import {
   distinctUntilChanged,
   filter,
   map,
+  merge as observableMerge,
+  Observable,
   scan,
-} from "rxjs/operators";
+} from "rxjs";
 import { Period } from "../../../manifest";
 import { IBufferType } from "../../segment_buffers";
-import { IMultiplePeriodStreamsEvent } from "../types";
+import { IStreamOrchestratorEvent } from "../types";
 
 interface IPeriodObject { period : Period;
                           buffers: Set<IBufferType>; }
@@ -72,7 +70,7 @@ type IPeriodsList = Partial<Record<string, IPeriodObject>>;
  * @returns {Observable}
  */
 export default function ActivePeriodEmitter(
-  buffers$: Array<Observable<IMultiplePeriodStreamsEvent>>
+  buffers$: Array<Observable<IStreamOrchestratorEvent>>
 ) : Observable<Period|null> {
   const numberOfStreams = buffers$.length;
   return observableMerge(...buffers$).pipe(
@@ -80,7 +78,7 @@ export default function ActivePeriodEmitter(
     filter(({ type }) => type === "periodStreamCleared" ||
                          type === "adaptationChange" ||
                          type === "representationChange"),
-    scan<IMultiplePeriodStreamsEvent, IPeriodsList>((acc, evt) => {
+    scan<IStreamOrchestratorEvent, IPeriodsList>((acc, evt) => {
       switch (evt.type) {
         case "periodStreamCleared": {
           const { period, type } = evt.value;
@@ -111,12 +109,12 @@ export default function ActivePeriodEmitter(
         case "representationChange": {
           const { period, type } = evt.value;
           const currentInfos = acc[period.id];
-          if (currentInfos !== undefined && !currentInfos.buffers.has(type)) {
-            currentInfos.buffers.add(type);
-          } else {
+          if (currentInfos === undefined) {
             const bufferSet = new Set<IBufferType>();
             bufferSet.add(type);
             acc[period.id] = { period, buffers: bufferSet };
+          } else if (!currentInfos.buffers.has(type)) {
+            currentInfos.buffers.add(type);
           }
         }
           break;

package/src/core/stream/orchestrator/are_streams_complete.ts

@@ -16,15 +16,13 @@
 
 import {
   combineLatest as observableCombineLatest,
-  Observable,
-} from "rxjs";
-import {
   distinctUntilChanged,
   filter,
   map,
+  Observable,
   startWith,
-} from "rxjs/operators";
-import { IMultiplePeriodStreamsEvent } from "../types";
+} from "rxjs";
+import { IStreamOrchestratorEvent } from "../types";
 
 /**
  * Returns an Observable which emits ``true`` when all PeriodStreams given are
@@ -44,7 +42,7 @@ import { IMultiplePeriodStreamsEvent } from "../types";
  * @returns {Observable}
  */
 export default function areStreamsComplete(
-  ...streams : Array<Observable<IMultiplePeriodStreamsEvent>>
+  ...streams : Array<Observable<IStreamOrchestratorEvent>>
 ) : Observable<boolean> {
   /**
    * Array of Observables linked to the Array of Streams which emit:

package/src/core/stream/orchestrator/get_blacklisted_ranges.ts

@@ -31,7 +31,7 @@ import { SegmentBuffer } from "../../segment_buffers";
  * @returns {Array.<Object>}
  */
 export default function getBlacklistedRanges(
-  segmentBuffer : SegmentBuffer<unknown>,
+  segmentBuffer : SegmentBuffer,
   contents : Array<{ adaptation : Adaptation;
                      period : Period;
                      representation : Representation; }>

package/src/core/stream/orchestrator/index.ts

@@ -15,12 +15,12 @@
  */
 
 import StreamOrchestrator, {
-  IStreamOrchestratorClockTick,
   IStreamOrchestratorOptions,
+  IStreamOrchestratorPlaybackObservation,
 } from "./stream_orchestrator";
 
 export default StreamOrchestrator;
 export {
-  IStreamOrchestratorClockTick,
   IStreamOrchestratorOptions,
+  IStreamOrchestratorPlaybackObservation,
 };

package/src/core/stream/orchestrator/stream_orchestrator.ts

@@ -15,29 +15,26 @@
  */
 
 import {
-  BehaviorSubject,
   combineLatest,
   concat as observableConcat,
   defer as observableDefer,
-  EMPTY,
-  merge as observableMerge,
-  Observable,
-  of as observableOf,
-  Subject,
-} from "rxjs";
-import {
   distinctUntilChanged,
+  EMPTY,
   exhaustMap,
   filter,
   ignoreElements,
   map,
+  merge as observableMerge,
   mergeMap,
+  Observable,
+  of as observableOf,
   share,
   startWith,
+  Subject,
   take,
   takeUntil,
   tap,
-} from "rxjs/operators";
+} from "rxjs";
 import config from "../../../config";
 import { MediaError } from "../../../errors";
 import log from "../../../log";
@@ -47,9 +44,11 @@ import Manifest, {
 import deferSubscriptions from "../../../utils/defer_subscriptions";
 import { fromEvent } from "../../../utils/event_emitter";
 import filterMap from "../../../utils/filter_map";
+import { IReadOnlySharedReference } from "../../../utils/reference";
 import SortedList from "../../../utils/sorted_list";
 import WeakMapMemory from "../../../utils/weak_map_memory";
 import ABRManager from "../../abr";
+import type { IReadOnlyPlaybackObserver } from "../../api";
 import { SegmentFetcherCreator } from "../../fetchers";
 import SegmentBuffersStore, {
   BufferGarbageCollector,
@@ -58,7 +57,7 @@ import SegmentBuffersStore, {
 } from "../../segment_buffers";
 import EVENTS from "../events_generators";
 import PeriodStream, {
-  IPeriodStreamClockTick,
+  IPeriodStreamPlaybackObservation,
   IPeriodStreamOptions,
 } from "../period";
 import {
@@ -71,7 +70,13 @@ import ActivePeriodEmitter from "./active_period_emitter";
 import areStreamsComplete from "./are_streams_complete";
 import getBlacklistedRanges from "./get_blacklisted_ranges";
 
-export type IStreamOrchestratorClockTick = IPeriodStreamClockTick;
+// 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 */
+
+export type IStreamOrchestratorPlaybackObservation = IPeriodStreamPlaybackObservation;
 
 const { MAXIMUM_MAX_BUFFER_AHEAD,
         MAXIMUM_MAX_BUFFER_BEHIND } = config;
@@ -79,9 +84,9 @@ const { MAXIMUM_MAX_BUFFER_AHEAD,
 /** Options tweaking the behavior of the StreamOrchestrator. */
 export type IStreamOrchestratorOptions =
   IPeriodStreamOptions &
-  { wantedBufferAhead$ : BehaviorSubject<number>;
-    maxBufferAhead$ : Observable<number>;
-    maxBufferBehind$ : Observable<number>; };
+  { wantedBufferAhead : IReadOnlySharedReference<number>;
+    maxBufferAhead : IReadOnlySharedReference<number>;
+    maxBufferBehind : IReadOnlySharedReference<number>; };
 
 /**
  * Create and manage the various Stream Observables needed for the content to
@@ -99,7 +104,7 @@ export type IStreamOrchestratorOptions =
  *   - Emit various events to notify of its health and issues
  *
  * @param {Object} content
- * @param {Observable} clock$ - Emit position information
+ * @param {Observable} playbackObserver - Emit position information
  * @param {Object} abrManager - Emit bitrate estimates and best Representation
  * to play.
  * @param {Object} segmentBuffersStore - Will be used to lazily create
@@ -111,19 +116,19 @@ export type IStreamOrchestratorOptions =
 export default function StreamOrchestrator(
   content : { manifest : Manifest;
               initialPeriod : Period; },
-  clock$ : Observable<IStreamOrchestratorClockTick>,
+  playbackObserver : IReadOnlyPlaybackObserver<IStreamOrchestratorPlaybackObservation>,
   abrManager : ABRManager,
   segmentBuffersStore : SegmentBuffersStore,
-  segmentFetcherCreator : SegmentFetcherCreator<any>,
+  segmentFetcherCreator : SegmentFetcherCreator,
   options: IStreamOrchestratorOptions
 ) : Observable<IStreamOrchestratorEvent> {
   const { manifest, initialPeriod } = content;
-  const { maxBufferAhead$, maxBufferBehind$, wantedBufferAhead$ } = options;
+  const { maxBufferAhead, maxBufferBehind, wantedBufferAhead } = options;
 
   // Keep track of a unique BufferGarbageCollector created per
   // SegmentBuffer.
   const garbageCollectors =
-    new WeakMapMemory((segmentBuffer : SegmentBuffer<unknown>) => {
+    new WeakMapMemory((segmentBuffer : SegmentBuffer) => {
       const { bufferType } = segmentBuffer;
       const defaultMaxBehind = MAXIMUM_MAX_BUFFER_BEHIND[bufferType] != null ?
                                  MAXIMUM_MAX_BUFFER_BEHIND[bufferType] as number :
@@ -133,18 +138,19 @@ export default function StreamOrchestrator(
                                 Infinity;
       return BufferGarbageCollector({
         segmentBuffer,
-        clock$: clock$.pipe(map(tick => tick.position + tick.wantedTimeOffset)),
-        maxBufferBehind$: maxBufferBehind$.pipe(
+        currentTime$: playbackObserver.observe(true)
+          .pipe(map(o => o.position + o.wantedTimeOffset)),
+        maxBufferBehind$: maxBufferBehind.asObservable().pipe(
           map(val => Math.min(val, defaultMaxBehind))),
-        maxBufferAhead$: maxBufferAhead$.pipe(
+        maxBufferAhead$: maxBufferAhead.asObservable().pipe(
           map(val => Math.min(val, defaultMaxAhead))),
       });
     });
 
   // trigger warnings when the wanted time is before or after the manifest's
   // segments
-  const outOfManifest$ = clock$.pipe(
-    filterMap<IStreamOrchestratorClockTick, IStreamWarningEvent, null>((
+  const outOfManifest$ = playbackObserver.observe(true).pipe(
+    filterMap<IStreamOrchestratorPlaybackObservation, IStreamWarningEvent, null>((
       { position, wantedTimeOffset }
     ) => {
       const offsetedPosition = wantedTimeOffset + position;
@@ -174,7 +180,7 @@ export default function StreamOrchestrator(
   const activePeriodChanged$ = ActivePeriodEmitter(streamsArray).pipe(
     filter((period) : period is Period => period !== null),
     map(period => {
-      log.info("Stream: New active period", period);
+      log.info("Stream: New active period", period.start);
       return EVENTS.activePeriodChanged(period);
     }));
 
@@ -202,8 +208,8 @@ export default function StreamOrchestrator(
    * Manage creation and removal of Streams for every Periods for a given type.
    *
    * Works by creating consecutive Streams through the
-   * `manageConsecutivePeriodStreams` function, and restarting it when the clock
-   * goes out of the bounds of these Streams.
+   * `manageConsecutivePeriodStreams` function, and restarting it when the
+   * current position goes out of the bounds of these Streams.
    * @param {string} bufferType - e.g. "audio" or "video"
    * @param {Period} basePeriod - Initial Period downloaded.
    * @returns {Observable}
@@ -211,7 +217,7 @@ export default function StreamOrchestrator(
   function manageEveryStreams(
     bufferType : IBufferType,
     basePeriod : Period
-  ) : Observable<IMultiplePeriodStreamsEvent> {
+  ) : Observable<IStreamOrchestratorEvent> {
     // Each Period for which there is currently a Stream, chronologically
     const periodList = new SortedList<Period>((a, b) => a.start - b.start);
     const destroyStreams$ = new Subject<void>();
@@ -229,24 +235,23 @@ export default function StreamOrchestrator(
      */
     function launchConsecutiveStreamsForPeriod(
       period : Period
-    ) : Observable<IMultiplePeriodStreamsEvent> {
+    ) : Observable<IStreamOrchestratorEvent> {
       return manageConsecutivePeriodStreams(bufferType, period, destroyStreams$).pipe(
-        filterMap<
-          IMultiplePeriodStreamsEvent,
-          IMultiplePeriodStreamsEvent,
-          null
-        >((message) => {
+        map((message) => {
           switch (message.type) {
-            case "needs-media-source-reload":
+            case "waiting-media-source-reload":
               // Only reload the MediaSource when the more immediately required
               // Period is the one asking for it
               const firstPeriod = periodList.head();
               if (firstPeriod === undefined ||
                   firstPeriod.id !== message.value.period.id)
               {
-                return null;
+                return EVENTS.lockedStream(message.value.bufferType,
+                                           message.value.period);
+              } else {
+                const { position, autoPlay } = message.value;
+                return EVENTS.needsMediaSourceReload(position, autoPlay);
               }
-              break;
             case "periodStreamReady":
               enableOutOfBoundsCheck = true;
               periodList.add(message.value.period);
@@ -256,7 +261,7 @@ export default function StreamOrchestrator(
               break;
           }
           return message;
-        }, null),
+        }),
         share()
       );
     }
@@ -281,9 +286,9 @@ export default function StreamOrchestrator(
 
     // Restart the current Stream when the wanted time is in another period
     // than the ones already considered
-    const restartStreamsWhenOutOfBounds$ = clock$.pipe(
+    const restartStreamsWhenOutOfBounds$ = playbackObserver.observe(true).pipe(
       filterMap<
-        IStreamOrchestratorClockTick,
+        IStreamOrchestratorPlaybackObservation,
         Period,
         null
       >(({ position, wantedTimeOffset }) => {
@@ -340,22 +345,25 @@ export default function StreamOrchestrator(
         return observableConcat(
           ...rangesToClean.map(({ start, end }) =>
             segmentBuffer.removeBuffer(start, end).pipe(ignoreElements())),
-          clock$.pipe(take(1), mergeMap((lastTick) => {
-            return observableConcat(
-              observableOf(EVENTS.needsDecipherabilityFlush(lastTick.position,
-                                                            !lastTick.isPaused,
-                                                            lastTick.duration)),
-              observableDefer(() => {
-                const lastPosition = lastTick.position + lastTick.wantedTimeOffset;
-                const newInitialPeriod = manifest.getPeriodForTime(lastPosition);
-                if (newInitialPeriod == null) {
-                  throw new MediaError(
-                    "MEDIA_TIME_NOT_FOUND",
-                    "The wanted position is not found in the Manifest.");
-                }
-                return launchConsecutiveStreamsForPeriod(newInitialPeriod);
-              }));
-          })));
+          playbackObserver.observe(true).pipe(
+            take(1),
+            mergeMap((observation) => {
+              return observableConcat(
+                observableOf(EVENTS.needsDecipherabilityFlush(observation.position,
+                                                              !observation.isPaused,
+                                                              observation.duration)),
+                observableDefer(() => {
+                  const lastPosition = observation.position +
+                                       observation.wantedTimeOffset;
+                  const newInitialPeriod = manifest.getPeriodForTime(lastPosition);
+                  if (newInitialPeriod == null) {
+                    throw new MediaError(
+                      "MEDIA_TIME_NOT_FOUND",
+                      "The wanted position is not found in the Manifest.");
+                  }
+                  return launchConsecutiveStreamsForPeriod(newInitialPeriod);
+                }));
+            })));
       }));
 
     return observableMerge(restartStreamsWhenOutOfBounds$,
@@ -375,7 +383,7 @@ export default function StreamOrchestrator(
    * coming after it (from the last chronological one to the first).
    *
    * To clean-up PeriodStreams, each one of them are also automatically
-   * destroyed once the clock announces a time superior or equal to the end of
+   * destroyed once the current position is superior or equal to the end of
    * the concerned Period.
    *
    * A "periodStreamReady" event is sent each times a new PeriodStream is
@@ -395,7 +403,7 @@ export default function StreamOrchestrator(
     basePeriod : Period,
     destroy$ : Observable<void>
   ) : Observable<IMultiplePeriodStreamsEvent> {
-    log.info("SO: Creating new Stream for", bufferType, basePeriod);
+    log.info("SO: Creating new Stream for", bufferType, basePeriod.start);
 
     // Emits the Period of the next Period Stream when it can be created.
     const createNextPeriodStream$ = new Subject<Period>();
@@ -405,7 +413,7 @@ export default function StreamOrchestrator(
     const destroyNextStreams$ = new Subject<void>();
 
     // Emits when the current position goes over the end of the current Stream.
-    const endOfCurrentStream$ = clock$
+    const endOfCurrentStream$ = playbackObserver.observe(true)
       .pipe(filter(({ position, wantedTimeOffset }) =>
         basePeriod.end != null &&
                     (position + wantedTimeOffset) >= basePeriod.end));
@@ -438,13 +446,13 @@ export default function StreamOrchestrator(
 
     const periodStream$ = PeriodStream({ abrManager,
                                          bufferType,
-                                         clock$,
                                          content: { manifest, period: basePeriod },
                                          garbageCollectors,
                                          segmentFetcherCreator,
                                          segmentBuffersStore,
                                          options,
-                                         wantedBufferAhead$ }
+                                         playbackObserver,
+                                         wantedBufferAhead }
     ).pipe(
       mergeMap((evt : IPeriodStreamEvent) : Observable<IMultiplePeriodStreamsEvent> => {
         if (evt.type === "stream-status") {
@@ -473,7 +481,7 @@ export default function StreamOrchestrator(
         periodStream$.pipe(takeUntil(killCurrentStream$)),
         observableOf(EVENTS.periodStreamCleared(bufferType, basePeriod))
           .pipe(tap(() => {
-            log.info("SO: Destroying Stream for", bufferType, basePeriod);
+            log.info("SO: Destroying Stream for", bufferType, basePeriod.start);
           })));
 
     return observableMerge(currentStream$,