rx-player 3.27.0 → 3.27.1-dev.2022041500

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

@@ -20,6 +20,7 @@ import Manifest, {
   Period,
   Representation,
 } from "../../../manifest";
+import isNullOrUndefined from "../../../utils/is_null_or_undefined";
 import { IReadOnlyPlaybackObserver } from "../../api";
 import {
   IBufferedChunk,
@@ -76,9 +77,11 @@ export interface IBufferStatus {
  * be filled by any segment, even in the future.
  *
  * @param {Object} content
- * @param {Object} playbackInfo
+ * @param {number} initialWantedTime
+ * @param {Object} playbackObserver
  * @param {number|undefined} fastSwitchThreshold
  * @param {number} bufferGoal
+ * @param {number} maxBufferSize
  * @param {Object} segmentBuffer
  * @returns {Object}
  */
@@ -87,21 +90,21 @@ export default function getBufferStatus(
              manifest : Manifest;
              period : Period;
              representation : Representation; },
-  wantedStartPosition : number,
+  initialWantedTime : number,
   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) };
 
-  const shouldRefreshManifest = representation.index.shouldRefresh(wantedStartPosition,
-                                                                   wantedEndPosition);
+  const { representation } = content;
+  const neededRange = getRangeOfNeededSegments(content,
+                                               initialWantedTime,
+                                               bufferGoal);
+  const shouldRefreshManifest = representation.index.shouldRefresh(neededRange.start,
+                                                                   neededRange.end);
 
   /**
    * Every segment awaiting an "EndOfSegment" operation, which indicates that a
@@ -136,7 +139,7 @@ export default function getBufferStatus(
 
   const prioritizedNeededSegments: IQueuedSegment[] = segmentsToLoad.map((segment) => (
     {
-      priority: getSegmentPriority(segment.time, wantedStartPosition),
+      priority: getSegmentPriority(segment.time, initialWantedTime),
       segment,
     }
   ));
@@ -145,38 +148,9 @@ export default function getBufferStatus(
    * `true` if the current `RepresentationStream` has loaded all the
    * needed segments for this Representation until the end of the Period.
    */
-  let hasFinishedLoading : boolean;
-
-  const lastPosition = representation.index.getLastPosition();
-  if (!representation.index.isInitialized() ||
-      period.end === undefined ||
-      prioritizedNeededSegments.length > 0 ||
-      segmentsOnHold.length  > 0)
-  {
-    hasFinishedLoading = false;
-  } else {
-    if (lastPosition === undefined) {
-      // We do not know the end of this index.
-      // If we reached the end of the period, check that all segments are
-      // available.
-      hasFinishedLoading = neededRange.end >= period.end &&
-                           representation.index.isFinished();
-    } else if (lastPosition === null) {
-      // There is no available segment in the index currently. If the index
-      // tells us it has finished generating new segments, we're done.
-      hasFinishedLoading = representation.index.isFinished();
-    } else {
-      // We have a declared end. Check that our range went until the last
-      // position available in the index. If that's the case and we're left
-      // with no segments after filtering them, it means we already have
-      // downloaded the last segments and have nothing left to do: full.
-      const endOfRange = period.end !== undefined ? Math.min(period.end,
-                                                             lastPosition) :
-                                                    lastPosition;
-      hasFinishedLoading = neededRange.end >= endOfRange &&
-                           representation.index.isFinished();
-    }
-  }
+  const hasFinishedLoading = neededRange.hasReachedPeriodEnd &&
+                             prioritizedNeededSegments.length === 0 &&
+                             segmentsOnHold.length === 0;
 
   let imminentDiscontinuity;
   if (!representation.index.isInitialized() ||
@@ -218,6 +192,93 @@ export default function getBufferStatus(
            shouldRefreshManifest };
 }
 
