rx-player 4.0.0-dev.2023111400 → 4.0.0-dev.2023120600

package/src/parsers/manifest/dash/common/indexes/template.ts

@@ -119,8 +119,15 @@ export interface ITemplateIndexIndexArgument {
 
 /** Aditional context needed by a SegmentTemplate RepresentationIndex. */
 export interface ITemplateIndexContextArgument {
-  /** Minimum availabilityTimeOffset concerning the segments of this Representation. */
-  availabilityTimeOffset : number;
+  /**
+   * availability time offset of the concerned Adaptation.
+   *
+   * If `undefined`, the corresponding property was not set in the MPD and it is
+   * thus assumed to be equal to `0`.
+   * It might however be semantically different than `0` in the RxPlayer as it
+   * means that the packager didn't include that information in the MPD.
+   */
+  availabilityTimeOffset : number | undefined;
   /** Allows to obtain the minimum and maximum positions of a content. */
   manifestBoundsCalculator : ManifestBoundsCalculator;
   /** Start of the period concerned by this RepresentationIndex, in seconds. */
@@ -382,14 +389,26 @@ export default class TemplateRepresentationIndex implements IRepresentationIndex
     const { timescale } = this._index;
     const segmentTimeRounding = getSegmentTimeRoundingError(timescale);
     const scaledPeriodStart = this._periodStart * timescale;
-    const scaledRelativeEnd = end * timescale - scaledPeriodStart;
+    const scaledRelativeStart = (start * timescale) - scaledPeriodStart;
+    const scaledRelativeEnd = (end * timescale) - scaledPeriodStart;
+    const lastSegmentStart = this._getLastSegmentStart();
+    if (isNullOrUndefined(lastSegmentStart)) {
+      const relativeScaledIndexEnd = this._estimateRelativeScaledEnd();
+      if (relativeScaledIndexEnd === undefined) {
+        return scaledRelativeEnd + segmentTimeRounding >= 0;
+      }
+      return scaledRelativeEnd + segmentTimeRounding >= 0 &&
+             scaledRelativeStart < relativeScaledIndexEnd - segmentTimeRounding;
+
+    }
+    const lastSegmentEnd = lastSegmentStart + this._index.duration;
 
     const relativeScaledIndexEnd = this._estimateRelativeScaledEnd();
     if (relativeScaledIndexEnd === undefined) {
-      return (scaledRelativeEnd + segmentTimeRounding) >= 0;
+      return scaledRelativeEnd > lastSegmentEnd - segmentTimeRounding;
     }
-    const scaledRelativeStart = start * timescale - scaledPeriodStart;
-    return (scaledRelativeStart - segmentTimeRounding) < relativeScaledIndexEnd;
+    return scaledRelativeEnd > lastSegmentEnd - segmentTimeRounding &&
+           scaledRelativeStart < relativeScaledIndexEnd - segmentTimeRounding;
   }
 
   /**
@@ -439,20 +458,20 @@ export default class TemplateRepresentationIndex implements IRepresentationIndex
   }
 
   /**
-   * Returns `true` if the last segments in this index have already been
+   * Returns `false` if the last segments in this index have already been
    * generated so that we can freely go to the next period.
-   * Returns `false` if the index is still waiting on future segments to be
+   * Returns `true` if the index is still waiting on future segments to be
    * generated.
    * @returns {Boolean}
    */
-  isFinished() : boolean {
+  isStillAwaitingFutureSegments() : boolean {
     if (!this._isDynamic) {
-      return true;
+      return false;
     }
 
     const scaledRelativeIndexEnd = this._estimateRelativeScaledEnd();
     if (scaledRelativeIndexEnd === undefined) {
-      return false;
+      return true;
     }
 
     const { timescale } = this._index;
@@ -461,11 +480,11 @@ export default class TemplateRepresentationIndex implements IRepresentationIndex
     // As last segment start is null if live time is before
     // current period, consider the index not to be finished.
     if (isNullOrUndefined(lastSegmentStart)) {
-      return false;
+      return true;
     }
     const lastSegmentEnd = lastSegmentStart + this._index.duration;
     const segmentTimeRounding = getSegmentTimeRoundingError(timescale);
-    return (lastSegmentEnd + segmentTimeRounding) >= scaledRelativeIndexEnd;
+    return (lastSegmentEnd + segmentTimeRounding) < scaledRelativeIndexEnd;
   }
 
   /**
@@ -520,8 +539,11 @@ export default class TemplateRepresentationIndex implements IRepresentationIndex
       // /!\ The scaled max position augments continuously and might not
       // reflect exactly the real server-side value. As segments are
       // generated discretely.
-      const maximumBound = this._manifestBoundsCalculator.estimateMaximumBound();
-      if (maximumBound !== undefined && maximumBound < this._periodStart) {
+      const maximumSegmentTime =
+        this._manifestBoundsCalculator.getEstimatedMaximumPosition(
+          this._availabilityTimeOffset ?? 0
+        );
+      if (maximumSegmentTime !== undefined && maximumSegmentTime < this._periodStart) {
         // Maximum position is before this period.
         // No segment is yet available here
         return null;
@@ -529,7 +551,7 @@ export default class TemplateRepresentationIndex implements IRepresentationIndex
     }
 
     const { duration, timescale } = this._index;
-    const firstPosition = this._manifestBoundsCalculator.estimateMinimumBound();
+    const firstPosition = this._manifestBoundsCalculator.getEstimatedMinimumSegmentTime();
     if (firstPosition === undefined) {
       return undefined;
     }
@@ -551,13 +573,12 @@ export default class TemplateRepresentationIndex implements IRepresentationIndex
     const { duration, timescale, endNumber, startNumber = 1 } = this._index;
 
     if (this._isDynamic) {
-      const lastPos = this._manifestBoundsCalculator.estimateMaximumBound();
-      if (lastPos === undefined) {
-        return undefined;
-      }
-      if (this._scaledRelativePeriodEnd !== undefined &&
-          this._scaledRelativePeriodEnd <
-            (lastPos - this._periodStart) * this._index.timescale) {
+      const liveEdge = this._manifestBoundsCalculator.getEstimatedLiveEdge();
+      if (liveEdge !== undefined &&
+          this._scaledRelativePeriodEnd !== undefined &&
+          this._scaledRelativePeriodEnd < liveEdge - (this._periodStart *
+                                                      this._index.timescale))
+      {
 
         let numberOfSegments = Math.ceil(this._scaledRelativePeriodEnd / duration);
         if (endNumber !== undefined && (endNumber - startNumber + 1) < numberOfSegments) {
@@ -565,10 +586,16 @@ export default class TemplateRepresentationIndex implements IRepresentationIndex
         }
         return (numberOfSegments - 1)  * duration;
       }
+      const lastPosition = this._manifestBoundsCalculator
+        .getEstimatedMaximumPosition(this._availabilityTimeOffset ?? 0);
+      if (lastPosition === undefined) {
+        return undefined;
+      }
+
       // /!\ The scaled last position augments continuously and might not
       // reflect exactly the real server-side value. As segments are
       // generated discretely.
-      const scaledLastPosition = (lastPos - this._periodStart) * timescale;
+      const scaledLastPosition = (lastPosition - this._periodStart) * timescale;
 
       // Maximum position is before this period.
       // No segment is yet available here
@@ -576,13 +603,7 @@ export default class TemplateRepresentationIndex implements IRepresentationIndex
         return null;
       }
 
-      const availabilityTimeOffset =
-        ((this._availabilityTimeOffset !== undefined ? this._availabilityTimeOffset : 0))
-        * timescale;
-
-      let numberOfSegmentsAvailable =
-        Math.floor((scaledLastPosition + availabilityTimeOffset) / duration);
-
+      let numberOfSegmentsAvailable = Math.floor(scaledLastPosition / duration);
       if (endNumber !== undefined &&
           (endNumber - startNumber + 1) < numberOfSegmentsAvailable) {
         numberOfSegmentsAvailable = endNumber - startNumber + 1;

package/src/parsers/manifest/dash/common/indexes/timeline/index.ts

@@ -14,5 +14,8 @@
  * limitations under the License.
  */
 
-import TimelineRepresentationIndex from "./timeline_representation_index";
+import TimelineRepresentationIndex, {
+  ITimelineIndexContextArgument,
+} from "./timeline_representation_index";
 export default TimelineRepresentationIndex;
+export { ITimelineIndexContextArgument };