rx-player 3.27.0-dev.2022032100 → 3.27.0

package/src/core/stream/representation/get_needed_segments.ts

@@ -84,7 +84,17 @@ export interface IGetNeededSegmentsArguments {
 
 
 interface INeededSegments {
-  neededSegments: ISegment[];
+  /** Segments that should be loaded right now, by chronological order. */
+  segmentsToLoad: ISegment[];
+  /**
+   * Segments that should be loaded, but not right now, due to some other
+   * constraints, such as memory limitations.
+   */
+  segmentsOnHold : ISegment[];
+  /**
+   * If `true` the buffer is currently full according to the given limits.
+   * Memory should be freed if possible, for example by cleaning the buffers.
+   */
   isBufferFull: boolean;
 }
 /**
@@ -112,8 +122,6 @@ export default function getNeededSegments({
                                                    segmentsBeingPushed,
                                                    maxBufferSize);
 
-  // Current buffer length in seconds
-  let bufferLength = getBufferLength(bufferedSegments, segmentsBeingPushed);
   const availableSegmentsForRange = representation.index
     .getSegments(neededRange.start, neededRange.end - neededRange.start);
 
@@ -151,16 +159,16 @@ export default function getNeededSegments({
       return true;
     });
   const { MINIMUM_SEGMENT_SIZE,
-          MIN_BUFFER_LENGTH,
-          MIN_BUFFER_DISTANCE_BEFORE_CLEAN_UP } = config.getCurrent();
-  let isMemorySaturated = false;
+          MIN_BUFFER_AHEAD } = config.getCurrent();
+  let shouldStopLoadingSegments = false;
   /**
    * Epsilon compensating for rounding errors when comparing the start and end
    * time of multiple segments.
    */
   const ROUNDING_ERROR = Math.min(1 / 60, MINIMUM_SEGMENT_SIZE);
   let isBufferFull = false;
-  const neededSegments = availableSegmentsForRange.filter(segment => {
+  const segmentsOnHold : ISegment[] = [];
+  const segmentsToLoad = availableSegmentsForRange.filter(segment => {
     const contentObject = objectAssign({ segment }, content);
 
     // First, check that the segment is not already being pushed
@@ -176,21 +184,10 @@ export default function getNeededSegments({
     if (segment.isInit) {
       return true; // never skip initialization segments
     }
-    if (isMemorySaturated) {
-      // If we are so saturated in memory
-      // That we cannot download atleast till
-      // NeededRange.Start ( current position ) + a CONST
-      // Then the buffer is full
-      if (time < neededRange.start + MIN_BUFFER_DISTANCE_BEFORE_CLEAN_UP) {
-        isBufferFull = true;
-      }
-    }
-    if (isMemorySaturated &&
-      bufferLength > MIN_BUFFER_LENGTH) {
-
+    if (shouldStopLoadingSegments) {
+      segmentsOnHold.push(segment);
       return false;
     }
-
     if (segment.complete && duration < MINIMUM_SEGMENT_SIZE) {
       return false; // too small, don't download
     }
@@ -239,29 +236,36 @@ export default function getNeededSegments({
       }
     }
 
+    const estimatedSegmentSize = (duration * content.representation.bitrate) / 8000;
+    if (availableBufferSize - estimatedSegmentSize < 0) {
+      isBufferFull = true;
+      if (time > neededRange.start + MIN_BUFFER_AHEAD) {
+        shouldStopLoadingSegments = true;
+        segmentsOnHold.push(segment);
+        return false;
+      }
+    }
+
     // check if there is an hole in place of the segment currently
     for (let i = 0; i < segmentsToKeep.length; i++) {
       const completeSeg = segmentsToKeep[i];
-      if (completeSeg.end > time) {
-        // `true` if `completeSeg` starts too far after `time`
-        return completeSeg.start > time + ROUNDING_ERROR ||
-          // `true` if `completeSeg` ends too soon before `end`
-          getLastContiguousSegment(segmentsToKeep, i).end < end - ROUNDING_ERROR;
-      }
-    }
 
-    const estimatedSegmentSize = (duration * content.representation.bitrate) / 8000;
-    if (availableBufferSize - estimatedSegmentSize < 0 &&
-        bufferLength > MIN_BUFFER_LENGTH) {
-      isMemorySaturated = true;
-      return false;
+      // For the first already-loaded segment, take the first one ending after
+      // this one' s start
+      if ((completeSeg.end + ROUNDING_ERROR) > time) {
+        const shouldLoad = completeSeg.start > time + ROUNDING_ERROR ||
+                           getLastContiguousSegment(segmentsToKeep, i).end <
+                             end - ROUNDING_ERROR;
+        if (shouldLoad) {
+          availableBufferSize -= estimatedSegmentSize;
+        }
+        return shouldLoad;
+      }
     }
     availableBufferSize -= estimatedSegmentSize;
-    bufferLength += duration;
-
     return true;
   });
-  return { neededSegments, isBufferFull };
+  return { segmentsToLoad, segmentsOnHold, isBufferFull };
 
 }
 /**
@@ -286,7 +290,7 @@ function getAvailableBufferSize(
   }, 0);
   return bufferedSegments.reduce((size, chunk) => {
     if (chunk.chunkSize !== undefined) {
-      return size - (chunk.chunkSize / 8000);
+      return size - (chunk.chunkSize / 1000);
     } else {
       return size;
     }
@@ -294,25 +298,6 @@ function getAvailableBufferSize(
   } , availableBufferSize);
 }
 
-/**
- * Compute the length of the buffer in seconds
- * @param bufferedSegments
- * @param segmentsBeingPushed
- * @returns bufferLength in seconds
- */
-function getBufferLength(
-  bufferedSegments: IBufferedChunk[],
-  segmentsBeingPushed: IEndOfSegmentInfos[]
-) : number {
-  const bufferLength = bufferedSegments.reduce((length, segment) => {
-    return length + (segment.end - segment.start);
-  }, 0);
-  const bufferBeingPushed = segmentsBeingPushed.reduce((length, segment) => {
-    return length + segment.segment.duration;
-  }, 0);
-  return bufferLength + bufferBeingPushed;
-}
-
 /**
  * From the given array of buffered chunks (`bufferedSegments`) returns the last
  * buffered chunk contiguous with the one at the `startIndex` index given.

package/src/core/stream/representation/representation_stream.ts

@@ -384,10 +384,12 @@ export default function RepresentationStream<TSegmentDataType>({
         const gcedPosition = Math.max(
           0,
           wantedStartPosition - UPTO_CURRENT_POSITION_CLEANUP);
-        bufferRemoval = segmentBuffer
-          .removeBuffer(0, gcedPosition)
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-          .pipe(ignoreElements());
+        if (gcedPosition > 0) {
+          bufferRemoval = segmentBuffer
+            .removeBuffer(0, gcedPosition)
+              // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+            .pipe(ignoreElements());
+        }
       }
       return status.shouldRefreshManifest ?
         observableConcat(observableOf(EVENTS.needsManifestRefresh()),

package/src/default_config.ts

@@ -1057,36 +1057,6 @@ const DEFAULT_CONFIG = {
      */
   EME_MAX_STORED_PERSISTENT_SESSION_INFORMATION: 1000,
 
-    /**
-     * Attempts to closing a MediaKeySession can fail, most likely because the
-     * MediaKeySession was not initialized yet.
-     * When we consider that we're in one of these case, we will retry to close it.
-     *
-     * To avoid going into an infinite loop of retry, this number indicates a
-     * maximum number of attemps we're going to make (`0` meaning no retry at all,
-     * `1` only one retry and so on).
-     */
-  EME_SESSION_CLOSING_MAX_RETRY: 5,
-
-    /**
-     * When closing a MediaKeySession failed due to the reasons explained for the
-     * `EME_SESSION_CLOSING_MAX_RETRY` config property, we may (among other
-     * triggers) choose to wait a delay raising exponentially at each retry before
-     * that new attempt.
-     * This value indicates the initial value for this delay, in milliseconds.
-     */
-  EME_SESSION_CLOSING_INITIAL_DELAY: 100,
-
-    /**
-     * When closing a MediaKeySession failed due to the reasons explained for the
-     * `EME_SESSION_CLOSING_MAX_RETRY` config property, we may (among other
-     * triggers) choose to wait a delay raising exponentially at each retry before
-     * that new attempt.
-     * This value indicates the maximum possible value for this delay, in
-     * milliseconds.
-     */
-  EME_SESSION_CLOSING_MAX_DELAY: 1000,
-
     /**
      * After loading a persistent MediaKeySession, the RxPlayer needs to ensure
      * that its keys still allow to decrypt a content.
@@ -1194,40 +1164,33 @@ const DEFAULT_CONFIG = {
      */
   DEFAULT_MAXIMUM_TIME_ROUNDING_ERROR: 1 / 1000,
 
-    /**
-     * RxPlayer's media buffers have a linked history registering recent events
-     * that happened on those.
-     * The reason is to implement various heuristics in case of weird browser
-     * behavior.
-     *
-     * The `BUFFERED_HISTORY_RETENTION_TIME` is the minimum age an entry of
-     * that history can have before being removed from the history.
-     */
+  /**
+   * RxPlayer's media buffers have a linked history registering recent events
+   * that happened on those.
+   * The reason is to implement various heuristics in case of weird browser
+   * behavior.
+   *
+   * The `BUFFERED_HISTORY_RETENTION_TIME` is the minimum age an entry of
+   * that history can have before being removed from the history.
+   */
   BUFFERED_HISTORY_RETENTION_TIME: 60000,
 
-    /**
-     * RxPlayer's media buffers have a linked history registering recent events
-     * that happened on those.
-     * The reason is to implement various heuristics in case of weird browser
-     * behavior.
-     *
-     * The `BUFFERED_HISTORY_RETENTION_TIME` is the maximum number of entries
-     * there can be in that history.
-     */
+  /**
+   * RxPlayer's media buffers have a linked history registering recent events
+   * that happened on those.
+   * The reason is to implement various heuristics in case of weird browser
+   * behavior.
+   *
+   * The `BUFFERED_HISTORY_RETENTION_TIME` is the maximum number of entries
+   * there can be in that history.
+   */
   BUFFERED_HISTORY_MAXIMUM_ENTRIES: 200,
 
-    /**
-     * Minimum buffer (in seconds) we should have, regardless of memory
-     * constraints
-     */
-  MIN_BUFFER_LENGTH : 5,
-
   /**
    * Minimum buffer in seconds ahead relative to current time
-   * we should be able to download
-   * Before trying to agressively free up memory
+   * we should be able to download, even in cases of saturated memory.
    */
-  MIN_BUFFER_DISTANCE_BEFORE_CLEAN_UP: 10,
+  MIN_BUFFER_AHEAD: 5,
 
   /**
    * Distance in seconds behind the current position

package/src/transports/dash/add_segment_integrity_checks_to_loader.ts

@@ -14,9 +14,7 @@
  * limitations under the License.
  */
 
-import TaskCanceller, {
-  CancellationError,
-} from "../../utils/task_canceller";
+import TaskCanceller from "../../utils/task_canceller";
 import { ISegmentLoader } from "../types";
 import checkISOBMFFIntegrity from "../utils/check_isobmff_integrity";
 import inferSegmentContainer from "../utils/infer_segment_container";
@@ -32,61 +30,60 @@ export default function addSegmentIntegrityChecks<T>(
   segmentLoader : ISegmentLoader<T>
 ) : ISegmentLoader<T> {
   return (url, content, initialCancelSignal, callbacks) => {
-    return new Promise((res, rej) => {
-      const canceller = new TaskCanceller();
-      const unregisterCancelLstnr = initialCancelSignal
-        .register(function onCheckCancellation(err : CancellationError) {
-          canceller.cancel();
-          rej(err);
-        });
+    return new Promise((resolve, reject) => {
+      const requestCanceller = new TaskCanceller({ cancelOn: initialCancelSignal });
 
-      /**
-       * If the data's seems to be corrupted, cancel the loading task and reject
-       * with an `INTEGRITY_ERROR` error.
-       * @param {*} data
-       */
-      function cancelAndRejectOnBadIntegrity(data : T) : void {
-        if (!(data instanceof Array) && !(data instanceof Uint8Array) ||
-            inferSegmentContainer(content.adaptation.type,
-                                  content.representation) !== "mp4")
-        {
-          return;
-        }
-        try {
-          checkISOBMFFIntegrity(new Uint8Array(data), content.segment.isInit);
-        } catch (err) {
-          unregisterCancelLstnr();
-          canceller.cancel();
-          rej(err);
-        }
-      }
+      // Reject the `CancellationError` when `requestCanceller`'s signal emits
+      // `stopRejectingOnCancel` here is a function allowing to stop this mechanism
+      const stopRejectingOnCancel = requestCanceller.signal.register(reject);
 
-      segmentLoader(url, content, canceller.signal, {
+      segmentLoader(url, content, requestCanceller.signal, {
         ...callbacks,
         onNewChunk(data) {
-          cancelAndRejectOnBadIntegrity(data);
-          if (!canceller.isUsed) {
+          try {
+            trowOnIntegrityError(data);
             callbacks.onNewChunk(data);
+          } catch (err) {
+            // Do not reject with a `CancellationError` after cancelling the request
+            stopRejectingOnCancel();
+            // Cancel the request
+            requestCanceller.cancel();
+            // Reject with thrown error
+            reject(err);
           }
         },
       }).then((info) => {
-        if (canceller.isUsed) {
+        if (requestCanceller.isUsed) {
           return;
         }
-        unregisterCancelLstnr();
-
+        stopRejectingOnCancel();
         if (info.resultType === "segment-loaded") {
-          cancelAndRejectOnBadIntegrity(info.resultData.responseData);
+          try {
+            trowOnIntegrityError(info.resultData.responseData);
+          } catch (err) {
+            reject(err);
+            return;
+          }
         }
-        res(info);
-
+        resolve(info);
       }, (error : unknown) => {
-        // The segmentLoader's cancellations cases are all handled here
-        if (!TaskCanceller.isCancellationError(error)) {
-          unregisterCancelLstnr();
-          rej(error);
-        }
+        stopRejectingOnCancel();
+        reject(error);
       });
     });
+
+    /**
+     * If the data's seems to be corrupted, throws an `INTEGRITY_ERROR` error.
+     * @param {*} data
+     */
+    function trowOnIntegrityError(data : T) : void {
+      if (!(data instanceof ArrayBuffer) && !(data instanceof Uint8Array) ||
+          inferSegmentContainer(content.adaptation.type,
+                                content.representation) !== "mp4")
+      {
+        return;
+      }
+      checkISOBMFFIntegrity(new Uint8Array(data), content.segment.isInit);
+    }
   };
 }

package/src/utils/reference.ts

@@ -18,7 +18,6 @@ import {
   Observable,
   Subscriber,
 } from "rxjs";
-import log from "../log";
 import { CancellationSignal } from "./task_canceller";
 
 /**
@@ -194,7 +193,6 @@ export function createSharedReference<T>(initialValue : T) : ISharedReference<T>
         if (__ENVIRONMENT__.CURRENT_ENV === __ENVIRONMENT__.DEV as number) {
           throw new Error("Finished shared references cannot be updated");
         } else {
-          log.error("Finished shared references cannot be updated");
           return;
         }
       }

package/src/utils/task_canceller.ts

@@ -136,14 +136,29 @@ export default class TaskCanceller {
    * Creates a new `TaskCanceller`, with its own `CancellationSignal` created
    * as its `signal` provide.
    * You can then pass this property to async task you wish to be cancellable.
+   * @param {Object|undefined} options
    */
-  constructor() {
+  constructor(options? : {
+    /**
+     * If set the TaskCanceller created here will automatically be triggered
+     * when that signal emits.
+     */
+    cancelOn? : CancellationSignal | undefined;
+  } | undefined) {
     const [trigger, register] = createCancellationFunctions();
     this.isUsed = false;
     this._trigger = trigger;
     this.signal = new CancellationSignal(register);
+
+    if (options?.cancelOn !== undefined) {
+      const unregisterParent = options.cancelOn.register(() => {
+        this.cancel();
+      });
+      this.signal.register(unregisterParent);
+    }
   }
 
+
   /**
    * "Trigger" the `TaskCanceller`, notify through its associated
    * `CancellationSignal` (its `signal` property) that a task should be aborted.