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

package/src/core/segment_buffers/implementations/image/image_segment_buffer.ts

@@ -14,11 +14,6 @@
  * limitations under the License.
  */
 
-import {
-  defer as observableDefer,
-  Observable,
-  of as observableOf,
-} from "rxjs";
 import log from "../../../../log";
 import { IBifThumbnail } from "../../../../parsers/images/bif";
 import {
@@ -45,55 +40,57 @@ export default class ImageSegmentBuffer extends SegmentBuffer {
 
   /**
    * @param {Object} data
+   * @returns {Promise}
    */
   public pushChunk(
     infos : IPushChunkInfos<unknown>
-  ) : Observable<void> {
-    return observableDefer(() => {
-      log.debug("ISB: appending new data.");
-      if (infos.data.chunk === null) {
-        return observableOf(undefined);
-      }
-      const { appendWindow,
-              chunk } = infos.data;
+  ) : Promise<void> {
+    log.debug("ISB: appending new data.");
+    if (infos.data.chunk === null) {
+      return Promise.resolve();
+    }
+    const { appendWindow,
+            chunk } = infos.data;
 
-      // The following check is ugly. I don't care, the image buffer is there
-      // due to an ugly deprecated API that will soon disappear
-      const { start, end, timescale } = chunk as IImageTrackSegmentData;
-      const appendWindowStart = appendWindow[0] ?? 0;
-      const appendWindowEnd = appendWindow[1] ?? Infinity;
+    // The following check is ugly. I don't care, the image buffer is there
+    // due to an ugly deprecated API that will soon disappear
+    const { start, end, timescale } = chunk as IImageTrackSegmentData;
+    const appendWindowStart = appendWindow[0] ?? 0;
+    const appendWindowEnd = appendWindow[1] ?? Infinity;
 
-      const timescaledStart = start / timescale;
-      const timescaledEnd = end / timescale;
+    const timescaledStart = start / timescale;
+    const timescaledEnd = end / timescale;
 
-      const startTime = Math.max(appendWindowStart, timescaledStart);
-      const endTime = Math.min(appendWindowEnd, timescaledEnd);
+    const startTime = Math.max(appendWindowStart, timescaledStart);
+    const endTime = Math.min(appendWindowEnd, timescaledEnd);
 
+    try {
       this._buffered.insert(startTime, endTime);
       if (infos.inventoryInfos !== null) {
         this._segmentInventory.insertChunk(infos.inventoryInfos);
       }
-      return observableOf(undefined);
-    });
+    } catch (err) {
+      return Promise.reject(err);
+    }
+    return Promise.resolve();
   }
 
   /**
    * @param {Number} from
    * @param {Number} to
+   * @returns {Promise}
    */
-  public removeBuffer(start : number, end : number) : Observable<void> {
-    return observableDefer(() => {
-      log.info("ISB: ignored image data remove order", start, end);
+  public removeBuffer(start : number, end : number) : Promise<void> {
+    log.info("ISB: ignored image data remove order", start, end);
 
-      // Logic removed as it caused more problems than it resolved:
-      // Image thumbnails are always downloaded as a single BIF file, meaning that
-      // any removing might necessitate to re-load the whole file in the future
-      // which seems pointless.
-      // In any case, image handling through the regular RxPlayer APIs has been
-      // completely deprecated now for several reasons, and should disappear in
-      // the next major version.
-      return observableOf(undefined);
-    });
+    // Logic removed as it caused more problems than it resolved:
+    // Image thumbnails are always downloaded as a single BIF file, meaning that
+    // any removing might necessitate to re-load the whole file in the future
+    // which seems pointless.
+    // In any case, image handling through the regular RxPlayer APIs has been
+    // completely deprecated now for several reasons, and should disappear in
+    // the next major version.
+    return Promise.resolve();
   }
 
   /**
@@ -103,13 +100,11 @@ export default class ImageSegmentBuffer extends SegmentBuffer {
    * The returned Observable will emit and complete successively 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> {
-    return observableDefer(() => {
-      this._segmentInventory.completeSegment(_infos, this._buffered);
-      return observableOf(undefined);
-    });
+  public endOfSegment(_infos : IEndOfSegmentInfos) : Promise<void> {
+    this._segmentInventory.completeSegment(_infos, this._buffered);
+    return Promise.resolve();
   }
 
   /**

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

@@ -14,19 +14,6 @@
  * limitations under the License.
  */
 
-import {
-  concat as observableConcat,
-  defer as observableDefer,
-  interval as observableInterval,
-  map,
-  merge as observableMerge,
-  Observable,
-  of as observableOf,
-  startWith,
-  Subject,
-  switchMap,
-  takeUntil,
-} from "rxjs";
 import {
   events,
   onHeightWidthChange,
@@ -34,6 +21,9 @@ import {
 import config from "../../../../../config";
 import log from "../../../../../log";
 import { ITextTrackSegmentData } from "../../../../../transports";
+import TaskCanceller, {
+  CancellationSignal,
+} from "../../../../../utils/task_canceller";
 import {
   IEndOfSegmentInfos,
   IPushChunkInfos,
@@ -44,31 +34,7 @@ import parseTextTrackToElements from "./parsers";
 import TextTrackCuesStore from "./text_track_cues_store";
 import updateProportionalElements from "./update_proportional_elements";
 
-const { onEnded$,
-        onSeeked$,
-        onSeeking$ } = events;
-
-
-/**
- * Generate the interval at which TextTrack HTML Cues should be refreshed.
- * @param {HTMLMediaElement} videoElement
- * @returns {Observable}
- */
-function generateRefreshInterval(videoElement : HTMLMediaElement) : Observable<boolean> {
-  const seeking$ = onSeeking$(videoElement);
-  const seeked$ = onSeeked$(videoElement);
-  const ended$ = onEnded$(videoElement);
-  const { MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL } = config.getCurrent();
-  const manualRefresh$ = observableMerge(seeked$, ended$);
-  const autoRefresh$ = observableInterval(MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL)
-    .pipe(startWith(null));
-
-  return manualRefresh$.pipe(
-    startWith(null),
-    switchMap(() => observableConcat(autoRefresh$.pipe(map(() => true),
-                                                       takeUntil(seeking$)),
-                                     observableOf(false))));
-}
+const { onEnded, onSeeked, onSeeking } = events;
 
 /**
  * @param {Element} element
@@ -116,12 +82,8 @@ export default class HTMLTextSegmentBuffer extends SegmentBuffer {
    */
   private readonly _videoElement : HTMLMediaElement;
 
-  /**
-   * When "nexting" that subject, every Observable declared here will be
-   * unsubscribed.
-   * Used for clean-up
-   */
-  private readonly _destroy$ : Subject<void>;
+  /** Used for clean-up. */
+  private readonly _canceller : TaskCanceller;
 
   /** HTMLElement which will contain the cues */
   private readonly _textTrackElement : HTMLElement;
@@ -131,10 +93,10 @@ export default class HTMLTextSegmentBuffer extends SegmentBuffer {
 
   /**
    * We could need us to automatically update styling depending on
-   * `_textTrackElement`'s size. This Subject allows to stop that
+   * `_textTrackElement`'s size. This TaskCanceller allows to stop that
    * regular check.
    */
-  private _clearSizeUpdates$ : Subject<void>;
+  private _sizeUpdateCanceller : TaskCanceller;
 
   /** Information on cues currently displayed. */
   private _currentCues : Array<{
@@ -167,72 +129,46 @@ export default class HTMLTextSegmentBuffer extends SegmentBuffer {
 
     this._videoElement = videoElement;
     this._textTrackElement = textTrackElement;
-    this._clearSizeUpdates$ = new Subject();
-    this._destroy$ = new Subject();
+    this._sizeUpdateCanceller = new TaskCanceller();
+    this._canceller = new TaskCanceller();
     this._buffer = new TextTrackCuesStore();
     this._currentCues = [];
 
-    // update text tracks
-    generateRefreshInterval(this._videoElement)
-      .pipe(takeUntil(this._destroy$))
-      .subscribe((shouldDisplay) => {
-        if (!shouldDisplay) {
-          this._disableCurrentCues();
-          return;
-        }
-        const { MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL } = config.getCurrent();
-        // to spread the time error, we divide the regular chosen interval.
-        const time = Math.max(this._videoElement.currentTime +
-                              (MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL / 1000) / 2,
-                              0);
-        const cues = this._buffer.get(time);
-        if (cues.length === 0) {
-          this._disableCurrentCues();
-        } else {
-          this._displayCues(cues);
-        }
-      });
+    this.autoRefreshSubtitles(this._canceller.signal);
   }
 
   /**
    * Push segment on Subscription.
    * @param {Object} infos
-   * @returns {Observable}
+   * @returns {Promise}
    */
-  public pushChunk(infos : IPushChunkInfos<unknown>) : Observable<void> {
-    return observableDefer(() => {
+  public pushChunk(infos : IPushChunkInfos<unknown>) : Promise<void> {
+    try {
       this.pushChunkSync(infos);
-      return observableOf(undefined);
-    });
+    } catch (err) {
+      return Promise.reject(err);
+    }
+    return Promise.resolve();
   }
 
   /**
    * Remove buffered data.
    * @param {number} start - start position, in seconds
    * @param {number} end - end position, in seconds
-   * @returns {Observable}
+   * @returns {Promise}
    */
-  public removeBuffer(start : number, end : number) : Observable<void> {
-    return observableDefer(() => {
-      this.removeBufferSync(start, end);
-      return observableOf(undefined);
-    });
+  public removeBuffer(start : number, end : number) : Promise<void> {
+    this.removeBufferSync(start, end);
+    return Promise.resolve();
   }
 
   /**
-   * 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.
    * @param {Object} infos
-   * @returns {Observable}
+   * @returns {Promise}
    */
-  public endOfSegment(_infos : IEndOfSegmentInfos) : Observable<void> {
-    return observableDefer(() => {
-      this._segmentInventory.completeSegment(_infos, this._buffered);
-      return observableOf(undefined);
-    });
+  public endOfSegment(infos : IEndOfSegmentInfos) : Promise<void> {
+    this._segmentInventory.completeSegment(infos, this._buffered);
+    return Promise.resolve();
   }
 
   /**
@@ -248,8 +184,7 @@ export default class HTMLTextSegmentBuffer extends SegmentBuffer {
     this._disableCurrentCues();
     this._buffer.remove(0, Infinity);
     this._buffered.remove(0, Infinity);
-    this._destroy$.next();
-    this._destroy$.complete();
+    this._canceller.cancel();
   }
 
   /**
@@ -264,7 +199,7 @@ export default class HTMLTextSegmentBuffer extends SegmentBuffer {
    *
    * /!\ This method won't add any data to the linked inventory.
    * Please use the `pushChunk` method for most use-cases.
-   * @param {Object} data
+   * @param {Object} infos
    * @returns {boolean}
    */
   public pushChunkSync(infos : IPushChunkInfos<unknown>) : void {
@@ -375,7 +310,7 @@ export default class HTMLTextSegmentBuffer extends SegmentBuffer {
    * Remove the current cue from being displayed.
    */
   private _disableCurrentCues() : void {
-    this._clearSizeUpdates$.next();
+    this._sizeUpdateCanceller.cancel();
     if (this._currentCues.length > 0) {
       for (let i = 0; i < this._currentCues.length; i++) {
         safelyRemoveChild(this._textTrackElement, this._currentCues[i].element);
@@ -386,7 +321,7 @@ export default class HTMLTextSegmentBuffer extends SegmentBuffer {
 
   /**
    * Display a new Cue. If one was already present, it will be replaced.
-   * @param {HTMLElement} element
+   * @param {HTMLElement} elements
    */
   private _displayCues(elements : HTMLElement[]) : void {
     const nothingChanged = this._currentCues.length === elements.length &&
@@ -399,7 +334,7 @@ export default class HTMLTextSegmentBuffer extends SegmentBuffer {
     // Remove and re-display everything
     // TODO More intelligent handling
 
-    this._clearSizeUpdates$.next();
+    this._sizeUpdateCanceller.cancel();
     for (let i = 0; i < this._currentCues.length; i++) {
       safelyRemoveChild(this._textTrackElement, this._currentCues[i].element);
     }
@@ -418,17 +353,80 @@ export default class HTMLTextSegmentBuffer extends SegmentBuffer {
                                element : HTMLElement; } => cue.resolution !== null);
 
     if (proportionalCues.length > 0) {
+      this._sizeUpdateCanceller = new TaskCanceller({ cancelOn: this._canceller.signal });
       const { TEXT_TRACK_SIZE_CHECKS_INTERVAL } = config.getCurrent();
       // update propertionally-sized elements periodically
-      onHeightWidthChange(this._textTrackElement, TEXT_TRACK_SIZE_CHECKS_INTERVAL)
-        .pipe(takeUntil(this._clearSizeUpdates$),
-              takeUntil(this._destroy$))
-        .subscribe(({ height, width }) => {
-          for (let i = 0; i < proportionalCues.length; i++) {
-            const { resolution, element } = proportionalCues[i];
-            updateProportionalElements(height, width, resolution, element);
-          }
-        });
+      const heightWidthRef = onHeightWidthChange(this._textTrackElement,
+                                                 TEXT_TRACK_SIZE_CHECKS_INTERVAL,
+                                                 this._sizeUpdateCanceller.signal);
+      heightWidthRef.onUpdate(({ height, width }) => {
+        for (let i = 0; i < proportionalCues.length; i++) {
+          const { resolution, element } = proportionalCues[i];
+          updateProportionalElements(height, width, resolution, element);
+        }
+      }, { clearSignal: this._sizeUpdateCanceller.signal,
+           emitCurrentValue: true });
+    }
+  }
+
+  /**
+   * Auto-refresh the display of subtitles according to the media element's
+   * position and events.
+   * @param {Object} cancellationSignal
+   */
+  private autoRefreshSubtitles(
+    cancellationSignal : CancellationSignal
+  ) : void {
+    let autoRefreshCanceller : TaskCanceller | null = null;
+    const { MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL } = config.getCurrent();
+
+    const startAutoRefresh = () => {
+      stopAutoRefresh();
+      autoRefreshCanceller = new TaskCanceller({ cancelOn: cancellationSignal });
+      const intervalId = setInterval(() => this.refreshSubtitles(),
+                                     MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL);
+      autoRefreshCanceller.signal.register(() => {
+        clearInterval(intervalId);
+      });
+      this.refreshSubtitles();
+    };
+
+    onSeeking(this._videoElement, () => {
+      stopAutoRefresh();
+      this._disableCurrentCues();
+    }, cancellationSignal);
+    onSeeked(this._videoElement, startAutoRefresh, cancellationSignal);
+    onEnded(this._videoElement, startAutoRefresh, cancellationSignal);
+
+    function stopAutoRefresh() {
+      if (autoRefreshCanceller !== null) {
+        autoRefreshCanceller.cancel();
+        autoRefreshCanceller = null;
+      }
+    }
+  }
+
+  /**
+   * Refresh current subtitles according to the current media element's
+   * position.
+   */
+  private refreshSubtitles() : void {
+    const videoElt = this._videoElement;
+    const { MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL } = config.getCurrent();
+    let time;
+    if (videoElt.paused || videoElt.playbackRate <= 0) {
+      time = videoElt.currentTime;
+    } else {
+      // to spread the time error, we divide the regular chosen interval.
+      time = Math.max(this._videoElement.currentTime +
+                       (MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL / 1000) / 2,
+                      0);
+    }
+    const cues = this._buffer.get(time);
+    if (cues.length === 0) {
+      this._disableCurrentCues();
+    } else {
+      this._displayCues(cues);
     }
   }
 }

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

@@ -14,11 +14,6 @@
  * limitations under the License.
  */
 
-import {
-  defer as observableDefer,
-  Observable,
-  of as observableOf,
-} from "rxjs";
 import {
   addTextTrack,
   ICompatTextTrack,
@@ -73,26 +68,26 @@ export default class NativeTextSegmentBuffer extends SegmentBuffer {
 
   /**
    * @param {Object} infos
-   * @returns {Observable}
+   * @returns {Promise}
    */
-  public pushChunk(infos : IPushChunkInfos<unknown>) : Observable<void> {
-    return observableDefer(() => {
-      log.debug("NTSB: Appending new native text tracks");
-      if (infos.data.chunk === null) {
-        return observableOf(undefined);
-      }
-      const { timestampOffset,
-              appendWindow,
-              chunk } = infos.data;
-      assertChunkIsTextTrackSegmentData(chunk);
-      const { start: startTime,
-              end: endTime,
-              data: dataString,
-              type,
-              language } = chunk;
-      const appendWindowStart = appendWindow[0] ?? 0;
-      const appendWindowEnd = appendWindow[1] ?? Infinity;
-
+  public pushChunk(infos : IPushChunkInfos<unknown>) : Promise<void> {
+    log.debug("NTSB: Appending new native text tracks");
+    if (infos.data.chunk === null) {
+      return Promise.resolve();
+    }
+    const { timestampOffset,
+            appendWindow,
+            chunk } = infos.data;
+    assertChunkIsTextTrackSegmentData(chunk);
+    const { start: startTime,
+            end: endTime,
+            data: dataString,
+            type,
+            language } = chunk;
+    const appendWindowStart = appendWindow[0] ?? 0;
+    const appendWindowEnd = appendWindow[1] ?? Infinity;
+
+    try {
       const cues = parseTextTrackToCues(type, dataString, timestampOffset, language);
 
       if (appendWindowStart !== 0 && appendWindowEnd !== Infinity) {
@@ -130,7 +125,7 @@ export default class NativeTextSegmentBuffer extends SegmentBuffer {
       } else {
         if (cues.length <= 0) {
           log.warn("NTSB: Current text tracks have no cues nor start time. Aborting");
-          return observableOf(undefined);
+          return Promise.resolve();
         }
         log.warn("NTSB: No start time given. Guessing from cues.");
         start = cues[0].startTime;
@@ -142,7 +137,7 @@ export default class NativeTextSegmentBuffer extends SegmentBuffer {
       } else {
         if (cues.length <= 0) {
           log.warn("NTSB: Current text tracks have no cues nor end time. Aborting");
-          return observableOf(undefined);
+          return Promise.resolve();
         }
         log.warn("NTSB: No end time given. Guessing from cues.");
         end = cues[cues.length - 1].endTime;
@@ -151,7 +146,7 @@ export default class NativeTextSegmentBuffer extends SegmentBuffer {
       if (end <= start) {
         log.warn("NTSB: Invalid text track appended: ",
                  "the start time is inferior or equal to the end time.");
-        return observableOf(undefined);
+        return Promise.resolve();
       }
 
       if (cues.length > 0) {
@@ -178,37 +173,31 @@ export default class NativeTextSegmentBuffer extends SegmentBuffer {
       if (infos.inventoryInfos !== null) {
         this._segmentInventory.insertChunk(infos.inventoryInfos);
       }
-      return observableOf(undefined);
-    });
+    } catch (err) {
+      return Promise.reject(err);
+    }
+
+    return Promise.resolve();
   }
 
   /**
    * Remove buffered data.
    * @param {number} start - start position, in seconds
    * @param {number} end - end position, in seconds
-   * @returns {Observable}
+   * @returns {Promise}
    */
-  public removeBuffer(start : number, end : number) : Observable<void> {
-    return observableDefer(() => {
-      this._removeData(start, end);
-      return observableOf(undefined);
-    });
+  public removeBuffer(start : number, end : number) : Promise<void> {
+    this._removeData(start, end);
+    return Promise.resolve();
   }
 
   /**
-   * 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.
    * @param {Object} infos
-   * @returns {Observable}
+   * @returns {Promise}
    */
-  public endOfSegment(_infos : IEndOfSegmentInfos) : Observable<void> {
-    return observableDefer(() => {
-      this._segmentInventory.completeSegment(_infos, this._buffered);
-      return observableOf(undefined);
-    });
+  public endOfSegment(_infos : IEndOfSegmentInfos) : Promise<void> {
+    this._segmentInventory.completeSegment(_infos, this._buffered);
+    return Promise.resolve();
   }
 
   /**

package/src/core/segment_buffers/implementations/types.ts

@@ -14,13 +14,13 @@
  * limitations under the License.
  */
 
-import { Observable } from "rxjs";
 import {
   Adaptation,
   ISegment,
   Period,
   Representation,
 } from "../../../manifest";
+import { CancellationSignal } from "../../../utils/task_canceller";
 import SegmentInventory, {
   IBufferedChunk,
   IBufferedHistoryEntry,
@@ -112,28 +112,41 @@ export abstract class SegmentBuffer {
    * `data.chunk` argument to null.
    *
    * @param {Object} infos
-   * @returns {Observable}
+   * @param {Object} cancellationSignal
+   * @returns {Promise}
    */
-  public abstract pushChunk(infos : IPushChunkInfos<unknown>) : Observable<void>;
+  public abstract pushChunk(
+    infos : IPushChunkInfos<unknown>,
+    cancellationSignal : CancellationSignal
+  ) : Promise<void>;
 
   /**
    * 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 abstract removeBuffer(start : number, end : number) : Observable<void>;
+  public abstract removeBuffer(
+    start : number,
+    end : number,
+    cancellationSignal : CancellationSignal
+  ) : Promise<void>;
 
   /**
    * 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}
+   * @param {Object} cancellationSignal
+   * @returns {Promise}
    */
-  public abstract endOfSegment(infos : IEndOfSegmentInfos) : Observable<void>;
+  public abstract endOfSegment(
+    infos : IEndOfSegmentInfos,
+    cancellationSignal : CancellationSignal
+  ) : Promise<void>;
 
   /**
    * Returns the currently buffered data, in a TimeRanges object.