rx-player 3.26.1 → 3.26.2

package/src/compat/eme/custom_media_keys/index.ts

@@ -44,12 +44,12 @@ import {
 import getWebKitMediaKeysCallbacks from "./webkit_media_keys";
 import { WebKitMediaKeysConstructor } from "./webkit_media_keys_constructor";
 
-let requestMediaKeySystemAccess : null |
-                                  ((keyType : string,
-                                    config : MediaKeySystemConfiguration[])
-                                      => Observable<MediaKeySystemAccess |
-                                                    CustomMediaKeySystemAccess>)
-                                = null;
+/** Generic implementation of the navigator.requestMediaKeySystemAccess API. */
+type ICompatRequestMediaKeySystemAccessFn =
+  (keyType : string, config : MediaKeySystemConfiguration[]) =>
+    Observable<MediaKeySystemAccess | CustomMediaKeySystemAccess>;
+
+let requestMediaKeySystemAccess : null | ICompatRequestMediaKeySystemAccessFn = null;
 
 let _setMediaKeys :
 ((elt: HTMLMediaElement, mediaKeys: MediaKeys | ICustomMediaKeys | null) => void) =

package/src/compat/eme/custom_media_keys/old_webkit_media_keys.ts

@@ -17,8 +17,8 @@
 import {
   merge as observableMerge,
   Subject,
+  takeUntil,
 } from "rxjs";
-import { takeUntil } from "rxjs/operators";
 import { base64ToBytes } from "../../../utils/base64";
 import EventEmitter from "../../../utils/event_emitter";
 import PPromise from "../../../utils/promise";
@@ -94,12 +94,15 @@ class OldWebkitMediaKeySession
             const licenseTypedArray =
               license instanceof ArrayBuffer ? new Uint8Array(license) :
                                                license;
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-            const json = JSON.parse(utf8ToStr(licenseTypedArray));
             /* eslint-disable @typescript-eslint/no-unsafe-member-access */
+            /* eslint-disable @typescript-eslint/no-unsafe-argument */
+            /* eslint-disable @typescript-eslint/no-unsafe-assignment */
+            const json = JSON.parse(utf8ToStr(licenseTypedArray));
             const key = base64ToBytes(json.keys[0].k);
             const kid = base64ToBytes(json.keys[0].kid);
             /* eslint-enable @typescript-eslint/no-unsafe-member-access */
+            /* eslint-enable @typescript-eslint/no-unsafe-argument */
+            /* eslint-enable @typescript-eslint/no-unsafe-assignment */
             resolve(this._vid.webkitAddKey(this._key, key, kid, /* sessionId */ ""));
           } else {
             resolve(this._vid.webkitAddKey(this._key, license, null, /* sessionId */ ""));

package/src/compat/eme/custom_media_keys/webkit_media_keys.ts

@@ -17,8 +17,8 @@
 import {
   merge as observableMerge,
   Subject,
+  takeUntil,
 } from "rxjs";
-import { takeUntil } from "rxjs/operators";
 import EventEmitter from "../../../utils/event_emitter";
 import PPromise from "../../../utils/promise";
 import { ICompatHTMLMediaElement } from "../../browser_compatibility_types";

package/src/compat/eme/generate_key_request.ts

@@ -15,10 +15,10 @@
  */
 
 import {
+  catchError,
   defer as observableDefer,
   Observable,
 } from "rxjs";
-import { catchError } from "rxjs/operators";
 import log from "../../log";
 import { getNextBoxOffsets } from "../../parsers/containers/isobmff";
 import {

package/src/compat/eme/load_session.ts

@@ -16,16 +16,14 @@
 
 import {
   defer as observableDefer,
+  map,
+  mergeMap,
   Observable,
   of as observableOf,
   race as observableRace,
+  take,
   timer as observableTimer,
 } from "rxjs";
-import {
-  mapTo,
-  mergeMap,
-  take,
-} from "rxjs/operators";
 import log from "../../log";
 import castToObservable from "../../utils/cast_to_observable";
 import tryCatch from "../../utils/rx-try_catch";
@@ -68,6 +66,6 @@ export default function loadSession(
     return observableRace(
       observableTimer(EME_WAITING_DELAY_LOADED_SESSION_EMPTY_KEYSTATUSES),
       onKeyStatusesChange$(session)
-    ).pipe(take(1), mapTo(isLoaded));
+    ).pipe(take(1), map(() => isLoaded));
   }));
 }

