rx-player 3.25.2 → 3.26.3-dev.2022021400

package/src/core/segment_buffers/{segment_inventory.ts → inventory/segment_inventory.ts}

@@ -14,33 +14,27 @@
  * limitations under the License.
  */
 
-import config from "../../config";
-import log from "../../log";
+import config from "../../../config";
+import log from "../../../log";
 import {
   Adaptation,
   areSameContent,
   ISegment,
   Period,
   Representation,
-} from "../../manifest";
-import takeFirstSet from "../../utils/take_first_set";
+} from "../../../manifest";
+import takeFirstSet from "../../../utils/take_first_set";
+import BufferedHistory, {
+  IBufferedHistoryEntry,
+} from "./buffered_history";
+import { IChunkContext } from "./types";
 
-const { MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE,
+const { BUFFERED_HISTORY_RETENTION_TIME,
+        BUFFERED_HISTORY_MAXIMUM_ENTRIES,
+        MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE,
         MAX_MANIFEST_BUFFERED_DURATION_DIFFERENCE,
         MINIMUM_SEGMENT_SIZE } = config;
 
-/** Content information for a single buffered chunk */
-interface IBufferedChunkInfos {
-  /** Adaptation this chunk is related to. */
-  adaptation : Adaptation;
-  /** Period this chunk is related to. */
-  period : Period;
-  /** Representation this chunk is related to. */
-  representation : Representation;
-  /** Segment this chunk is related to. */
-  segment : ISegment;
-}
-
 /** Information stored on a single chunk by the SegmentInventory. */
 export interface IBufferedChunk {
   /**
@@ -57,18 +51,7 @@ export interface IBufferedChunk {
    * synchronization for that chunk this value could be more or less precize.
    */
   bufferedStart : number|undefined;
-  /**
-   * Supposed end, in seconds, the chunk is expected to end at.
-   *
-   * It can correspond either to the end of the chunk or to the end of the whole
-   * segment the chunk is linked to. This should not matter as chunks linked to
-   * the same segment will all be merged once all chunks have been pushed and
-   * the `completeSegment` API call is done. Until then, this property should
-   * not be relied on.
-   *
-   * You can know whether the `completeSegment` API has been called by checking
-   * the `partiallyPushed` property.
-   */
+  /** Supposed end, in seconds, the chunk is expected to end at. */
   end : number;
   /**
    * If `true` the `end` property is an estimate the `SegmentInventory` has
@@ -89,11 +72,9 @@ export interface IBufferedChunk {
    */
   precizeStart : boolean;
   /** Information on what that chunk actually contains. */
-  infos : IBufferedChunkInfos;
+  infos : IChunkContext;
   /**
    * If `true`, this chunk is only a partial chunk of a whole segment.
-   * In this condition, `start` and `end` may be ignored, as they may either
-   * refer to the chunk or to the whole segment.
    *
    * Inversely, if `false`, this chunk is a whole segment whose inner chunks
    * have all been fully pushed.
@@ -102,16 +83,23 @@ export interface IBufferedChunk {
    */
   partiallyPushed : boolean;
   /**
-   * Supposed start, in seconds, the chunk is expected to start at.
+   * If `true`, the segment as a whole is divided into multiple parts in the
+   * buffer, with other segment(s) between them.
+   * If `false`, it is contiguous.
    *
-   * It can correspond either to the start of the chunk or to the start of the
-   * whole segment the chunk is linked to. This should not matter as chunks
-   * linked to the same segment will all be merged once all chunks have been
-   * pushed and the `completeSegment` API call is done. Until then, this
-   * property should not be relied on.
+   * Splitted segments are a rare occurence that is more complicated to handle
+   * than contiguous ones.
+   */
+  splitted : boolean;
+  /**
+   * Supposed start, in seconds, the chunk is expected to start at.
    *
-   * You can know whether the `completeSegment` API has been called by checking
-   * the `partiallyPushed` property.
+   * If the current `chunk` is part of a "partially pushed" segment (see
+   * `partiallyPushed`), the definition of this property is flexible in the way
+   * that it can correspond either to the start of the chunk or to the start of
+   * the whole segment the chunk is linked to.
+   * As such, this property should not be relied on until the segment has been
+   * fully-pushed.
    */
   start : number; // Supposed start the segment should start from, in seconds
 }
@@ -161,8 +149,12 @@ export default class SegmentInventory {
    */
   private _inventory : IBufferedChunk[];
 
+  private _bufferedHistory : BufferedHistory;
+
   constructor() {
     this._inventory = [];
+    this._bufferedHistory = new BufferedHistory(BUFFERED_HISTORY_RETENTION_TIME,
+                                                BUFFERED_HISTORY_MAXIMUM_ENTRIES);
   }
 
   /**
@@ -173,8 +165,8 @@ export default class SegmentInventory {
   }
 
   /**
-   * Infer each segment's bufferedStart and bufferedEnd from the TimeRanges
-   * given.
+   * Infer each segment's `bufferedStart` and `bufferedEnd` properties from the
+   * TimeRanges given.
    *
    * The TimeRanges object given should come from the media buffer linked to
    * that SegmentInventory.
@@ -227,7 +219,7 @@ export default class SegmentInventory {
                                     null = null;
 
       // remove garbage-collected segments
-      // (not in that TimeRange nor in the previous one)
+      // (Those not in that TimeRange nor in the previous one)
       const numberOfSegmentToDelete = inventoryIndex - indexBefore;
       if (numberOfSegmentToDelete > 0) {
         const lastDeletedSegment = // last garbage-collected segment
@@ -259,6 +251,8 @@ export default class SegmentInventory {
                                          bufferType);
 
         if (inventoryIndex === inventory.length - 1) {
+          // This is the last segment in the inventory.
+          // We can directly update the end as the end of the current range.
           guessBufferedEndFromRangeEnd(thisSegment, rangeEnd, bufferType);
           return;
         }
@@ -347,7 +341,7 @@ export default class SegmentInventory {
 
     const inventory = this._inventory;
     const newSegment = { partiallyPushed: true,
-                         estimatedStart: start,
+                         splitted: false,
                          start,
                          end,
                          precizeStart: false,
@@ -554,6 +548,7 @@ export default class SegmentInventory {
               log.debug("SI: Segment pushed is contained in a previous one",
                         bufferType, start, end, segmentI.start, segmentI.end);
               const nextSegment = { partiallyPushed: segmentI.partiallyPushed,
+                                    splitted: true,
                                     start: newSegment.end,
                                     end: segmentI.end,
                                     precizeStart: segmentI.precizeStart &&
@@ -564,6 +559,7 @@ export default class SegmentInventory {
                                     bufferedEnd: segmentI.end,
                                     infos: segmentI.infos };
               segmentI.end = newSegment.start;
+              segmentI.splitted = true;
               segmentI.bufferedEnd = undefined;
               segmentI.precizeEnd = segmentI.precizeEnd &&
                                     newSegment.precizeStart;
@@ -677,20 +673,26 @@ export default class SegmentInventory {
     content : { period: Period;
                 adaptation: Adaptation;
                 representation: Representation;
-                segment: ISegment; }
+                segment: ISegment; },
+    newBuffered : TimeRanges
   ) : void {
     if (content.segment.isInit) {
       return;
     }
     const inventory = this._inventory;
 
-    let foundIt = false;
+    const resSegments : IBufferedChunk[] = [];
+
     for (let i = 0; i < inventory.length; i++) {
       if (areSameContent(inventory[i].infos, content)) {
-        if (foundIt) {
-          log.warn("SI: Completed Segment is splitted.", content);
+        let splitted = false;
+        if (resSegments.length > 0) {
+          splitted = true;
+          if (resSegments.length === 1) {
+            log.warn("SI: Completed Segment is splitted.", content);
+            resSegments[0].splitted = true;
+          }
         }
-        foundIt = true;
 
         const firstI = i;
         i += 1;
@@ -711,11 +713,25 @@ export default class SegmentInventory {
         this._inventory[firstI].partiallyPushed = false;
         this._inventory[firstI].end = lastEnd;
         this._inventory[firstI].bufferedEnd = lastBufferedEnd;
+        this._inventory[firstI].splitted = splitted;
+        resSegments.push(this._inventory[firstI]);
       }
     }
 
-    if (!foundIt) {
+    if (resSegments.length === 0) {
       log.warn("SI: Completed Segment not found", content);
+    } else {
+      this.synchronizeBuffered(newBuffered);
+      for (const seg of resSegments) {
+        if (seg.bufferedStart !== undefined && seg.bufferedEnd !== undefined) {
+          this._bufferedHistory.addBufferedSegment(seg.infos,
+                                                   seg.bufferedStart,
+                                                   seg.bufferedEnd);
+        } else {
+          log.debug("SI: buffered range not known after sync. Skipping history.",
+                    seg);
+        }
+      }
     }
   }
 
@@ -729,6 +745,23 @@ export default class SegmentInventory {
   public getInventory() : IBufferedChunk[] {
     return this._inventory;
   }
+
+  /**
+   * Returns a recent history of registered operations performed and event
+   * received linked to the segment given in argument.
+   *
+   * Not all operations and events are registered in the returned history.
+   * Please check the return type for more information on what is available.
+   *
+   * Note that history is short-lived for memory usage and performance reasons.
+   * You may not receive any information on operations that happened too long
+   * ago.
+   * @param {Object} context
+   * @returns {Array.<Object>}
+   */
+  public getHistoryFor(context : IChunkContext) : IBufferedHistoryEntry[] {
+    return this._bufferedHistory.getHistoryFor(context);
+  }
 }
 
 /**
@@ -793,7 +826,7 @@ function guessBufferedStartFromRangeStart(
   rangeStart : number,
   lastDeletedSegmentInfos : { end : number; precizeEnd : boolean } |
                             null,
-  bufferType? : string
+  bufferType : string
 ) : void {
   if (firstSegmentInRange.bufferedStart !== undefined) {
     if (firstSegmentInRange.bufferedStart < rangeStart) {
@@ -942,7 +975,7 @@ function prettyPrintInventory(inventory : IBufferedChunk[]) : string {
   let lastChunk : IBufferedChunk | null = null;
   let lastLetter : string | null = null;
 
-  function generateNewLetter(infos : IBufferedChunkInfos) : string {
+  function generateNewLetter(infos : IChunkContext) : string {
     const currentLetter = String.fromCharCode(letters.length + 65);
     letters.push({ letter: currentLetter,
                    periodId: infos.period.id,

package/{dist/_esm5.processed/manifest/are_same_content.js → src/core/segment_buffers/inventory/types.ts}

@@ -13,15 +13,23 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-/**
- * Check if two contents are the same
- * @param {Object} content1
- * @param {Object} content2
- * @returns {boolean}
- */
-export default function areSameContent(content1, content2) {
-    return (content1.segment.id === content2.segment.id &&
-        content1.representation.id === content2.representation.id &&
-        content1.adaptation.id === content2.adaptation.id &&
-        content1.period.id === content2.period.id);
+
+import {
+  Adaptation,
+  ISegment,
+  Period,
+  Representation,
+} from "../../../manifest";
+
+/** Content information for a single buffered chunk */
+export interface IChunkContext {
+  /** Adaptation this chunk is related to. */
+  adaptation : Adaptation;
+  /** Period this chunk is related to. */
+  period : Period;
+  /** Representation this chunk is related to. */
+  representation : Representation;
+  /** Segment this chunk is related to. */
+  segment : ISegment;
 }
+

package/src/core/segment_buffers/segment_buffers_store.ts

@@ -91,16 +91,7 @@ export default class SegmentBuffersStore {
    * disabled. This means that the corresponding type (e.g. audio, video etc.)
    * won't be needed when playing the current content.
    */
-  private _initializedSegmentBuffers : {
-    audio? : SegmentBuffer<BufferSource | null> |
-             null;
-    video? : SegmentBuffer<BufferSource | null> |
-              null;
-    text? : SegmentBuffer<unknown> |
-            null;
-    image? : SegmentBuffer<unknown> |
-             null;
-  };
+  private _initializedSegmentBuffers : Partial<Record<IBufferType, SegmentBuffer | null>>;
 
   /**
    * Callbacks called after a SourceBuffer is either created or disabled.
@@ -172,7 +163,7 @@ export default class SegmentBuffersStore {
    * @returns {Object|null}
    */
   public getStatus(bufferType : IBufferType) : { type : "initialized";
-                                                 value : SegmentBuffer<any>; } |
+                                                 value : SegmentBuffer; } |
                                                { type : "uninitialized" } |
                                                { type : "disabled" }
   {
@@ -251,7 +242,7 @@ export default class SegmentBuffersStore {
     bufferType : IBufferType,
     codec : string,
     options : ISegmentBufferOptions = {}
-  ) : SegmentBuffer<any> {
+  ) : SegmentBuffer {
     const memorizedSegmentBuffer = this._initializedSegmentBuffers[bufferType];
     if (shouldHaveNativeBuffer(bufferType)) {
       if (memorizedSegmentBuffer != null) {
@@ -279,7 +270,7 @@ export default class SegmentBuffersStore {
       return memorizedSegmentBuffer;
     }
 
-    let segmentBuffer : SegmentBuffer<unknown>;
+    let segmentBuffer : SegmentBuffer;
     if (bufferType === "text") {
       log.info("SB: Creating a new text SegmentBuffer");
 

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

@@ -25,25 +25,22 @@
  */
 
 import {
-  BehaviorSubject,
+  catchError,
   concat as observableConcat,
   defer as observableDefer,
-  EMPTY,
-  merge as observableMerge,
-  Observable,
-  of as observableOf,
-} from "rxjs";
-import {
-  catchError,
   distinctUntilChanged,
+  EMPTY,
   exhaustMap,
   filter,
   map,
+  merge as observableMerge,
   mergeMap,
+  Observable,
+  of as observableOf,
   share,
   take,
   tap,
-} from "rxjs/operators";
+} from "rxjs";
 import config from "../../../config";
 import { formatError } from "../../../errors";
 import log from "../../../log";
@@ -53,69 +50,79 @@ import Manifest, {
   Representation,
 } from "../../../manifest";
 import deferSubscriptions from "../../../utils/defer_subscriptions";
+import {
+  createSharedReference,
+  IReadOnlySharedReference,
+} from "../../../utils/reference";
 import ABRManager, {
   IABREstimate,
+  IABRMetricsEventValue,
+  IABRRequestBeginEventValue,
+  IABRRequestEndEventValue,
+  IABRRequestProgressEventValue,
 } from "../../abr";
+import { IReadOnlyPlaybackObserver } from "../../api";
 import { SegmentFetcherCreator } from "../../fetchers";
 import { SegmentBuffer } from "../../segment_buffers";
 import EVENTS from "../events_generators";
+import reloadAfterSwitch from "../reload_after_switch";
 import RepresentationStream, {
-  IRepresentationStreamClockTick,
+  IRepresentationStreamPlaybackObservation,
   ITerminationOrder,
 } from "../representation";
 import {
   IAdaptationStreamEvent,
   IRepresentationStreamEvent,
 } from "../types";
-import reloadAfterSwitch from "../utils";
 import createRepresentationEstimator from "./create_representation_estimator";
 
 const { DELTA_POSITION_AFTER_RELOAD } = config;
 
-/** `Clock tick` information needed by the AdaptationStream. */
-export interface IAdaptationStreamClockTick extends IRepresentationStreamClockTick {
-  /**
-   * For the current SegmentBuffer, difference in seconds between the next position
-   * where no segment data is available and the current position.
-   */
-  bufferGap : number;
-  /** `duration` property of the HTMLMediaElement on which the content plays. */
-  duration : number;
-  /** Allows to fetch the current position at any time. */
-  getCurrentTime : () => number;
-  /** If true, the player has been put on pause. */
-  isPaused: boolean;
-  /** Last "playback rate" asked by the user. */
-  speed : number;
-}
+/** Regular playback information needed by the AdaptationStream. */
+export interface IAdaptationStreamPlaybackObservation extends
+  IRepresentationStreamPlaybackObservation {
+    /**
+     * For the current SegmentBuffer, difference in seconds between the next position
+     * where no segment data is available and the current position.
+     */
+    bufferGap : number;
+    /** `duration` property of the HTMLMediaElement on which the content plays. */
+    duration : number;
+    /** If true, the player has been put on pause. */
+    isPaused: boolean;
+    /** Last "playback rate" asked by the user. */
+    speed : number;
+    /**
+     * Only set for live contents.
+     * Difference between the live edge and the current position, in seconds.
+     */
+    liveGap : number | undefined;
+  }
 
 /** Arguments given when creating a new `AdaptationStream`. */
-export interface IAdaptationStreamArguments<T> {
+export interface IAdaptationStreamArguments {
   /**
    * Module allowing to find the best Representation depending on the current
    * conditions like the current network bandwidth.
    */
   abrManager : ABRManager;
-  /**
-   * Regularly emit playback conditions.
-   * The main AdaptationStream logic will be triggered on each `tick`.
-   */
-  clock$ : Observable<IAdaptationStreamClockTick>;
+  /** Regularly emit playback conditions. */
+  playbackObserver : IReadOnlyPlaybackObserver<IAdaptationStreamPlaybackObservation>;
   /** Content you want to create this Stream for. */
   content : { manifest : Manifest;
               period : Period;
               adaptation : Adaptation; };
   options: IAdaptationStreamOptions;
   /** SourceBuffer wrapper - needed to push media segments. */
-  segmentBuffer : SegmentBuffer<T>;
+  segmentBuffer : SegmentBuffer;
   /** Module used to fetch the wanted media segments. */
-  segmentFetcherCreator : SegmentFetcherCreator<any>;
+  segmentFetcherCreator : SegmentFetcherCreator;
   /**
    * "Buffer goal" wanted, or the ideal amount of time ahead of the current
    * position in the current SegmentBuffer. When this amount has been reached
    * this AdaptationStream won't try to download new segments.
    */
-  wantedBufferAhead$ : BehaviorSubject<number>;
+  wantedBufferAhead : IReadOnlySharedReference<number>;
 }
 
 /**
@@ -174,15 +181,15 @@ export interface IAdaptationStreamOptions {
  * @param {Object} args
  * @returns {Observable}
  */
-export default function AdaptationStream<T>({
+export default function AdaptationStream({
   abrManager,
-  clock$,
+  playbackObserver,
   content,
   options,
   segmentBuffer,
   segmentFetcherCreator,
-  wantedBufferAhead$,
-} : IAdaptationStreamArguments<T>) : Observable<IAdaptationStreamEvent<T>> {
+  wantedBufferAhead,
+} : IAdaptationStreamArguments) : Observable<IAdaptationStreamEvent> {
   const directManualBitrateSwitching = options.manualBitrateSwitchingMode === "direct";
   const { manifest, period, adaptation } = content;
 
@@ -196,24 +203,38 @@ export default function AdaptationStream<T>({
    */
   const bufferGoalRatioMap: Partial<Record<string, number>> = {};
 
-  const { estimator$, requestFeedback$, streamFeedback$ } =
-    createRepresentationEstimator(content, abrManager, clock$);
+  const { estimator$, abrFeedbacks$ } =
+    createRepresentationEstimator(content, abrManager, playbackObserver.observe(true));
 
   /** Allows the `RepresentationStream` to easily fetch media segments. */
-  const segmentFetcher = segmentFetcherCreator.createSegmentFetcher(adaptation.type,
-                                                                    requestFeedback$);
+  const segmentFetcher = segmentFetcherCreator
+    .createSegmentFetcher(adaptation.type,
+                          {
+                            onRequestBegin(value : IABRRequestBeginEventValue) {
+                              abrFeedbacks$.next({ type: "requestBegin", value });
+                            },
+                            onRequestEnd(value : IABRRequestEndEventValue) {
+                              abrFeedbacks$.next({ type: "requestEnd", value });
+                            },
+                            onProgress(value : IABRRequestProgressEventValue) {
+                              abrFeedbacks$.next({ type: "progress", value });
+                            },
+                            onMetrics(value : IABRMetricsEventValue) {
+                              abrFeedbacks$.next({ type: "metrics", value });
+                            },
+                          });
 
   /**
-   * Emits each time an estimate is made through the `abrEstimate$` Observable,
-   * starting with the last one.
+   * Stores the last estimate emitted through the `abrEstimate$` Observable,
+   * starting with `null`.
    * This allows to easily rely on that value in inner Observables which might also
    * need the last already-considered value.
    */
-  const lastEstimate$ = new BehaviorSubject<IABREstimate | null>(null);
+  const lastEstimate = createSharedReference<IABREstimate | null>(null);
 
   /** Emits abr estimates on Subscription. */
   const abrEstimate$ = estimator$.pipe(
-    tap((estimate) => { lastEstimate$.next(estimate); }),
+    tap((estimate) => { lastEstimate.setValue(estimate); }),
     deferSubscriptions(),
     share());
 
@@ -229,7 +250,7 @@ export default function AdaptationStream<T>({
 
   /** Recursively create `RepresentationStream`s according to the last estimate. */
   const representationStreams$ = abrEstimate$
-    .pipe(exhaustMap((estimate, i) : Observable<IAdaptationStreamEvent<T>> => {
+    .pipe(exhaustMap((estimate, i) : Observable<IAdaptationStreamEvent> => {
       return recursivelyCreateRepresentationStreams(estimate, i === 0);
     }));
 
@@ -250,7 +271,7 @@ export default function AdaptationStream<T>({
   function recursivelyCreateRepresentationStreams(
     fromEstimate : IABREstimate,
     isFirstEstimate : boolean
-  ) : Observable<IAdaptationStreamEvent<T>> {
+  ) : Observable<IAdaptationStreamEvent> {
     const { representation } = fromEstimate;
 
     // A manual bitrate switch might need an immediate feedback.
@@ -259,14 +280,17 @@ export default function AdaptationStream<T>({
         fromEstimate.manual &&
         !isFirstEstimate)
     {
-      return reloadAfterSwitch(period, clock$, DELTA_POSITION_AFTER_RELOAD.bitrateSwitch);
+      return reloadAfterSwitch(period,
+                               adaptation.type,
+                               playbackObserver,
+                               DELTA_POSITION_AFTER_RELOAD.bitrateSwitch);
     }
 
     /**
      * Emit when the current RepresentationStream should be terminated to make
      * place for a new one (e.g. when switching quality).
      */
-    const terminateCurrentStream$ = lastEstimate$.pipe(
+    const terminateCurrentStream$ = lastEstimate.asObservable().pipe(
       filter((newEstimate) => newEstimate === null ||
                               newEstimate.representation.id !== representation.id ||
                               (newEstimate.manual && !fromEstimate.manual)),
@@ -298,7 +322,7 @@ export default function AdaptationStream<T>({
      */
     const fastSwitchThreshold$ = !options.enableFastSwitching ?
       observableOf(0) : // Do not fast-switch anything
-      lastEstimate$.pipe(
+      lastEstimate.asObservable().pipe(
         map((estimate) => estimate === null ? undefined :
                                               estimate.knownStableBitrate),
         distinctUntilChanged());
@@ -316,16 +340,16 @@ export default function AdaptationStream<T>({
         if (evt.type === "representationChange" ||
             evt.type === "added-segment")
         {
-          return streamFeedback$.next(evt);
+          return abrFeedbacks$.next(evt);
         }
       }),
       mergeMap((evt) => {
         if (evt.type === "stream-terminating") {
-          const lastEstimate = lastEstimate$.getValue();
-          if (lastEstimate === null) {
+          const estimate = lastEstimate.getValue();
+          if (estimate === null) {
             return EMPTY;
           }
-          return recursivelyCreateRepresentationStreams(lastEstimate, false);
+          return recursivelyCreateRepresentationStreams(estimate, false);
         }
         return observableOf(evt);
       }));
@@ -341,19 +365,22 @@ export default function AdaptationStream<T>({
     representation : Representation,
     terminateCurrentStream$ : Observable<ITerminationOrder>,
     fastSwitchThreshold$ : Observable<number | undefined>
-  ) : Observable<IRepresentationStreamEvent<T>> {
+  ) : Observable<IRepresentationStreamEvent> {
     return observableDefer(() => {
       const oldBufferGoalRatio = bufferGoalRatioMap[representation.id];
       const bufferGoalRatio = oldBufferGoalRatio != null ? oldBufferGoalRatio :
                                                            1;
       bufferGoalRatioMap[representation.id] = bufferGoalRatio;
 
-      const bufferGoal$ = wantedBufferAhead$.pipe(
+      const bufferGoal$ = wantedBufferAhead.asObservable().pipe(
         map((wba) => wba * bufferGoalRatio)
       );
 
-      log.info("Stream: changing representation", adaptation.type, representation);
-      return RepresentationStream({ clock$,
+      log.info("Stream: changing representation",
+               adaptation.type,
+               representation.id,
+               representation.bitrate);
+      return RepresentationStream({ playbackObserver,
                                     content: { representation,
                                                adaptation,
                                                period,
@@ -370,11 +397,9 @@ export default function AdaptationStream<T>({
             defaultReason: "Unknown `RepresentationStream` error",
           });
           if (formattedError.code === "BUFFER_FULL_ERROR") {
-            const wantedBufferAhead = wantedBufferAhead$.getValue();
+            const wba = wantedBufferAhead.getValue();
             const lastBufferGoalRatio = bufferGoalRatio;
-            if (lastBufferGoalRatio <= 0.25 ||
-                wantedBufferAhead * lastBufferGoalRatio <= 2)
-            {
+            if (lastBufferGoalRatio <= 0.25 || wba * lastBufferGoalRatio <= 2) {
               throw formattedError;
             }
             bufferGoalRatioMap[representation.id] = lastBufferGoalRatio - 0.25;