rx-player 3.25.2 → 3.26.3-dev.2022021400

package/src/core/init/update_playback_rate.ts

@@ -16,39 +16,38 @@
 
 import {
   defer as observableDefer,
-  Observable,
-  of as observableOf,
-} from "rxjs";
-import {
   distinctUntilChanged,
   map,
+  Observable,
+  of as observableOf,
   startWith,
   switchMap,
   tap,
-} from "rxjs/operators";
+} from "rxjs";
 import log from "../../log";
-import { IInitClockTick } from "./types";
+import { IReadOnlySharedReference } from "../../utils/reference";
+import { IPlaybackObservation } from "../api";
 
-export interface IPlaybackRateOptions { pauseWhenStalled? : boolean }
+export interface IPlaybackRateOptions { pauseWhenRebuffering? : boolean }
 
 /**
  * Manage playback speed.
  * Set playback rate set by the user, pause playback when the player appear to
- * stall and restore the speed once it appears to un-stall.
+ * rebuffering and restore the speed once it appears to exit rebuffering status.
  *
  * @param {HTMLMediaElement} mediaElement
- * @param {Observable} speed$ - emit speed set by the user
- * @param {Observable} clock$ - Current playback conditions
+ * @param {Observable} speed - last speed set by the user
+ * @param {Observable} observation$ - Current playback conditions
  * @returns {Observable}
  */
 export default function updatePlaybackRate(
   mediaElement : HTMLMediaElement,
-  speed$ : Observable<number>,
-  clock$ : Observable<IInitClockTick>
+  speed : IReadOnlySharedReference<number>,
+  observation$ : Observable<IPlaybackObservation>
 ) : Observable<number> {
-  const forcePause$ = clock$
+  const forcePause$ = observation$
     .pipe(
-      map((timing) => timing.stalled !== null),
+      map((observation) => observation.rebuffering !== null),
       startWith(false),
       distinctUntilChanged()
     );
@@ -62,10 +61,10 @@ export default function updatePlaybackRate(
           return observableOf(0);
         });
       }
-      return speed$
-        .pipe(tap((speed) => {
-          log.info("Init: Resume playback speed", speed);
-          mediaElement.playbackRate = speed;
+      return speed.asObservable()
+        .pipe(tap((lastSpeed) => {
+          log.info("Init: Resume playback speed", lastSpeed);
+          mediaElement.playbackRate = lastSpeed;
         }));
     }));
 }

package/src/core/segment_buffers/README.md

@@ -134,8 +134,8 @@ periodically perform "garbage collection" manually on a given
 
 It is based on the following building bricks:
 
-  - A clock, which is an observable emitting the current time (in seconds) when
-    the garbage collection task should be performed
+  - An observable emitting the current time (in seconds) when the garbage
+    collection task should be performed
 
   - The `SegmentBuffer` on which the garbage collection task should run
 
@@ -145,7 +145,7 @@ It is based on the following building bricks:
   - The maximum time margin authorized for the buffer ahead of the current
     position
 
-Basically, each times the given clock ticks, the BufferGarbageCollector will
+Basically, each times the given Observable emits, the BufferGarbageCollector will
 ensure that the volume of data before and ahead of the current position does not
 grow into a larger value than what is configured.
 

package/src/core/segment_buffers/garbage_collector.ts