package/src/compat/event_listeners.ts

@@ -20,24 +20,21 @@
  */
 
 import {
+  NEVER,
+  Observable,
   combineLatest as observableCombineLatest,
   defer as observableDefer,
+  delay,
+  distinctUntilChanged,
   fromEvent as observableFromEvent,
   interval as observableInterval,
+  map,
   merge as observableMerge,
-  NEVER,
-  Observable,
   of as observableOf,
-} from "rxjs";
-import {
-  delay,
-  distinctUntilChanged,
-  map,
-  mapTo,
   startWith,
   switchMap,
   throttleTime,
-} from "rxjs/operators";
+} from "rxjs";
 import config from "../config";
 import log from "../log";
 import { IEventEmitter } from "../utils/event_emitter";
@@ -137,7 +134,7 @@ function compatibleListener<T extends Event>(
       if (isNonEmptyString(mem)) {
         return observableFromEvent(element, mem) as Observable<T>;
       } else {
-        if (__DEV__) {
+        if (__ENVIRONMENT__.CURRENT_ENV === __ENVIRONMENT__.DEV as number) {
           log.warn(`compat: element ${element.tagName}` +
                    " does not support any of these events: " +
                    prefixedEvents.join(", "));
@@ -188,20 +185,13 @@ function visibilityChange() : Observable<boolean> {
   });
 }
 
-/**
- * @returns {Observable}
- */
-function videoSizeChange() : Observable<unknown> {
-  return observableFromEvent(window, "resize");
-}
-
 /**
  * Emit `true` if the page is considered active.
  * `false` when considered inactive.
  * Emit the original value on subscription.
  * @returns {Observable}
  */
-function isActive() : Observable<boolean> {
+function isPageActive() : Observable<boolean> {
   return visibilityChange().pipe(
     switchMap((x) => {
       if (!x) {
@@ -271,7 +261,7 @@ function onPictureInPictureEvent$(
           }).pictureInPictureWindow ?? null,
         }))),
       observableFromEvent(mediaElement, "leavepictureinpicture")
-        .pipe(mapTo({ isEnabled: false, pipWindow: null }))
+        .pipe(map(() => ({ isEnabled: false, pipWindow: null })))
     ).pipe(startWith(initialState));
   });
 }
