rx-player 3.27.0 → 3.27.1-dev.2022041500

package/dist/_esm5.processed/parsers/manifest/smooth/create_parser.js

@@ -378,8 +378,12 @@ function createSmoothStreamingParser(parserOptions) {
         var firstAudioAdaptation = adaptations.audio !== undefined ?
             adaptations.audio[0] :
             undefined;
-        var firstTimeReference;
-        var lastTimeReference;
+        /** Minimum time that can be reached regardless of the StreamIndex chosen. */
+        var safeMinimumTime;
+        /** Maximum time that can be reached regardless of the StreamIndex chosen. */
+        var safeMaximumTime;
+        /** Maximum time that can be reached in absolute on the content. */
+        var unsafeMaximumTime;
         if (firstVideoAdaptation !== undefined || firstAudioAdaptation !== undefined) {
             var firstTimeReferences = [];
             var lastTimeReferences = [];
@@ -410,40 +414,45 @@ function createSmoothStreamingParser(parserOptions) {
                 }
             }
             if (firstTimeReferences.length > 0) {
-                firstTimeReference = Math.max.apply(Math, firstTimeReferences);
+                safeMinimumTime = Math.max.apply(Math, firstTimeReferences);
             }
             if (lastTimeReferences.length > 0) {
-                lastTimeReference = Math.min.apply(Math, lastTimeReferences);
+                safeMaximumTime = Math.min.apply(Math, lastTimeReferences);
+                unsafeMaximumTime = Math.max.apply(Math, lastTimeReferences);
             }
         }
         var manifestDuration = root.getAttribute("Duration");
-        var duration = (manifestDuration != null && +manifestDuration !== 0) ?
+        var duration = (manifestDuration !== null && +manifestDuration !== 0) ?
             (+manifestDuration / timescale) : undefined;
         if (isLive) {
             suggestedPresentationDelay = parserOptions.suggestedPresentationDelay;
             availabilityStartTime = referenceDateTime;
-            minimumTime = firstTimeReference !== null && firstTimeReference !== void 0 ? firstTimeReference : availabilityStartTime;
-            var maximumTime = lastTimeReference != null ?
-                lastTimeReference :
-                (Date.now() / 1000 - availabilityStartTime);
-            maximumTimeData = { isLinear: true,
-                value: maximumTime,
-                time: performance.now() };
+            minimumTime = safeMinimumTime !== null && safeMinimumTime !== void 0 ? safeMinimumTime : availabilityStartTime;
+            var livePosition = unsafeMaximumTime;
+            if (livePosition === undefined) {
+                livePosition = (Date.now() / 1000 - availabilityStartTime);
+            }
+            var maximumSafePosition = safeMaximumTime;
+            if (maximumSafePosition === undefined) {
+                maximumSafePosition = livePosition;
+            }
+            maximumTimeData = { isLinear: true, maximumSafePosition: maximumSafePosition, livePosition: livePosition, time: performance.now() };
             timeshiftDepth = timeShiftBufferDepth !== null && timeShiftBufferDepth !== void 0 ? timeShiftBufferDepth : null;
         }
         else {
-            minimumTime = firstTimeReference !== null && firstTimeReference !== void 0 ? firstTimeReference : 0;
-            var maximumTime = lastTimeReference !== undefined ? lastTimeReference :
+            minimumTime = safeMinimumTime !== null && safeMinimumTime !== void 0 ? safeMinimumTime : 0;
+            var maximumTime = safeMaximumTime !== undefined ? safeMaximumTime :
                 duration !== undefined ? minimumTime + duration :
                     Infinity;
             maximumTimeData = { isLinear: false,
-                value: maximumTime,
+                maximumSafePosition: maximumTime,
+                livePosition: undefined,
                 time: performance.now() };
         }
         var periodStart = isLive ? 0 :
             minimumTime;
         var periodEnd = isLive ? undefined :
