rx-player 3.26.2 → 3.27.0-dev.20220317

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

@@ -35,7 +35,6 @@ import checkForDiscontinuity from "./check_for_discontinuity";
 import getNeededSegments from "./get_needed_segments";
 import getSegmentPriority from "./get_segment_priority";
 
-const { MINIMUM_SEGMENT_SIZE } = config;
 
 /** Analysis of the current buffer's status. */
 export interface IBufferStatus {
@@ -62,6 +61,11 @@ export interface IBufferStatus {
    * on which segments should be loaded.
    */
   shouldRefreshManifest : boolean;
+  /**
+   * If 'true', the buffer memory is saturated before being able to download
+   * at least MIN_REQUIRED_BUFFER_AHEAD ( default : 10sec )
+   */
+  isBufferFull: boolean;
 }
 
 /**
@@ -87,11 +91,11 @@ export default function getBufferStatus(
   playbackObserver : IReadOnlyPlaybackObserver<unknown>,
   fastSwitchThreshold : number | undefined,
   bufferGoal : number,
+  maxBufferSize : number,
   segmentBuffer : SegmentBuffer
 ) : IBufferStatus {
   const { period, representation } = content;
   segmentBuffer.synchronizeInventory();
-
   const wantedEndPosition = wantedStartPosition + bufferGoal;
   const neededRange = { start: Math.max(wantedStartPosition, period.start),
                         end: Math.min(wantedEndPosition, period.end ?? Infinity) };
@@ -119,15 +123,21 @@ export default function getBufferStatus(
   const getBufferedHistory = segmentBuffer.getSegmentHistory.bind(segmentBuffer);
 
   /** List of segments we will need to download. */
-  const neededSegments = getNeededSegments({ content,
-                                             bufferedSegments,
-                                             currentPlaybackTime,
-                                             fastSwitchThreshold,
-                                             getBufferedHistory,
-                                             neededRange,
-                                             segmentsBeingPushed })
-    .map((segment) => ({ priority: getSegmentPriority(segment.time, wantedStartPosition),
-                         segment }));
+  const { neededSegments, isBufferFull } = getNeededSegments({ content,
+                                                               bufferedSegments,
+                                                               currentPlaybackTime,
+                                                               fastSwitchThreshold,
+                                                               getBufferedHistory,
+                                                               neededRange,
+                                                               segmentsBeingPushed,
+                                                               maxBufferSize });
+
+  const prioritizedNeededSegments: IQueuedSegment[] =  neededSegments.map((segment) => (
+    {
+      priority: getSegmentPriority(segment.time, wantedStartPosition),
+      segment,
+    }
+  ));
 
   /**
    * `true` if the current `RepresentationStream` has loaded all the
@@ -138,7 +148,7 @@ export default function getBufferStatus(
   const lastPosition = representation.index.getLastPosition();
   if (!representation.index.isInitialized() ||
       period.end === undefined ||
-      neededSegments.length > 0)
+      prioritizedNeededSegments.length > 0)
   {
     hasFinishedLoading = false;
   } else {
@@ -182,10 +192,10 @@ export default function getBufferStatus(
     if (segmentsBeingPushed.length > 0) {
       nextSegmentStart = Math.min(...segmentsBeingPushed.map(info => info.segment.time));
     }
-    if (neededSegments.length > 0) {
+    if (prioritizedNeededSegments.length > 0) {
       nextSegmentStart = nextSegmentStart !== null ?
-        Math.min(nextSegmentStart, neededSegments[0].segment.time) :
-        neededSegments[0].segment.time;
+        Math.min(nextSegmentStart, prioritizedNeededSegments[0].segment.time) :
+        prioritizedNeededSegments[0].segment.time;
     }
     imminentDiscontinuity = checkForDiscontinuity(content,
                                                   neededRange,
@@ -195,7 +205,8 @@ export default function getBufferStatus(
   }
   return { imminentDiscontinuity,
            hasFinishedLoading,
-           neededSegments,
+           neededSegments: prioritizedNeededSegments,
+           isBufferFull,
            shouldRefreshManifest };
 }
 
@@ -211,6 +222,7 @@ function getPlayableBufferedSegments(
   neededRange : { start : number; end : number },
   segmentInventory : IBufferedChunk[]
 ) : IBufferedChunk[] {
+  const { MINIMUM_SEGMENT_SIZE } = config.getCurrent();
   const segmentRoundingError = Math.max(1 / 60, MINIMUM_SEGMENT_SIZE);
   const minEnd = neededRange.start + segmentRoundingError;
   const maxStart = neededRange.end - segmentRoundingError;

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

@@ -25,24 +25,25 @@ import Manifest, {
   Representation,
 } from "../../../manifest";
 import objectAssign from "../../../utils/object_assign";
-import { IBufferedChunk } from "../../segment_buffers";
+import { IBufferedChunk, IEndOfSegmentInfos } from "../../segment_buffers";
 import {
   IBufferedHistoryEntry,
   IChunkContext,
 } from "../../segment_buffers/inventory";
 
-const { CONTENT_REPLACEMENT_PADDING,
-        BITRATE_REBUFFERING_RATIO,
-        MAX_TIME_MISSING_FROM_COMPLETE_SEGMENT,
-        MINIMUM_SEGMENT_SIZE } = config;
+
+interface IContentContext {
+  adaptation: Adaptation;
+  manifest: Manifest;
+  period: Period;
+  representation: Representation;
+}
+
 
 /** Arguments for `getNeededSegments`. */
 export interface IGetNeededSegmentsArguments {
   /** The content we want to load segments for */
-  content: { adaptation : Adaptation;
-             manifest : Manifest;
-             period : Period;
-             representation : Representation; };
+  content: IContentContext;
   /**
    * The current playing position.
    * Important to avoid asking for segments on the same exact position, which
@@ -61,10 +62,7 @@ export interface IGetNeededSegmentsArguments {
   /** The range we want to fill with segments. */
   neededRange : { start: number; end: number };
   /** The list of segments that are already in the process of being pushed. */
-  segmentsBeingPushed : Array<{ adaptation : Adaptation;
-                                period : Period;
-                                representation : Representation;
-                                segment : ISegment; }>;
+  segmentsBeingPushed : IEndOfSegmentInfos[];
   /**
    * Information on the segments already in the buffer, in chronological order.
    *
@@ -76,15 +74,19 @@ export interface IGetNeededSegmentsArguments {
    */
   bufferedSegments : IBufferedChunk[];
 
+  /**
+   * maxBufferSize is the maximum memory in kilobytes that the buffer should take
+   */
+  maxBufferSize: number;
+
   getBufferedHistory : (context : IChunkContext) => IBufferedHistoryEntry[];
 }
 
-/**
- * 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);
 
+interface INeededSegments {
+  neededSegments: ISegment[];
+  isBufferFull: boolean;
+}
 /**
  * Return the list of segments that can currently be downloaded to fill holes
  * in the buffer in the given range, including already-pushed segments currently
@@ -103,9 +105,15 @@ export default function getNeededSegments({
   getBufferedHistory,
   neededRange,
   segmentsBeingPushed,
-} : IGetNeededSegmentsArguments) : ISegment[] {
+  maxBufferSize,
+} : IGetNeededSegmentsArguments) : INeededSegments {
   const { representation } = content;
+  let availableBufferSize = getAvailableBufferSize(bufferedSegments,
+                                                   segmentsBeingPushed,
+                                                   maxBufferSize);
 
+  // Current buffer length in seconds
+  let bufferLength = getBufferLength(bufferedSegments, segmentsBeingPushed);
   const availableSegmentsForRange = representation.index
     .getSegments(neededRange.start, neededRange.end - neededRange.start);
 
@@ -132,7 +140,7 @@ export default function getNeededSegments({
         }
         log.debug("Stream: skipping segment gc-ed at the start", currentSeg);
       }
-      if (doesEndSeemGarbageCollected(currentSeg, nextSeg, neededRange.start)) {
+      if (doesEndSeemGarbageCollected(currentSeg, nextSeg, neededRange.end)) {
         lazySegmentHistory = lazySegmentHistory ?? getBufferedHistory(currentSeg.infos);
         if (shouldReloadSegmentGCedAtTheEnd(lazySegmentHistory,
                                             currentSeg.bufferedEnd)) {
@@ -142,8 +150,17 @@ export default function getNeededSegments({
       }
       return true;
     });
-
-  const segmentsToDownload = availableSegmentsForRange.filter(segment => {
+  const { MINIMUM_SEGMENT_SIZE,
+          MIN_BUFFER_LENGTH,
+          MIN_BUFFER_DISTANCE_BEFORE_CLEAN_UP } = config.getCurrent();
+  let isMemorySaturated = 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 contentObject = objectAssign({ segment }, content);
 
     // First, check that the segment is not already being pushed
@@ -159,6 +176,20 @@ 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) {
+
+      return false;
+    }
 
     if (segment.complete && duration < MINIMUM_SEGMENT_SIZE) {
       return false; // too small, don't download
@@ -218,10 +249,68 @@ export default function getNeededSegments({
           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;
+    }
+    availableBufferSize -= estimatedSegmentSize;
+    bufferLength += duration;
+
     return true;
   });
+  return { neededSegments, isBufferFull };
+
+}
+/**
+ * Compute the estimated available buffer size in memory in kilobytes
+ * @param bufferedSegments
+ * @param segmentsBeingPushed
+ * @param maxVideoBufferSize
+ * @returns availableBufferSize in kilobytes
+ */
+function getAvailableBufferSize(
+  bufferedSegments: IBufferedChunk[],
+  segmentsBeingPushed: IEndOfSegmentInfos[],
+  maxVideoBufferSize: number
+) : number {
+  let availableBufferSize = maxVideoBufferSize;
+  availableBufferSize -= segmentsBeingPushed.reduce((size, segment) => {
+    const { bitrate } = segment.representation;
+    // Not taking into account the fact that the segment
+    // can still be generated and the duration not fully exact
+    const { duration } = segment.segment;
+    return size + ((bitrate / 8000) * duration);
+  }, 0);
+  return bufferedSegments.reduce((size, chunk) => {
+    if (chunk.chunkSize !== undefined) {
+      return size - (chunk.chunkSize / 8000);
+    } else {
+      return size;
+    }
 
-  return segmentsToDownload;
+  } , 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;
 }
 
 /**
@@ -236,7 +325,12 @@ function getLastContiguousSegment(
   startIndex : number
 ) : IBufferedChunk {
   let j = startIndex + 1;
-
+  const { MINIMUM_SEGMENT_SIZE } = config.getCurrent();
+  /**
+   * 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);
   // go through all contiguous segments and take the last one
   while (j < bufferedSegments.length - 1 &&
          (bufferedSegments[j - 1].end + ROUNDING_ERROR) >
@@ -248,6 +342,7 @@ function getLastContiguousSegment(
   return bufferedSegments[j];
 }
 
+
 /**
  * Returns `true` if segments linked to the given `oldContent` currently present
  * in the buffer should be replaced by segments coming from `currentContent`.
@@ -258,16 +353,14 @@ function getLastContiguousSegment(
  * @returns {boolean}
  */
 function shouldContentBeReplaced(
-  oldContent : { adaptation : Adaptation;
-                 period : Period;
-                 representation : Representation;
-                 segment : ISegment; },
+  oldContent : IEndOfSegmentInfos,
   currentContent : { adaptation : Adaptation;
                      period : Period;
                      representation : Representation; },
   currentPlaybackTime: number,
   fastSwitchThreshold? : number
 ) : boolean {
+  const { CONTENT_REPLACEMENT_PADDING } = config.getCurrent();
   if (oldContent.period.id !== currentContent.period.id) {
     return false; // keep segments from another Period by default.
   }
@@ -302,6 +395,7 @@ function canFastSwitch(
   fastSwitchThreshold : number | undefined
 ) : boolean {
   const oldContentBitrate = oldSegmentRepresentation.bitrate;
+  const { BITRATE_REBUFFERING_RATIO } = config.getCurrent();
   if (fastSwitchThreshold === undefined) {
     // only re-load comparatively-poor bitrates for the same Adaptation.
     const bitrateCeil = oldContentBitrate * BITRATE_REBUFFERING_RATIO;
@@ -328,6 +422,7 @@ function doesStartSeemGarbageCollected(
   prevSeg : IBufferedChunk | null,
   maximumStartTime : number
 ) {
+  const { MAX_TIME_MISSING_FROM_COMPLETE_SEGMENT } = config.getCurrent();
   if (currentSeg.bufferedStart === undefined)  {
     log.warn("Stream: Start of a segment unknown. " +
              "Assuming it is garbage collected by default.",
@@ -370,6 +465,7 @@ function doesEndSeemGarbageCollected(
   nextSeg : IBufferedChunk | null,
   minimumEndTime : number
 ) {
+  const { MAX_TIME_MISSING_FROM_COMPLETE_SEGMENT } = config.getCurrent();
   if (currentSeg.bufferedEnd === undefined)  {
     log.warn("Stream: End of a segment unknown. " +
              "Assuming it is garbage collected by default.",

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

@@ -16,7 +16,6 @@
 
 import config from "../../../config";
 
-const { SEGMENT_PRIORITIES_STEPS } = config;
 
 /**
  * Calculate the priority number for a given segment start time, in function of
@@ -35,7 +34,7 @@ export default function getSegmentPriority(
   wantedStartTimestamp : number
 ) : number {
   const distance = segmentTime - wantedStartTimestamp;
-
+  const { SEGMENT_PRIORITIES_STEPS } = config.getCurrent();
   for (let priority = 0; priority < SEGMENT_PRIORITIES_STEPS.length; priority++) {
     if (distance < SEGMENT_PRIORITIES_STEPS[priority]) {
       return priority;

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

@@ -35,7 +35,6 @@ import EVENTS from "../events_generators";
 import { IStreamEventAddedSegment } from "../types";
 import appendSegmentToBuffer from "./append_segment_to_buffer";
 
-const { APPEND_WINDOW_SECURITIES } = config;
 
 /**
  * Push a given media segment (non-init segment) to a SegmentBuffer.
@@ -70,9 +69,10 @@ export default function pushMediaSegment<T>(
     const { chunkData,
             chunkInfos,
             chunkOffset,
+            chunkSize,
             appendWindow } = parsedSegment;
     const codec = content.representation.getMimeTypeString();
-
+    const { APPEND_WINDOW_SECURITIES } = config.getCurrent();
     // Cutting exactly at the start or end of the appendWindow can lead to
     // cases of infinite rebuffering due to how browser handle such windows.
     // To work-around that, we add a small offset before and after those.
@@ -102,6 +102,7 @@ export default function pushMediaSegment<T>(
     }
 
     const inventoryInfos = objectAssign({ segment,
+                                          chunkSize,
                                           start: estimatedStart,
                                           end: estimatedEnd },
                                         content);

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

@@ -41,6 +41,7 @@ import {
   takeWhile,
   withLatestFrom,
 } from "rxjs";
+import config from "../../../config";
 import log from "../../../log";
 import Manifest, {
   Adaptation,
@@ -134,6 +135,7 @@ export interface IRepresentationStreamArguments<TSegmentDataType> {
   options: IRepresentationStreamOptions;
 }
 
+
 /**
  * Various specific stream "options" which tweak the behavior of the
  * RepresentationStream.
@@ -145,6 +147,14 @@ export interface IRepresentationStreamOptions {
    * goes below that size again.
    */
   bufferGoal$ : Observable<number>;
+
+  /**
+   *  The buffer size limit in memory that we can reach.
+   *  Once reached, no segments will be loaded until it
+   *  goes below that size again
+   */
+  maxBufferSize$ : Observable<number>;
+
   /**
    * Hex-encoded DRM "system ID" as found in:
    * https://dashif.org/identifiers/content_protection/
@@ -221,6 +231,7 @@ export default function RepresentationStream<TSegmentDataType>({
           adaptation,
           representation } = content;
   const { bufferGoal$,
+          maxBufferSize$,
           drmSystemId,
           fastSwitchThreshold$ } = options;
   const bufferType = adaptation.type;
@@ -264,7 +275,7 @@ export default function RepresentationStream<TSegmentDataType>({
     const encryptionData = representation.getEncryptionData(drmSystemId);
     if (encryptionData.length > 0) {
       encryptionEvent$ = observableOf(...encryptionData.map(d =>
-        EVENTS.encryptionDataEncountered(d)));
+        EVENTS.encryptionDataEncountered(d, content)));
       hasSentEncryptionData = true;
     }
   }
@@ -277,13 +288,14 @@ export default function RepresentationStream<TSegmentDataType>({
   const status$ = observableCombineLatest([
     playbackObserver.observe(true),
     bufferGoal$,
+    maxBufferSize$,
     terminate$.pipe(take(1),
                     startWith(null)),
     reCheckNeededSegments$.pipe(startWith(undefined)),
   ]).pipe(
     withLatestFrom(fastSwitchThreshold$),
     mergeMap(function (
-      [ [ observation, bufferGoal, terminate ],
+      [ [ observation, bufferGoal, maxBufferSize, terminate ],
         fastSwitchThreshold ]
     ) : Observable<IStreamStatusEvent |
                    IStreamNeedsManifestRefresh |
@@ -295,6 +307,7 @@ export default function RepresentationStream<TSegmentDataType>({
                                      playbackObserver,
                                      fastSwitchThreshold,
                                      bufferGoal,
+                                     maxBufferSize,
                                      segmentBuffer);
       const { neededSegments } = status;
 
@@ -365,11 +378,21 @@ export default function RepresentationStream<TSegmentDataType>({
                                 imminentDiscontinuity: status.imminentDiscontinuity,
                                 hasFinishedLoading: status.hasFinishedLoading,
                                 neededSegments: status.neededSegments } });
-
+      let bufferRemoval = EMPTY;
+      const { UPTO_CURRENT_POSITION_CLEANUP } = config.getCurrent();
+      if (status.isBufferFull) {
+        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());
+      }
       return status.shouldRefreshManifest ?
         observableConcat(observableOf(EVENTS.needsManifestRefresh()),
-                         bufferStatusEvt) :
-        bufferStatusEvt;
+                         bufferStatusEvt, bufferRemoval) :
+        observableConcat(bufferStatusEvt, bufferRemoval);
     }),
     takeWhile((e) => e.type !== "stream-terminating", true)
   );
@@ -458,7 +481,7 @@ export default function RepresentationStream<TSegmentDataType>({
       const initEncEvt$ = !hasSentEncryptionData &&
                           allEncryptionData.length > 0 ?
         observableOf(...allEncryptionData.map(p =>
-          EVENTS.encryptionDataEncountered(p))) :
+          EVENTS.encryptionDataEncountered(p, content))) :
         EMPTY;
       const pushEvent$ = pushInitSegment({ playbackObserver,
                                            content,
@@ -476,7 +499,7 @@ export default function RepresentationStream<TSegmentDataType>({
       const segmentEncryptionEvent$ = protectionDataUpdate &&
                                      !hasSentEncryptionData ?
         observableOf(...representation.getAllEncryptionData().map(p =>
-          EVENTS.encryptionDataEncountered(p))) :
+          EVENTS.encryptionDataEncountered(p, content))) :
         EMPTY;
 
       const manifestRefresh$ =  needsManifestRefresh === true ?

package/src/core/stream/types.ts

@@ -23,7 +23,7 @@ import {
   Representation,
 } from "../../manifest";
 import { IEMSG } from "../../parsers/containers/isobmff";
-import { IContentProtection } from "../eme";
+import { IContentProtection } from "../decrypt";
 import { IBufferType } from "../segment_buffers";
 
 /** Information about a Segment waiting to be loaded by the Stream. */