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

package/dist/_esm5.processed/parsers/manifest/smooth/representation_index.d.ts

@@ -15,79 +15,29 @@
  */
 import { IRepresentationIndex, ISegment } from "../../../manifest";
 import { IPlayerError } from "../../../public_types";
-/**
- * Object describing information about one segment or several consecutive
- * segments.
- */
-export interface IIndexSegment {
-    /** Time (timescaled) at which the segment starts. */
-    start: number;
-    /** Duration (timescaled) of the segment. */
-    duration: number;
-    /**
-     * Amount of consecutive segments with that duration.
-     *
-     * For example let's consider the following IIndexSegment:
-     * ```
-     * { start: 10, duration: 2, repeatCount: 2 }
-     * ```
-     * Here, because `repeatCount` is set to `2`, this object actually defines 3
-     * segments:
-     *   1. one starting at `10` and ending at `12` (10 + 2)
-     *   2. another one starting at `12` (the previous one's end) and ending at
-     *      `14` (12 + 2)
-     *   3. another one starting at `14` (the previous one's end) and ending at
-     *      `16` (14 +2)
-     */
-    repeatCount: number;
-}
-/**
- * Object containing information about the segments available in a
- * `SmoothRepresentationIndex`.
- */
-interface ITimelineIndex {
-    /**
-     * "Timescale" used here allowing to convert the time in this object into
-     * seconds (by doing `time / timescale`).
-     */
-    timescale: number;
-    /**
-     * Generic tokenized (e.g. with placeholders for time information) URL for
-     * every segments anounced here.
-     */
-    media: string;
-    /** Contains information about all segments available here. */
-    timeline: IIndexSegment[];
-}
+import SharedSmoothSegmentTimeline from "./shared_smooth_segment_timeline";
 /**
  * Supplementary options taken by a SmoothRepresentationIndex bringing the
  * context the segments are in.
  */
 export interface ISmoothRepresentationIndexContextInformation {
-    /**
-     * if `true`, the `SmoothRepresentationIndex` will return segments even if
-     * we're not sure they had time to be generated on the server side.
-     *
-     * TODO(Paul B.) This is a somewhat ugly option, only here for very specific
-     * Canal+ use-cases for now (most of all for Peer-to-Peer efficiency),
-     * scheduled to be removed in a next major version.
-     */
-    aggressiveMode: boolean;
     /**
      * If `true` the corresponding Smooth Manifest was announced as a live
      * content.
      * `false` otherwise.
      */
     isLive: boolean;
-    /** Value of `performance.now()` when the Manifest request was finished. */
-    manifestReceivedTime: number | undefined;
+    /**
+     * Generic tokenized (e.g. with placeholders for time information) URL for
+     * every segments anounced here.
+     */
+    media: string;
     /**
      * Contains information allowing to generate the corresponding initialization
      * segment.
      */
     segmentPrivateInfos: ISmoothInitSegmentPrivateInfos;
-    /** Depth of the DVR window, in seconds. */
-    timeShiftBufferDepth: number | undefined;
+    sharedSmoothTimeline: SharedSmoothSegmentTimeline;
 }
 /** Information allowing to generate a Smooth initialization segment. */
 interface ISmoothInitSegmentPrivateInfos {
@@ -99,6 +49,8 @@ interface ISmoothInitSegmentPrivateInfos {
     protection?: {
         keyId: Uint8Array;
     } | undefined;
+    height?: number | undefined;
+    width?: number | undefined;
 }
 /**
  * RepresentationIndex implementation for Smooth Manifests.
@@ -113,15 +65,6 @@ export default class SmoothRepresentationIndex implements IRepresentationIndex {
      * Taken from the Manifest.
      */
     private _initSegmentInfos;
-    /**
-     * if `true`, this class will return segments even if we're not sure they had
-     * time to be generated on the server side.
-     *
-     * This is a somewhat ugly option, only here for very specific Canal+
-     * use-cases for now (most of all for Peer-to-Peer efficiency), scheduled to
-     * be removed in a next major version.
-     */
-    private _isAggressiveMode;
     /**
      * Value only calculated for live contents.
      *
@@ -137,13 +80,6 @@ export default class SmoothRepresentationIndex implements IRepresentationIndex {
      * be valid, in the index's timescale.
      */
     private _initialScaledLastPosition;
-    /**
-     * Defines the earliest time when this index was known to be valid (that is, when
-     * all segments declared in it are available). This means either:
-     *   - the manifest downloading time, if known
-     *   - else, the time of creation of this RepresentationIndex, as the best guess
-     */
-    private _indexValidityTime;
     /**
      * If `true` the corresponding Smooth Manifest was announced as a live
      * content.
@@ -154,15 +90,18 @@ export default class SmoothRepresentationIndex implements IRepresentationIndex {
      * Contains information on the list of segments available in this
      * SmoothRepresentationIndex.
      */
-    private _index;
-    /** Depth of the DVR window anounced in the Manifest, in seconds. */
-    private _timeShiftBufferDepth;
+    private _sharedSmoothTimeline;
+    /**
+     * Generic tokenized (e.g. with placeholders for time information) URL for
+     * every segments anounced here.
+     */
+    private _media;
     /**
      * Creates a new `SmoothRepresentationIndex`.
      * @param {Object} index
      * @param {Object} options
      */
-    constructor(index: ITimelineIndex, options: ISmoothRepresentationIndexContextInformation);
+    constructor(options: ISmoothRepresentationIndexContextInformation);
     /**
      * Construct init Segment compatible with a Smooth Manifest.
      * @returns {Object}
@@ -265,20 +204,19 @@ export default class SmoothRepresentationIndex implements IRepresentationIndex {
      * @returns {Boolean}
      */
     isInitialized(): true;
+    initialize(): void;
     /**
-     * Add new segments to a `SmoothRepresentationIndex`.
+     * 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.
      */
-    addNewSegments(nextSegments: Array<{
+    addPredictedSegments(nextSegments: Array<{
         duration: number;
         time: number;
         timescale: number;
-    }>, currentSegment: {
-        duration: number;
-        time: number;
-    }): void;
+    }>, currentSegment: ISegment): void;
     /**
      * Clean-up timeline to remove segment information which should not be
      * available due to the timeshift window

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

@@ -16,11 +16,8 @@
 import { NetworkError } from "../../../errors";
 import log from "../../../log";
 import assert from "../../../utils/assert";
-import clearTimelineFromPosition from "../utils/clear_timeline_from_position";
 import { checkDiscontinuity, getIndexSegmentEnd, } from "../utils/index_helpers";
 import isSegmentStillAvailable from "../utils/is_segment_still_available";
-import updateSegmentTimeline from "../utils/update_segment_timeline";
-import addSegmentInfos from "./utils/add_segment_infos";
 import { replaceSegmentSmoothTokens } from "./utils/tokens";
 /**
  * @param {Number} start
@@ -43,12 +40,12 @@ function getSegmentNumber(start, up, duration) {
  *   - up {Number}: timescaled timestamp of the beginning time
  *   - to {Number}: timescaled timestamp of the end time (start time + duration)
  */
-function normalizeRange(index, start, duration) {
-    var timescale = index.timescale === undefined ||
-        index.timescale === 0 ? 1 :
-        index.timescale;
-    return { up: start * timescale,
-        to: (start + duration) * timescale };
+function normalizeRange(timescale, start, duration) {
+    var ts = timescale === undefined ||
+        timescale === 0 ? 1 :
+        timescale;
+    return { up: start * ts,
+        to: (start + duration) * ts };
 }
 /**
  * Calculate the number of times a segment repeat based on the next segment.
@@ -63,7 +60,7 @@ function calculateRepeat(segment, nextSegment) {
     // start of the next S element, the end of the Period or until the
     // next MPD update.
     // TODO Also for SMOOTH????
-    if (segment.duration != null && repeatCount < 0) {
+    if (segment.duration !== undefined && repeatCount < 0) {
         var repeatEnd = nextSegment !== undefined ? nextSegment.start :
             Infinity;
         repeatCount = Math.ceil((repeatEnd - segment.start) / segment.duration) - 1;
@@ -83,31 +80,27 @@ var SmoothRepresentationIndex = /** @class */ (function () {
      * @param {Object} index
      * @param {Object} options
      */
-    function SmoothRepresentationIndex(index, options) {
-        var aggressiveMode = options.aggressiveMode, isLive = options.isLive, segmentPrivateInfos = options.segmentPrivateInfos, timeShiftBufferDepth = options.timeShiftBufferDepth;
-        var estimatedReceivedTime = options.manifestReceivedTime == null ?
-            performance.now() :
-            options.manifestReceivedTime;
-        this._index = index;
-        this._indexValidityTime = estimatedReceivedTime;
-        this._timeShiftBufferDepth = timeShiftBufferDepth;
+    function SmoothRepresentationIndex(options) {
+        var isLive = options.isLive, segmentPrivateInfos = options.segmentPrivateInfos, media = options.media, sharedSmoothTimeline = options.sharedSmoothTimeline;
+        this._sharedSmoothTimeline = sharedSmoothTimeline;
         this._initSegmentInfos = { bitsPerSample: segmentPrivateInfos.bitsPerSample,
             channels: segmentPrivateInfos.channels,
             codecPrivateData: segmentPrivateInfos.codecPrivateData,
             packetSize: segmentPrivateInfos.packetSize,
             samplingRate: segmentPrivateInfos.samplingRate,
-            timescale: index.timescale,
+            timescale: sharedSmoothTimeline.timescale,
+            height: segmentPrivateInfos.height,
+            width: segmentPrivateInfos.width,
             protection: segmentPrivateInfos.protection };
-        this._isAggressiveMode = aggressiveMode;
         this._isLive = isLive;
-        if (index.timeline.length !== 0) {
-            var lastItem = index.timeline[index.timeline.length - 1];
+        this._media = media;
+        if (sharedSmoothTimeline.timeline.length !== 0 && isLive) {
+            var timeline = sharedSmoothTimeline.timeline, validityTime = sharedSmoothTimeline.validityTime;
+            var lastItem = timeline[timeline.length - 1];
             var scaledEnd = getIndexSegmentEnd(lastItem, null);
-            this._initialScaledLastPosition = scaledEnd;
-            if (isLive) {
-                var scaledReceivedTime = (estimatedReceivedTime / 1000) * index.timescale;
-                this._scaledLiveGap = scaledReceivedTime - scaledEnd;
-            }
+            var scaledTimelineValidityTime = (validityTime / 1000) *
+                sharedSmoothTimeline.timescale;
+            this._scaledLiveGap = scaledTimelineValidityTime - scaledEnd;
         }
     }
     /**
@@ -134,13 +127,13 @@ var SmoothRepresentationIndex = /** @class */ (function () {
      */
     SmoothRepresentationIndex.prototype.getSegments = function (from, dur) {
         this._refreshTimeline();
-        var _a = normalizeRange(this._index, from, dur), up = _a.up, to = _a.to;
-        var _b = this._index, timeline = _b.timeline, timescale = _b.timescale, media = _b.media;
-        var isAggressive = this._isAggressiveMode;
+        var _a = this._sharedSmoothTimeline, timescale = _a.timescale, timeline = _a.timeline;
+        var _b = normalizeRange(timescale, from, dur), up = _b.up, to = _b.to;
+        var media = this._media;
         var currentNumber;
         var segments = [];
         var timelineLength = timeline.length;
-        var maxPosition = this._scaledLiveGap == null ?
+        var maxPosition = this._scaledLiveGap === undefined ?
             undefined :
             ((performance.now() / 1000) * timescale) - this._scaledLiveGap;
         for (var i = 0; i < timelineLength; i++) {
@@ -149,14 +142,13 @@ var SmoothRepresentationIndex = /** @class */ (function () {
             var repeat = calculateRepeat(segmentRange, timeline[i + 1]);
             var segmentNumberInCurrentRange = getSegmentNumber(start, up, duration);
             var segmentTime = start + segmentNumberInCurrentRange * duration;
-            var timeToAddToCheckMaxPosition = isAggressive ? 0 :
-                duration;
+            var timeToAddToCheckMaxPosition = duration;
             while (segmentTime < to &&
                 segmentNumberInCurrentRange <= repeat &&
-                (maxPosition == null ||
+                (maxPosition === undefined ||
                     (segmentTime + timeToAddToCheckMaxPosition) <= maxPosition)) {
                 var time = segmentTime;
-                var number = currentNumber != null ?
+                var number = currentNumber !== undefined ?
                     currentNumber + segmentNumberInCurrentRange :
                     undefined;
                 var segment = { id: String(segmentTime),
@@ -176,7 +168,7 @@ var SmoothRepresentationIndex = /** @class */ (function () {
                 // we reached ``to``, we're done
                 return segments;
             }
-            if (currentNumber != null) {
+            if (currentNumber !== undefined) {
                 currentNumber += repeat + 1;
             }
         }
@@ -194,7 +186,7 @@ var SmoothRepresentationIndex = /** @class */ (function () {
         if (!this._isLive) {
             return false;
         }
-        var _a = this._index, timeline = _a.timeline, timescale = _a.timescale;
+        var _a = this._sharedSmoothTimeline, timeline = _a.timeline, timescale = _a.timescale;
         var lastSegmentInCurrentTimeline = timeline[timeline.length - 1];
         if (lastSegmentInCurrentTimeline === undefined) {
             return false;
@@ -219,11 +211,11 @@ var SmoothRepresentationIndex = /** @class */ (function () {
      */
     SmoothRepresentationIndex.prototype.getFirstAvailablePosition = function () {
         this._refreshTimeline();
-        var index = this._index;
-        if (index.timeline.length === 0) {
+        var _a = this._sharedSmoothTimeline, timeline = _a.timeline, timescale = _a.timescale;
+        if (timeline.length === 0) {
             return null;
         }
-        return index.timeline[0].start / index.timescale;
+        return timeline[0].start / timescale;
     };
     /**
      * Returns last position available in the index.
@@ -231,21 +223,20 @@ var SmoothRepresentationIndex = /** @class */ (function () {
      */
     SmoothRepresentationIndex.prototype.getLastAvailablePosition = function () {
         this._refreshTimeline();
-        var index = this._index;
-        if (this._scaledLiveGap == null) {
-            var lastTimelineElement = index.timeline[index.timeline.length - 1];
-            return getIndexSegmentEnd(lastTimelineElement, null) / index.timescale;
+        var _a = this._sharedSmoothTimeline, timeline = _a.timeline, timescale = _a.timescale;
+        if (this._scaledLiveGap === undefined) {
+            var lastTimelineElement = timeline[timeline.length - 1];
+            return getIndexSegmentEnd(lastTimelineElement, null) / timescale;
         }
-        for (var i = index.timeline.length - 1; i >= 0; i--) {
-            var timelineElt = index.timeline[i];
-            var timescaledNow = (performance.now() / 1000) * index.timescale;
+        for (var i = timeline.length - 1; i >= 0; i--) {
+            var timelineElt = timeline[i];
+            var timescaledNow = (performance.now() / 1000) * timescale;
             var start = timelineElt.start, duration = timelineElt.duration, repeatCount = timelineElt.repeatCount;
             for (var j = repeatCount; j >= 0; j--) {
                 var end = start + (duration * (j + 1));
-                var positionToReach = this._isAggressiveMode ? end - duration :
-                    end;
+                var positionToReach = end;
                 if (positionToReach <= timescaledNow - this._scaledLiveGap) {
-                    return end / index.timescale;
+                    return end / timescale;
                 }
             }
         }
@@ -297,7 +288,7 @@ var SmoothRepresentationIndex = /** @class */ (function () {
      */
     SmoothRepresentationIndex.prototype.checkDiscontinuity = function (timeSec) {
         this._refreshTimeline();
-        return checkDiscontinuity(this._index, timeSec, undefined);
+        return checkDiscontinuity(this._sharedSmoothTimeline, timeSec, undefined);
     };
     /**
      * Returns `true` if a Segment returned by this index is still considered
@@ -312,7 +303,7 @@ var SmoothRepresentationIndex = /** @class */ (function () {
             return true;
         }
         this._refreshTimeline();
-        var _a = this._index, timeline = _a.timeline, timescale = _a.timescale;
+        var _a = this._sharedSmoothTimeline, timeline = _a.timeline, timescale = _a.timescale;
         return isSegmentStillAvailable(segment, timeline, timescale, 0);
     };
     /**
@@ -333,57 +324,9 @@ var SmoothRepresentationIndex = /** @class */ (function () {
      * @param {Object} newIndex
      */
     SmoothRepresentationIndex.prototype._replace = function (newIndex) {
-        var oldTimeline = this._index.timeline;
-        var newTimeline = newIndex._index.timeline;
-        var oldTimescale = this._index.timescale;
-        var newTimescale = newIndex._index.timescale;
-        this._index = newIndex._index;
         this._initialScaledLastPosition = newIndex._initialScaledLastPosition;
-        this._indexValidityTime = newIndex._indexValidityTime;
         this._scaledLiveGap = newIndex._scaledLiveGap;
-        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._index.timeline = this._index.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._index.timeline = this._index.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._index.timeline = this._index.timeline.concat(supplementarySegments);
-                return;
-            }
-        }
+        this._sharedSmoothTimeline.replace(newIndex._sharedSmoothTimeline);
     };
     /**
      * Update the current index with a new, partial, version.
@@ -391,10 +334,8 @@ var SmoothRepresentationIndex = /** @class */ (function () {
      * @param {Object} newIndex
      */
     SmoothRepresentationIndex.prototype._update = function (newIndex) {
-        updateSegmentTimeline(this._index.timeline, newIndex._index.timeline);
-        this._initialScaledLastPosition = newIndex._initialScaledLastPosition;
-        this._indexValidityTime = newIndex._indexValidityTime;
         this._scaledLiveGap = newIndex._scaledLiveGap;
+        this._sharedSmoothTimeline.update(newIndex._sharedSmoothTimeline);
     };
     /**
      * Returns `true` if the last segments in this index have already been
@@ -416,38 +357,25 @@ var SmoothRepresentationIndex = /** @class */ (function () {
     SmoothRepresentationIndex.prototype.isInitialized = function () {
         return true;
     };
+    SmoothRepresentationIndex.prototype.initialize = function () {
+        log.error("A `SmoothRepresentationIndex` does not need to be initialized");
+    };
     /**
-     * Add new segments to a `SmoothRepresentationIndex`.
+     * 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.
      */
-    SmoothRepresentationIndex.prototype.addNewSegments = function (nextSegments, currentSegment) {
-        this._refreshTimeline();
-        for (var i = 0; i < nextSegments.length; i++) {
-            addSegmentInfos(this._index, nextSegments[i], currentSegment);
-        }
+    SmoothRepresentationIndex.prototype.addPredictedSegments = function (nextSegments, currentSegment) {
+        this._sharedSmoothTimeline.addPredictedSegments(nextSegments, currentSegment);
     };
     /**
      * Clean-up timeline to remove segment information which should not be
      * available due to the timeshift window
      */
     SmoothRepresentationIndex.prototype._refreshTimeline = function () {
-        // clean segments before time shift buffer depth
-        if (this._initialScaledLastPosition == null) {
-            return;
-        }
-        var index = this._index;
-        var timeShiftBufferDepth = this._timeShiftBufferDepth;
-        var timeSinceLastRealUpdate = (performance.now() -
-            this._indexValidityTime) / 1000;
-        var lastPositionEstimate = timeSinceLastRealUpdate +
-            this._initialScaledLastPosition / index.timescale;
-        if (timeShiftBufferDepth != null) {
-            var minimumPosition = (lastPositionEstimate - timeShiftBufferDepth) *
-                index.timescale;
-            clearTimelineFromPosition(index.timeline, minimumPosition);
-        }
+        this._sharedSmoothTimeline.refresh();
     };
     return SmoothRepresentationIndex;
 }());

package/dist/_esm5.processed/parsers/manifest/smooth/shared_smooth_segment_timeline.d.ts

@@ -0,0 +1,119 @@
+/**
+ * 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 { ISegment } from "../../../manifest";
+/**
+ * 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
+ */
+export default class SharedSmoothSegmentTimeline {
+    /**
+     * Array describing the list of segments available.
+     * Note that this same list might be shared by multiple `RepresentationIndex`
+     * (as they link to the same timeline in the Manifest).
+     */
+    timeline: IIndexSegment[];
+    /** Timescale allowing to convert time values in `timeline` into seconds. */
+    timescale: number;
+    /**
+     * Defines the earliest time - in terms of `performance.now()` - when the
+     * timeline was known to be valid (that is, when all segments declared in it
+     * are available).
+     *
+     * This is either:
+     *   - the Manifest downloading time, if known
+     *   - else, the time of creation of this SharedSmoothSegmentTimeline, as a
+     *     guess
+     */
+    validityTime: number;
+    private _timeShiftBufferDepth;
+    private _initialScaledLastPosition;
+    constructor(args: ISharedSmoothSegmentTimelineArguments);
+    /**
+     * Clean-up timeline to remove segment information which should not be
+     * available due to the timeshift window
+     */
+    refresh(): void;
+    /**
+     * 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
+     */
+    replace(newSmoothTimeline: SharedSmoothSegmentTimeline): void;
+    /**
+     * Update the current SharedSmoothSegmentTimeline with a new, partial, version.
+     * This method might be use to only add information about new segments.
+     * @param {Object} newSmoothTimeline
+     */
+    update(newSmoothTimeline: SharedSmoothSegmentTimeline): void;
+    /**
+     * 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.
+     */
+    addPredictedSegments(nextSegments: Array<{
+        duration: number;
+        time: number;
+        timescale: number;
+    }>, currentSegment: ISegment): void;
+}
+export interface ISharedSmoothSegmentTimelineArguments {
+    timeline: IIndexSegment[];
+    timescale: number;
+    timeShiftBufferDepth: number | undefined;
+    manifestReceivedTime: number | undefined;
+}
+/**
+ * Object describing information about one segment or several consecutive
+ * segments.
+ */
+export interface IIndexSegment {
+    /** Time (timescaled) at which the segment starts. */
+    start: number;
+    /** Duration (timescaled) of the segment. */
+    duration: number;
+    /**
+     * Amount of consecutive segments with that duration.
+     *
+     * For example let's consider the following IIndexSegment:
+     * ```
+     * { start: 10, duration: 2, repeatCount: 2 }
+     * ```
+     * Here, because `repeatCount` is set to `2`, this object actually defines 3
+     * segments:
+     *   1. one starting at `10` and ending at `12` (10 + 2)
+     *   2. another one starting at `12` (the previous one's end) and ending at
+     *      `14` (12 + 2)
+     *   3. another one starting at `14` (the previous one's end) and ending at
+     *      `16` (14 +2)
+     */
+    repeatCount: number;
+}