-            maximumTimeData.value;
+            maximumTimeData.maximumSafePosition;
         var manifest = {
             availabilityStartTime: availabilityStartTime === undefined ?
                 0 :
@@ -452,7 +461,7 @@ function createSmoothStreamingParser(parserOptions) {
             isLive: isLive,
             isDynamic: isLive,
             isLastPeriodKnown: true,
-            timeBounds: { absoluteMinimumTime: minimumTime, timeshiftDepth: timeshiftDepth, maximumTimeData: maximumTimeData },
+            timeBounds: { minimumSafePosition: minimumTime, timeshiftDepth: timeshiftDepth, maximumTimeData: maximumTimeData },
             periods: [{ adaptations: adaptations, duration: periodEnd !== undefined ?
                         periodEnd - periodStart : duration,
                     end: periodEnd,

package/dist/_esm5.processed/parsers/manifest/types.d.ts

@@ -250,10 +250,15 @@ export interface IParsedManifest {
      */
     timeBounds: {
         /**
-         * The minimum time, in seconds, available in this Manifest.
-         * `undefined` if that value is unknown.
+         * This is the theoretical minimum playable position on the content
+         * regardless of the current Adaptation chosen, as estimated at parsing
+         * time.
+         * `undefined` if unknown.
+         *
+         * More technically, the `minimumSafePosition` is the maximum between all
+         * the minimum positions reachable in any of the audio and video Adaptation.
          */
-        absoluteMinimumTime?: number | undefined;
+        minimumSafePosition?: number | undefined;
         /**
          * Some dynamic contents have the concept of a "window depth" (or "buffer
          * depth") which allows to set a minimum position for all reachable
@@ -270,27 +275,50 @@ export interface IParsedManifest {
         timeshiftDepth: number | null;
         /** Data allowing to calculate the maximum position at any given time. */
         maximumTimeData: {
-            /** Maximum seekable time in milliseconds calculated at `time`. */
-            value: number;
             /**
-             * `Performance.now()` output at the time `value` was calculated.
-             * This can be used to retrieve the maximum position from `value` when it
-             * linearly evolves over time (see `isLinear` property).
+             * Current position representing live content.
+             * Only makes sense for un-ended live contents.
+             *
+             * `undefined` if unknown or if it doesn't make sense in the current context.
              */
-            time: number;
+            livePosition: number | undefined;
             /**
-             * Whether the maximum seekable position evolves linearly over time.
+             * Whether the maximum positions should evolve linearly over time.
              *
-             * If set to `false`, `value` indicates the constant maximum position.
-             *
-             * If set to `true`, the maximum seekable time continuously increase at
+             * If set to `true`, the maximum seekable position continuously increase at
              * the same rate than the time since `time` does.
-             * For example, a `value` of 50000 (50 seconds) will indicate a maximum time
-             * of 51 seconds after 1 second have passed, of 56 seconds after 6 seconds
-             * have passed (we know how many seconds have passed since the initial
-             * calculation of value by checking the `time` property) etc.
+             *
+             * For example, a `maximumSafePosition` of 50000 (50 seconds) will
+             * indicate a maximum time of 51 seconds after 1 second have passed, of 56
+             * seconds after 6 seconds have passed (we know how many seconds have
+             * passed since the initial calculation of the maximum position by
+             * checking the `time` property) etc.
              */
             isLinear: boolean;
+            /**
+             * This is the theoretical maximum playable position on the content,
+             * regardless of the current Adaptation chosen, as estimated at parsing
+             * time.
+             *
+             * More technically, the `maximumSafePosition` is the minimum between all
+             * attributes indicating the duration of the content in the Manifest.
+             *
+             * That is the minimum between:
+             *   - The Manifest original attributes relative to its duration
+             *   - The minimum between all known maximum audio positions
+             *   - The minimum between all known maximum video positions
+             *
+             * This can for example be understood as the safe maximum playable
+             * position through all possible tacks.
+             */
+            maximumSafePosition: number;
+            /**
+             * `Performance.now()` output at the time both `maximumSafePosition` and
+             * `maximumPositionWithMediaData` were calculated.
+             * This can be used to retrieve a new maximum position from them when they
+             * linearly evolves over time (see `isLinear` property).
+             */
+            time: number;
         };
     };
     /**

package/dist/_esm5.processed/parsers/manifest/utils/{get_maximum_position.d.ts → get_maximum_positions.d.ts}

@@ -18,4 +18,7 @@ import { IParsedPeriod } from "../types";
  * @param {Object} manifest
  * @returns {number | undefined}
  */
-export default function getMaximumPosition(periods: IParsedPeriod[]): number | undefined;
+export default function getMaximumPosition(periods: IParsedPeriod[]): {
+    safe: number | undefined;
+    unsafe: number | undefined;
+};

package/dist/_esm5.processed/parsers/manifest/utils/{get_maximum_position.js → get_maximum_positions.js}

@@ -36,14 +36,14 @@ export default function getMaximumPosition(periods) {
             if (firstAudioAdaptationFromPeriod !== undefined) {
                 var lastPosition = getLastPositionFromAdaptation(firstAudioAdaptationFromPeriod);
                 if (lastPosition === undefined) {
-                    return undefined;
+                    return { safe: undefined, unsafe: undefined };
                 }
                 maximumAudioPosition = lastPosition;
             }
             if (firstVideoAdaptationFromPeriod !== undefined) {
                 var lastPosition = getLastPositionFromAdaptation(firstVideoAdaptationFromPeriod);
                 if (lastPosition === undefined) {
-                    return undefined;
+                    return { safe: undefined, unsafe: undefined };
                 }
                 maximumVideoPosition = lastPosition;
             }
@@ -52,17 +52,21 @@ export default function getMaximumPosition(periods) {
                 (firstVideoAdaptationFromPeriod !== undefined &&
                     maximumVideoPosition === null)) {
                 log.info("Parser utils: found Period with no segment. ", "Going to previous one to calculate last position");
-                return undefined;
+                return { safe: undefined, unsafe: undefined };
             }
             if (maximumVideoPosition !== null) {
                 if (maximumAudioPosition !== null) {
-                    return Math.min(maximumAudioPosition, maximumVideoPosition);
+                    return { safe: Math.min(maximumAudioPosition, maximumVideoPosition),
+                        unsafe: Math.max(maximumAudioPosition, maximumVideoPosition) };
                 }
-                return maximumVideoPosition;
+                return { safe: maximumVideoPosition,
+                    unsafe: maximumVideoPosition };
             }
             if (maximumAudioPosition !== null) {
-                return maximumAudioPosition;
+                return { safe: maximumAudioPosition,
+                    unsafe: maximumAudioPosition };
             }
         }
     }
+    return { safe: undefined, unsafe: undefined };
 }