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

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

@@ -0,0 +1,159 @@
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import log from "../../../log";
+import clearTimelineFromPosition from "../utils/clear_timeline_from_position";
+import { getIndexSegmentEnd } from "../utils/index_helpers";
+import updateSegmentTimeline from "../utils/update_segment_timeline";
+import addSegmentInfos from "./utils/add_segment_infos";
+/**
+ * Smooth contents provide the index of segments under a "StreamIndex", the
+ * smooth equivalent of an AdaptationSet.
+ *
+ * This means that multiple "QualityLevel" (smooth's Representation) are going
+ * to rely on the exact same list of segments. This also means that all
+ * mutations on that timeline (whether it is to evict old segments or to add
+ * new ones) should presumably happen for all of them at the same time.
+ *
+ * The `SharedSmoothSegmentTimeline` is an abstraction over that index of
+ * segments whose goal is to explicitely provide a data structure that can be
+ * shared to every `RepresentationIndex` linked to Representations being part
+ * of the same smooth Adaptation, thus allowing to mutualize any side-effect
+ * done to it automatically.
+ *
+ * @class SharedSmoothSegmentTimeline
+ */
+var SharedSmoothSegmentTimeline = /** @class */ (function () {
+    function SharedSmoothSegmentTimeline(args) {
+        var timeline = args.timeline, timescale = args.timescale, timeShiftBufferDepth = args.timeShiftBufferDepth, manifestReceivedTime = args.manifestReceivedTime;
+        this.timeline = timeline;
+        this.timescale = timescale;
+        var estimatedReceivedTime = manifestReceivedTime !== null && manifestReceivedTime !== void 0 ? manifestReceivedTime : performance.now();
+        this.validityTime = estimatedReceivedTime;
+        this._timeShiftBufferDepth = timeShiftBufferDepth;
+        if (timeline.length !== 0) {
+            var lastItem = timeline[timeline.length - 1];
+            var scaledEnd = getIndexSegmentEnd(lastItem, null);
+            this._initialScaledLastPosition = scaledEnd;
+        }
+    }
+    /**
+     * Clean-up timeline to remove segment information which should not be
+     * available due to the timeshift window
+     */
+    SharedSmoothSegmentTimeline.prototype.refresh = function () {
+        // clean segments before time shift buffer depth
+        if (this._initialScaledLastPosition === undefined) {
+            return;
+        }
+        var timeShiftBufferDepth = this._timeShiftBufferDepth;
+        var timeSinceLastRealUpdate = (performance.now() -
+            this.validityTime) / 1000;
+        var lastPositionEstimate = timeSinceLastRealUpdate +
+            this._initialScaledLastPosition / this.timescale;
+        if (timeShiftBufferDepth !== undefined) {
+            var minimumPosition = (lastPositionEstimate - timeShiftBufferDepth) *
+                this.timescale;
+            clearTimelineFromPosition(this.timeline, minimumPosition);
+        }
+    };
+    /**
+     * Replace this SharedSmoothSegmentTimeline by a newly downloaded one.
+     * Check if the old timeline had more information about new segments and re-add
+     * them if that's the case.
+     * @param {Object} newSmoothTimeline
+     */
+    SharedSmoothSegmentTimeline.prototype.replace = function (newSmoothTimeline) {
+        var oldTimeline = this.timeline;
+        var newTimeline = newSmoothTimeline.timeline;
+        var oldTimescale = this.timescale;
+        var newTimescale = newSmoothTimeline.timescale;
+        this._initialScaledLastPosition = newSmoothTimeline._initialScaledLastPosition;
+        this.validityTime = newSmoothTimeline.validityTime;
+        if (oldTimeline.length === 0 ||
+            newTimeline.length === 0 ||
+            oldTimescale !== newTimescale) {
+            return; // don't take risk, if something is off, take the new one
+        }
+        var lastOldTimelineElement = oldTimeline[oldTimeline.length - 1];
+        var lastNewTimelineElement = newTimeline[newTimeline.length - 1];
+        var newEnd = getIndexSegmentEnd(lastNewTimelineElement, null);
+        if (getIndexSegmentEnd(lastOldTimelineElement, null) <= newEnd) {
+            return;
+        }
+        for (var i = 0; i < oldTimeline.length; i++) {
+            var oldTimelineRange = oldTimeline[i];
+            var oldEnd = getIndexSegmentEnd(oldTimelineRange, null);
+            if (oldEnd === newEnd) { // just add the supplementary segments
+                this.timeline = this.timeline.concat(oldTimeline.slice(i + 1));
+                return;
+            }
+            if (oldEnd > newEnd) { // adjust repeatCount + add supplementary segments
+                if (oldTimelineRange.duration !== lastNewTimelineElement.duration) {
+                    return;
+                }
+                var rangeDuration = newEnd - oldTimelineRange.start;
+                if (rangeDuration === 0) {
+                    log.warn("Smooth Parser: a discontinuity detected in the previous manifest" +
+                        " has been resolved.");
+                    this.timeline = this.timeline.concat(oldTimeline.slice(i));
+                    return;
+                }
+                if (rangeDuration < 0 || rangeDuration % oldTimelineRange.duration !== 0) {
+                    return;
+                }
+                var repeatWithOld = (rangeDuration / oldTimelineRange.duration) - 1;
+                var relativeRepeat = oldTimelineRange.repeatCount - repeatWithOld;
+                if (relativeRepeat < 0) {
+                    return;
+                }
+                lastNewTimelineElement.repeatCount += relativeRepeat;
+                var supplementarySegments = oldTimeline.slice(i + 1);
+                this.timeline = this.timeline.concat(supplementarySegments);
+                return;
+            }
+        }
+    };
+    /**
+     * Update the current SharedSmoothSegmentTimeline with a new, partial, version.
+     * This method might be use to only add information about new segments.
+     * @param {Object} newSmoothTimeline
+     */
+    SharedSmoothSegmentTimeline.prototype.update = function (newSmoothTimeline) {
+        updateSegmentTimeline(this.timeline, newSmoothTimeline.timeline);
+        this._initialScaledLastPosition = newSmoothTimeline._initialScaledLastPosition;
+        this.validityTime = newSmoothTimeline.validityTime;
+    };
+    /**
+     * Add segments to a `SharedSmoothSegmentTimeline` that were predicted to come
+     * after `currentSegment`.
+     * @param {Array.<Object>} nextSegments - The segment information parsed.
+     * @param {Object} segment - Information on the segment which contained that
+     * new segment information.
+     */
+    SharedSmoothSegmentTimeline.prototype.addPredictedSegments = function (nextSegments, currentSegment) {
+        var _a;
+        if (((_a = currentSegment.privateInfos) === null || _a === void 0 ? void 0 : _a.smoothMediaSegment) === undefined) {
+            log.warn("Smooth Parser: should only encounter SmoothRepresentationIndex");
+            return;
+        }
+        this.refresh();
+        for (var i = 0; i < nextSegments.length; i++) {
+            addSegmentInfos(this.timeline, this.timescale, nextSegments[i], currentSegment.privateInfos.smoothMediaSegment);
+        }
+    };
+    return SharedSmoothSegmentTimeline;
+}());
+export default SharedSmoothSegmentTimeline;