@@ -301,6 +291,7 @@ function isVideoVisible(
  * Get video width from HTML video element, or video estimated dimensions
  * when Picture-in-Picture is activated.
  * @param {HTMLMediaElement} mediaElement
+ * @param {Observable} pip$
  * @returns {Observable}
  */
 function videoWidth$(
@@ -310,7 +301,7 @@ function videoWidth$(
   return observableCombineLatest([
     pip$,
     observableInterval(20000).pipe(startWith(null)),
-    videoSizeChange().pipe(throttleTime(500), startWith(null)),
+    observableFromEvent(window, "resize").pipe(throttleTime(500), startWith(null)),
   ]).pipe(
     switchMap(([ pip ]) : Observable<number> => {
       if (!pip.isEnabled) {
@@ -451,7 +442,7 @@ const onKeyError$ = compatibleListener(["keyerror", "error"]);
 const onKeyStatusesChange$ = compatibleListener(["keystatuseschange"]);
 
 export {
-  isActive,
+  isPageActive,
   isVideoVisible,
   videoWidth$,
   onPlayPause$,

package/src/compat/on_height_width_change.ts

@@ -16,15 +16,13 @@
 
 import {
   defer as observableDefer,
+  distinctUntilChanged,
   interval as observableInterval,
+  map,
   Observable,
   Observer,
-} from "rxjs";
-import {
-  distinctUntilChanged,
-  map,
   startWith,
-} from "rxjs/operators";
+} from "rxjs";
 import log from "../log";
 import isNode from "./is_node";
 

package/src/compat/set_element_src.ts

@@ -35,7 +35,7 @@ export default function setElementSrc$(
   url : string
 ) : Observable<void> {
   return new Observable((observer : Observer<void>) => {
-    log.info("Setting URL to Element", url, mediaElement);
+    log.info("Setting URL to HTMLMediaElement", url);
 
     mediaElement.src = url;
 

package/src/compat/when_loaded_metadata.ts

@@ -17,8 +17,8 @@
 import {
   Observable,
   of as observableOf,
+  take,
 } from "rxjs";
-import { take } from "rxjs/operators";
 import { READY_STATES } from "./browser_compatibility_types";
 import { onLoadedMetadata$ } from "./event_listeners";
 

package/src/compat/when_media_source_open.ts

@@ -17,8 +17,8 @@
 import {
   Observable,
   of as observableOf,
+  take,
 } from "rxjs";
-import { take } from "rxjs/operators";
 import { onSourceOpen$ } from "./event_listeners";
 
 /**

package/src/config.ts

@@ -323,7 +323,7 @@ export default {
    */
   DEFAULT_LIVE_GAP: {
     DEFAULT: 10,
-    LOW_LATENCY: 3,
+    LOW_LATENCY: 3.5,
   },
 
   /**
@@ -457,17 +457,12 @@ export default {
   },
 
   /**
-   * Minimum interval at which timeupdate events will be "constructed". This
+   * Minimum interval at which playback information samples will be taken. This
    * variable is for the "regular" mediasource strategy (that is, not for the
    * directfile API.
    *
-   * Those events are the base of various important mechanisms in the player:
-   *   - set the clock used to regularly check which segments should be loaded
-   *   - set the clock for the ABR strategy.
-   *   - used to trigger positionUpdate events.
-   *
-   * This common logic is for performance reasons, as we call multiple browser's
-   * APIs which are useful for most of these.
+   * At each of these interval, various different modules in the RxPlayer will
+   * run based on the information communicated.
    *
    * Keep in mind this is the minimum interval. This logic will also be
    * triggered when various events of the media element are received.

package/src/core/abr/README.md

@@ -20,13 +20,13 @@ be the most adapted, that is the quality which:
     be not as pleasant to watch)
 
 In order to estimate the quality that maximizes the playback experience, the ABR
-relies on two "estimators":
-  1. The bandwidth estimator picks a quality from network conditions.
-  2. The buffer based chooser relies on buffering conditions to make its
-     choices.
+relies on multiple algorithms:
+  1. One which picks a quality from network conditions.
+  2. Another relies on buffering conditions to make its choices.
+  3. A third, only used in very rare conditions, "guess" the right quality by
+     progressively raising the quality until an un-maintainable one is found.
 
-
-## Bandwidth estimator #########################################################
+## Bandwidth-based algorithm ###################################################
 
 ```
                  Long
@@ -85,7 +85,7 @@ The quality's bitrate ceiling relies on it to return the chosen quality.
 
 
 
-## Buffer based estimator ######################################################
+## Buffer-based algorithm ######################################################
 
 ```
                               Qualities

package/src/core/abr/abr_manager.ts

@@ -15,22 +15,26 @@
  */
 
 import {
+  combineLatest as observableCombineLatest,
+  map,
   Observable,
   of as observableOf,
 } from "rxjs";
 import log from "../../log";
 import { Representation } from "../../manifest";
+import objectAssign from "../../utils/object_assign";
+import { ISharedReference } from "../../utils/reference";
 import takeFirstSet from "../../utils/take_first_set";
 import { IBufferType } from "../segment_buffers";
 import BandwidthEstimator from "./bandwidth_estimator";
-import createFilters from "./create_filters";
 import RepresentationEstimator, {
   IABREstimate,
+  IABRFiltersObject,
   IABRStreamEvents,
-  IRepresentationEstimatorClockTick,
+  IRepresentationEstimatorPlaybackObservation,
 } from "./representation_estimator";
 
-export type IABRManagerClockTick = IRepresentationEstimatorClockTick;
+export type IABRManagerPlaybackObservation = IRepresentationEstimatorPlaybackObservation;
 
 // Options for every RepresentationEstimator
 interface IRepresentationEstimatorsThrottlers {
@@ -48,15 +52,16 @@ export interface IABRManagerArguments {
   lowLatencyMode: boolean; // Some settings can depend on wether you're playing a
                            // low-latency content. Set it to `true` if you're playing
                            // such content.
-  minAutoBitrates: Partial<Record<IBufferType,          // Minimum bitrate chosen
-                                  Observable<number>>>; // when in auto mode, per
-                                                        // type (0 by default)
-  maxAutoBitrates: Partial<Record<IBufferType,          // Maximum bitrate chosen
-                                  Observable<number>>>; // when in auto mode, per
-                                                        // type (Infinity by default)
-  manualBitrates: Partial<Record<IBufferType,          // Manual bitrate set for
-                                 Observable<number>>>; // a given type (-1 for
-                                                       // auto mode)
+
+  /** Minimum bitrate chosen when in auto mode, per type (0 by default) */
+  minAutoBitrates: Partial<Record<IBufferType, ISharedReference<number>>>;
+
+  /** Maximum bitrate chosen when in auto mode, per type (0 by default) */
+  maxAutoBitrates: Partial<Record<IBufferType, ISharedReference<number>>>;
+
+  /** Manually forced bitrate set for a given type (`-1` for auto mode */
+  manualBitrates: Partial<Record<IBufferType, ISharedReference<number>>>;
+
   throttlers: IRepresentationEstimatorsThrottlers; // Throttle from external events
 }
 
@@ -70,9 +75,9 @@ export interface IABRManagerArguments {
 export default class ABRManager {
   private _bandwidthEstimators : Partial<Record<IBufferType, BandwidthEstimator>>;
   private _initialBitrates : Partial<Record<IBufferType, number>>;
-  private _manualBitrates : Partial<Record<IBufferType, Observable<number>>>;
-  private _minAutoBitrates : Partial<Record<IBufferType, Observable<number>>>;
-  private _maxAutoBitrates : Partial<Record<IBufferType, Observable<number>>>;
+  private _manualBitrates : Partial<Record<IBufferType, ISharedReference<number>>>;
+  private _minAutoBitrates : Partial<Record<IBufferType, ISharedReference<number>>>;
+  private _maxAutoBitrates : Partial<Record<IBufferType, ISharedReference<number>>>;
   private _throttlers : IRepresentationEstimatorsThrottlers;
   private _lowLatencyMode : boolean;
 
@@ -95,24 +100,25 @@ export default class ABRManager {
    * state).
    * @param {string} type
    * @param {Array.<Representation>} representations
-   * @param {Observable<Object>} clock$
+   * @param {Observable<Object>} observation$
    * @param {Observable<Object>} streamEvents$
    * @returns {Observable}
    */
   public get$(
     type : IBufferType,
     representations : Representation[],
-    clock$ : Observable<IABRManagerClockTick>,
+    observation$ : Observable<IABRManagerPlaybackObservation>,
     streamEvents$ : Observable<IABRStreamEvents>
   ) : Observable<IABREstimate> {
     const bandwidthEstimator = this._getBandwidthEstimator(type);
     const manualBitrate$ =
-      takeFirstSet<Observable<number>>(this._manualBitrates[type], observableOf(-1));
+      takeFirstSet<Observable<number>>(this._manualBitrates[type]?.asObservable(),
+                                       observableOf(-1));
     const minAutoBitrate$ =
-      takeFirstSet<Observable<number>>(this._minAutoBitrates[type],
+      takeFirstSet<Observable<number>>(this._minAutoBitrates[type]?.asObservable(),
                                        observableOf(0));
     const maxAutoBitrate$ =
-      takeFirstSet<Observable<number>>(this._maxAutoBitrates[type],
+      takeFirstSet<Observable<number>>(this._maxAutoBitrates[type]?.asObservable(),
                                        observableOf(Infinity));
     const initialBitrate = takeFirstSet<number>(this._initialBitrates[type], 0);
     const filters$ = createFilters(this._throttlers.limitWidth[type],
@@ -120,7 +126,7 @@ export default class ABRManager {
                                    this._throttlers.throttle[type]);
     return RepresentationEstimator({ bandwidthEstimator,
                                      streamEvents$,
-                                     clock$,
+                                     observation$,
                                      filters$,
                                      initialBitrate,
                                      manualBitrate$,
@@ -145,3 +151,38 @@ export default class ABRManager {
     return originalBandwidthEstimator;
   }
 }
+
+/**
+ * Create Observable that merge several throttling Observables into one.
+ * @param {Observable} limitWidth$ - Emit the width at which the chosen
+ * Representation should be limited.
+ * @param {Observable} throttleBitrate$ - Emit the maximum bitrate authorized.
+ * @param {Observable} throttle$ - Also emit the maximum bitrate authorized.
+ * Here for legacy reasons.
+ * @returns {Observable}
+ */
+function createFilters(
+  limitWidth$? : Observable<number>,
+  throttleBitrate$? : Observable<number>,
+  throttle$? : Observable<number>
+) : Observable<IABRFiltersObject> {
+  const deviceEventsArray : Array<Observable<IABRFiltersObject>> = [];
+
+  if (limitWidth$ != null) {
+    deviceEventsArray.push(limitWidth$.pipe(map(width => ({ width }))));
+  }
+  if (throttle$ != null) {
+    deviceEventsArray.push(throttle$.pipe(map(bitrate => ({ bitrate }))));
+  }
+  if (throttleBitrate$ != null) {
+    deviceEventsArray.push(throttleBitrate$.pipe(map(bitrate => ({ bitrate }))));
+  }
+
+  // Emit restrictions on the pools of available representations to choose
+  // from.
+  return deviceEventsArray.length > 0 ?
+    observableCombineLatest(deviceEventsArray)
+      .pipe(map((args : IABRFiltersObject[]) =>
+        objectAssign({}, ...args) as IABRFiltersObject)) :
+    observableOf({});
+}

package/src/core/abr/bandwidth_estimator.ts

@@ -15,7 +15,7 @@
  */
 
 import config from "../../config";
-import EWMA from "./ewma";
+import EWMA from "./utils/ewma";
 
 const { ABR_MINIMUM_TOTAL_BYTES,
         ABR_MINIMUM_CHUNK_SIZE,

package/src/core/abr/buffer_based_chooser.ts

@@ -14,12 +14,14 @@
  * limitations under the License.
  */
 
-import { Observable } from "rxjs";
-import { map } from "rxjs/operators";
+import {
+  map,
+  Observable,
+} from "rxjs";
 import log from "../../log";
 import getBufferLevels from "./get_buffer_levels";
 import getEstimateFromBufferLevels, {
-  IBufferBasedChooserClockTick,
+  IBufferBasedChooserPlaybackObservation,
 } from "./get_estimate_from_buffer_levels";
 
 /**
@@ -38,13 +40,13 @@ import getEstimateFromBufferLevels, {
  * @returns {Observable}
  */
 export default function BufferBasedChooser(
-  update$ : Observable<IBufferBasedChooserClockTick>,
+  update$ : Observable<IBufferBasedChooserPlaybackObservation>,
   bitrates: number[]
 ) : Observable<number|undefined> {
   const levelsMap = getBufferLevels(bitrates);
   log.debug("ABR: Steps for buffer based chooser.",
             levelsMap.map((l, i) => ({ bufferLevel: l, bitrate: bitrates[i] })));
-  return update$.pipe(map((clockTick) => {
-    return getEstimateFromBufferLevels(clockTick, bitrates, levelsMap);
+  return update$.pipe(map((playbackObservation) => {
+    return getEstimateFromBufferLevels(playbackObservation, bitrates, levelsMap);
   }));
 }

package/src/core/abr/get_buffer_levels.ts

@@ -40,6 +40,9 @@ export default function getBufferLevels(bitrates : number[]) : number[] {
       return 0;
     }
     const boundedIndex = Math.min(Math.max(1, index), bitrates.length - 1);
+    if (bitrates[boundedIndex] === bitrates[boundedIndex - 1]) {
+      return minBufferLevelForBitrate(index - 1);
+    }
     return Vp * (gp + (bitrates[boundedIndex] * utilities[boundedIndex - 1] -
       bitrates[boundedIndex - 1] * utilities[boundedIndex]) / (bitrates[boundedIndex] -
       bitrates[boundedIndex - 1])) + 4;

package/src/core/abr/get_estimate_from_buffer_levels.ts

@@ -17,7 +17,7 @@
 import log from "../../log";
 import arrayFindIndex from "../../utils/array_find_index";
 
-export interface IBufferBasedChooserClockTick {
+export interface IBufferBasedChooserPlaybackObservation {
   bufferGap : number; // Difference in seconds between the current position and
                       // the next non-buffered position
   currentBitrate? : number; // The bitrate of the currently downloaded segments, in bps
@@ -28,17 +28,17 @@ export interface IBufferBasedChooserClockTick {
 
 /**
  * From the buffer gap, choose a representation.
- * @param {Object} clockTick
+ * @param {Object} playbackObservation
  * @param {Array.<Number>} bitrates
  * @param {Array.<Number>} bufferLevels
  * @returns {Object|undefined}
  */
 export default function getEstimateFromBufferLevels(
-  clockTick : IBufferBasedChooserClockTick,
+  playbackObservation : IBufferBasedChooserPlaybackObservation,
   bitrates : number[],
   bufferLevels : number[]
 ) : number|undefined {
-  const { bufferGap, currentBitrate, currentScore, speed } = clockTick;
+  const { bufferGap, currentBitrate, currentScore, speed } = playbackObservation;
   if (currentBitrate == null) {
     return bitrates[0];
   }