rx-player 4.0.0-beta.2 → 4.0.0-beta.3

package/src/core/adaptive/adaptive_representation_selector.ts

@@ -23,12 +23,10 @@ import Manifest, {
   Representation,
 } from "../../manifest";
 import noop from "../../utils/noop";
-import { getLeftSizeOfRange } from "../../utils/ranges";
-import createSharedReference, {
+import { getLeftSizeOfBufferedTimeRange } from "../../utils/ranges";
+import SharedReference, {
   IReadOnlySharedReference,
-  ISharedReference,
 } from "../../utils/reference";
-import takeFirstSet from "../../utils/take_first_set";
 import TaskCanceller, {
   CancellationSignal,
 } from "../../utils/task_canceller";
@@ -54,10 +52,10 @@ import selectOptimalRepresentation from "./utils/select_optimal_representation";
 
 // Create default shared references
 
-const limitWidthDefaultRef = createSharedReference(undefined);
+const limitWidthDefaultRef = new SharedReference<IResolutionInfo | undefined>(undefined);
 limitWidthDefaultRef.finish();
 
-const throttleBitrateDefaultRef = createSharedReference(Infinity);
+const throttleBitrateDefaultRef = new SharedReference(Infinity);
 throttleBitrateDefaultRef.finish();
 
 /**
@@ -105,14 +103,10 @@ export default function createAdaptiveRepresentationSelector(
   ) : IRepresentationEstimatorResponse {
     const { type } = context.adaptation;
     const bandwidthEstimator = _getBandwidthEstimator(type);
-    const initialBitrate = takeFirstSet<number>(initialBitrates[type], 0);
+    const initialBitrate = initialBitrates[type] ?? 0;
     const filters = {
-      limitResolution: takeFirstSet<
-        IReadOnlySharedReference<IResolutionInfo | undefined>
-      >(throttlers.limitResolution[type], limitWidthDefaultRef),
-      throttleBitrate: takeFirstSet<IReadOnlySharedReference<number>>(
-        throttlers.throttleBitrate[type],
-        throttleBitrateDefaultRef),
+      limitResolution: throttlers.limitResolution[type] ?? limitWidthDefaultRef,
+      throttleBitrate: throttlers.throttleBitrate[type] ?? throttleBitrateDefaultRef,
     };
     return getEstimateReference({ bandwidthEstimator,
                                   context,
@@ -176,7 +170,12 @@ function getEstimateReference(
   const networkAnalyzer = new NetworkAnalyzer(initialBitrate ?? 0, lowLatencyMode);
   const requestsStore = new PendingRequestsStore();
 
+  /**
+   * Callback called each time a new segment is pushed, with the information on the
+   * new pushed segment.
+   */
   let onAddedSegment : (val : IAddedSegmentCallbackPayload) => void = noop;
+
   const callbacks : IRepresentationEstimatorCallbacks = {
     metrics: onMetric,
     requestBegin: onRequestBegin,
@@ -193,43 +192,55 @@ function getEstimateReference(
   let currentEstimatesCanceller = new TaskCanceller();
   currentEstimatesCanceller.linkToSignal(stopAllEstimates);
 
-  // Create `ISharedReference` on which estimates will be emitted.
+  // Create `SharedReference` on which estimates will be emitted.
   const estimateRef = createEstimateReference(representationsRef.getValue(),
                                               currentEstimatesCanceller.signal);
-
   representationsRef.onUpdate(restartEstimatesProductionFromCurrentConditions,
                               { clearSignal: stopAllEstimates });
 
   return { estimates: estimateRef, callbacks };
 
+  /**
+   * Emit the ABR estimates on various events through the returned
+   * `SharedReference`.
+   * @param {Array.<Object>} unsortedRepresentations - All `Representation` that
+   * the ABR logic can choose from.
+   * @param {Object} innerCancellationSignal - When this `CancellationSignal`
+   * emits, all events registered to to emit new estimates will be unregistered.
+   * Note that the returned reference may still be used to produce new estimates
+   * in the future if you want to even after this signal emits.
+   * @returns {Object} - `SharedReference` through which ABR estimates will be
+   * produced.
+   */
   function createEstimateReference(
-    representations : Representation[],
+    unsortedRepresentations : Representation[],
     innerCancellationSignal : CancellationSignal
-  ) : ISharedReference<IABREstimate> {
-    if (representations.length === 1) {
+  ) : SharedReference<IABREstimate> {
+    if (unsortedRepresentations.length <= 1) {
       // There's only a single Representation. Just choose it.
-      return createSharedReference({ bitrate: undefined,
-                                     representation: representations[0],
-                                     urgent: true,
-                                     knownStableBitrate: undefined });
+      return new SharedReference<IABREstimate>({
+        bitrate: undefined,
+        representation: unsortedRepresentations[0],
+        urgent: true,
+        knownStableBitrate: undefined,
+      });
     }
 
     /** If true, Representation estimates based on the buffer health might be used. */
     let allowBufferBasedEstimates = false;
 
-    /**
-     * Current optimal Representation's bandwidth choosen by a buffer-based
-     * adaptive algorithm.
-     */
-    let currentBufferBasedEstimate : number | undefined;
-    const bitrates = representations.map(r => r.bitrate);
+    /** Ensure `Representation` objects are sorted by bitrates and only rely on this. */
+    const sortedRepresentations = unsortedRepresentations
+      .sort((ra, rb) => ra.bitrate - rb.bitrate);
 
     /**
      * Module calculating the optimal Representation based on the current
      * buffer's health (i.e. whether enough data is buffered, history of
      * buffer size etc.).
      */
-    const bufferBasedChooser = new BufferBasedChooser(bitrates);
+    const bufferBasedChooser = new BufferBasedChooser(
+      sortedRepresentations.map(r => r.bitrate)
+    );
 
     /** Store the previous estimate made here. */
     const prevEstimate = new LastEstimateStorage();
@@ -245,7 +256,7 @@ function getEstimateReference(
     let lastPlaybackObservation = playbackObserver.getReference().getValue();
 
     /** Reference through which estimates are emitted. */
-    const innerEstimateRef = createSharedReference<IABREstimate>(getCurrentEstimate());
+    const innerEstimateRef = new SharedReference<IABREstimate>(getCurrentEstimate());
 
     // Listen to playback observations
     playbackObserver.listen((obs) => {
@@ -259,12 +270,12 @@ function getEstimateReference(
       }
       const { position, speed } = lastPlaybackObservation;
       const timeRanges = val.buffered;
-      const bufferGap = getLeftSizeOfRange(timeRanges, position.last);
+      const bufferGap = getLeftSizeOfBufferedTimeRange(timeRanges, position.last);
       const { representation } = val.content;
       const currentScore = scoreCalculator.getEstimate(representation);
       const currentBitrate = representation.bitrate;
       const observation = { bufferGap, currentBitrate, currentScore, speed };
-      currentBufferBasedEstimate = bufferBasedChooser.getEstimate(observation);
+      bufferBasedChooser.onAddedSegment(observation);
       updateEstimate();
     };
     innerCancellationSignal.register(() => {
@@ -283,13 +294,13 @@ function getEstimateReference(
     }
 
     /** Returns the actual estimate based on all methods and algorithm available. */
-    function getCurrentEstimate() {
+    function getCurrentEstimate(): IABREstimate {
       const { bufferGap, position, maximumPosition } = lastPlaybackObservation;
       const resolutionLimit = filters.limitResolution.getValue();
       const bitrateThrottle = filters.throttleBitrate.getValue();
       const currentRepresentationVal = currentRepresentation.getValue();
 
-      const filteredReps = getFilteredRepresentations(representations,
+      const filteredReps = getFilteredRepresentations(sortedRepresentations,
                                                       resolutionLimit,
                                                       bitrateThrottle);
       const requests = requestsStore.getRequests();
@@ -328,6 +339,12 @@ function getEstimateReference(
       const chosenRepFromBandwidth = selectOptimalRepresentation(filteredReps,
                                                                  bitrateChosen);
 
+      /**
+       * Current optimal Representation's bandwidth choosen by a buffer-based
+       * adaptive algorithm.
+       */
+      const currentBufferBasedEstimate = bufferBasedChooser.getLastEstimate();
+
       let currentBestBitrate = chosenRepFromBandwidth.bitrate;
 
       /**
@@ -373,7 +390,7 @@ function getEstimateReference(
           maximumPosition - position.last < 40)
       {
         chosenRepFromGuessMode = guessBasedChooser
-          .getGuess(representations,
+          .getGuess(sortedRepresentations,
                     lastPlaybackObservation,
                     currentRepresentationVal,
                     currentBestBitrate,

package/src/core/adaptive/buffer_based_chooser.ts

@@ -16,6 +16,7 @@
 
 import log from "../../log";
 import arrayFindIndex from "../../utils/array_find_index";
+import getMonotonicTimeStamp from "../../utils/monotonic_timestamp";
 import getBufferLevels from "./utils/get_buffer_levels";
 import {
   IRepresentationMaintainabilityScore,
@@ -86,8 +87,16 @@ export default class BufferBasedChooser {
   private _bitrates : number[];
 
   /**
-   * Laast timestamp, in terms of `performance.now`, at which the current
-   * quality was seen as too high by this algorithm.
+   * Current last best Representation's bitrate estimate made by the
+   * `BufferBasedChooser` or `undefined` if it has no such guess for now.
+   *
+   * Might be updated each time `onAddedSegment` is called.
+   */
+  private _currentEstimate: number | undefined;
+
+  /**
+   * Last monotonically-raising timestamp (as defined by the RxPlayer), at which
+   * the current quality was seen as too high by this algorithm.
    * Begins at `undefined`.
    */
   private _lastUnsuitableQualityTimestamp: number | undefined;
@@ -121,14 +130,15 @@ export default class BufferBasedChooser {
    * @param {Object} playbackObservation
    * @returns {number|undefined}
    */
-  public getEstimate(
+  public onAddedSegment(
     playbackObservation : IBufferBasedChooserPlaybackObservation
-  ) : number | undefined {
+  ) : void {
     const bufferLevels = this._levelsMap;
     const bitrates = this._bitrates;
     const { bufferGap, currentBitrate, currentScore, speed } = playbackObservation;
     if (currentBitrate == null) {
-      return bitrates[0];
+      this._currentEstimate = bitrates[0];
+      return ;
     }
 
     let currentBitrateIndex = -1;
@@ -143,8 +153,9 @@ export default class BufferBasedChooser {
     }
 
     if (currentBitrateIndex < 0 || bitrates.length !== bufferLevels.length) {
-      log.error("ABR: Current Bitrate not found in the calculated levels");
-      return bitrates[0];
+      log.info("ABR: Current Bitrate not found in the calculated levels");
+      this._currentEstimate = bitrates[0];
+      return ;
     }
 
     let scaledScore : number|undefined;
@@ -156,7 +167,7 @@ export default class BufferBasedChooser {
       bufferGap :
       0;
 
-    const now = performance.now();
+    const now = getMonotonicTimeStamp();
 
     if (
       actualBufferGap < bufferLevels[currentBitrateIndex] ||
@@ -184,10 +195,12 @@ export default class BufferBasedChooser {
       const baseIndex = arrayFindIndex(bitrates, (b) => b === currentBitrate);
       for (let i = baseIndex - 1; i >= 0; i--) {
         if (actualBufferGap >= bufferLevels[i]) {
-          return bitrates[i];
+          this._currentEstimate =  bitrates[i];
+          return;
         }
       }
-      return bitrates[0];
+      this._currentEstimate = bitrates[0];
+      return ;
     }
 
     if (
@@ -198,7 +211,8 @@ export default class BufferBasedChooser {
       scaledScore === undefined || scaledScore < 1.15 ||
       currentScore?.confidenceLevel !== ScoreConfidenceLevel.HIGH
     ) {
-      return currentBitrate;
+      this._currentEstimate = currentBitrate;
+      return ;
     }
 
     const currentBufferLevel = bufferLevels[currentBitrateIndex];
@@ -213,10 +227,24 @@ export default class BufferBasedChooser {
       const nextBufferLevel = bufferLevels[nextIndex];
       if (bufferGap >= nextBufferLevel) {
         log.debug("ABR: Raising quality in BufferBasedChooser", bitrates[nextIndex]);
-        return bitrates[nextIndex];
+        this._currentEstimate = bitrates[nextIndex];
+        return ;
       }
     }
-    return currentBitrate;
+    this._currentEstimate = currentBitrate;
+    return ;
+  }
+
+  /**
+   * Returns the last best Representation's bitrate estimate made by the
+   * `BufferBasedChooser` or `undefined` if it has no such guess for now.
+   *
+   * Might be updated after `onAddedSegment` is called.
+   *
+   * @returns {number|undefined}
+   */
+  public getLastEstimate(): number | undefined {
+    return this._currentEstimate;
   }
 }
 

package/src/core/adaptive/guess_based_chooser.ts

@@ -17,6 +17,7 @@
 import log from "../../log";
 import { Representation } from "../../manifest";
 import arrayFindIndex from "../../utils/array_find_index";
+import getMonotonicTimeStamp from "../../utils/monotonic_timestamp";
 import { estimateRequestBandwidth } from "./network_analyzer";
 import LastEstimateStorage, {
   ABRAlgorithmType,
@@ -151,7 +152,7 @@ export default class GuessBasedChooser {
     if (shouldStopGuess) {
       // Block guesses for a time
       this._consecutiveWrongGuesses++;
-      this._blockGuessesUntil = performance.now() +
+      this._blockGuessesUntil = getMonotonicTimeStamp() +
         Math.min(this._consecutiveWrongGuesses * 15000, 120000);
       return getPreviousRepresentation(representations, currentRepresentation);
     } else if (scoreData === undefined) {
@@ -182,7 +183,7 @@ export default class GuessBasedChooser {
     { score, confidenceLevel } : IRepresentationMaintainabilityScore
   ) : boolean {
     return isFinite(bufferGap) && bufferGap >= 2.5 &&
-           performance.now() > this._blockGuessesUntil &&
+           getMonotonicTimeStamp() > this._blockGuessesUntil &&
            confidenceLevel === ScoreConfidenceLevel.HIGH &&
            score / speed > 1.01;
   }
@@ -212,7 +213,7 @@ export default class GuessBasedChooser {
       return req.content.representation.id === lastGuess.id;
     });
 
-    const now = performance.now();
+    const now = getMonotonicTimeStamp();
     for (const req of guessedRepresentationRequests) {
       const requestElapsedTime = now - req.requestTimestamp;
       if (req.content.segment.isInit) {

package/src/core/adaptive/network_analyzer.ts

@@ -18,6 +18,8 @@ import config from "../../config";
 import log from "../../log";
 import { Representation } from "../../manifest";
 import arrayFind from "../../utils/array_find";
+import isNullOrUndefined from "../../utils/is_null_or_undefined";
+import getMonotonicTimeStamp from "../../utils/monotonic_timestamp";
 import {
   IRepresentationEstimatorPlaybackObservation,
 } from "./adaptive_representation_selector";
@@ -161,7 +163,7 @@ function estimateStarvationModeBitrate(
   }
 
   const concernedRequest = concernedRequests[0];
-  const now = performance.now();
+  const now = getMonotonicTimeStamp();
 
   let minimumRequestTime = concernedRequest.content.segment.duration * 1.5;
   minimumRequestTime = Math.min(minimumRequestTime, 3000);
@@ -245,7 +247,7 @@ function shouldDirectlySwitchToLowBitrate(
     return true;
   }
 
-  const now = performance.now();
+  const now = getMonotonicTimeStamp();
   const lastProgressEvent = nextRequest.progress.length > 0 ?
     nextRequest.progress[nextRequest.progress.length - 1] :
     undefined;
@@ -358,10 +360,10 @@ export default class NetworkAnalyzer {
                                                         this._lowLatencyMode,
                                                         lastEstimatedBitrate);
 
-      if (bandwidthEstimate != null) {
+      if (bandwidthEstimate !== undefined) {
         log.info("ABR: starvation mode emergency estimate:", bandwidthEstimate);
         bandwidthEstimator.reset();
-        newBitrateCeil = currentRepresentation == null ?
+        newBitrateCeil = isNullOrUndefined(currentRepresentation) ?
           bandwidthEstimate :
           Math.min(bandwidthEstimate, currentRepresentation.bitrate);
       }
@@ -371,11 +373,11 @@ export default class NetworkAnalyzer {
     if (newBitrateCeil == null) {
       bandwidthEstimate = bandwidthEstimator.getEstimate();
 
-      if (bandwidthEstimate != null) {
+      if (bandwidthEstimate !== undefined) {
         newBitrateCeil = bandwidthEstimate *
           (this._inStarvationMode ? localConf.starvationBitrateFactor :
                                     localConf.regularBitrateFactor);
-      } else if (lastEstimatedBitrate != null) {
+      } else if (lastEstimatedBitrate !== undefined) {
         newBitrateCeil = lastEstimatedBitrate *
           (this._inStarvationMode ? localConf.starvationBitrateFactor :
                                     localConf.regularBitrateFactor);

package/src/core/adaptive/utils/pending_requests_store.ts

@@ -54,7 +54,7 @@ export default class PendingRequestsStore {
   public addProgress(progress : IPendingRequestStoreProgress) : void {
     const request = this._currentRequests[progress.id];
     if (request == null) {
-      if (__ENVIRONMENT__.CURRENT_ENV === __ENVIRONMENT__.DEV as number) {
+      if (__ENVIRONMENT__.CURRENT_ENV as number === __ENVIRONMENT__.DEV as number) {
         throw new Error("ABR: progress for a request not added");
       }
       log.warn("ABR: progress for a request not added");
@@ -69,7 +69,7 @@ export default class PendingRequestsStore {
    */
   public remove(id : string) : void {
     if (this._currentRequests[id] == null) {
-      if (__ENVIRONMENT__.CURRENT_ENV === __ENVIRONMENT__.DEV as number) {
+      if (__ENVIRONMENT__.CURRENT_ENV as number === __ENVIRONMENT__.DEV as number) {
         throw new Error("ABR: can't remove unknown request");
       }
       log.warn("ABR: can't remove unknown request");
@@ -103,7 +103,11 @@ export interface IPendingRequestStoreProgress {
   id: string;
   /** Current downloaded size, in bytes. */
   size : number;
-  /** Value of `performance.now` at the time this progression report was available. */
+  /**
+  /**
+   * Monotonically-raising timestamp (common to the RxPlayer) corresponding to
+   * the time at which this progress report was processed.
+   */
   timestamp : number;
   /**
    * Total size of the segment to download (including already-loaded data),
@@ -121,7 +125,10 @@ export interface IPendingRequestStoreBegin {
    * should have this `id` at the same time.
    */
   id: string;
-  /** Value of `performance.now` at the time the request began.  */
+  /**
+   * Value of the monotonically-raising timestamp used by the RxPlayer at the
+   * time the request began.
+   */
   requestTimestamp: number;
   /** Context associated to the segment. */
   content: IRequestInfoContent;
@@ -131,7 +138,10 @@ export interface IPendingRequestStoreBegin {
 export interface IRequestInfo {
   /** Information on the current progress made by this request. */
   progress: IPendingRequestStoreProgress[];
-  /** `Performance.now()` corresponding to the time at which the request began. */
+  /**
+   * Value of the monotonically-raising timestamp used by the RxPlayer at the
+   * time the request began.
+   */
   requestTimestamp: number;
   /** Context associated to the segment. */
   content: IRequestInfoContent;

package/src/core/api/debug/buffer_size_graph.ts

@@ -1,3 +1,5 @@
+import getMonotonicTimeStamp from "../../../utils/monotonic_timestamp";
+
 /**
  * Maximum history of the buffer size that will be displayed, in milliseconds.
  * For example, a value of `3000` indicates that we will just show at most the
@@ -30,7 +32,7 @@ export default class BufferSizeGraph {
   }
 
   public pushBufferSize(bufferSize : number) : void {
-    const now = performance.now();
+    const now = getMonotonicTimeStamp();
     this._history.push({ timestamp: now, bufferSize });
     if (this._history.length > 0) {
       const minimumTime = now - TIME_SAMPLES_MS;

package/src/core/api/option_utils.ts

@@ -78,11 +78,11 @@ interface IParsedLoadVideoOptionsBase {
   onCodecSwitch : "continue"|"reload";
   checkMediaSegmentIntegrity? : boolean | undefined;
   manifestLoader?: IManifestLoader | undefined;
-  manifestUpdateUrl? : string | undefined;
   referenceDateTime? : number | undefined;
   representationFilter? : IRepresentationFilter | undefined;
   segmentLoader? : ISegmentLoader | undefined;
   serverSyncInfos? : IServerSyncInfos | undefined;
+  __priv_manifestUpdateUrl? : string | undefined;
   __priv_patchLastSegmentInSidx? : boolean | undefined;
 }
 
@@ -397,6 +397,7 @@ function parseLoadVideoOptions(
   /* eslint-disable @typescript-eslint/no-unsafe-assignment */
   /* eslint-disable @typescript-eslint/no-unsafe-member-access */
   return { __priv_patchLastSegmentInSidx: (options as any).__priv_patchLastSegmentInSidx,
+           __priv_manifestUpdateUrl: (options as any).__priv_manifestUpdateUrl,
   /* eslint-enable @typescript-eslint/no-explicit-any */
   /* eslint-enable @typescript-eslint/no-unsafe-assignment */
   /* eslint-enable @typescript-eslint/no-unsafe-member-access */
@@ -408,7 +409,6 @@ function parseLoadVideoOptions(
            keySystems,
            lowLatencyMode,
            manifestLoader: options.manifestLoader,
-           manifestUpdateUrl: options.manifestUpdateUrl,
            minimumManifestUpdateInterval,
            requestConfig,
            onCodecSwitch,

package/src/core/api/playback_observer.ts

@@ -16,10 +16,11 @@
 
 import config from "../../config";
 import log from "../../log";
+import getMonotonicTimeStamp from "../../utils/monotonic_timestamp";
 import noop from "../../utils/noop";
 import objectAssign from "../../utils/object_assign";
-import { getRange } from "../../utils/ranges";
-import createSharedReference, {
+import { getBufferedTimeRange } from "../../utils/ranges";
+import SharedReference, {
   IReadOnlySharedReference,
 } from "../../utils/reference";
 import TaskCanceller, {
@@ -315,8 +316,8 @@ export default class PlaybackObserver {
       return timings;
     };
 
-    const returnedSharedReference = createSharedReference(getCurrentObservation("init"),
-                                                          this._canceller.signal);
+    const returnedSharedReference = new SharedReference(getCurrentObservation("init"),
+                                                        this._canceller.signal);
 
     const generateObservationForEvent = (event : IPlaybackObserverEventType) => {
       const newObservation = getCurrentObservation(event);
@@ -455,7 +456,10 @@ export interface IRebufferingStatus {
   reason : "seeking" | // Building buffer after seeking
            "not-ready" | // Building buffer after low readyState
            "buffering"; // Other cases
-  /** `performance.now` at the time the rebuffering happened. */
+  /**
+   * Monotonically-raising timestamp at the time the rebuffering happened on the
+   * main thread.
+   */
   timestamp : number;
   /**
    * Position, in seconds, at which data is awaited.
@@ -471,7 +475,10 @@ export interface IRebufferingStatus {
  * an unknown reason.
  */
 export interface IFreezingStatus {
-  /** `performance.now` at the time the freezing started to be detected. */
+  /**
+   * Monotonically-raising timestamp at the time the freezing started to be
+   * detected.
+   */
   timestamp : number;
 }
 
@@ -660,7 +667,7 @@ function getMediaInfos(
     currentRange = undefined;
     bufferGap = undefined;
   } else {
-    currentRange = getRange(buffered, currentTime);
+    currentRange = getBufferedTimeRange(buffered, currentTime);
     bufferGap = currentRange !== null ? currentRange.end - currentTime :
                                         // TODO null/0 would probably be
                                         // more appropriate
@@ -819,7 +826,7 @@ function getRebufferingStatus(
                position: rebufferEndPosition };
     }
     return { reason,
-             timestamp: performance.now(),
+             timestamp: getMonotonicTimeStamp(),
              position: rebufferEndPosition };
   }
   return null;
@@ -860,7 +867,7 @@ function getFreezingStatus(
          currentInfo.readyState >= 1 &&
          currentInfo.playbackRate !== 0 &&
          currentInfo.position === prevObservation.position ?
-           { timestamp: performance.now() } :
+           { timestamp: getMonotonicTimeStamp() } :
            null;
 }