package/dist/_esm5.processed/parsers/manifest/smooth/utils/add_segment_infos.d.ts

@@ -18,20 +18,17 @@ export interface IIndexSegment {
     duration: number;
     repeatCount: number;
 }
-export interface ITimelineIndex {
-    timescale: number;
-    timeline: IIndexSegment[];
-}
 /**
  * Add a new segment to the index.
  *
  * /!\ Mutate the given index
- * @param {Object} index
+ * @param {Array.<Object>} timeline
+ * @param {number} timescale
  * @param {Object} newSegment
  * @param {Object} currentSegment
  * @returns {Boolean} - true if the segment has been added
  */
-export default function _addSegmentInfos(index: ITimelineIndex, newSegment: {
+export default function _addSegmentInfos(timeline: IIndexSegment[], timescale: number, newSegment: {
     time: number;
     duration: number;
     timescale: number;

package/dist/_esm5.processed/parsers/manifest/smooth/utils/add_segment_infos.js

@@ -18,13 +18,13 @@ import { getIndexSegmentEnd } from "../../utils/index_helpers";
  * Add a new segment to the index.
  *
  * /!\ Mutate the given index
- * @param {Object} index
+ * @param {Array.<Object>} timeline
+ * @param {number} timescale
  * @param {Object} newSegment
  * @param {Object} currentSegment
  * @returns {Boolean} - true if the segment has been added
  */
-export default function _addSegmentInfos(index, newSegment, currentSegment) {
-    var timeline = index.timeline, timescale = index.timescale;
+export default function _addSegmentInfos(timeline, timescale, newSegment, currentSegment) {
     var timelineLength = timeline.length;
     var last = timeline[timelineLength - 1];
     var scaledNewSegment = newSegment.timescale === timescale ?
@@ -50,7 +50,7 @@ export default function _addSegmentInfos(index, newSegment, currentSegment) {
             last.repeatCount++;
         }
         else {
-            index.timeline.push({ duration: scaledNewSegment.duration,
+            timeline.push({ duration: scaledNewSegment.duration,
                 start: scaledNewSegment.time,
                 repeatCount: 0 });
         }

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

@@ -129,9 +129,9 @@ export interface IParsedRepresentation {
     contentProtections?: IContentProtections | undefined;
     /**
      * Frame rate (images per seconds) associated with this Representation.
-     * Not set if unknown or if it makes no sense (e.g. for subtitles).
+     * Not set if unknown or if it makes no sense.
      */
-    frameRate?: string | undefined;
+    frameRate?: number | undefined;
     /**
      * Height (top to bottom) in pixels this Representation has.
      * Not set if unknown or if it makes no sense (e.g. for audio).
@@ -154,9 +154,10 @@ export interface IParsedRepresentation {
     hdrInfo?: IHDRInformation | undefined;
     /** `true` if audio has Dolby Atmos. */
     isSpatialAudio?: boolean | undefined;
+    supplementalCodecs?: string | undefined;
 }
 /** Every possible types an Adaptation can have. */
-export type IParsedAdaptationType = "audio" | "video" | "text" | "image";
+export type IParsedAdaptationType = "audio" | "video" | "text";
 /**
  * Collection of multiple `Adaptation`, regrouped by type, as used by a
  * `Period`.

package/dist/_esm5.processed/parsers/texttracks/ttml/html/apply_extent.js

@@ -48,14 +48,7 @@ export default function applyExtent(element, extent) {
         if (secondExtent[2] === "px" ||
             secondExtent[2] === "%" ||
             secondExtent[2] === "em") {
-            var toNum = Number(secondExtent[1]);
-            if (secondExtent[2] === "%" && !isNaN(toNum) &&
-                (toNum < 0 || toNum > 100)) {
-                element.style.width = "80%";
-            }
-            else {
-                element.style.height = secondExtent[1] + secondExtent[2];
-            }
+            element.style.height = secondExtent[1] + secondExtent[2];
         }
         else if (secondExtent[2] === "c") {
             addClassName(element, "proportional-style");

package/dist/_esm5.processed/parsers/texttracks/ttml/html/apply_origin.js

@@ -47,15 +47,7 @@ export default function applyOrigin(element, origin) {
         if (secondOrigin[2] === "px" ||
             secondOrigin[2] === "%" ||
             secondOrigin[2] === "em") {
-            var toNum = Number(secondOrigin[1]);
-            if (secondOrigin[2] === "%" && !isNaN(toNum) &&
-                (toNum < 0 || toNum > 100)) {
-                element.style.bottom = "5%";
-                element.style.left = "10%";
-            }
-            else {
-                element.style.top = secondOrigin[1] + secondOrigin[2];
-            }
+            element.style.top = secondOrigin[1] + secondOrigin[2];
         }
         else if (secondOrigin[2] === "c") {
             addClassName(element, "proportional-style");