rx-player 3.26.1 → 3.26.2

package/src/core/segment_buffers/implementations/text/html/html_text_segment_buffer.ts

@@ -18,17 +18,15 @@ import {
   concat as observableConcat,
   defer as observableDefer,
   interval as observableInterval,
+  map,
   merge as observableMerge,
   Observable,
   of as observableOf,
-  Subject,
-} from "rxjs";
-import {
-  mapTo,
   startWith,
-  switchMapTo,
+  Subject,
+  switchMap,
   takeUntil,
-} from "rxjs/operators";
+} from "rxjs";
 import {
   events,
   onHeightWidthChange,
@@ -54,11 +52,11 @@ const { MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL,
         TEXT_TRACK_SIZE_CHECKS_INTERVAL } = config;
 
 /**
- * Generate the clock at which TextTrack HTML Cues should be refreshed.
+ * Generate the interval at which TextTrack HTML Cues should be refreshed.
  * @param {HTMLMediaElement} videoElement
  * @returns {Observable}
  */
-function generateClock(videoElement : HTMLMediaElement) : Observable<boolean> {
+function generateRefreshInterval(videoElement : HTMLMediaElement) : Observable<boolean> {
   const seeking$ = onSeeking$(videoElement);
   const seeked$ = onSeeked$(videoElement);
   const ended$ = onEnded$(videoElement);
@@ -69,9 +67,9 @@ function generateClock(videoElement : HTMLMediaElement) : Observable<boolean> {
 
   return manualRefresh$.pipe(
     startWith(null),
-    switchMapTo(observableConcat(autoRefresh$.pipe(mapTo(true),
-                                                   takeUntil(seeking$)),
-                                 observableOf(false))));
+    switchMap(() => observableConcat(autoRefresh$.pipe(map(() => true),
+                                                       takeUntil(seeking$)),
+                                     observableOf(false))));
 }
 
 /**
@@ -177,7 +175,7 @@ export default class HTMLTextSegmentBuffer extends SegmentBuffer {
     this._currentCues = [];
 
     // update text tracks
-    generateClock(this._videoElement)
+    generateRefreshInterval(this._videoElement)
       .pipe(takeUntil(this._destroy$))
       .subscribe((shouldDisplay) => {
         if (!shouldDisplay) {
@@ -463,7 +461,7 @@ export interface INativeTextTracksBufferSegmentData {
 function assertChunkIsTextTrackSegmentData(
   chunk : unknown
 ) : asserts chunk is INativeTextTracksBufferSegmentData {
-  if (!__DEV__) {
+  if (__ENVIRONMENT__.CURRENT_ENV === __ENVIRONMENT__.PRODUCTION as number) {
     return;
   }
   if (
@@ -477,11 +475,11 @@ function assertChunkIsTextTrackSegmentData(
     ) ||
     (
       (chunk as INativeTextTracksBufferSegmentData).start !== undefined &&
-      typeof (chunk as INativeTextTracksBufferSegmentData).start !== "string"
+      typeof (chunk as INativeTextTracksBufferSegmentData).start !== "number"
     ) ||
     (
       (chunk as INativeTextTracksBufferSegmentData).end !== undefined &&
-      typeof (chunk as INativeTextTracksBufferSegmentData).end !== "string"
+      typeof (chunk as INativeTextTracksBufferSegmentData).end !== "number"
     )
   ) {
     throw new Error("Invalid format given to a NativeTextSegmentBuffer");
@@ -497,7 +495,7 @@ function assertChunkIsTextTrackSegmentData(
  * It doesn't correspond at all to real code that will be called. This is just
  * a hack to tell TypeScript to perform that check.
  */
-if (__DEV__) {
+if (__ENVIRONMENT__.CURRENT_ENV === __ENVIRONMENT__.DEV as number) {
   /* eslint-disable @typescript-eslint/no-unused-vars */
   /* eslint-disable @typescript-eslint/ban-ts-comment */
   // @ts-ignore

package/src/core/segment_buffers/implementations/text/html/text_track_cues_store.ts

@@ -84,7 +84,7 @@ export default class TextTrackCuesStore {
    * @param {Number} to
    */
   remove(from : number, _to : number) : void {
-    if (__DEV__) {
+    if (__ENVIRONMENT__.CURRENT_ENV === __ENVIRONMENT__.DEV as number) {
       assert(from >= 0);
       assert(_to >= 0);
       assert(_to > from);

package/src/core/segment_buffers/implementations/text/native/native_text_segment_buffer.ts

@@ -284,7 +284,7 @@ export interface INativeTextTracksBufferSegmentData {
 function assertChunkIsTextTrackSegmentData(
   chunk : unknown
 ) : asserts chunk is INativeTextTracksBufferSegmentData {
-  if (!__DEV__) {
+  if (__ENVIRONMENT__.CURRENT_ENV === __ENVIRONMENT__.PRODUCTION as number) {
     return;
   }
   if (
@@ -298,11 +298,11 @@ function assertChunkIsTextTrackSegmentData(
     ) ||
     (
       (chunk as INativeTextTracksBufferSegmentData).start !== undefined &&
-      typeof (chunk as INativeTextTracksBufferSegmentData).start !== "string"
+      typeof (chunk as INativeTextTracksBufferSegmentData).start !== "number"
     ) ||
     (
       (chunk as INativeTextTracksBufferSegmentData).end !== undefined &&
-      typeof (chunk as INativeTextTracksBufferSegmentData).end !== "string"
+      typeof (chunk as INativeTextTracksBufferSegmentData).end !== "number"
     )
   ) {
     throw new Error("Invalid format given to a NativeTextSegmentBuffer");
@@ -318,7 +318,7 @@ function assertChunkIsTextTrackSegmentData(
  * It doesn't correspond at all to real code that will be called. This is just
  * a hack to tell TypeScript to perform that check.
  */
-if (__DEV__) {
+if (__ENVIRONMENT__.CURRENT_ENV === __ENVIRONMENT__.DEV as number) {
   /* eslint-disable @typescript-eslint/no-unused-vars */
   /* eslint-disable @typescript-eslint/ban-ts-comment */
   // @ts-ignore

package/src/core/segment_buffers/implementations/utils/manual_time_ranges.ts

@@ -39,7 +39,7 @@ export default class ManualTimeRanges implements TimeRanges {
   }
 
   insert(start : number, end : number) : void {
-    if (__DEV__) {
+    if (__ENVIRONMENT__.CURRENT_ENV === __ENVIRONMENT__.DEV as number) {
       assert(start >= 0, "invalid start time");
       assert(end - start > 0, "invalid end time");
     }
@@ -48,7 +48,7 @@ export default class ManualTimeRanges implements TimeRanges {
   }
 
   remove(start : number, end : number) : void {
-    if (__DEV__) {
+    if (__ENVIRONMENT__.CURRENT_ENV === __ENVIRONMENT__.DEV as number) {
       assert(start >= 0, "invalid start time");
       assert(end - start > 0, "invalid end time");
     }

package/src/core/segment_buffers/inventory/buffered_history.ts

@@ -116,12 +116,12 @@ export default class BufferedHistory {
       }
     }
     if (firstKeptIndex > 0) {
-      this._history.splice(firstKeptIndex);
+      this._history = this._history.splice(firstKeptIndex);
     }
 
     if (this._history.length > this._maxHistoryLength) {
       const toRemove = this._history.length - this._maxHistoryLength;
-      this._history.splice(toRemove);
+      this._history = this._history.splice(toRemove);
     }
   }
 }

package/src/core/segment_buffers/inventory/segment_inventory.ts

@@ -51,16 +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.
-   *
-   * 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 end of the chunk or to the end 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.
-   */
+  /** Supposed end, in seconds, the chunk is expected to end at. */
   end : number;
   /**
    * If `true` the `end` property is an estimate the `SegmentInventory` has
@@ -84,8 +75,6 @@ export interface IBufferedChunk {
   infos : IChunkContext;
   /**
    * If `true`, this chunk is only a partial chunk of a whole segment.
-   * In this condition, the `start` and `end` properties may be ignored, as it
-   * is unclear if they 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.
@@ -692,7 +681,6 @@ export default class SegmentInventory {
     }
     const inventory = this._inventory;
 
-
     const resSegments : IBufferedChunk[] = [];
 
     for (let i = 0; i < inventory.length; i++) {

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,15 +50,24 @@ 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 {
@@ -72,22 +78,26 @@ 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 {
@@ -96,11 +106,8 @@ export interface IAdaptationStreamArguments {
    * 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;
@@ -115,7 +122,7 @@ export interface IAdaptationStreamArguments {
    * 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>;
 }
 
 /**
@@ -176,12 +183,12 @@ export interface IAdaptationStreamOptions {
  */
 export default function AdaptationStream({
   abrManager,
-  clock$,
+  playbackObserver,
   content,
   options,
   segmentBuffer,
   segmentFetcherCreator,
-  wantedBufferAhead$,
+  wantedBufferAhead,
 } : IAdaptationStreamArguments) : Observable<IAdaptationStreamEvent> {
   const directManualBitrateSwitching = options.manualBitrateSwitchingMode === "direct";
   const { manifest, period, adaptation } = content;
@@ -196,24 +203,38 @@ export default function AdaptationStream({
    */
   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());
 
@@ -261,7 +282,7 @@ export default function AdaptationStream({
     {
       return reloadAfterSwitch(period,
                                adaptation.type,
-                               clock$,
+                               playbackObserver,
                                DELTA_POSITION_AFTER_RELOAD.bitrateSwitch);
     }
 
@@ -269,7 +290,7 @@ export default function AdaptationStream({
      * 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)),
@@ -301,7 +322,7 @@ export default function AdaptationStream({
      */
     const fastSwitchThreshold$ = !options.enableFastSwitching ?
       observableOf(0) : // Do not fast-switch anything
-      lastEstimate$.pipe(
+      lastEstimate.asObservable().pipe(
         map((estimate) => estimate === null ? undefined :
                                               estimate.knownStableBitrate),
         distinctUntilChanged());
@@ -319,16 +340,16 @@ export default function AdaptationStream({
         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);
       }));
@@ -351,12 +372,15 @@ export default function AdaptationStream({
                                                            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,
@@ -373,11 +397,9 @@ export default function AdaptationStream({
             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;

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/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,16 +14,14 @@
  * 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 { IStreamOrchestratorEvent } from "../types";
@@ -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,14 +16,12 @@
 
 import {
   combineLatest as observableCombineLatest,
-  Observable,
-} from "rxjs";
-import {
   distinctUntilChanged,
   filter,
   map,
+  Observable,
   startWith,
-} from "rxjs/operators";
+} from "rxjs";
 import { IStreamOrchestratorEvent } from "../types";
 
 /**