rx-player 3.26.1 → 3.26.2

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,14 +116,14 @@ export type IStreamOrchestratorOptions =
 export default function StreamOrchestrator(
   content : { manifest : Manifest;
               initialPeriod : Period; },
-  clock$ : Observable<IStreamOrchestratorClockTick>,
+  playbackObserver : IReadOnlyPlaybackObserver<IStreamOrchestratorPlaybackObservation>,
   abrManager : ABRManager,
   segmentBuffersStore : SegmentBuffersStore,
   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.
@@ -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}
@@ -280,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 }) => {
@@ -339,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$,
@@ -374,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
@@ -394,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>();
@@ -404,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));
@@ -437,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") {
@@ -472,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$,

package/src/core/stream/period/create_empty_adaptation_stream.ts

@@ -16,12 +16,14 @@
 
 import {
   combineLatest as observableCombineLatest,
+  mergeMap,
   Observable,
   of as observableOf,
 } from "rxjs";
-import { mergeMap } from "rxjs/operators";
 import log from "../../../log";
 import { Period } from "../../../manifest";
+import { IReadOnlySharedReference } from "../../../utils/reference";
+import { IReadOnlyPlaybackObserver } from "../../api";
 import { IBufferType } from "../../segment_buffers";
 import { IStreamStatusEvent } from "../types";
 
@@ -30,31 +32,33 @@ import { IStreamStatusEvent } from "../types";
  *
  * This observable will never download any segment and just emit a "full"
  * event when reaching the end.
