rx-player 3.25.2 → 3.26.3-dev.2022021400

package/src/core/abr/network_analyzer.ts

@@ -18,13 +18,12 @@ import config from "../../config";
 import log from "../../log";
 import { Representation } from "../../manifest";
 import arrayFind from "../../utils/array_find";
-import arrayFindIndex from "../../utils/array_find_index";
 import BandwidthEstimator from "./bandwidth_estimator";
-import EWMA from "./ewma";
 import {
-  IProgressEventValue,
+  IPendingRequestStoreProgress,
   IRequestInfo,
 } from "./pending_requests_store";
+import EWMA from "./utils/ewma";
 
 const { ABR_REGULAR_FACTOR,
         ABR_STARVATION_DURATION_DELTA,
@@ -52,7 +51,8 @@ interface IPlaybackConditionsInfo {
 
 /**
  * Get pending segment request(s) starting with the asked segment position.
- * @param {Object} requests
+ * @param {Object} requests - Every requests pending, in a chronological
+ * order in terms of segment time.
  * @param {number} position
  * @returns {Array.<Object>}
  */
@@ -61,26 +61,36 @@ function getConcernedRequests(
   neededPosition : number
 ) : IRequestInfo[] {
   /** Index of the request for the next needed segment, in `requests`. */
-  const nextSegmentIndex = arrayFindIndex(requests, (request) => {
-    if (request.duration <= 0) {
-      return false;
+  let nextSegmentIndex = -1;
+  for (let i = 0; i < requests.length; i++) {
+    const { segment } = requests[i].content;
+    if (segment.duration <= 0) {
+      continue;
+    }
+    const segmentEnd = segment.time + segment.duration;
+    if (!segment.complete) {
+      if (i === requests.length - 1 && neededPosition - segment.time > -1.2) {
+        nextSegmentIndex = i;
+        break;
+      }
     }
-    const segmentEnd = request.time + request.duration;
-    return segmentEnd > neededPosition &&
-           neededPosition - request.time > -1.2;
-  });
+    if (segmentEnd > neededPosition && neededPosition - segment.time > -1.2) {
+      nextSegmentIndex = i;
+      break;
+    }
+  }
 
   if (nextSegmentIndex < 0) { // Not found
     return [];
   }
 
   const nextRequest = requests[nextSegmentIndex];
-  const segmentTime = nextRequest.time;
+  const segmentTime = nextRequest.content.segment.time;
   const filteredRequests = [nextRequest];
 
   // Get the possibly multiple requests for that segment's position
   for (let i = nextSegmentIndex + 1; i < requests.length; i++) {
-    if (requests[i].time === segmentTime) {
+    if (requests[i].content.segment.time === segmentTime) {
       filteredRequests.push(requests[i]);
     } else {
       break;
@@ -96,7 +106,7 @@ function getConcernedRequests(
  * @param {Object} request
  * @returns {number|undefined}
  */
-function estimateRequestBandwidth(request : IRequestInfo) : number|undefined {
+export function estimateRequestBandwidth(request : IRequestInfo) : number|undefined {
   if (request.progress.length < 5) { // threshold from which we can consider
                                      // progress events reliably
     return undefined;
@@ -122,7 +132,7 @@ function estimateRequestBandwidth(request : IRequestInfo) : number|undefined {
  * @returns {number}
  */
 function estimateRemainingTime(
-  lastProgressEvent: IProgressEventValue,
+  lastProgressEvent: IPendingRequestStoreProgress,
   bandwidthEstimate : number
 ) : number {
   const remainingData = (lastProgressEvent.totalSize - lastProgressEvent.size) * 8;
@@ -133,10 +143,14 @@ function estimateRemainingTime(
  * Check if the request for the most needed segment is too slow.
  * If that's the case, re-calculate the bandwidth urgently based on
  * this single request.
- * @param {Object} pendingRequests - Current pending requests.
+ * @param {Object} pendingRequests - Every requests pending, in a chronological
+ * order in terms of segment time.
  * @param {Object} playbackInfo - Information on the current playback.
  * @param {Object|null} currentRepresentation - The Representation being
  * presently being loaded.
+ * @param {boolean} lowLatencyMode - If `true`, we're playing the content as a
+ * low latency content - where requests might be pending when the segment is
+ * still encoded.
  * @param {Number} lastEstimatedBitrate - Last bitrate estimate emitted.
  * @returns {Number|undefined}
  */
@@ -144,8 +158,13 @@ function estimateStarvationModeBitrate(
   pendingRequests : IRequestInfo[],
   playbackInfo : IPlaybackConditionsInfo,
   currentRepresentation : Representation | null,
+  lowLatencyMode : boolean,
   lastEstimatedBitrate : number|undefined
 ) : number|undefined {
+  if (lowLatencyMode) {
+    // TODO Skip only for newer segments?
+    return undefined;
+  }
   const { bufferGap, speed, position } = playbackInfo;
   const realBufferGap = isFinite(bufferGap) ? bufferGap :
                                               0;
@@ -158,7 +177,6 @@ function estimateStarvationModeBitrate(
   }
 
   const concernedRequest = concernedRequests[0];
-  const chunkDuration = concernedRequest.duration;
   const now = performance.now();
   const lastProgressEvent = concernedRequest.progress.length > 0 ?
     concernedRequest.progress[concernedRequest.progress.length - 1] :
@@ -182,6 +200,11 @@ function estimateStarvationModeBitrate(
     }
   }
 
+  if (!concernedRequest.content.segment.complete) {
+    return undefined;
+  }
+
+  const chunkDuration = concernedRequest.content.segment.duration;
   const requestElapsedTime = (now - concernedRequest.requestTimestamp) / 1000;
   const reasonableElapsedTime = requestElapsedTime <=
     ((chunkDuration * 1.5 + 2) / speed);
@@ -204,22 +227,28 @@ function estimateStarvationModeBitrate(
  * switch immediately if a lower bitrate is more adapted.
  * Returns false if it estimates that you have time before switching to a lower
  * bitrate.
- * @param {Object} playbackInfo
+ * @param {Object} playbackInfo - Information on the current playback.
  * @param {Object} requests - Every requests pending, in a chronological
  * order in terms of segment time.
- * @param {number} abrStarvationGap - "Buffer gap" from which we enter a
- * "starvation mode".
+ * @param {boolean} lowLatencyMode - If `true`, we're playing the content as a
+ * low latency content, as close to the live edge as possible.
  * @returns {boolean}
  */
 function shouldDirectlySwitchToLowBitrate(
   playbackInfo : IPlaybackConditionsInfo,
-  requests : IRequestInfo[]
+  requests : IRequestInfo[],
+  lowLatencyMode : boolean
 ) : boolean {
+  if (lowLatencyMode) {
+    // TODO only when playing close to the live edge?
+    return true;
+  }
   const realBufferGap = isFinite(playbackInfo.bufferGap) ? playbackInfo.bufferGap :
                                                            0;
   const nextNeededPosition = playbackInfo.position + realBufferGap;
-  const nextRequest = arrayFind(requests, (r) =>
-    r.duration > 0 && (r.time + r.duration) > nextNeededPosition);
+  const nextRequest = arrayFind(requests, ({ content }) =>
+    content.segment.duration > 0 &&
+    (content.segment.time + content.segment.duration) > nextNeededPosition);
 
   if (nextRequest === undefined) {
     return true;
@@ -251,6 +280,7 @@ function shouldDirectlySwitchToLowBitrate(
  * @class NetworkAnalyzer
  */
 export default class NetworkAnalyzer {
+  private _lowLatencyMode : boolean;
   private _inStarvationMode : boolean;
   private _initialBitrate : number;
   private _config : { starvationGap : number;
@@ -261,6 +291,7 @@ export default class NetworkAnalyzer {
   constructor(initialBitrate: number, lowLatencyMode: boolean) {
     this._initialBitrate = initialBitrate;
     this._inStarvationMode = false;
+    this._lowLatencyMode = lowLatencyMode;
     if (lowLatencyMode) {
       this._config = { starvationGap: ABR_STARVATION_GAP.LOW_LATENCY,
                        outOfStarvationGap: OUT_OF_STARVATION_GAP.LOW_LATENCY,
@@ -278,11 +309,16 @@ export default class NetworkAnalyzer {
    * Gives an estimate of the current bandwidth and of the bitrate that should
    * be considered for chosing a `representation`.
    * This estimate is only based on network metrics.
-   * @param {Object} playbackInfo - Gives current information about playback
-   * @param {Object} bandwidthEstimator
-   * @param {Object|null} currentRepresentation
-   * @param {Array.<Object>} currentRequests
-   * @param {number|undefined} lastEstimatedBitrate
+   * @param {Object} playbackInfo - Gives current information about playback.
+   * @param {Object} bandwidthEstimator - `BandwidthEstimator` allowing to
+   * produce network bandwidth estimates.
+   * @param {Object|null} currentRepresentation - The Representation currently
+   * chosen.
+   * `null` if no Representation has been chosen yet.
+   * @param {Array.<Object>} currentRequests - All segment requests by segment's
+   * start chronological order
+   * @param {number|undefined} lastEstimatedBitrate - Bitrate emitted during the
+   * last estimate.
    * @returns {Object}
    */
   public getBandwidthEstimate(
@@ -291,7 +327,7 @@ export default class NetworkAnalyzer {
     currentRepresentation : Representation | null,
     currentRequests : IRequestInfo[],
     lastEstimatedBitrate: number|undefined
-  ) : { bandwidthEstimate? : number; bitrateChosen : number } {
+  ) : { bandwidthEstimate? : number | undefined; bitrateChosen : number } {
     let newBitrateCeil : number | undefined; // bitrate ceil for the chosen Representation
     let bandwidthEstimate;
     const localConf = this._config;
@@ -324,6 +360,7 @@ export default class NetworkAnalyzer {
       bandwidthEstimate = estimateStarvationModeBitrate(currentRequests,
                                                         playbackInfo,
                                                         currentRepresentation,
+                                                        this._lowLatencyMode,
                                                         lastEstimatedBitrate);
 
       if (bandwidthEstimate != null) {
@@ -361,8 +398,12 @@ export default class NetworkAnalyzer {
 
   /**
    * For a given wanted bitrate, tells if should switch urgently.
-   * @param {number} bitrate
-   * @param {Object} playbackInfo
+   * @param {number} bitrate - The new estimated bitrate.
+   * @param {Object|null} currentRepresentation - The Representation being
+   * presently being loaded.
+   * @param {Array.<Object>} currentRequests - All segment requests by segment's
+   * start chronological order
+   * @param {Object} playbackInfo - Information on the current playback.
    * @returns {boolean}
    */
   public isUrgent(
@@ -378,6 +419,8 @@ export default class NetworkAnalyzer {
     } else if (bitrate > currentRepresentation.bitrate) {
       return !this._inStarvationMode;
     }
-    return shouldDirectlySwitchToLowBitrate(playbackInfo, currentRequests);
+    return shouldDirectlySwitchToLowBitrate(playbackInfo,
+                                            currentRequests,
+                                            this._lowLatencyMode);
   }
 }

package/src/core/abr/pending_requests_store.ts

@@ -15,38 +15,14 @@
  */
 
 import log from "../../log";
+import Manifest, {
+  Adaptation,
+  ISegment,
+  Period,
+  Representation,
+} from "../../manifest";
 import objectValues from "../../utils/object_values";
 
-export interface IProgressEventValue {
-  duration : number; // current duration for the request, in ms
-  id: string|number; // unique ID for the request
-  size : number; // current downloaded size, in bytes
-  timestamp : number; // timestamp of the progress event since unix epoch, in ms
-  totalSize : number; // total size to download, in bytes
-}
-
-export interface IBeginRequestValue {
-  id: string|number;
-  time: number;
-  duration: number;
-  requestTimestamp: number;
-}
-
-export interface IRequestInfo {
-  duration : number; // duration of the corresponding chunk, in seconds
-  progress: IProgressEventValue[]; // progress events for this request
-  requestTimestamp: number; // unix timestamp at which the request began, in ms
-  time: number; // time at which the corresponding segment begins, in seconds
-}
-
-export interface IProgressEventValue {
-  duration : number; // current duration for the request, in ms
-  id: string|number; // unique ID for the request
-  size : number; // current downloaded size, in bytes
-  timestamp : number; // timestamp of the progress event since unix epoch, in ms
-  totalSize : number; // total size to download, in bytes
-}
-
 /**
  * Store information about pending requests, like information about:
  *   - for which segments they are
@@ -65,22 +41,21 @@ export default class PendingRequestsStore {
    * @param {string} id
    * @param {Object} payload
    */
-  public add(payload : IBeginRequestValue) : void {
-    const { id, time, duration, requestTimestamp } = payload;
-    this._currentRequests[id] = { time,
-                                  duration,
-                                  requestTimestamp,
-                                  progress: [] };
+  public add(payload : IPendingRequestStoreBegin) : void {
+    const { id, requestTimestamp, content } = payload;
+    this._currentRequests[id] = { requestTimestamp,
+                                  progress: [],
+                                  content };
   }
 
   /**
    * Notify of the progress of a currently pending request.
    * @param {Object} progress
    */
-  public addProgress(progress : IProgressEventValue) : void {
+  public addProgress(progress : IPendingRequestStoreProgress) : void {
     const request = this._currentRequests[progress.id];
     if (request == null) {
-      if (__DEV__) {
+      if (__ENVIRONMENT__.CURRENT_ENV === __ENVIRONMENT__.DEV as number) {
         throw new Error("ABR: progress for a request not added");
       }
       log.warn("ABR: progress for a request not added");
@@ -95,7 +70,7 @@ export default class PendingRequestsStore {
    */
   public remove(id : string) : void {
     if (this._currentRequests[id] == null) {
-      if (__DEV__) {
+      if (__ENVIRONMENT__.CURRENT_ENV === __ENVIRONMENT__.DEV as number) {
         throw new Error("ABR: can't remove unknown request");
       }
       log.warn("ABR: can't remove unknown request");
@@ -111,6 +86,63 @@ export default class PendingRequestsStore {
   public getRequests() : IRequestInfo[] {
     return objectValues(this._currentRequests)
       .filter((x) : x is IRequestInfo => x != null)
-      .sort((reqA, reqB) => reqA.time - reqB.time);
+      .sort((reqA, reqB) => reqA.content.segment.time - reqB.content.segment.time);
   }
 }
+
+/**
+ * Payload needed to add progress information for a request to the
+ * PendingRequestsStore.
+ */
+export interface IPendingRequestStoreProgress {
+  /** Amount of time since the request has started, in seconds. */
+  duration : number;
+  /**
+   * Same `id` value used to identify that request at the time the corresponding
+   * `IABRRequestBeginEventValue` was sent.
+   */
+  id: string;
+  /** Current downloaded size, in bytes. */
+  size : number;
+  /** Value of `performance.now` at the time this progression report was available. */
+  timestamp : number;
+  /**
+   * Total size of the segment to download (including already-loaded data),
+   * in bytes.
+   */
+  totalSize : number;
+}
+
+/** Payload needed to add a request to the PendingRequestsStore. */
+export interface IPendingRequestStoreBegin {
+  /**
+   * String identifying this request.
+   *
+   * Only one request communicated to the current `RepresentationEstimator`
+   * should have this `id` at the same time.
+   */
+  id: string;
+  /** Value of `performance.now` at the time the request began.  */
+  requestTimestamp: number;
+  /** Context associated to the segment. */
+  content: IRequestInfoContent;
+}
+
+/** Information linked to a segment request, stored in the PendingRequestsStore. */
+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. */
+  requestTimestamp: number;
+  /** Context associated to the segment. */
+  content: IRequestInfoContent;
+}
+
+/** Content linked to a segment request. */
+export interface IRequestInfoContent {
+  manifest : Manifest;
+  period : Period;
+  adaptation : Adaptation;
+  representation : Representation;
+  segment : ISegment;
+}