rx-player 3.25.2 → 3.26.3-dev.2022021400

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

@@ -26,6 +26,10 @@ import Manifest, {
 } from "../../../manifest";
 import objectAssign from "../../../utils/object_assign";
 import { IBufferedChunk } from "../../segment_buffers";
+import {
+  IBufferedHistoryEntry,
+  IChunkContext,
+} from "../../segment_buffers/inventory";
 
 const { CONTENT_REPLACEMENT_PADDING,
         BITRATE_REBUFFERING_RATIO,
@@ -71,6 +75,8 @@ export interface IGetNeededSegmentsArguments {
    * re-requested.
    */
   bufferedSegments : IBufferedChunk[];
+
+  getBufferedHistory : (context : IChunkContext) => IBufferedHistoryEntry[];
 }
 
 /**
@@ -90,12 +96,13 @@ const ROUNDING_ERROR = Math.min(1 / 60, MINIMUM_SEGMENT_SIZE);
  * @returns {Array.<Object>}
  */
 export default function getNeededSegments({
+  bufferedSegments,
   content,
   currentPlaybackTime,
   fastSwitchThreshold,
+  getBufferedHistory,
   neededRange,
   segmentsBeingPushed,
-  bufferedSegments,
 } : IGetNeededSegmentsArguments) : ISegment[] {
   const { representation } = content;
 
@@ -115,8 +122,25 @@ export default function getNeededSegments({
                                 consideredSegments[i - 1];
       const nextSeg = i >= consideredSegments.length - 1 ? null :
                                                            consideredSegments[i + 1];
-      return !isStartGarbageCollected(currentSeg, prevSeg, neededRange.start) &&
-             !isEndGarbageCollected(currentSeg, nextSeg, neededRange.end);
+
+      let lazySegmentHistory : IBufferedHistoryEntry[] | null = null;
+      if (doesStartSeemGarbageCollected(currentSeg, prevSeg, neededRange.start)) {
+        lazySegmentHistory = getBufferedHistory(currentSeg.infos);
+        if (shouldReloadSegmentGCedAtTheStart(lazySegmentHistory,
+                                              currentSeg.bufferedStart)) {
+          return false;
+        }
+        log.debug("Stream: skipping segment gc-ed at the start", currentSeg);
+      }
+      if (doesEndSeemGarbageCollected(currentSeg, nextSeg, neededRange.start)) {
+        lazySegmentHistory = lazySegmentHistory ?? getBufferedHistory(currentSeg.infos);
+        if (shouldReloadSegmentGCedAtTheEnd(lazySegmentHistory,
+                                            currentSeg.bufferedEnd)) {
+          return false;
+        }
+        log.debug("Stream: skipping segment gc-ed at the end", currentSeg);
+      }
+      return true;
     });
 
   const segmentsToDownload = availableSegmentsForRange.filter(segment => {
@@ -136,7 +160,7 @@ export default function getNeededSegments({
       return true; // never skip initialization segments
     }
 
-    if (duration < MINIMUM_SEGMENT_SIZE) {
+    if (segment.complete && duration < MINIMUM_SEGMENT_SIZE) {
       return false; // too small, don't download
     }
 
@@ -299,7 +323,7 @@ function canFastSwitch(
  * If `currentSeg` has only been garbage collected for some data which is before
  * that time, we will return `false`.
  */
-function isStartGarbageCollected(
+function doesStartSeemGarbageCollected(
   currentSeg : IBufferedChunk,
   prevSeg : IBufferedChunk | null,
   maximumStartTime : number
@@ -341,7 +365,7 @@ function isStartGarbageCollected(
  * If `currentSeg` has only been garbage collected for some data which is after
  * that time, we will return `false`.
  */
-function isEndGarbageCollected(
+function doesEndSeemGarbageCollected(
   currentSeg : IBufferedChunk,
   nextSeg : IBufferedChunk | null,
   minimumEndTime : number
@@ -369,3 +393,108 @@ function isEndGarbageCollected(
 
   return false;
 }
+
+/**
+ * Returns `true` if a segment that has been garbage-collected at the start
+ * might profit from being re-loaded.
+ *
+ * Returns `false` if we have a high chance of staying in the same situation
+ * after re-loading the segment.
+ *
+ * This function takes in argument the entries of a SegmentBuffer's history
+ * related to the corresponding segment and check if the segment appeared
+ * garbage-collected at the start directly after the last few times it was
+ * pushed, indicating that the issue might be sourced at a browser issue instead
+ * of classical garbage collection.
+ *
+ * @param {Array.<Object>} segmentEntries
+ * @param {number|undefined} currentBufferedStart
+ * @returns {boolean}
+ */
+function shouldReloadSegmentGCedAtTheStart(
+  segmentEntries : IBufferedHistoryEntry[],
+  currentBufferedStart : number | undefined
+) : boolean {
+  if (segmentEntries.length < 2) {
+    return true;
+  }
+
+  const lastEntry = segmentEntries[segmentEntries.length - 1];
+  const lastBufferedStart = lastEntry.bufferedStart;
+
+  // If the current segment's buffered start is much higher than what it
+  // initially was when we pushed it, the segment has a very high chance of
+  // having been truly garbage-collected.
+  if (currentBufferedStart !== undefined &&
+      currentBufferedStart - lastBufferedStart > 0.05)
+  {
+    return true;
+  }
+
+  const prevEntry = segmentEntries[segmentEntries.length - 2];
+  const prevBufferedStart = prevEntry.bufferedStart;
+
+  // Compare `bufferedStart` from the last time this segment was pushed
+  // (`entry.bufferedStart`) to the previous time it was pushed
+  // (`prevSegEntry.bufferedStart`).
+  //
+  // If in both cases, we notice that their initial `bufferedStart` are close,
+  // it means that in recent history the same segment has been accused to be
+  // garbage collected two times at roughly the same positions just after being
+  // pushed.
+  // This is very unlikely and might be linked to either a content or browser
+  // issue. In that case, don't try to reload.
+  return Math.abs(prevBufferedStart - lastBufferedStart) > 0.01;
+}
+
+/**
+ * Returns `true` if a segment that has been garbage-collected at the end
+ * might profit from being re-loaded.
+ *
+ * Returns `false` if we have a high chance of staying in the same situation
+ * after re-loading the segment.
+ *
+ * This function takes in argument the entries of a SegmentBuffer's history
+ * related to the corresponding segment and check if the segment appeared
+ * garbage-collected at the end directly after the last few times it was
+ * pushed, indicating that the issue might be sourced at a browser issue instead
+ * of classical garbage collection.
+ *
+ * @param {Array.<Object>} segmentEntries
+ * @param {number|undefined} currentBufferedStart
+ * @returns {boolean}
+ */
+function shouldReloadSegmentGCedAtTheEnd(
+  segmentEntries : IBufferedHistoryEntry[],
+  currentBufferedEnd : number | undefined
+) : boolean {
+  if (segmentEntries.length < 2) {
+    return true;
+  }
+  const lastEntry = segmentEntries[segmentEntries.length - 1];
+  const lastBufferedEnd = lastEntry.bufferedEnd;
+
+  // If the current segment's buffered end is much lower than what it
+  // initially was when we pushed it, the segment has a very high chance of
+  // having been truly garbage-collected.
+  if (currentBufferedEnd !== undefined &&
+      lastBufferedEnd - currentBufferedEnd > 0.05)
+  {
+    return true;
+  }
+
+  const prevEntry = segmentEntries[segmentEntries.length - 2];
+  const prevBufferedEnd = prevEntry.bufferedEnd;
+
+  // Compare `bufferedEnd` from the last time this segment was pushed
+  // (`entry.bufferedEnd`) to the previous time it was pushed
+  // (`prevSegEntry.bufferedEnd`).
+  //
+  // If in both cases, we notice that their initial `bufferedEnd` are close,
+  // it means that in recent history the same segment has been accused to be
+  // garbage collected two times at roughly the same positions just after being
+  // pushed.
+  // This is very unlikely and might be linked to either a content or browser
+  // issue. In that case, don't try to reload.
+  return Math.abs(prevBufferedEnd - lastBufferedEnd) > 0.01;
+}

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

@@ -19,24 +19,22 @@ import config from "../../../config";
 const { SEGMENT_PRIORITIES_STEPS } = config;
 
 /**
- * Calculate the priority number for a given time, in function of the distance
- * with the current time.
+ * Calculate the priority number for a given segment start time, in function of
+ * the distance with the wanted starting timestamp.
  *
  * The lower is this number, the higher should be the priority of the request.
  *
- * Note that a `timeWanted` given behind the current time will always have the
+ * Note that a `segmentTime` given behind the current time will always have the
  * highest priority.
- * @param {number} timeWanted
- * @param {Object} clockTick
+ * @param {number} segmentTime
+ * @param {Object} wantedStartTimestamp
  * @returns {number}
  */
 export default function getSegmentPriority(
-  timeWanted : number,
-  clockTick : { position : number;
-                wantedTimeOffset : number; }
+  segmentTime : number,
+  wantedStartTimestamp : number
 ) : number {
-  const currentTime = clockTick.position + clockTick.wantedTimeOffset;
-  const distance = timeWanted - currentTime;
+  const distance = segmentTime - wantedStartTimestamp;
 
   for (let priority = 0; priority < SEGMENT_PRIORITIES_STEPS.length; priority++) {
     if (distance < SEGMENT_PRIORITIES_STEPS[priority]) {

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

@@ -16,13 +16,13 @@
 
 import RepresentationStream, {
   IRepresentationStreamArguments,
-  IRepresentationStreamClockTick,
+  IRepresentationStreamPlaybackObservation,
   ITerminationOrder,
 } from "./representation_stream";
 
 export default RepresentationStream;
 export {
   IRepresentationStreamArguments,
-  IRepresentationStreamClockTick,
+  IRepresentationStreamPlaybackObservation,
   ITerminationOrder,
 };

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

@@ -17,15 +17,16 @@
 import {
   defer as observableDefer,
   EMPTY,
+  map,
   Observable,
 } from "rxjs";
-import { map } from "rxjs/operators";
 import Manifest, {
   Adaptation,
   ISegment,
   Period,
   Representation,
 } from "../../../manifest";
+import { IReadOnlyPlaybackObserver } from "../../api";
 import {
   IPushedChunkData,
   SegmentBuffer,
@@ -43,18 +44,20 @@ import appendSegmentToBuffer from "./append_segment_to_buffer";
  * @returns {Observable}
  */
 export default function pushInitSegment<T>(
-  { clock$,
+  { playbackObserver,
     content,
     segment,
     segmentData,
-    segmentBuffer } : { clock$ : Observable<{ position : number }>;
-                        content: { adaptation : Adaptation;
-                                   manifest : Manifest;
-                                   period : Period;
-                                   representation : Representation; };
-                        segmentData : T | null;
-                        segment : ISegment;
-                        segmentBuffer : SegmentBuffer<T>; }
+    segmentBuffer } :
+  { playbackObserver : IReadOnlyPlaybackObserver<{ position : number;
+                                                   wantedTimeOffset : number; }>;
+    content: { adaptation : Adaptation;
+               manifest : Manifest;
+               period : Period;
+               representation : Representation; };
+    segmentData : T | null;
+    segment : ISegment;
+    segmentBuffer : SegmentBuffer; }
 ) : Observable< IStreamEventAddedSegment<T> > {
   return observableDefer(() => {
     if (segmentData === null) {
@@ -66,11 +69,11 @@ export default function pushInitSegment<T>(
                                          timestampOffset: 0,
                                          appendWindow: [ undefined, undefined ],
                                          codec };
-    return appendSegmentToBuffer(clock$, segmentBuffer, { data,
-                                                          inventoryInfos: null })
-      .pipe(map(() => {
-        const buffered = segmentBuffer.getBufferedRanges();
-        return EVENTS.addedSegment(content, segment, buffered, segmentData);
-      }));
+    return appendSegmentToBuffer(playbackObserver,
+                                 segmentBuffer,
+                                 { data, inventoryInfos: null }).pipe(map(() => {
+      const buffered = segmentBuffer.getBufferedRanges();
+      return EVENTS.addedSegment(content, segment, buffered, segmentData);
+    }));
   });
 }

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

@@ -17,9 +17,9 @@
 import {
   defer as observableDefer,
   EMPTY,
+  map,
   Observable,
 } from "rxjs";
-import { map } from "rxjs/operators";
 import config from "../../../config";
 import Manifest, {
   Adaptation,
@@ -27,8 +27,9 @@ import Manifest, {
   Period,
   Representation,
 } from "../../../manifest";
-import { ISegmentParserParsedSegment } from "../../../transports";
+import { ISegmentParserParsedMediaChunk } from "../../../transports";
 import objectAssign from "../../../utils/object_assign";
+import { IReadOnlyPlaybackObserver } from "../../api";
 import { SegmentBuffer } from "../../segment_buffers";
 import EVENTS from "../events_generators";
 import { IStreamEventAddedSegment } from "../types";
@@ -45,20 +46,22 @@ const { APPEND_WINDOW_SECURITIES } = config;
  * @returns {Observable}
  */
 export default function pushMediaSegment<T>(
-  { clock$,
+  { playbackObserver,
     content,
     initSegmentData,
     parsedSegment,
     segment,
-    segmentBuffer } : { clock$ : Observable<{ position : number }>;
-                        content: { adaptation : Adaptation;
-                                   manifest : Manifest;
-                                   period : Period;
-                                   representation : Representation; };
-                        initSegmentData : T | null;
-                        parsedSegment : ISegmentParserParsedSegment<T>;
-                        segment : ISegment;
-                        segmentBuffer : SegmentBuffer<T>; }
+    segmentBuffer } :
+  { playbackObserver : IReadOnlyPlaybackObserver<{ position : number;
+                                                   wantedTimeOffset : number; }>;
+    content: { adaptation : Adaptation;
+               manifest : Manifest;
+               period : Period;
+               representation : Representation; };
+    initSegmentData : T | null;
+    parsedSegment : ISegmentParserParsedMediaChunk<T>;
+    segment : ISegment;
+    segmentBuffer : SegmentBuffer; }
 ) : Observable< IStreamEventAddedSegment<T> > {
   return observableDefer(() => {
     if (parsedSegment.chunkData === null) {
@@ -103,10 +106,11 @@ export default function pushMediaSegment<T>(
                                           end: estimatedEnd },
                                         content);
 
-    return appendSegmentToBuffer(clock$, segmentBuffer, { data, inventoryInfos })
-      .pipe(map(() => {
-        const buffered = segmentBuffer.getBufferedRanges();
-        return EVENTS.addedSegment(content, segment, buffered, chunkData);
-      }));
+    return appendSegmentToBuffer(playbackObserver,
+                                 segmentBuffer,
+                                 { data, inventoryInfos }).pipe(map(() => {
+      const buffered = segmentBuffer.getBufferedRanges();
+      return EVENTS.addedSegment(content, segment, buffered, chunkData);
+    }));
   });
 }