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

package/src/core/init/stall_avoider.ts

@@ -31,6 +31,7 @@ import Manifest, {
   Period,
 } from "../../manifest";
 import { getNextRangeGap } from "../../utils/ranges";
+import { IReadOnlySharedReference } from "../../utils/reference";
 import {
   IPlaybackObservation,
   PlaybackObserver,
@@ -121,14 +122,16 @@ interface IDiscontinuityStoredInfo {
  * encountered and exited.
  * @param {object} playbackObserver - emit the current playback conditions.
  * @param {Object} manifest - The Manifest of the currently-played content.
+ * @param {Object} speed - The last speed set by the user
+ * @param {Observable} lockedStream$
  * @param {Observable} discontinuityUpdate$ - Observable emitting encountered
  * discontinuities for loaded Period and buffer types.
- * @param {Function} setCurrentTime
  * @returns {Observable}
  */
 export default function StallAvoider(
   playbackObserver : PlaybackObserver,
   manifest: Manifest | null,
+  speed : IReadOnlySharedReference<number>,
   lockedStream$ : Observable<ILockedStreamEvent>,
   discontinuityUpdate$: Observable<IDiscontinuityEvent>
 ) : Observable<IStalledEvent | IUnstalledEvent | IWarningEvent> {
@@ -181,11 +184,10 @@ export default function StallAvoider(
   const unlock$ = lockedStream$.pipe(
     withLatestFrom(playbackObserver.getReference().asObservable()),
     tap(([lockedStreamEvt, observation]) => {
-      // TODO(PaulB) also skip when the user's wanted speed is set to `0`, as we
-      // might not want to seek in that case?
       if (
         !observation.rebuffering ||
-        observation.paused || (
+        observation.paused ||
+        speed.getValue() <= 0 || (
           lockedStreamEvt.bufferType !== "audio" &&
           lockedStreamEvt.bufferType !== "video"
         )
@@ -226,6 +228,22 @@ export default function StallAvoider(
               UNFREEZING_SEEK_DELAY,
               UNFREEZING_DELTA_POSITION } = config.getCurrent();
 
+      if (
+        !observation.seeking &&
+        isSeekingApproximate &&
+        ignoredStallTimeStamp === null &&
+        lastSeekingPosition !== null &&
+        observation.position < lastSeekingPosition
+      ) {
+        log.debug("Init: the device appeared to have seeked back by itself.");
+        const now = performance.now();
+        ignoredStallTimeStamp = now;
+      }
+
+      lastSeekingPosition = observation.seeking ?
+        Math.max(observation.pendingInternalSeek ?? 0, observation.position) :
+        null;
+
       if (freezing !== null) {
         const now = performance.now();
 
@@ -254,8 +272,8 @@ export default function StallAvoider(
           // Return that we're stalled
           let reason : IStallingSituation;
           if (observation.seeking) {
-            reason = observation.internalSeeking ? "internal-seek" :
-                                                   "seeking";
+            reason = observation.pendingInternalSeek !== null ? "internal-seek" :
+                                                                "seeking";
           } else {
             reason = "not-ready";
           }
@@ -269,27 +287,20 @@ export default function StallAvoider(
       // We want to separate a stall situation when a seek is due to a seek done
       // internally by the player to when its due to a regular user seek.
       const stalledReason = rebuffering.reason === "seeking" &&
-                            observation.internalSeeking ? "internal-seek" as const :
-                                                          rebuffering.reason;
+                            observation.pendingInternalSeek !== null ?
+        "internal-seek" as const :
+        rebuffering.reason;
 
-      if (observation.seeking) {
-        lastSeekingPosition = observation.position;
-      } else if (lastSeekingPosition !== null) {
+      if (ignoredStallTimeStamp !== null) {
         const now = performance.now();
-        if (ignoredStallTimeStamp === null) {
-          ignoredStallTimeStamp = now;
-        }
-        if (isSeekingApproximate && observation.position < lastSeekingPosition) {
-          log.debug("Init: the device appeared to have seeked back by itself.");
-          if (now - ignoredStallTimeStamp < FORCE_DISCONTINUITY_SEEK_DELAY) {
-            return { type: "stalled" as const,
-                     value: stalledReason };
-          } else {
-            log.warn("Init: ignored stall for too long, checking discontinuity",
-                     now - ignoredStallTimeStamp);
-          }
+        if (now - ignoredStallTimeStamp < FORCE_DISCONTINUITY_SEEK_DELAY) {
+          log.debug("Init: letting the device get out of a stall by itself");
+          return { type: "stalled" as const,
+                   value: stalledReason };
+        } else {
+          log.warn("Init: ignored stall for too long, checking discontinuity",
+                   now - ignoredStallTimeStamp);
         }
-        lastSeekingPosition = null;
       }
 
       ignoredStallTimeStamp = null;
@@ -302,7 +313,7 @@ export default function StallAvoider(
       /** Position at which data is awaited. */
       const { position: stalledPosition } = rebuffering;
 
-      if (stalledPosition !== null) {
+      if (stalledPosition !== null && speed.getValue() > 0) {
         const skippableDiscontinuity = findSeekableDiscontinuity(discontinuitiesStore,
                                                                  manifest,
                                                                  stalledPosition);
@@ -331,7 +342,10 @@ export default function StallAvoider(
       // implementation that might drop an injected segment, or in
       // case of small discontinuity in the content.
       const nextBufferRangeGap = getNextRangeGap(buffered, freezePosition);
-      if (nextBufferRangeGap < BUFFER_DISCONTINUITY_THRESHOLD) {
+      if (
+        speed.getValue() > 0 &&
+        nextBufferRangeGap < BUFFER_DISCONTINUITY_THRESHOLD
+      ) {
         const seekTo = (freezePosition + nextBufferRangeGap + EPSILON);
         if (playbackObserver.getCurrentTime() < seekTo) {
           log.warn("Init: discontinuity encountered inferior to the threshold",

package/src/core/segment_buffers/garbage_collector.ts

@@ -14,52 +14,66 @@
  * limitations under the License.
  */
 
-import {
-  combineLatest as observableCombineLatest,
-  concatAll,
-  EMPTY,
-  from as observableFrom,
-  ignoreElements,
-  mergeMap,
-  Observable,
-  of as observableOf,
-} from "rxjs";
 import log from "../../log";
 import { getInnerAndOuterTimeRanges } from "../../utils/ranges";
+import { IReadOnlySharedReference } from "../../utils/reference";
+import { CancellationSignal } from "../../utils/task_canceller";
+import { IReadOnlyPlaybackObserver } from "../api";
+import { IStreamOrchestratorPlaybackObservation } from "../stream";
 import { SegmentBuffer } from "./implementations";
 
 export interface IGarbageCollectorArgument {
   /** SegmentBuffer implementation */
   segmentBuffer : SegmentBuffer;
   /** Emit current position in seconds regularly */
-  currentTime$ : Observable<number>;
+  playbackObserver : IReadOnlyPlaybackObserver<
+    Pick<IStreamOrchestratorPlaybackObservation, "position">
+  >;
   /** Maximum time to keep behind current time position, in seconds */
-  maxBufferBehind$ : Observable<number>;
+  maxBufferBehind : IReadOnlySharedReference<number>;
   /** Minimum time to keep behind current time position, in seconds */
-  maxBufferAhead$ : Observable<number>;
+  maxBufferAhead : IReadOnlySharedReference<number>;
 }
 
 /**
  * Perform cleaning of the buffer according to the values set by the user
- * each time `currentTime$` emits and each times the
+ * each time `playbackObserver` emits and each times the
  * maxBufferBehind/maxBufferAhead values change.
  *
+ * Abort this operation when the `cancellationSignal` emits.
+ *
  * @param {Object} opt
+ * @param {Object} cancellationSignal
  * @returns {Observable}
  */
-export default function BufferGarbageCollector({
-  segmentBuffer,
-  currentTime$,
-  maxBufferBehind$,
-  maxBufferAhead$,
-} : IGarbageCollectorArgument) : Observable<never> {
-  return observableCombineLatest([currentTime$, maxBufferBehind$, maxBufferAhead$]).pipe(
-    mergeMap(([currentTime, maxBufferBehind, maxBufferAhead]) => {
-      return clearBuffer(segmentBuffer,
-                         currentTime,
-                         maxBufferBehind,
-                         maxBufferAhead);
-    }));
+export default function BufferGarbageCollector(
+  { segmentBuffer,
+    playbackObserver,
+    maxBufferBehind,
+    maxBufferAhead } : IGarbageCollectorArgument,
+  cancellationSignal : CancellationSignal
+) : void {
+  let lastPosition : number;
+  playbackObserver.listen((o) => {
+    lastPosition = o.position.pending ?? o.position.last;
+    clean();
+  }, { includeLastObservation: true, clearSignal: cancellationSignal });
+  function clean() {
+    clearBuffer(segmentBuffer,
+                lastPosition,
+                maxBufferBehind.getValue(),
+                maxBufferAhead.getValue(),
+                cancellationSignal)
+      .catch(e => {
+        const errMsg = e instanceof Error ?
+          e.message :
+          "Unknown error";
+        log.error("Could not run BufferGarbageCollector:", errMsg);
+      });
+  }
+  maxBufferBehind.onUpdate(clean, { clearSignal: cancellationSignal });
+  maxBufferAhead.onUpdate(clean, { clearSignal: cancellationSignal });
+  clean();
 }
 
 /**
@@ -76,16 +90,17 @@ export default function BufferGarbageCollector({
  * @param {Number} position - The current position
  * @param {Number} maxBufferBehind
  * @param {Number} maxBufferAhead
- * @returns {Observable}
+ * @returns {Promise}
  */
-function clearBuffer(
+async function clearBuffer(
   segmentBuffer : SegmentBuffer,
   position : number,
   maxBufferBehind : number,
-  maxBufferAhead : number
-) : Observable<never> {
+  maxBufferAhead : number,
+  cancellationSignal : CancellationSignal
+) : Promise<void> {
   if (!isFinite(maxBufferBehind) && !isFinite(maxBufferAhead)) {
-    return EMPTY;
+    return Promise.resolve();
   }
 
   const cleanedupRanges : Array<{ start : number;
@@ -150,21 +165,14 @@ function clearBuffer(
 
   collectBufferBehind();
   collectBufferAhead();
-  const clean$ = observableFrom(
-    cleanedupRanges.map((range) => {
+
+  for (const range of cleanedupRanges) {
+    if (range.start < range.end) {
       log.debug("GC: cleaning range from SegmentBuffer", range.start, range.end);
-      if (range.start >= range.end) {
-        return observableOf(null);
+      if (cancellationSignal.cancellationError !== null) {
+        throw cancellationSignal.cancellationError;
       }
-      return segmentBuffer.removeBuffer(range.start, range.end);
-    })
-  ).pipe(concatAll(),
-        // 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 */
-         ignoreElements());
-
-  return clean$;
+      await segmentBuffer.removeBuffer(range.start, range.end, cancellationSignal);
+    }
+  }
 }

package/src/core/segment_buffers/implementations/audio_video/audio_video_segment_buffer.ts

@@ -14,15 +14,6 @@
  * limitations under the License.
  */
 
-import {
-  fromEvent,
-  interval,
-  Observable,
-  Observer,
-  Subject,
-  takeUntil,
-  tap,
-} from "rxjs";
 import {
   ICompatSourceBuffer,
   tryToChangeSourceBufferType,
@@ -34,7 +25,12 @@ import areArraysOfNumbersEqual from "../../../../utils/are_arrays_of_numbers_equ
 import assertUnreachable from "../../../../utils/assert_unreachable";
 import { toUint8Array } from "../../../../utils/byte_parsing";
 import hashBuffer from "../../../../utils/hash_buffer";
+import noop from "../../../../utils/noop";
 import objectAssign from "../../../../utils/object_assign";
+import TaskCanceller, {
+  CancellationError,
+  CancellationSignal,
+} from "../../../../utils/task_canceller";
 import { IInsertedChunkInfos } from "../../inventory";
 import {
   IEndOfSegmentInfos,
@@ -57,7 +53,10 @@ import {
  * AudioVideoSegmentBuffer to emit an event when the corresponding queued
  * operation is completely processed.
  */
-type IAVSBQueueItem = ISBOperation<BufferSource> & { subject: Subject<void> };
+type IAVSBQueueItem = ISBOperation<BufferSource> & {
+  resolve : () => void;
+  reject : (err : Error) => void;
+};
 
 /**
  * Task currently processed by the AudioVideoSegmentBuffer.
@@ -70,8 +69,14 @@ type IAVSBQueueItem = ISBOperation<BufferSource> & { subject: Subject<void> };
  * segment before the wanted media segment.
  */
 type IAVSBPendingTask = IPushTask |
-                        IRemoveOperation & { subject: Subject<void> } |
-                        IEndOfSegmentOperation & { subject: Subject<void> };
+                        IRemoveOperation & {
+                          resolve : () => void;
+                          reject : (err : Error) => void;
+                        } |
+                        IEndOfSegmentOperation & {
+                          resolve : () => void;
+                          reject : (err : Error) => void;
+                        };
 
 /** Structure of a `IAVSBPendingTask` item corresponding to a "Push" operation. */
 type IPushTask = IPushOperation<BufferSource> & {
@@ -88,8 +93,10 @@ type IPushTask = IPushOperation<BufferSource> & {
    */
   inventoryData : IInsertedChunkInfos |
                   null;
-  /** Subject used to emit an event to the caller when the operation is finished. */
-  subject : Subject<void>;
+  /** Callback to call when the push operation succeed. */
+  resolve : () => void;
+  /** Callback to call when the push operation fails. */
+  reject : (err : Error) => void;
 };
 
 /**
@@ -110,10 +117,9 @@ export default class AudioVideoSegmentBuffer extends SegmentBuffer {
   private readonly _sourceBuffer : ICompatSourceBuffer;
 
   /**
-   * Subject triggered when this AudioVideoSegmentBuffer is disposed.
-   * Helps to clean-up Observables created at its creation.
+   * Helps to clean-up resource taken at the AudioVideoSegmentBuffer creation.
    */
-  private _destroy$ : Subject<void>;
+  private _canceller : TaskCanceller;
 
   /**
    * Queue of awaited buffer "operations".
@@ -152,7 +158,7 @@ export default class AudioVideoSegmentBuffer extends SegmentBuffer {
    * @constructor
    * @param {string} bufferType
    * @param {string} codec
-   * @param {SourceBuffer} sourceBuffer
+   * @param {MediaSource} mediaSource
    */
   constructor(
     bufferType : "audio" | "video",
@@ -162,7 +168,7 @@ export default class AudioVideoSegmentBuffer extends SegmentBuffer {
     super();
     const sourceBuffer = mediaSource.addSourceBuffer(codec);
 
-    this._destroy$ = new Subject<void>();
+    this._canceller = new TaskCanceller();
     this.bufferType = bufferType;
     this._mediaSource = mediaSource;
     this._sourceBuffer = sourceBuffer;
@@ -171,7 +177,8 @@ export default class AudioVideoSegmentBuffer extends SegmentBuffer {
     this._lastInitSegment = null;
     this.codec = codec;
 
-    const { SOURCE_BUFFER_FLUSHING_INTERVAL } = config.getCurrent();
+    const onError = this._onPendingTaskError.bind(this);
+    const reCheck = this._flush.bind(this);
 
     // Some browsers (happened with firefox 66) sometimes "forget" to send us
     // `update` or `updateend` events.
@@ -179,19 +186,16 @@ export default class AudioVideoSegmentBuffer extends SegmentBuffer {
     // stay locked in a waiting state.
     // This interval is here to check at regular intervals if the underlying
     // SourceBuffer is currently updating.
-    interval(SOURCE_BUFFER_FLUSHING_INTERVAL).pipe(
-      tap(() => this._flush()),
-      takeUntil(this._destroy$)
-    ).subscribe();
-
-    fromEvent(this._sourceBuffer, "error").pipe(
-      tap((err) => this._onPendingTaskError(err)),
-      takeUntil(this._destroy$)
-    ).subscribe();
-    fromEvent(this._sourceBuffer, "updateend").pipe(
-      tap(() => this._flush()),
-      takeUntil(this._destroy$)
-    ).subscribe();
+    const { SOURCE_BUFFER_FLUSHING_INTERVAL } = config.getCurrent();
+    const intervalId = setInterval(reCheck, SOURCE_BUFFER_FLUSHING_INTERVAL);
+    this._sourceBuffer.addEventListener("error", onError);
+    this._sourceBuffer.addEventListener("updateend", reCheck);
+
+    this._canceller.signal.register(() => {
+      clearInterval(intervalId);
+      this._sourceBuffer.removeEventListener("error", onError);
+      this._sourceBuffer.removeEventListener("updateend", reCheck);
+    });
   }
 
   /**
@@ -218,47 +222,62 @@ export default class AudioVideoSegmentBuffer extends SegmentBuffer {
    * `data.chunk` argument to null.
    *
    * @param {Object} infos
-   * @returns {Observable}
+   * @param {Object} cancellationSignal
+   * @returns {Promise}
    */
-  public pushChunk(infos : IPushChunkInfos<unknown>) : Observable<void> {
+  public pushChunk(
+    infos : IPushChunkInfos<unknown>,
+    cancellationSignal : CancellationSignal
+  ) : Promise<void> {
     assertPushedDataIsBufferSource(infos);
     log.debug("AVSB: receiving order to push data to the SourceBuffer",
               this.bufferType,
               getLoggableSegmentId(infos.inventoryInfos));
     return this._addToQueue({ type: SegmentBufferOperation.Push,
-                              value: infos });
+                              value: infos },
+                            cancellationSignal);
   }
 
   /**
    * Remove buffered data (added to the same FIFO queue than `pushChunk`).
    * @param {number} start - start position, in seconds
    * @param {number} end - end position, in seconds
-   * @returns {Observable}
+   * @param {Object} cancellationSignal
+   * @returns {Promise}
    */
-  public removeBuffer(start : number, end : number) : Observable<void> {
+  public removeBuffer(
+    start : number,
+    end : number,
+    cancellationSignal : CancellationSignal
+  ) : Promise<void> {
     log.debug("AVSB: receiving order to remove data from the SourceBuffer",
               this.bufferType,
               start,
               end);
     return this._addToQueue({ type: SegmentBufferOperation.Remove,
-                              value: { start, end } });
+                              value: { start, end } },
+                            cancellationSignal);
   }
 
   /**
    * Indicate that every chunks from a Segment has been given to pushChunk so
    * far.
    * This will update our internal Segment inventory accordingly.
-   * The returned Observable will emit and complete successively once the whole
-   * segment has been pushed and this indication is acknowledged.
+   * The returned Promise will resolve once the whole segment has been pushed
+   * and this indication is acknowledged.
    * @param {Object} infos
-   * @returns {Observable}
+   * @returns {Promise}
    */
-  public endOfSegment(infos : IEndOfSegmentInfos) : Observable<void> {
+  public endOfSegment(
+    infos : IEndOfSegmentInfos,
+    cancellationSignal : CancellationSignal
+  ) : Promise<void> {
     log.debug("AVSB: receiving order for validating end of segment",
               this.bufferType,
               getLoggableSegmentId(infos));
     return this._addToQueue({ type: SegmentBufferOperation.EndOfSegment,
-                              value: infos });
+                              value: infos },
+                            cancellationSignal);
   }
 
   /**
@@ -302,18 +321,17 @@ export default class AudioVideoSegmentBuffer extends SegmentBuffer {
    * @private
    */
   public dispose() : void {
-    this._destroy$.next();
-    this._destroy$.complete();
+    this._canceller.cancel();
 
     if (this._pendingTask !== null) {
-      this._pendingTask.subject.complete();
+      this._pendingTask.reject(new CancellationError());
       this._pendingTask = null;
     }
 
     while (this._queue.length > 0) {
       const nextElement = this._queue.shift();
       if (nextElement !== undefined) {
-        nextElement.subject.complete();
+        nextElement.reject(new CancellationError());
       }
     }
 
@@ -329,7 +347,7 @@ export default class AudioVideoSegmentBuffer extends SegmentBuffer {
 
   /**
    * Called when an error arised that made the current task fail.
-   * @param {Event} error
+   * @param {Event} err
    */
   private _onPendingTaskError(err : unknown) : void {
     this._lastInitSegment = null; // initialize init segment as a security
@@ -338,7 +356,7 @@ export default class AudioVideoSegmentBuffer extends SegmentBuffer {
                       err :
                       new Error("An unknown error occured when doing operations " +
                                 "on the SourceBuffer");
-      this._pendingTask.subject.error(error);
+      this._pendingTask.reject(error);
     }
   }
 
@@ -350,24 +368,22 @@ export default class AudioVideoSegmentBuffer extends SegmentBuffer {
    * Cancel queued operation on unsubscription.
    * @private
    * @param {Object} operation
-   * @returns {Observable}
+   * @param {Object} cancellationSignal
+   * @returns {Promise}
    */
-  private _addToQueue(operation : ISBOperation<BufferSource>) : Observable<void> {
-    return new Observable((obs : Observer<void>) => {
+  private _addToQueue(
+    operation : ISBOperation<BufferSource>,
+    cancellationSignal : CancellationSignal
+  ) : Promise<void> {
+    return new Promise((resolve, reject) => {
+      if (cancellationSignal.cancellationError !== null) {
+        return reject(cancellationSignal.cancellationError);
+      }
       const shouldRestartQueue = this._queue.length === 0 &&
                                  this._pendingTask === null;
-      const subject = new Subject<void>();
-      const queueItem = objectAssign({ subject }, operation);
+      const queueItem = objectAssign({ resolve, reject }, operation);
       this._queue.push(queueItem);
-
-      const subscription = subject.subscribe(obs);
-      if (shouldRestartQueue) {
-        this._flush();
-      }
-
-      return () => {
-        subscription.unsubscribe();
-
+      cancellationSignal.register((error : CancellationError) => {
         // Remove the corresponding element from the AudioVideoSegmentBuffer's
         // queue.
         // If the operation was a pending task, it should still continue to not
@@ -376,7 +392,14 @@ export default class AudioVideoSegmentBuffer extends SegmentBuffer {
         if (index >= 0) {
           this._queue.splice(index, 1);
         }
-      };
+        queueItem.resolve = noop;
+        queueItem.reject = noop;
+        reject(error);
+      });
+
+      if (shouldRestartQueue) {
+        this._flush();
+      }
     });
   }
 
@@ -409,10 +432,9 @@ export default class AudioVideoSegmentBuffer extends SegmentBuffer {
             assertUnreachable(task);
         }
 
-        const { subject } = task;
+        const { resolve } = task;
         this._pendingTask = null;
-        subject.next();
-        subject.complete();
+        resolve();
         this._flush(); // Go to next item in queue
         return;
       }
@@ -436,7 +458,7 @@ export default class AudioVideoSegmentBuffer extends SegmentBuffer {
             e :
             new Error("An unknown error occured when preparing a push operation");
           this._lastInitSegment = null; // initialize init segment as a security
-          nextItem.subject.error(error);
+          nextItem.reject(error);
           return;
         }
 
@@ -492,7 +514,7 @@ export default class AudioVideoSegmentBuffer extends SegmentBuffer {
    *
    * This method allows to "prepare" that push operation so that all is left is
    * to push the returned segment data one after the other (from first to last).
-   * @param {Object} item
+   * @param {Object} data
    * @returns {Object}
    */
   private _preparePushOperation(