@@ -16,24 +16,22 @@
 
 import {
   combineLatest as observableCombineLatest,
+  concatAll,
   EMPTY,
   from as observableFrom,
-  Observable,
-} from "rxjs";
-import {
-  concatAll,
   ignoreElements,
   mergeMap,
-} from "rxjs/operators";
+  Observable,
+} from "rxjs";
 import log from "../../log";
 import { getInnerAndOuterTimeRanges } from "../../utils/ranges";
 import { SegmentBuffer } from "./implementations";
 
 export interface IGarbageCollectorArgument {
   /** SegmentBuffer implementation */
-  segmentBuffer : SegmentBuffer<unknown>;
+  segmentBuffer : SegmentBuffer;
   /** Emit current position in seconds regularly */
-  clock$ : Observable<number>;
+  currentTime$ : Observable<number>;
   /** Maximum time to keep behind current time position, in seconds */
   maxBufferBehind$ : Observable<number>;
   /** Minimum time to keep behind current time position, in seconds */
@@ -42,19 +40,19 @@ export interface IGarbageCollectorArgument {
 
 /**
  * Perform cleaning of the buffer according to the values set by the user
- * at each clock tick and each times the maxBufferBehind/maxBufferAhead values
- * change.
+ * each time `currentTime$` emits and each times the
+ * maxBufferBehind/maxBufferAhead values change.
  *
  * @param {Object} opt
  * @returns {Observable}
  */
 export default function BufferGarbageCollector({
   segmentBuffer,
-  clock$,
+  currentTime$,
   maxBufferBehind$,
   maxBufferAhead$,
 } : IGarbageCollectorArgument) : Observable<never> {
-  return observableCombineLatest([clock$, maxBufferBehind$, maxBufferAhead$]).pipe(
+  return observableCombineLatest([currentTime$, maxBufferBehind$, maxBufferAhead$]).pipe(
     mergeMap(([currentTime, maxBufferBehind, maxBufferAhead]) => {
       return clearBuffer(segmentBuffer,
                          currentTime,
@@ -80,7 +78,7 @@ export default function BufferGarbageCollector({
  * @returns {Observable}
  */
 function clearBuffer(
-  segmentBuffer : SegmentBuffer<unknown>,
+  segmentBuffer : SegmentBuffer,
   position : number,
   maxBufferBehind : number,
   maxBufferAhead : number
@@ -156,7 +154,13 @@ function clearBuffer(
       log.debug("GC: cleaning range from SegmentBuffer", range);
       return segmentBuffer.removeBuffer(range.start, range.end);
     })
-  ).pipe(concatAll(), ignoreElements());
+  ).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$;
 }

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

@@ -20,23 +20,22 @@ import {
   Observable,
   Observer,
   Subject,
-} from "rxjs";
-import {
   takeUntil,
   tap,
-} from "rxjs/operators";
+} from "rxjs";
 import {
   ICompatSourceBuffer,
   tryToChangeSourceBufferType,
 } from "../../../../compat";
 import config from "../../../../config";
 import log from "../../../../log";
+import { getLoggableSegmentId } from "../../../../manifest";
 import areArraysOfNumbersEqual from "../../../../utils/are_arrays_of_numbers_equal";
 import assertUnreachable from "../../../../utils/assert_unreachable";
 import { toUint8Array } from "../../../../utils/byte_parsing";
 import hashBuffer from "../../../../utils/hash_buffer";
 import objectAssign from "../../../../utils/object_assign";
-import { IInsertedChunkInfos } from "../../segment_inventory";
+import { IInsertedChunkInfos } from "../../inventory";
 import {
   IEndOfSegmentInfos,
   IEndOfSegmentOperation,
@@ -104,7 +103,7 @@ type IPushTask = IPushOperation<BufferSource> & {
  *
  * @class AudioVideoSegmentBuffer
  */
-export default class AudioVideoSegmentBuffer extends SegmentBuffer<BufferSource> {
+export default class AudioVideoSegmentBuffer extends SegmentBuffer {
   /** "Type" of the buffer concerned. */
   public readonly bufferType : "audio" | "video";
 
@@ -220,10 +219,11 @@ export default class AudioVideoSegmentBuffer extends SegmentBuffer<BufferSource>
    * @param {Object} infos
    * @returns {Observable}
    */
-  public pushChunk(infos : IPushChunkInfos<BufferSource>) : Observable<void> {
+  public pushChunk(infos : IPushChunkInfos<unknown>) : Observable<void> {
+    assertPushedDataIsBufferSource(infos);
     log.debug("AVSB: receiving order to push data to the SourceBuffer",
               this.bufferType,
-              infos);
+              getLoggableSegmentId(infos.inventoryInfos));
     return this._addToQueue({ type: SegmentBufferOperation.Push,
                               value: infos });
   }
@@ -255,7 +255,7 @@ export default class AudioVideoSegmentBuffer extends SegmentBuffer<BufferSource>
   public endOfSegment(infos : IEndOfSegmentInfos) : Observable<void> {
     log.debug("AVSB: receiving order for validating end of segment",
               this.bufferType,
-              infos.segment);
+              getLoggableSegmentId(infos));
     return this._addToQueue({ type: SegmentBufferOperation.EndOfSegment,
                               value: infos });
   }
@@ -277,7 +277,7 @@ export default class AudioVideoSegmentBuffer extends SegmentBuffer<BufferSource>
   public getPendingOperations() : Array<ISBOperation<BufferSource>> {
     const parseQueuedOperation =
       (op : IAVSBQueueItem | IAVSBPendingTask) : ISBOperation<BufferSource> => {
-        // Had to be written that way for TypeScrypt
+        // Had to be written that way for TypeScript
         switch (op.type) {
           case SegmentBufferOperation.Push:
             return { type: op.type, value: op.value };
@@ -398,7 +398,7 @@ export default class AudioVideoSegmentBuffer extends SegmentBuffer<BufferSource>
             }
             break;
           case SegmentBufferOperation.EndOfSegment:
-            this._segmentInventory.completeSegment(task.value);
+            this._segmentInventory.completeSegment(task.value, this.getBufferedRanges());
             break;
           case SegmentBufferOperation.Remove:
             this.synchronizeInventory();
@@ -448,7 +448,8 @@ export default class AudioVideoSegmentBuffer extends SegmentBuffer<BufferSource>
       switch (this._pendingTask.type) {
         case SegmentBufferOperation.EndOfSegment:
           // nothing to do, we will just acknowledge the segment.
-          log.debug("AVSB: Acknowledging complete segment", this._pendingTask.value);
+          log.debug("AVSB: Acknowledging complete segment",
+                    getLoggableSegmentId(this._pendingTask.value));
           this._flush();
           return;
 
@@ -458,6 +459,9 @@ export default class AudioVideoSegmentBuffer extends SegmentBuffer<BufferSource>
             this._flush();
             return;
           }
+          log.debug("AVSB: pushing segment",
+                    this.bufferType,
+                    getLoggableSegmentId(this._pendingTask.inventoryData));
           this._sourceBuffer.appendBuffer(segmentData);
           break;
 
@@ -582,3 +586,34 @@ export default class AudioVideoSegmentBuffer extends SegmentBuffer<BufferSource>
     return false;
   }
 }
+
+/**
+ * Throw if the given input is not in the expected format.
+ * Allows to enforce runtime type-checking as compile-time type-checking here is
+ * difficult to enforce.
+ * @param {Object} pushedData
+ */
+function assertPushedDataIsBufferSource(
+  pushedData : IPushChunkInfos<unknown>
+) : asserts pushedData is IPushChunkInfos<BufferSource> {
+  if (__ENVIRONMENT__.CURRENT_ENV === __ENVIRONMENT__.PRODUCTION as number) {
+    return;
+  }
+  const { chunk, initSegment } = pushedData.data;
+  if (
+    typeof chunk !== "object" ||
+    typeof initSegment !== "object" ||
+    (
+      chunk !== null &&
+      !(chunk instanceof ArrayBuffer) &&
+      !((chunk as ArrayBufferView).buffer instanceof ArrayBuffer)
+    ) ||
+    (
+      initSegment !== null &&
+      !(initSegment instanceof ArrayBuffer) &&
+      !((initSegment as ArrayBufferView).buffer instanceof ArrayBuffer)
+    )
+  ) {
+    throw new Error("Invalid data given to the AudioVideoSegmentBuffer");
+  }
+}

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

@@ -28,25 +28,11 @@ import {
 } from "../types";
 import ManualTimeRanges from "../utils/manual_time_ranges";
 
-/** Format of the data pushed to the `ImageSegmentBuffer`. */
-export interface IImageTrackSegmentData {
-  /** Image track data, in the given type */
-  data : IBifThumbnail[];
-  /** The type of the data (example: "bif") */
-  type : string;
-  /** End time until which the segment apply */
-  end : number;
-  /** Start time from which the segment apply */
-  start : number;
-  /** Timescale to convert the start and end into seconds */
-  timescale : number;
-}
-
 /**
  * Image SegmentBuffer implementation.
  * @class ImageSegmentBuffer
  */
-export default class ImageSegmentBuffer extends SegmentBuffer<IImageTrackSegmentData> {
+export default class ImageSegmentBuffer extends SegmentBuffer {
   public readonly bufferType : "image";
   private _buffered : ManualTimeRanges;
 
@@ -61,7 +47,7 @@ export default class ImageSegmentBuffer extends SegmentBuffer<IImageTrackSegment
    * @param {Object} data
    */
   public pushChunk(
-    infos : IPushChunkInfos<IImageTrackSegmentData>
+    infos : IPushChunkInfos<unknown>
   ) : Observable<void> {
     return observableDefer(() => {
       log.debug("ISB: appending new data.");
@@ -70,7 +56,10 @@ export default class ImageSegmentBuffer extends SegmentBuffer<IImageTrackSegment
       }
       const { appendWindow,
               chunk } = infos.data;
-      const { start, end, timescale } = chunk;
+
+      // 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;
 
@@ -118,7 +107,7 @@ export default class ImageSegmentBuffer extends SegmentBuffer<IImageTrackSegment
    */
   public endOfSegment(_infos : IEndOfSegmentInfos) : Observable<void> {
     return observableDefer(() => {
-      this._segmentInventory.completeSegment(_infos);
+      this._segmentInventory.completeSegment(_infos, this._buffered);
       return observableOf(undefined);
     });
   }
@@ -136,3 +125,17 @@ export default class ImageSegmentBuffer extends SegmentBuffer<IImageTrackSegment
     this._buffered.remove(0, Infinity);
   }
 }
+
+/** Format of the data pushed to the `ImageSegmentBuffer`. */
+export interface IImageTrackSegmentData {
+  /** Image track data, in the given type */
+  data : IBifThumbnail[];
+  /** The type of the data (example: "bif") */
+  type : string;
+  /** End time until which the segment apply */
+  end : number;
+  /** Start time from which the segment apply */
+  start : number;
+  /** Timescale to convert the start and end into seconds */
+  timescale : number;
+}

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))));
 }
 
 /**
@@ -111,9 +109,7 @@ function getElementResolution(
  * HTML element.
  * @class HTMLTextSegmentBuffer
  */
-export default class HTMLTextSegmentBuffer
-  extends SegmentBuffer<ITextTrackSegmentData>
-{
+export default class HTMLTextSegmentBuffer extends SegmentBuffer {
   readonly bufferType : "text";
 
   /**
@@ -179,7 +175,7 @@ export default class HTMLTextSegmentBuffer
     this._currentCues = [];
 
     // update text tracks
-    generateClock(this._videoElement)
+    generateRefreshInterval(this._videoElement)
       .pipe(takeUntil(this._destroy$))
       .subscribe((shouldDisplay) => {
         if (!shouldDisplay) {
@@ -205,7 +201,7 @@ export default class HTMLTextSegmentBuffer
    * @param {Object} infos
    * @returns {Observable}
    */
-  public pushChunk(infos : IPushChunkInfos<ITextTrackSegmentData>) : Observable<void> {
+  public pushChunk(infos : IPushChunkInfos<unknown>) : Observable<void> {
     return observableDefer(() => {
       this.pushChunkSync(infos);
       return observableOf(undefined);
@@ -236,7 +232,7 @@ export default class HTMLTextSegmentBuffer
    */
   public endOfSegment(_infos : IEndOfSegmentInfos) : Observable<void> {
     return observableDefer(() => {
-      this._segmentInventory.completeSegment(_infos);
+      this._segmentInventory.completeSegment(_infos, this._buffered);
       return observableOf(undefined);
     });
   }
@@ -273,7 +269,7 @@ export default class HTMLTextSegmentBuffer
    * @param {Object} data
    * @returns {boolean}
    */
-  public pushChunkSync(infos : IPushChunkInfos<ITextTrackSegmentData>) : void {
+  public pushChunkSync(infos : IPushChunkInfos<unknown>) : void {
     log.debug("HTSB: Appending new html text tracks");
     const { timestampOffset,
             appendWindow,
@@ -282,6 +278,7 @@ export default class HTMLTextSegmentBuffer
       return;
     }
 
+    assertChunkIsTextTrackSegmentData(chunk);
     const { start: startTime,
             end: endTime,
             data: dataString,
@@ -436,3 +433,80 @@ export default class HTMLTextSegmentBuffer
     }
   }
 }
+
+/** Data of chunks that should be pushed to the NativeTextSegmentBuffer. */
+export interface INativeTextTracksBufferSegmentData {
+  /** The text track data, in the format indicated in `type`. */
+  data : string;
+  /** The format of `data` (examples: "ttml", "srt" or "vtt") */
+  type : string;
+  /**
+   * Language in which the text track is, as a language code.
+   * This is mostly needed for "sami" subtitles, to know which cues can / should
+   * be parsed.
+   */
+  language? : string | undefined;
+  /** start time from which the segment apply, in seconds. */
+  start? : number | undefined;
+  /** end time until which the segment apply, in seconds. */
+  end? : number | undefined;
+}
+
+/**
+ * Throw if the given input is not in the expected format.
+ * Allows to enforce runtime type-checking as compile-time type-checking here is
+ * difficult to enforce.
+ * @param {Object} chunk
+ */
+function assertChunkIsTextTrackSegmentData(
+  chunk : unknown
+) : asserts chunk is INativeTextTracksBufferSegmentData {
+  if (__ENVIRONMENT__.CURRENT_ENV === __ENVIRONMENT__.PRODUCTION as number) {
+    return;
+  }
+  if (
+    typeof chunk !== "object" ||
+    chunk === null ||
+    typeof (chunk as INativeTextTracksBufferSegmentData).data !== "string" ||
+    typeof (chunk as INativeTextTracksBufferSegmentData).type !== "string" ||
+    (
+      (chunk as INativeTextTracksBufferSegmentData).language !== undefined &&
+      typeof (chunk as INativeTextTracksBufferSegmentData).language !== "string"
+    ) ||
+    (
+      (chunk as INativeTextTracksBufferSegmentData).start !== undefined &&
+      typeof (chunk as INativeTextTracksBufferSegmentData).start !== "number"
+    ) ||
+    (
+      (chunk as INativeTextTracksBufferSegmentData).end !== undefined &&
+      typeof (chunk as INativeTextTracksBufferSegmentData).end !== "number"
+    )
+  ) {
+    throw new Error("Invalid format given to a NativeTextSegmentBuffer");
+  }
+}
+
+/*
+ * The following ugly code is here to provide a compile-time check that an
+ * `INativeTextTracksBufferSegmentData` (type of data pushed to a
+ * `NativeTextSegmentBuffer`) can be derived from a `ITextTrackSegmentData`
+ * (text track data parsed from a segment).
+ *
+ * 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 (__ENVIRONMENT__.CURRENT_ENV === __ENVIRONMENT__.DEV as number) {
+  /* eslint-disable @typescript-eslint/no-unused-vars */
+  /* eslint-disable @typescript-eslint/ban-ts-comment */
+  // @ts-ignore
+  function _checkType(
+    input : ITextTrackSegmentData
+  ) : void {
+    function checkEqual(_arg : INativeTextTracksBufferSegmentData) : void {
+      /* nothing */
+    }
+    checkEqual(input);
+  }
+  /* eslint-enable @typescript-eslint/no-unused-vars */
+  /* eslint-enable @typescript-eslint/ban-ts-comment */
+}