- * @param {Observable} streamClock$
- * @param {Observable} wantedBufferAhead$
+ * @param {Observable} playbackObserver
+ * @param {Object} wantedBufferAhead
  * @param {string} bufferType
  * @param {Object} content
  * @returns {Observable}
  */
 export default function createEmptyAdaptationStream(
-  streamClock$ : Observable<{ position : number }>,
-  wantedBufferAhead$ : Observable<number>,
+  playbackObserver : IReadOnlyPlaybackObserver<{ position : number }>,
+  wantedBufferAhead : IReadOnlySharedReference<number>,
   bufferType : IBufferType,
   content : { period : Period }
 ) : Observable<IStreamStatusEvent> {
   const { period } = content;
   let hasFinishedLoading = false;
-  return observableCombineLatest([streamClock$, wantedBufferAhead$]).pipe(
-    mergeMap(([clockTick, wantedBufferAhead]) => {
-      const { position } = clockTick;
-      if (period.end !== undefined && position + wantedBufferAhead >= period.end) {
+  const wantedBufferAhead$ = wantedBufferAhead.asObservable();
+  const observation$ = playbackObserver.observe(true);
+  return observableCombineLatest([observation$, wantedBufferAhead$]).pipe(
+    mergeMap(([observation, wba]) => {
+      const { position } = observation;
+      if (period.end !== undefined && position + wba >= period.end) {
         log.debug("Stream: full \"empty\" AdaptationStream", bufferType);
         hasFinishedLoading = true;
       }
       return observableOf({ type: "stream-status" as const,
                             value: { period,
                                      bufferType,
-                                     position: clockTick.position,
+                                     position: observation.position,
                                      imminentDiscontinuity: null,
                                      hasFinishedLoading,
                                      neededSegments: [],

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

@@ -16,14 +16,14 @@
 
 import PeriodStream, {
   IPeriodStreamArguments,
-  IPeriodStreamClockTick,
   IPeriodStreamOptions,
+  IPeriodStreamPlaybackObservation,
 } from "./period_stream";
 
 export default PeriodStream;
 
 export {
   IPeriodStreamArguments,
-  IPeriodStreamClockTick,
   IPeriodStreamOptions,
+  IPeriodStreamPlaybackObservation,
 };

package/src/core/stream/period/period_stream.ts

@@ -15,24 +15,20 @@
  */
 
 import {
-  BehaviorSubject,
+  catchError,
   concat as observableConcat,
+  defer as observableDefer,
   EMPTY,
+  ignoreElements,
+  map,
   merge as observableMerge,
+  mergeMap,
   Observable,
   of as observableOf,
   ReplaySubject,
-} from "rxjs";
-import {
-  catchError,
-  ignoreElements,
-  map,
-  mapTo,
-  mergeMap,
   startWith,
   switchMap,
-  take,
-} from "rxjs/operators";
+} from "rxjs";
 import config from "../../../config";
 import { formatError } from "../../../errors";
 import log from "../../../log";
@@ -42,8 +38,10 @@ import Manifest, {
 } from "../../../manifest";
 import objectAssign from "../../../utils/object_assign";
 import { getLeftSizeOfRange } from "../../../utils/ranges";
+import { IReadOnlySharedReference } from "../../../utils/reference";
 import WeakMapMemory from "../../../utils/weak_map_memory";
 import ABRManager from "../../abr";
+import { IReadOnlyPlaybackObserver } from "../../api";
 import { SegmentFetcherCreator } from "../../fetchers";
 import SegmentBuffersStore, {
   IBufferType,
@@ -51,7 +49,7 @@ import SegmentBuffersStore, {
   SegmentBuffer,
 } from "../../segment_buffers";
 import AdaptationStream, {
-  IAdaptationStreamOptions,
+  IAdaptationStreamOptions, IAdaptationStreamPlaybackObservation,
 } from "../adaptation";
 import EVENTS from "../events_generators";
 import reloadAfterSwitch from "../reload_after_switch";
@@ -65,30 +63,42 @@ import getAdaptationSwitchStrategy from "./get_adaptation_switch_strategy";
 
 const { DELTA_POSITION_AFTER_RELOAD } = config;
 
-export interface IPeriodStreamClockTick {
-  position : number; // the position we are in the video in s at the time of the tic
-  getCurrentTime : () => number; // fetch the current time
-  duration : number; // duration of the HTMLMediaElement
-  isPaused: boolean; // If true, the player is on pause
-  liveGap? : number; // gap between the current position and the edge of a
-                     // live content. Not set for non-live contents
-  readyState : number; // readyState of the HTMLMediaElement
-  speed : number; // playback rate at which the content plays
-  wantedTimeOffset : number; // offset in s to add to the time to obtain the
-                             // position we actually want to download from
+/** Playback observation required by the `PeriodStream`. */
+export interface IPeriodStreamPlaybackObservation {
+  /** The position we are in the video in seconds at the time of the observation. */
+  position : number;
+  /** `duration` property of the HTMLMediaElement. */
+  duration : number;
+  /** If `true`, the player is currently paused. */
+  isPaused: boolean;
+  /** `readyState` property of the HTMLMediaElement. */
+  readyState : number;
+  /** Target playback rate at which we want to play the content. */
+  speed : number;
+  /**
+   * Offset, in seconds to add to `position` to obtain the starting position at
+   * which we actually want to download segments for.
+   */
+  wantedTimeOffset : number;
+  /**
+   * Only set for live contents.
+   * Difference between the live edge and the current position, in seconds.
+   */
+  liveGap : number | undefined;
 }
 
+/** Arguments required by the `PeriodStream`. */
 export interface IPeriodStreamArguments {
   abrManager : ABRManager;
   bufferType : IBufferType;
-  clock$ : Observable<IPeriodStreamClockTick>;
   content : { manifest : Manifest;
               period : Period; };
   garbageCollectors : WeakMapMemory<SegmentBuffer, Observable<never>>;
   segmentFetcherCreator : SegmentFetcherCreator;
   segmentBuffersStore : SegmentBuffersStore;
+  playbackObserver : IReadOnlyPlaybackObserver<IPeriodStreamPlaybackObservation>;
   options: IPeriodStreamOptions;
-  wantedBufferAhead$ : BehaviorSubject<number>;
+  wantedBufferAhead : IReadOnlySharedReference<number>;
 }
 
 /** Options tweaking the behavior of the PeriodStream. */
@@ -126,13 +136,13 @@ export type IPeriodStreamOptions =
 export default function PeriodStream({
   abrManager,
   bufferType,
-  clock$,
   content,
   garbageCollectors,
+  playbackObserver,
   segmentFetcherCreator,
   segmentBuffersStore,
   options,
-  wantedBufferAhead$,
+  wantedBufferAhead,
 } : IPeriodStreamArguments) : Observable<IPeriodStreamEvent> {
   const { period } = content;
 
@@ -158,14 +168,14 @@ export default function PeriodStream({
                                  DELTA_POSITION_AFTER_RELOAD.trackSwitch.other;
 
       if (adaptation === null) { // Current type is disabled for that Period
-        log.info(`Stream: Set no ${bufferType} Adaptation`, period);
+        log.info(`Stream: Set no ${bufferType} Adaptation. P:`, period.start);
         const segmentBufferStatus = segmentBuffersStore.getStatus(bufferType);
         let cleanBuffer$ : Observable<unknown>;
 
         if (segmentBufferStatus.type === "initialized") {
           log.info(`Stream: Clearing previous ${bufferType} SegmentBuffer`);
           if (SegmentBuffersStore.isNative(bufferType)) {
-            return reloadAfterSwitch(period, bufferType, clock$, 0);
+            return reloadAfterSwitch(period, bufferType, playbackObserver, 0);
           }
           cleanBuffer$ = segmentBufferStatus.value
             .removeBuffer(period.start,
@@ -179,57 +189,69 @@ export default function PeriodStream({
         }
 
         return observableConcat(
-          cleanBuffer$.pipe(mapTo(EVENTS.adaptationChange(bufferType, null, period))),
-          createEmptyStream(clock$, wantedBufferAhead$, bufferType, { period })
+          cleanBuffer$.pipe(map(() => EVENTS.adaptationChange(bufferType, null, period))),
+          createEmptyStream(playbackObserver, wantedBufferAhead, bufferType, { period })
         );
       }
 
       if (SegmentBuffersStore.isNative(bufferType) &&
           segmentBuffersStore.getStatus(bufferType).type === "disabled")
       {
-        return reloadAfterSwitch(period, bufferType, clock$, relativePosAfterSwitch);
+        return reloadAfterSwitch(period,
+                                 bufferType,
+                                 playbackObserver,
+                                 relativePosAfterSwitch);
       }
 
-      log.info(`Stream: Updating ${bufferType} adaptation`, adaptation, period);
+      log.info(`Stream: Updating ${bufferType} adaptation`,
+               `A: ${adaptation.id}`,
+               `P: ${period.start}`);
 
-      const newStream$ = clock$.pipe(
-        take(1),
-        mergeMap((tick) => {
-          const segmentBuffer = createOrReuseSegmentBuffer(segmentBuffersStore,
-                                                           bufferType,
-                                                           adaptation,
-                                                           options);
-          const playbackInfos = { currentTime: tick.getCurrentTime(),
-                                  readyState: tick.readyState };
-          const strategy = getAdaptationSwitchStrategy(segmentBuffer,
-                                                       period,
-                                                       adaptation,
-                                                       playbackInfos,
-                                                       options);
-          if (strategy.type === "needs-reload") {
-            return reloadAfterSwitch(period, bufferType, clock$, relativePosAfterSwitch);
-          }
+      const newStream$ = observableDefer(() => {
+        const readyState = playbackObserver.getReadyState();
+        const segmentBuffer = createOrReuseSegmentBuffer(segmentBuffersStore,
+                                                         bufferType,
+                                                         adaptation,
+                                                         options);
+        const playbackInfos = { currentTime: playbackObserver.getCurrentTime(),
+                                readyState };
+        const strategy = getAdaptationSwitchStrategy(segmentBuffer,
+                                                     period,
+                                                     adaptation,
+                                                     playbackInfos,
+                                                     options);
+        if (strategy.type === "needs-reload") {
+          return reloadAfterSwitch(period,
+                                   bufferType,
+                                   playbackObserver,
+                                   relativePosAfterSwitch);
+        }
 
-          const needsBufferFlush$ = strategy.type === "flush-buffer"
-            ? observableOf(EVENTS.needsBufferFlush())
-            : EMPTY;
+        const needsBufferFlush$ = strategy.type === "flush-buffer"
+          ? observableOf(EVENTS.needsBufferFlush())
+          : EMPTY;
 
-          const cleanBuffer$ =
-            strategy.type === "clean-buffer" || strategy.type === "flush-buffer" ?
-              observableConcat(...strategy.value.map(({ start, end }) =>
-                segmentBuffer.removeBuffer(start, end))
-              ).pipe(ignoreElements()) : EMPTY;
+        const cleanBuffer$ =
+          strategy.type === "clean-buffer" || strategy.type === "flush-buffer" ?
+            observableConcat(...strategy.value.map(({ start, end }) =>
+              segmentBuffer.removeBuffer(start, end))
+            // 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()) : EMPTY;
 
-          const bufferGarbageCollector$ = garbageCollectors.get(segmentBuffer);
-          const adaptationStream$ = createAdaptationStream(adaptation, segmentBuffer);
+        const bufferGarbageCollector$ = garbageCollectors.get(segmentBuffer);
+        const adaptationStream$ = createAdaptationStream(adaptation, segmentBuffer);
 
-          return segmentBuffersStore.waitForUsableBuffers().pipe(mergeMap(() => {
-            return observableConcat(cleanBuffer$,
-                                    needsBufferFlush$,
-                                    observableMerge(adaptationStream$,
-                                                    bufferGarbageCollector$));
-          }));
+        return segmentBuffersStore.waitForUsableBuffers().pipe(mergeMap(() => {
+          return observableConcat(cleanBuffer$,
+                                  needsBufferFlush$,
+                                  observableMerge(adaptationStream$,
+                                                  bufferGarbageCollector$));
         }));
+      });
 
       return observableConcat(
         observableOf(EVENTS.adaptationChange(bufferType, adaptation, period)),
@@ -249,20 +271,15 @@ export default function PeriodStream({
     segmentBuffer : SegmentBuffer
   ) : Observable<IAdaptationStreamEvent|IStreamWarningEvent> {
     const { manifest } = content;
-    const adaptationStreamClock$ = clock$.pipe(map(tick => {
-      const buffered = segmentBuffer.getBufferedRanges();
-      return objectAssign({},
-                          tick,
-                          { bufferGap: getLeftSizeOfRange(buffered,
-                                                          tick.position) });
-    }));
+    const adaptationPlaybackObserver =
+      createAdaptationStreamPlaybackObserver(playbackObserver, segmentBuffer);
     return AdaptationStream({ abrManager,
-                              clock$: adaptationStreamClock$,
                               content: { manifest, period, adaptation },
                               options,
+                              playbackObserver: adaptationPlaybackObserver,
                               segmentBuffer,
                               segmentFetcherCreator,
-                              wantedBufferAhead$ }).pipe(
+                              wantedBufferAhead }).pipe(
       catchError((error : unknown) => {
         // Stream linked to a non-native media buffer should not impact the
         // stability of the player. ie: if a text buffer sends an error, we want
@@ -277,7 +294,7 @@ export default function PeriodStream({
           });
           return observableConcat(
             observableOf(EVENTS.warning(formattedError)),
-            createEmptyStream(clock$, wantedBufferAhead$, bufferType, { period })
+            createEmptyStream(playbackObserver, wantedBufferAhead, bufferType, { period })
           );
         }
         log.error(`Stream: ${bufferType} Stream crashed. Stopping playback.`, error);
@@ -322,3 +339,29 @@ function getFirstDeclaredMimeType(adaptation : Adaptation) : string {
   }
   return representations[0].getMimeTypeString();
 }
+
+/**
+ * Create AdaptationStream's version of a playback observer.
+ * @param {Object} initialPlaybackObserver
+ * @param {Object} segmentBuffer
+ * @returns {Object}
+ */
+function createAdaptationStreamPlaybackObserver(
+  initialPlaybackObserver : IReadOnlyPlaybackObserver<IPeriodStreamPlaybackObservation>,
+  segmentBuffer : SegmentBuffer
+) : IReadOnlyPlaybackObserver<IAdaptationStreamPlaybackObservation> {
+  return initialPlaybackObserver.deriveReadOnlyObserver(
+    (observation$) => observation$.pipe(map(mapObservation)),
+    mapObservation
+  );
+
+  function mapObservation(
+    baseObservation : IPeriodStreamPlaybackObservation
+  ) : IAdaptationStreamPlaybackObservation {
+    const buffered = segmentBuffer.getBufferedRanges();
+    return objectAssign({},
+                        baseObservation,
+                        { bufferGap: getLeftSizeOfRange(buffered,
+                                                        baseObservation.position) });
+  }
+}