+/**
+ * Returns both the time range of segments that should be loaded (from a
+ * starting position to an ending position) and whether the end of the Period is
+ * reached by that range.
+ * @param {Object} content
+ * @param {number} initialWantedTime
+ * @param {number} bufferGoal
+ * @returns {Object}
+ */
+function getRangeOfNeededSegments(
+  content: { adaptation : Adaptation;
+             manifest : Manifest;
+             period : Period;
+             representation : Representation; },
+  initialWantedTime : number,
+  bufferGoal : number
+) : { start : number; end : number; hasReachedPeriodEnd : boolean } {
+  let wantedStartPosition : number;
+  const { manifest, period, representation } = content;
+  const lastIndexPosition = representation.index.getLastPosition();
+  const representationIndex = representation.index;
+
+  // There is an exception for when the current initially wanted time is already
+  // after the last position with segments AND when we're playing the absolute
+  // last Period in the Manifest.
+  // In that case, we want to actually request at least the last segment to
+  // avoid ending the last Period - and by extension the content - with a
+  // segment which isn't the last one.
+  if (!isNullOrUndefined(lastIndexPosition) &&
+      initialWantedTime >= lastIndexPosition &&
+      representationIndex.isInitialized() &&
+      representationIndex.isFinished() &&
+      isPeriodTheCurrentAndLastOne(manifest, period, initialWantedTime))
+  {
+    wantedStartPosition = lastIndexPosition - 1;
+  } else {
+    wantedStartPosition = initialWantedTime;
+  }
+
+  const wantedEndPosition = wantedStartPosition + bufferGoal;
+
+  let hasReachedPeriodEnd;
+  if (!representation.index.isInitialized() ||
+      !representation.index.isFinished() ||
+      period.end === undefined)
+  {
+    hasReachedPeriodEnd = false;
+  } else if (lastIndexPosition === undefined) {
+    // We do not know the end of this index.
+    hasReachedPeriodEnd = wantedEndPosition >= period.end;
+  } else if (lastIndexPosition === null) {
+    // There is no available segment in the index currently.
+    hasReachedPeriodEnd = true;
+  } else {
+    // We have a declared end. Check that our range went until the last
+    // position available in the index. If that's the case and we're left
+    // with no segments after filtering them, it means we already have
+    // downloaded the last segments and have nothing left to do: full.
+    hasReachedPeriodEnd = wantedEndPosition >= lastIndexPosition;
+  }
+
+  return { start: Math.max(wantedStartPosition,
+                           period.start),
+           end: Math.min(wantedEndPosition, period.end ?? Infinity),
+           hasReachedPeriodEnd };
+}
+
+/**
+ * Returns `true` if the given Period is both:
+ *   - the one being played (the current position is known from `time`)
+ *   - the absolute last one in the Manifest (that is, there will never be a
+ *     Period after it).
+ * @param {Object} manifest
+ * @param {Object} period
+ * @param {number} time
+ * @returns {boolean}
+ */
+function isPeriodTheCurrentAndLastOne(
+  manifest : Manifest,
+  period : Period,
+  time : number
+) : boolean {
+  return period.containsTime(time) &&
+         manifest.isLastPeriodKnown &&
+         period.id === manifest.periods[manifest.periods.length - 1]?.id;
+}
+
 /**
  * From the given SegmentInventory, filters the "playable" (in a supported codec
  * and not known to be undecipherable) buffered Segment Objects which overlap

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

@@ -301,9 +301,9 @@ export default function RepresentationStream<TSegmentDataType>({
                    IStreamNeedsManifestRefresh |
                    IStreamTerminatingEvent>
     {
-      const wantedStartPosition = observation.position + observation.wantedTimeOffset;
+      const initialWantedTime = observation.position + observation.wantedTimeOffset;
       const status = getBufferStatus(content,
-                                     wantedStartPosition,
+                                     initialWantedTime,
                                      playbackObserver,
                                      fastSwitchThreshold,
                                      bufferGoal,
@@ -383,7 +383,7 @@ export default function RepresentationStream<TSegmentDataType>({
       if (status.isBufferFull) {
         const gcedPosition = Math.max(
           0,
-          wantedStartPosition - UPTO_CURRENT_POSITION_CLEANUP);
+          initialWantedTime - UPTO_CURRENT_POSITION_CLEANUP);
         if (gcedPosition > 0) {
           bufferRemoval = segmentBuffer
             .removeBuffer(0, gcedPosition)

package/src/manifest/__tests__/manifest.test.ts

@@ -47,11 +47,13 @@ describe("Manifest - Manifest", () => {
                                  isDynamic: false,
                                  isLive: false,
                                  duration: 5,
-                                 timeBounds: { absoluteMinimumTime: 0,
+                                 timeBounds: { minimumSafePosition: 0,
                                                timeshiftDepth: null,
-                                               maximumTimeData: { isLinear: false,
-                                                                  value: 10,
-                                                                  time: 10 } },
+                                               maximumTimeData: {
+                                                 isLinear: false,
+                                                 maximumSafePosition: 10,
+                                                 time: 10,
+                                               } },
                                  periods: [] };
 
     const Manifest = require("../manifest").default;
@@ -63,8 +65,8 @@ describe("Manifest - Manifest", () => {
     expect(manifest.isDynamic).toEqual(false);
     expect(manifest.isLive).toEqual(false);
     expect(manifest.lifetime).toEqual(undefined);
-    expect(manifest.getMaximumPosition()).toEqual(10);
-    expect(manifest.getMinimumPosition()).toEqual(0);
+    expect(manifest.getMaximumSafePosition()).toEqual(10);
+    expect(manifest.getMinimumSafePosition()).toEqual(0);
     expect(manifest.contentWarnings).toEqual([]);
     expect(manifest.periods).toEqual([]);
     expect(manifest.suggestedPresentationDelay).toEqual(undefined);
@@ -83,11 +85,13 @@ describe("Manifest - Manifest", () => {
                                  isDynamic: false,
                                  isLive: false,
                                  duration: 5,
-                                 timeBounds: { absoluteMinimumTime: 0,
+                                 timeBounds: { minimumSafePosition: 0,
                                                timeshiftDepth: null,
-                                               maximumTimeData: { isLinear: false,
-                                                                  value: 10,
-                                                                  time: 10 } },
+                                               maximumTimeData: {
+                                                 isLinear: false,
+                                                 maximumSafePosition: 10,
+                                                 time: 10,
+                                               } },
                                  periods: [period1, period2] };
 
     const fakePeriod = jest.fn((period) => {
@@ -123,11 +127,13 @@ describe("Manifest - Manifest", () => {
                                  isDynamic: false,
                                  isLive: false,
                                  duration: 5,
-                                 timeBounds: { absoluteMinimumTime: 0,
+                                 timeBounds: { minimumSafePosition: 0,
                                                timeshiftDepth: null,
-                                               maximumTimeData: { isLinear: false,
-                                                                  value: 10,
-                                                                  time: 10 } },
+                                               maximumTimeData: {
+                                                 isLinear: false,
+                                                 maximumSafePosition: 10,
+                                                 time: 10,
+                                               } },
                                  periods: [period1, period2] };
 
     const representationFilter = function() { return false; };
@@ -161,11 +167,13 @@ describe("Manifest - Manifest", () => {
                                  isDynamic: false,
                                  isLive: false,
                                  duration: 5,
-                                 timeBounds: { absoluteMinimumTime: 0,
+                                 timeBounds: { minimumSafePosition: 0,
                                                timeshiftDepth: null,
-                                               maximumTimeData: { isLinear: false,
-                                                                  value: 10,
-                                                                  time: 10 } },
+                                               maximumTimeData: {
+                                                 isLinear: false,
+                                                 maximumSafePosition: 10,
+                                                 time: 10,
+                                               } },
                                  periods: [period1, period2] };
 
     const fakePeriod = jest.fn((period) => {
@@ -199,11 +207,13 @@ describe("Manifest - Manifest", () => {
                                  isDynamic: false,
                                  isLive: false,
                                  duration: 5,
-                                 timeBounds: { absoluteMinimumTime: 0,
+                                 timeBounds: { minimumSafePosition: 0,
                                                timeshiftDepth: null,
-                                               maximumTimeData: { isLinear: false,
-                                                                  value: 10,
-                                                                  time: 10 } },
+                                               maximumTimeData: {
+                                                 isLinear: false,
+                                                 maximumSafePosition: 10,
+                                                 time: 10,
+                                               } },
                                  periods: [period1, period2] };
 
     const fakePeriod = jest.fn((period) => {
@@ -242,10 +252,10 @@ describe("Manifest - Manifest", () => {
                               lifetime: 13,
                               contentWarnings: [new Error("a"), new Error("b")],
                               periods: [oldPeriod1, oldPeriod2],
-                              timeBounds: { absoluteMinimumTime: 5,
+                              timeBounds: { minimumSafePosition: 5,
                                             timeshiftDepth: null,
                                             maximumTimeData: { isLinear: false,
-                                                               value: 10,
+                                                               maximumSafePosition: 10,
                                                                time } },
                               suggestedPresentationDelay: 99,
                               uris: ["url1", "url2"] };
@@ -267,8 +277,8 @@ describe("Manifest - Manifest", () => {
     expect(manifest.isLive).toEqual(false);
     expect(manifest.lifetime).toEqual(13);
     expect(manifest.contentWarnings).toEqual([new Error("0"), new Error("1")]);
-    expect(manifest.getMaximumPosition()).toEqual(10);
-    expect(manifest.getMinimumPosition()).toEqual(5);
+    expect(manifest.getMaximumSafePosition()).toEqual(10);
+    expect(manifest.getMinimumSafePosition()).toEqual(5);
     expect(manifest.periods).toEqual([
       { id: "foo0", contentWarnings: [new Error("0")], adaptations: {}, start: 4 },
       { id: "foo1", contentWarnings: [new Error("1")], adaptations: {}, start: 12 },
@@ -301,11 +311,13 @@ describe("Manifest - Manifest", () => {
                                isDynamic: false,
                                isLive: false,
                                lifetime: 13,
-                               timeBounds: { absoluteMinimumTime: 0,
+                               timeBounds: { minimumSafePosition: 0,
                                              timeshiftDepth: null,
-                                             maximumTimeData: { isLinear: false,
-                                                                value: 10,
-                                                                time: 10 } },
+                                             maximumTimeData: {
+                                               isLinear: false,
+                                               maximumSafePosition: 10,
+                                               time: 10,
+                                             } },
                                contentWarnings: [new Error("a"), new Error("b")],
                                periods: [ { id: "0", start: 4, adaptations: {} },
                                           { id: "1", start: 12, adaptations: {} } ],
@@ -325,11 +337,13 @@ describe("Manifest - Manifest", () => {
                                periods: [ { id: "0", start: 4, adaptations: {} },
                                           { id: "1", start: 12, adaptations: {} } ],
                                suggestedPresentationDelay: 99,
-                               timeBounds: { absoluteMinimumTime: 0,
+                               timeBounds: { minimumSafePosition: 0,
                                              timeshiftDepth: null,
-                                             maximumTimeData: { isLinear: false,
-                                                                value: 10,
-                                                                time: 10 } },
+                                             maximumTimeData: {
+                                               isLinear: false,
+                                               maximumSafePosition: 10,
+                                               time: 10,
+                                             } },
                                uris: [] };
     const manifest2 = new Manifest(oldManifestArgs2, {});
     expect(manifest2.getUrl()).toEqual(undefined);
@@ -362,11 +376,13 @@ describe("Manifest - Manifest", () => {
                                                  new Error("b") ],
                               periods: [ { id: "0", start: 4, adaptations: {} },
                                          { id: "1", start: 12, adaptations: {} } ],
-                              timeBounds: { absoluteMinimumTime: 7,
+                              timeBounds: { minimumSafePosition: 7,
                                             timeshiftDepth: 10,
-                                            maximumTimeData: { isLinear: true,
-                                                               value: 30,
-                                                               time: 30000 } },
+                                            maximumTimeData: {
+                                              isLinear: true,
+                                              maximumSafePosition: 30,
+                                              time: 30000,
+                                            } },
                               suggestedPresentationDelay: 99,
                               uris: ["url1", "url2"] };
 
@@ -389,11 +405,13 @@ describe("Manifest - Manifest", () => {
                           contentWarnings: [new Error("c"), new Error("d")],
                           suggestedPresentationDelay: 100,
                           timeShiftBufferDepth: 3,
-                          _timeBounds: { absoluteMinimumTime: 7,
+                          _timeBounds: { minimumSafePosition: 7,
                                          timeshiftDepth: 5,
-                                         maximumTimeData: { isLinear: false,
-                                                            value: 40,
-                                                            time: 30000 } },
+                                         maximumTimeData: {
+                                           isLinear: false,
+                                           maximumSafePosition: 40,
+                                           time: 30000,
+                                         } },
                           periods: [newPeriod1, newPeriod2],
                           uris: ["url3", "url4"] };
 
@@ -405,8 +423,8 @@ describe("Manifest - Manifest", () => {
     expect(manifest.isLive).toEqual(true);
     expect(manifest.lifetime).toEqual(14);
     expect(manifest.contentWarnings).toEqual([new Error("c"), new Error("d")]);
-    expect(manifest.getMinimumPosition()).toEqual(40 - 5);
-    expect(manifest.getMaximumPosition()).toEqual(40);
+    expect(manifest.getMinimumSafePosition()).toEqual(40 - 5);
+    expect(manifest.getMaximumSafePosition()).toEqual(40);
     expect(manifest.suggestedPresentationDelay).toEqual(100);
     expect(manifest.uris).toEqual(["url3", "url4"]);
 
@@ -431,11 +449,13 @@ describe("Manifest - Manifest", () => {
                               isDynamic: false,
                               isLive: false,
                               lifetime: 13,
-                              timeBounds: { absoluteMinimumTime: 0,
+                              timeBounds: { minimumSafePosition: 0,
                                             timeshiftDepth: null,
-                                            maximumTimeData: { isLinear: false,
-                                                               value: 10,
-                                                               time: 10 } },
+                                            maximumTimeData: {
+                                              isLinear: false,
+                                              maximumSafePosition: 10,
+                                              time: 10,
+                                            } },
                               contentWarnings: [new Error("a"), new Error("b")],
                               periods: [{ id: "1", start: 4, adaptations: {} }],
                               suggestedPresentationDelay: 99,
@@ -493,10 +513,10 @@ describe("Manifest - Manifest", () => {
                           periods: [ newPeriod1,
                                      newPeriod2,
                                      newPeriod3 ],
-                          timeBounds: { absoluteMinimumTime: 0,
+                          timeBounds: { minimumSafePosition: 0,
                                         timeshiftDepth: null,
                                         maximumTimeData: { isLinear: false,
-                                                           value: 10,
+                                                           maximumSafePosition: 10,
                                                            time: 10 } },
                           uris: ["url3", "url4"] };
 
@@ -528,11 +548,13 @@ describe("Manifest - Manifest", () => {
                               contentWarnings: [new Error("a"), new Error("b")],
                               periods: [{ id: "1" }],
                               suggestedPresentationDelay: 99,
-                              timeBounds: { absoluteMinimumTime: 0,
+                              timeBounds: { minimumSafePosition: 0,
                                             timeshiftDepth: null,
-                                            maximumTimeData: { isLinear: false,
-                                                               value: 10,
-                                                               time: 10 } },
+                                            maximumTimeData: {
+                                              isLinear: false,
+                                              maximumSafePosition: 10,
+                                              time: 10,
+                                            } },
                               uris: ["url1", "url2"] };
 
     const fakePeriod = jest.fn((period) => {
@@ -570,10 +592,10 @@ describe("Manifest - Manifest", () => {
                           contentWarnings: [new Error("c"), new Error("d")],
                           suggestedPresentationDelay: 100,
                           periods: [newPeriod1, newPeriod2, newPeriod3],
-                          timeBounds: { absoluteMinimumTime: 0,
+                          timeBounds: { minimumSafePosition: 0,
                                         timeshiftDepth: null,
                                         maximumTimeData: { isLinear: false,
-                                                           value: 10,
+                                                           maximumSafePosition: 10,
                                                            time: 10 } },
                           uris: ["url3", "url4"] };
 
@@ -603,11 +625,13 @@ describe("Manifest - Manifest", () => {
                               contentWarnings: [new Error("a"), new Error("b")],
                               periods: [{ id: "1" }],
                               suggestedPresentationDelay: 99,
-                              timeBounds: { absoluteMinimumTime: 0,
+                              timeBounds: { minimumSafePosition: 0,
                                             timeshiftDepth: null,
-                                            maximumTimeData: { isLinear: false,
-                                                               value: 10,
-                                                               time: 10 } },
+                                            maximumTimeData: {
+                                              isLinear: false,
+                                              maximumSafePosition: 10,
+                                              time: 10,
+                                            } },
                               uris: ["url1", "url2"] };
 
     const fakePeriod = jest.fn((period) => {
@@ -644,10 +668,10 @@ describe("Manifest - Manifest", () => {
                           contentWarnings: [new Error("c"), new Error("d")],
                           suggestedPresentationDelay: 100,
                           periods: [newPeriod1, newPeriod2, newPeriod3],
-                          timeBounds: { absoluteMinimumTime: 0,
+                          timeBounds: { minimumSafePosition: 0,
                                         timeshiftDepth: null,
                                         maximumTimeData: { isLinear: false,
-                                                           value: 10,
+                                                           maximumSafePosition: 10,
                                                            time: 10 } },
                           uris: ["url3", "url4"] };
 
@@ -675,11 +699,13 @@ describe("Manifest - Manifest", () => {
                               periods: [{ id: "1", start: 2 },
                                         { id: "2", start: 4 },
                                         { id: "3", start: 6 }],
-                              timeBounds: { absoluteMinimumTime: 0,
+                              timeBounds: { minimumSafePosition: 0,
                                             timeshiftDepth: null,
-                                            maximumTimeData: { isLinear: false,
-                                                               value: 10,
-                                                               time: 10 } },
+                                            maximumTimeData: {
+                                              isLinear: false,
+                                              maximumSafePosition: 10,
+                                              time: 10,
+                                            } },
                               suggestedPresentationDelay: 99,
                               uris: ["url1", "url2"] };
 
@@ -725,10 +751,10 @@ describe("Manifest - Manifest", () => {
                                      newPeriod3,
                                      newPeriod4,
                                      newPeriod5 ],
-                          timeBounds: { absoluteMinimumTime: 0,
+                          timeBounds: { minimumSafePosition: 0,
                                         timeshiftDepth: null,
                                         maximumTimeData: { isLinear: false,
-                                                           value: 10,
+                                                           maximumSafePosition: 10,
                                                            time: 10 } },
                           uris: ["url3", "url4"] };