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

package/dist/commonjs/parsers/manifest/dash/common/indexes/index.d.ts

@@ -13,8 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import BaseRepresentationIndex from "./base";
-import ListRepresentationIndex from "./list";
-import TemplateRepresentationIndex from "./template";
-import TimelineRepresentationIndex from "./timeline";
-export { BaseRepresentationIndex, ListRepresentationIndex, TemplateRepresentationIndex, TimelineRepresentationIndex, };
+import BaseRepresentationIndex, { IBaseIndexContextArgument } from "./base";
+import ListRepresentationIndex, { IListIndexContextArgument } from "./list";
+import TemplateRepresentationIndex, { ITemplateIndexContextArgument } from "./template";
+import TimelineRepresentationIndex, { ITimelineIndexContextArgument } from "./timeline";
+export { BaseRepresentationIndex, ListRepresentationIndex, TemplateRepresentationIndex, TimelineRepresentationIndex, IBaseIndexContextArgument, IListIndexContextArgument, ITemplateIndexContextArgument, ITimelineIndexContextArgument, };

package/dist/commonjs/parsers/manifest/dash/common/indexes/list.d.ts

@@ -178,7 +178,7 @@ export default class ListRepresentationIndex implements IRepresentationIndex {
     /**
      * @returns {Boolean}
      */
-    isFinished(): true;
+    isStillAwaitingFutureSegments(): false;
     /**
      * @returns {Boolean}
      */

package/dist/commonjs/parsers/manifest/dash/common/indexes/list.js

@@ -187,8 +187,8 @@ var ListRepresentationIndex = /** @class */ (function () {
     /**
      * @returns {Boolean}
      */
-    ListRepresentationIndex.prototype.isFinished = function () {
-        return true;
+    ListRepresentationIndex.prototype.isStillAwaitingFutureSegments = function () {
+        return false;
     };
     /**
      * @returns {Boolean}

package/dist/commonjs/parsers/manifest/dash/common/indexes/template.d.ts

@@ -102,8 +102,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. */
@@ -208,13 +215,13 @@ export default class TemplateRepresentationIndex implements IRepresentationIndex
      */
     canBeOutOfSyncError(): false;
     /**
-     * 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;
     /**
      * @returns {Boolean}
      */

package/dist/commonjs/parsers/manifest/dash/common/indexes/template.js

@@ -201,13 +201,24 @@ var TemplateRepresentationIndex = /** @class */ (function () {
         var timescale = this._index.timescale;
         var segmentTimeRounding = (0, utils_1.getSegmentTimeRoundingError)(timescale);
         var scaledPeriodStart = this._periodStart * timescale;
-        var scaledRelativeEnd = end * timescale - scaledPeriodStart;
+        var scaledRelativeStart = (start * timescale) - scaledPeriodStart;
+        var scaledRelativeEnd = (end * timescale) - scaledPeriodStart;
+        var lastSegmentStart = this._getLastSegmentStart();
+        if ((0, is_null_or_undefined_1.default)(lastSegmentStart)) {
+            var relativeScaledIndexEnd_1 = this._estimateRelativeScaledEnd();
+            if (relativeScaledIndexEnd_1 === undefined) {
+                return scaledRelativeEnd + segmentTimeRounding >= 0;
+            }
+            return scaledRelativeEnd + segmentTimeRounding >= 0 &&
+                scaledRelativeStart < relativeScaledIndexEnd_1 - segmentTimeRounding;
+        }
+        var lastSegmentEnd = lastSegmentStart + this._index.duration;
         var relativeScaledIndexEnd = this._estimateRelativeScaledEnd();
         if (relativeScaledIndexEnd === undefined) {
-            return (scaledRelativeEnd + segmentTimeRounding) >= 0;
+            return scaledRelativeEnd > lastSegmentEnd - segmentTimeRounding;
         }
-        var scaledRelativeStart = start * timescale - scaledPeriodStart;
-        return (scaledRelativeStart - segmentTimeRounding) < relativeScaledIndexEnd;
+        return scaledRelativeEnd > lastSegmentEnd - segmentTimeRounding &&
+            scaledRelativeStart < relativeScaledIndexEnd - segmentTimeRounding;
     };
     /**
      * Returns true if, based on the arguments, the index should be refreshed.
@@ -252,30 +263,30 @@ var TemplateRepresentationIndex = /** @class */ (function () {
         return false;
     };
     /**
-     * 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}
      */
-    TemplateRepresentationIndex.prototype.isFinished = function () {
+    TemplateRepresentationIndex.prototype.isStillAwaitingFutureSegments = function () {
         if (!this._isDynamic) {
-            return true;
+            return false;
         }
         var scaledRelativeIndexEnd = this._estimateRelativeScaledEnd();
         if (scaledRelativeIndexEnd === undefined) {
-            return false;
+            return true;
         }
         var timescale = this._index.timescale;
         var lastSegmentStart = this._getLastSegmentStart();
         // As last segment start is null if live time is before
         // current period, consider the index not to be finished.
         if ((0, is_null_or_undefined_1.default)(lastSegmentStart)) {
-            return false;
+            return true;
         }
         var lastSegmentEnd = lastSegmentStart + this._index.duration;
         var segmentTimeRounding = (0, utils_1.getSegmentTimeRoundingError)(timescale);
-        return (lastSegmentEnd + segmentTimeRounding) >= scaledRelativeIndexEnd;
+        return (lastSegmentEnd + segmentTimeRounding) < scaledRelativeIndexEnd;
     };
     /**
      * @returns {Boolean}
@@ -313,6 +324,7 @@ var TemplateRepresentationIndex = /** @class */ (function () {
      * @returns {number | null | undefined}
      */
     TemplateRepresentationIndex.prototype._getFirstSegmentStart = function () {
+        var _a;
         if (!this._isDynamic) {
             return 0; // it is the start of the Period
         }
@@ -322,15 +334,15 @@ var TemplateRepresentationIndex = /** @class */ (function () {
             // /!\ The scaled max position augments continuously and might not
             // reflect exactly the real server-side value. As segments are
             // generated discretely.
-            var maximumBound = this._manifestBoundsCalculator.estimateMaximumBound();
-            if (maximumBound !== undefined && maximumBound < this._periodStart) {
+            var maximumSegmentTime = this._manifestBoundsCalculator.getEstimatedMaximumPosition((_a = this._availabilityTimeOffset) !== null && _a !== void 0 ? _a : 0);
+            if (maximumSegmentTime !== undefined && maximumSegmentTime < this._periodStart) {
                 // Maximum position is before this period.
                 // No segment is yet available here
                 return null;
             }
         }
-        var _a = this._index, duration = _a.duration, timescale = _a.timescale;
-        var firstPosition = this._manifestBoundsCalculator.estimateMinimumBound();
+        var _b = this._index, duration = _b.duration, timescale = _b.timescale;
+        var firstPosition = this._manifestBoundsCalculator.getEstimatedMinimumSegmentTime();
         if (firstPosition === undefined) {
             return undefined;
         }
@@ -347,34 +359,35 @@ var TemplateRepresentationIndex = /** @class */ (function () {
      * @returns {number|null|undefined}
      */
     TemplateRepresentationIndex.prototype._getLastSegmentStart = function () {
-        var _a;
-        var _b = this._index, duration = _b.duration, timescale = _b.timescale, endNumber = _b.endNumber, _c = _b.startNumber, startNumber = _c === void 0 ? 1 : _c;
+        var _a, _b;
+        var _c = this._index, duration = _c.duration, timescale = _c.timescale, endNumber = _c.endNumber, _d = _c.startNumber, startNumber = _d === void 0 ? 1 : _d;
         if (this._isDynamic) {
-            var lastPos = this._manifestBoundsCalculator.estimateMaximumBound();
-            if (lastPos === undefined) {
-                return undefined;
-            }
-            if (this._scaledRelativePeriodEnd !== undefined &&
-                this._scaledRelativePeriodEnd <
-                    (lastPos - this._periodStart) * this._index.timescale) {
+            var liveEdge = this._manifestBoundsCalculator.getEstimatedLiveEdge();
+            if (liveEdge !== undefined &&
+                this._scaledRelativePeriodEnd !== undefined &&
+                this._scaledRelativePeriodEnd < liveEdge - (this._periodStart *
+                    this._index.timescale)) {
                 var numberOfSegments = Math.ceil(this._scaledRelativePeriodEnd / duration);
                 if (endNumber !== undefined && (endNumber - startNumber + 1) < numberOfSegments) {
                     numberOfSegments = endNumber - startNumber + 1;
                 }
                 return (numberOfSegments - 1) * duration;
             }
+            var lastPosition = this._manifestBoundsCalculator
+                .getEstimatedMaximumPosition((_a = this._availabilityTimeOffset) !== null && _a !== void 0 ? _a : 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.
-            var scaledLastPosition = (lastPos - this._periodStart) * timescale;
+            var scaledLastPosition = (lastPosition - this._periodStart) * timescale;
             // Maximum position is before this period.
             // No segment is yet available here
             if (scaledLastPosition < 0) {
                 return null;
             }
-            var availabilityTimeOffset = ((this._availabilityTimeOffset !== undefined ? this._availabilityTimeOffset : 0))
-                * timescale;
-            var numberOfSegmentsAvailable = Math.floor((scaledLastPosition + availabilityTimeOffset) / duration);
+            var numberOfSegmentsAvailable = Math.floor(scaledLastPosition / duration);
             if (endNumber !== undefined &&
                 (endNumber - startNumber + 1) < numberOfSegmentsAvailable) {
                 numberOfSegmentsAvailable = endNumber - startNumber + 1;
@@ -384,7 +397,7 @@ var TemplateRepresentationIndex = /** @class */ (function () {
                 (numberOfSegmentsAvailable - 1) * duration;
         }
         else {
-            var maximumTime = (_a = this._scaledRelativePeriodEnd) !== null && _a !== void 0 ? _a : 0;
+            var maximumTime = (_b = this._scaledRelativePeriodEnd) !== null && _b !== void 0 ? _b : 0;
             var numberOfSegments = Math.ceil(maximumTime / duration);
             if (endNumber !== undefined && (endNumber - startNumber + 1) < numberOfSegments) {
                 numberOfSegments = endNumber - startNumber + 1;

package/dist/commonjs/parsers/manifest/dash/common/indexes/timeline/index.d.ts

@@ -13,5 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import TimelineRepresentationIndex from "./timeline_representation_index";
+import TimelineRepresentationIndex, { ITimelineIndexContextArgument } from "./timeline_representation_index";
 export default TimelineRepresentationIndex;
+export { ITimelineIndexContextArgument };

package/dist/commonjs/parsers/manifest/dash/common/indexes/timeline/timeline_representation_index.d.ts

@@ -27,6 +27,8 @@ import ManifestBoundsCalculator from "../../manifest_bounds_calculator";
 export interface ITimelineIndex {
     /** If `false`, the last segment anounced might be still incomplete. */
     availabilityTimeComplete: boolean;
+    /** Minimum availabilityTimeOffset concerning the segments of this Representation. */
+    availabilityTimeOffset: number;
     /** Byte range for a possible index of segments in the server. */
     indexRange?: [number, number] | undefined;
     /**
@@ -123,8 +125,25 @@ export interface ITimelineIndexIndexArgument {
 }
 /** Aditional context needed by a SegmentTimeline RepresentationIndex. */
 export interface ITimelineIndexContextArgument {
-    /** If `false`, the last segment anounced might be still incomplete. */
-    availabilityTimeComplete: boolean;
+    /**
+     * If `false`, declared segments in the MPD might still be not completely generated.
+     * If `true`, they are completely generated.
+     *
+     * If `undefined`, the corresponding property was not set in the MPD and it is
+     * thus assumed that they are all generated.
+     * It might however be semantically different than `true` in the RxPlayer as it
+     * means that the packager didn't include that information in the MPD.
+     */
+    availabilityTimeComplete: boolean | undefined;
+    /**
+     * 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 linked to this RepresentationIndex, in seconds. */
@@ -164,6 +183,11 @@ export interface ILastSegmentInformation {
     /** Defines the time at which `lastPosition` was last calculated. */
     time: number;
 }
+/**
+ * `IRepresentationIndex` implementation for a DASH `SegmentTimeline` segment
+ * indexing scheme.
+ * @class TimelineRepresentationIndex
+ */
 export default class TimelineRepresentationIndex implements IRepresentationIndex {
     /** Underlying structure to retrieve segment information. */
     protected _index: ITimelineIndex;
@@ -287,12 +311,12 @@ export default class TimelineRepresentationIndex implements IRepresentationIndex
      */
     _update(newIndex: TimelineRepresentationIndex): void;
     /**
-     * Returns `true` if this RepresentationIndex currently contains its last
+     * Returns `false` if this RepresentationIndex currently contains its last
      * segment.
-     * Returns `false` if it's still pending.
+     * Returns `true` if it's still pending.
      * @returns {Boolean}
      */
-    isFinished(): boolean;
+    isStillAwaitingFutureSegments(): boolean;
     /**
      * @returns {Boolean}
      */
@@ -311,7 +335,6 @@ export default class TimelineRepresentationIndex implements IRepresentationIndex
      * available due to timeshifting.
      */
     private _refreshTimeline;
-    static getIndexEnd(timeline: IIndexSegment[], scaledPeriodEnd: number | undefined): number | null;
     /**
      * Allows to generate the "timeline" for this RepresentationIndex.
      * Call this function when the timeline is unknown.
@@ -336,3 +359,73 @@ export default class TimelineRepresentationIndex implements IRepresentationIndex
      */
     private _getTimeline;
 }
+/**
+ * Returns true if a Segment returned by the corresponding index is still
+ * considered available.
+ * Returns false if it is not available anymore.
+ * Returns undefined if we cannot know whether it is still available or not.
+ * /!\ We do not check the mediaURLs of the segment.
+ * @param {Object} segment
+ * @param {Object} index
+ * @param {Object} manifestBoundsCalculator
+ * @param {number|undefined} scaledPeriodEnd
+ * @returns {Boolean|undefined}
+ */
+export declare function isSegmentStillAvailable(segment: ISegment, index: {
+    availabilityTimeOffset: number;
+    timeline: IIndexSegment[];
+    indexTimeOffset: number;
+    timescale: number;
+}, manifestBoundsCalculator: ManifestBoundsCalculator, scaledPeriodEnd: number | undefined): boolean | undefined;
+/**
+ * Returns from the given RepresentationIndex information on the last segment
+ * that may be requested currently.
+ *
+ * Returns `null` if there's no such segment.
+ * @param {Object} index
+ * @param {Object} manifestBoundsCalculator
+ * @param {number|undefined} scaledPeriodEnd
+ * @returns {number|null}
+ */
+export declare function getLastRequestableSegmentInfo(index: {
+    availabilityTimeOffset: number;
+    timeline: IIndexSegment[];
+    timescale: number;
+}, manifestBoundsCalculator: ManifestBoundsCalculator, scaledPeriodEnd: number | undefined): ILastRequestableSegmentInfo | null;
+/**
+ * Information on the last requestable segment deduced from a timeline array of
+ * segment information.
+ */
+export interface ILastRequestableSegmentInfo {
+    /**
+     * If `true`, we know that the last requestable segment is equal to the last
+     * segment that can be deduced from the corresponding given timeline.
+     * Written another way, there seem to be no segment announced in the timeline
+     * that are not yet requestable.
+     *
+     * If `false`, we know that the last requestable segment is not the last
+     * segment that can be deduced from the corresponding timeline.
+     * Written another way, there are supplementary segments in the timeline which
+     * are not yet requestable.
+     *
+     * Note that if the last requestable segment has its information from the last
+     * element from the timeline but it's not the last segment that would be
+     * deduced from the `repeatCount` property, then this value is set to `false`.
+     */
+    isLastOfTimeline: boolean;
+    /**
+     * End time at which the last requestable segment ends, in the corresponding
+     * index timescale (__NOT__ in seconds).
+     */
+    end: number;
+    /**
+     * The index in `timeline` of the last requestable segment.
+     * Note that its `repeatCount` may be updated and put as `newRepeatCount`.
+     */
+    timelineIdx: number;
+    /**
+     * The new `repeatCount` value for that last segment. May be equal or
+     * different from the timeline element found at `timelineIdx`.
+     */
+    newRepeatCount: number;
+}