rx-player 4.5.0-dev.2026012301 → 4.5.0-dev.2026012302

package/dist/commonjs/core/segment_sinks/inventory/segment_inventory.js

@@ -0,0 +1,1124 @@
+"use strict";
+/**
+ * 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.
+ */
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var config_1 = require("../../../config");
+var log_1 = require("../../../log");
+var manifest_1 = require("../../../manifest");
+var is_null_or_undefined_1 = require("../../../utils/is_null_or_undefined");
+var monotonic_timestamp_1 = require("../../../utils/monotonic_timestamp");
+var buffered_history_1 = require("./buffered_history");
+/**
+ * Keep track of every chunk downloaded and currently in the linked media
+ * buffer.
+ *
+ * The main point of this class is to know which chunks are already pushed to
+ * the corresponding media buffer, at which bitrate, and which have been garbage-collected
+ * since by the browser (and thus may need to be re-loaded).
+ * @class SegmentInventory
+ */
+var SegmentInventory = /** @class */ (function () {
+    function SegmentInventory() {
+        var _a = config_1.default.getCurrent(), BUFFERED_HISTORY_RETENTION_TIME = _a.BUFFERED_HISTORY_RETENTION_TIME, BUFFERED_HISTORY_MAXIMUM_ENTRIES = _a.BUFFERED_HISTORY_MAXIMUM_ENTRIES;
+        this._inventory = [];
+        this._bufferedHistory = new buffered_history_1.default(BUFFERED_HISTORY_RETENTION_TIME, BUFFERED_HISTORY_MAXIMUM_ENTRIES);
+    }
+    /**
+     * Reset the whole inventory.
+     */
+    SegmentInventory.prototype.reset = function () {
+        this._inventory.length = 0;
+    };
+    /**
+     * Infer each segment's `bufferedStart` and `bufferedEnd` properties from the
+     * ranges given.
+     *
+     * The ranges object given should come from the media buffer linked to that
+     * SegmentInventory.
+     *
+     * /!\ A SegmentInventory should not be associated to multiple media buffers
+     * at a time, so each `synchronizeBuffered` call should be given ranges coming
+     * from the same buffer.
+     * @param {Array.<Object>} ranges
+     */
+    SegmentInventory.prototype.synchronizeBuffered = function (ranges) {
+        var e_1, _a;
+        var _b, _c, _d, _e, _f, _g, _h;
+        var inventory = this._inventory;
+        var inventoryIndex = 0; // Current index considered.
+        var thisSegment = inventory[0]; // Current segmentInfos considered
+        var MINIMUM_SEGMENT_SIZE = config_1.default.getCurrent().MINIMUM_SEGMENT_SIZE;
+        /** Type of buffer considered, used for logs */
+        var bufferType = thisSegment === null || thisSegment === void 0 ? void 0 : thisSegment.infos.adaptation.type;
+        if (log_1.default.hasLevel("DEBUG")) {
+            var prettyPrintedRanges = ranges.map(function (r) { return "".concat(r.start, "-").concat(r.end); }).join(",");
+            log_1.default.debug("SI", "synchronizing ".concat(bufferType !== null && bufferType !== void 0 ? bufferType : "unknown", " buffered ranges:"), prettyPrintedRanges);
+        }
+        var rangesLength = ranges.length;
+        for (var i = 0; i < rangesLength; i++) {
+            if (thisSegment === undefined) {
+                // we arrived at the end of our inventory
+                return;
+            }
+            // take the i'nth contiguous buffered range
+            var rangeStart = ranges[i].start;
+            var rangeEnd = ranges[i].end;
+            if (rangeEnd - rangeStart < MINIMUM_SEGMENT_SIZE) {
+                log_1.default.warn("SI", "skipped range when synchronizing because it was too small", {
+                    t: bufferType,
+                    rangeStart: rangeStart,
+                    rangeEnd: rangeEnd,
+                });
+                continue;
+            }
+            var indexBefore = inventoryIndex; // keep track of that number
+            // Find the first segment either within this range or completely past
+            // it:
+            // skip until first segment with at least `MINIMUM_SEGMENT_SIZE` past the
+            // start of that range.
+            while (thisSegment !== undefined &&
+                ((_b = thisSegment.bufferedEnd) !== null && _b !== void 0 ? _b : thisSegment.end) - rangeStart < MINIMUM_SEGMENT_SIZE) {
+                thisSegment = inventory[++inventoryIndex];
+            }
+            // Contains infos about the last garbage-collected segment before
+            // `thisSegment`.
+            var lastDeletedSegmentInfos = null;
+            // remove garbage-collected segments
+            // (Those not in that range nor in the previous one)
+            var numberOfSegmentToDelete = inventoryIndex - indexBefore;
+            if (numberOfSegmentToDelete > 0) {
+                var lastDeletedSegment = inventory[indexBefore + numberOfSegmentToDelete - 1]; // last garbage-collected segment
+                lastDeletedSegmentInfos = {
+                    end: (_c = lastDeletedSegment.bufferedEnd) !== null && _c !== void 0 ? _c : lastDeletedSegment.end,
+                    precizeEnd: lastDeletedSegment.precizeEnd,
+                };
+                log_1.default.debug("SI", "".concat(numberOfSegmentToDelete, " segments GCed."), {
+                    t: bufferType,
+                });
+                var removed = inventory.splice(indexBefore, numberOfSegmentToDelete);
+                try {
+                    for (var removed_1 = (e_1 = void 0, __values(removed)), removed_1_1 = removed_1.next(); !removed_1_1.done; removed_1_1 = removed_1.next()) {
+                        var seg = removed_1_1.value;
+                        if (seg.bufferedStart === undefined &&
+                            seg.bufferedEnd === undefined &&
+                            seg.status !== 2 /* ChunkStatus.Failed */) {
+                            this._bufferedHistory.addBufferedSegment(seg.infos, null);
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (removed_1_1 && !removed_1_1.done && (_a = removed_1.return)) _a.call(removed_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+                inventoryIndex = indexBefore;
+            }
+            if (thisSegment === undefined) {
+                return;
+            }
+            // If the current segment is actually completely outside that range (it
+            // is contained in one of the next one), skip that part.
+            if (rangeEnd - ((_d = thisSegment.bufferedStart) !== null && _d !== void 0 ? _d : thisSegment.start) >=
+                MINIMUM_SEGMENT_SIZE) {
+                guessBufferedStartFromRangeStart(thisSegment, rangeStart, lastDeletedSegmentInfos, bufferType);
+                if (inventoryIndex === inventory.length - 1) {
+                    // This is the last segment in the inventory.
+                    // We can directly update the end as the end of the current range.
+                    guessBufferedEndFromRangeEnd(thisSegment, rangeEnd, bufferType);
+                    return;
+                }
+                thisSegment = inventory[++inventoryIndex];
+                // Make contiguous until first segment outside that range
+                var thisSegmentStart = (_e = thisSegment.bufferedStart) !== null && _e !== void 0 ? _e : thisSegment.start;
+                var thisSegmentEnd = (_f = thisSegment.bufferedEnd) !== null && _f !== void 0 ? _f : thisSegment.end;
+                var nextRangeStart = i < rangesLength - 1 ? ranges[i + 1].start : undefined;
+                while (thisSegment !== undefined) {
+                    if (rangeEnd < thisSegmentStart) {
+                        // `thisSegment` is part of the next range
+                        break;
+                    }
+                    if (rangeEnd - thisSegmentStart < MINIMUM_SEGMENT_SIZE &&
+                        thisSegmentEnd - rangeEnd >= MINIMUM_SEGMENT_SIZE) {
+                        // Ambiguous, but `thisSegment` seems more to come after the current
+                        // range than during it.
+                        break;
+                    }
+                    if (nextRangeStart !== undefined &&
+                        rangeEnd - thisSegmentStart < thisSegmentEnd - nextRangeStart) {
+                        // Ambiguous, but `thisSegment` has more chance to be part of the
+                        // next range than the current one
+                        break;
+                    }
+                    var prevSegment = inventory[inventoryIndex - 1];
+                    // those segments are contiguous, we have no way to infer their real
+                    // end
+                    if (prevSegment.bufferedEnd === undefined) {
+                        if (thisSegment.precizeStart) {
+                            prevSegment.bufferedEnd = thisSegment.start;
+                        }
+                        else if (prevSegment.infos.segment.complete) {
+                            prevSegment.bufferedEnd = prevSegment.end;
+                        }
+                        else {
+                            // We cannot truly trust the anounced end here as the segment was
+                            // potentially not complete at its time of announce.
+                            // Just assume the next's segment announced start is right - as
+                            // `start` is in that scenario more "trustable" than `end`.
+                            prevSegment.bufferedEnd = thisSegment.start;
+                        }
+                        log_1.default.debug("SI", "calculating buffered end of contiguous segment", {
+                            t: bufferType,
+                            prevSegmentBufferedEnd: prevSegment.bufferedEnd,
+                            pse: prevSegment.end,
+                        });
+                    }
+                    thisSegment.bufferedStart = prevSegment.bufferedEnd;
+                    thisSegment = inventory[++inventoryIndex];
+                    if (thisSegment !== undefined) {
+                        thisSegmentStart = (_g = thisSegment.bufferedStart) !== null && _g !== void 0 ? _g : thisSegment.start;
+                        thisSegmentEnd = (_h = thisSegment.bufferedEnd) !== null && _h !== void 0 ? _h : thisSegment.end;
+                    }
+                }
+            }
+            // update the bufferedEnd of the last segment in that range
+            var lastSegmentInRange = inventory[inventoryIndex - 1];
+            if (lastSegmentInRange !== undefined) {
+                guessBufferedEndFromRangeEnd(lastSegmentInRange, rangeEnd, bufferType);
+            }
+        }
+        // if we still have segments left, they are not affiliated to any range.
+        // They might have been garbage collected, delete them from here.
+        if (!(0, is_null_or_undefined_1.default)(thisSegment)) {
+            var SEGMENT_SYNCHRONIZATION_DELAY = config_1.default.getCurrent().SEGMENT_SYNCHRONIZATION_DELAY;
+            var now = (0, monotonic_timestamp_1.default)();
+            for (var i = inventoryIndex; i < inventory.length; i++) {
+                var segmentInfo = inventory[i];
+                if (now - segmentInfo.insertionTs >= SEGMENT_SYNCHRONIZATION_DELAY) {
+                    log_1.default.debug("SI", "A segment at the end has been completely GCed", (0, manifest_1.getLoggableSegmentId)(segmentInfo.infos));
+                    if (segmentInfo.bufferedStart === undefined &&
+                        segmentInfo.bufferedEnd === undefined &&
+                        segmentInfo.status !== 2 /* ChunkStatus.Failed */) {
+                        this._bufferedHistory.addBufferedSegment(segmentInfo.infos, null);
+                    }
+                    inventory.splice(i, 1);
+                    i--;
+                }
+            }
+        }
+        if (bufferType !== undefined && log_1.default.hasLevel("DEBUG")) {
+            // TODO: Do not log if it did not change?
+            log_1.default.debug("SI", "current ".concat(bufferType, " inventory timeline:\n") +
+                prettyPrintInventory(this._inventory));
+        }
+    };
+    /**
+     * Add a new chunk in the inventory.
+     *
+     * Chunks are decodable sub-parts of a whole segment. Once all chunks in a
+     * segment have been inserted, you should call the `completeSegment` method.
+     * @param {Object} chunkInformation
+     * @param {boolean} succeed - If `true` the insertion operation finished with
+     * success, if `false` an error arised while doing it.
+     * @param {number} insertionTs - The monotonically-increasing timestamp at the
+     * time the segment has been confirmed to be inserted by the buffer.
+     */
+    SegmentInventory.prototype.insertChunk = function (_a, succeed, insertionTs) {
+        var period = _a.period, adaptation = _a.adaptation, representation = _a.representation, segment = _a.segment, chunkSize = _a.chunkSize, start = _a.start, end = _a.end;
+        if (segment.isInit) {
+            return;
+        }
+        var bufferType = adaptation.type;
+        if (start >= end) {
+            log_1.default.warn("SI", "Invalid chunked inserted: starts before it ends", {
+                t: bufferType,
+                start: start,
+                end: end,
+            });
+            return;
+        }
+        var inventory = this._inventory;
+        var newSegment = {
+            status: succeed ? 0 /* ChunkStatus.PartiallyPushed */ : 2 /* ChunkStatus.Failed */,
+            insertionTs: insertionTs,
+            chunkSize: chunkSize,
+            splitted: false,
+            start: start,
+            end: end,
+            precizeStart: false,
+            precizeEnd: false,
+            bufferedStart: undefined,
+            bufferedEnd: undefined,
+            infos: { segment: segment, period: period, adaptation: adaptation, representation: representation },
+        };
+        // begin by the end as in most use cases this will be faster
+        for (var i = inventory.length - 1; i >= 0; i--) {
+            var segmentI = inventory[i];
+            if (segmentI.start <= start) {
+                if (segmentI.end <= start) {
+                    // our segment is after, push it after this one
+                    //
+                    // Case 1:
+                    //   prevSegment  : |------|
+                    //   newSegment   :        |======|
+                    //   ===>         : |------|======|
+                    //
+                    // Case 2:
+                    //   prevSegment  : |------|
+                    //   newSegment   :          |======|
+                    //   ===>         : |------| |======|
+                    log_1.default.debug("SI", "Pushing segment strictly after previous one.", {
+                        t: bufferType,
+                        pse: segmentI.end,
+                        ss: start,
+                    });
+                    this._inventory.splice(i + 1, 0, newSegment);
+                    i += 2; // Go to segment immediately after newSegment
+                    while (i < inventory.length && inventory[i].start < newSegment.end) {
+                        if (inventory[i].end > newSegment.end) {
+                            // The next segment ends after newSegment.
+                            // Mutate the next segment.
+                            //
+                            // Case 1:
+                            //   prevSegment  : |------|
+                            //   newSegment   :        |======|
+                            //   nextSegment  :            |----|
+                            //   ===>         : |------|======|-|
+                            log_1.default.debug("SI", "Segment pushed updates the start of the next one", {
+                                t: bufferType,
+                                pss: inventory[i].start,
+                                ss: start,
+                                se: end,
+                            });
+                            inventory[i].start = newSegment.end;
+                            inventory[i].bufferedStart = undefined;
+                            inventory[i].precizeStart =
+                                inventory[i].precizeStart && newSegment.precizeEnd;
+                            return;
+                        }
+                        // The next segment was completely contained in newSegment.
+                        // Remove it.
+                        //
+                        // Case 1:
+                        //   prevSegment  : |------|
+                        //   newSegment   :        |======|
+                        //   nextSegment  :          |---|
+                        //   ===>         : |------|======|
+                        //
+                        // Case 2:
+                        //   prevSegment  : |------|
+                        //   newSegment   :        |======|
+                        //   nextSegment  :          |----|
+                        //   ===>         : |------|======|
+                        log_1.default.debug("SI", "Segment pushed removes the next one", {
+                            t: bufferType,
+                            ss: start,
+                            se: end,
+                            pss: inventory[i].start,
+                            pse: inventory[i].end,
+                        });
+                        inventory.splice(i, 1);
+                    }
+                    return;
+                }
+                else {
+                    if (segmentI.start === start) {
+                        if (segmentI.end <= end) {
+                            // In those cases, replace
+                            //
+                            // Case 1:
+                            //  prevSegment  : |-------|
+                            //  newSegment   : |=======|
+                            //  ===>         : |=======|
+                            //
+                            // Case 2:
+                            //  prevSegment  : |-------|
+                            //  newSegment   : |==========|
+                            //  ===>         : |==========|
+                            log_1.default.debug("SI", "Segment pushed replace another one", {
+                                t: bufferType,
+                                ss: start,
+                                se: end,
+                                pss: segmentI.start,
+                                pse: segmentI.end,
+                            });
+                            this._inventory.splice(i, 1, newSegment);
+                            i += 1; // Go to segment immediately after newSegment
+                            while (i < inventory.length && inventory[i].start < newSegment.end) {
+                                if (inventory[i].end > newSegment.end) {
+                                    // The next segment ends after newSegment.
+                                    // Mutate the next segment.
+                                    //
+                                    // Case 1:
+                                    //   newSegment   : |======|
+                                    //   nextSegment  :      |----|
+                                    //   ===>         : |======|--|
+                                    log_1.default.debug("SI", "Segment pushed updates the start of the next one", {
+                                        t: bufferType,
+                                        ss: start,
+                                        se: end,
+                                        pss: inventory[i].start,
+                                        pse: inventory[i].end,
+                                    });
+                                    inventory[i].start = newSegment.end;
+                                    inventory[i].bufferedStart = undefined;
+                                    inventory[i].precizeStart =
+                                        inventory[i].precizeStart && newSegment.precizeEnd;
+                                    return;
+                                }
+                                // The next segment was completely contained in newSegment.
+                                // Remove it.
+                                //
+                                // Case 1:
+                                //   newSegment   : |======|
+                                //   nextSegment  :   |---|
+                                //   ===>         : |======|
+                                //
+                                // Case 2:
+                                //   newSegment   : |======|
+                                //   nextSegment  :   |----|
+                                //   ===>         : |======|
+                                log_1.default.debug("SI", "Segment pushed removes the next one", {
+                                    t: bufferType,
+                                    ss: start,
+                                    se: end,
+                                    pss: inventory[i].start,
+                                    pse: inventory[i].end,
+                                });
+                                inventory.splice(i, 1);
+                            }
+                            return;
+                        }
+                        else {
+                            // The previous segment starts at the same time and finishes
+                            // after the new segment.
+                            // Update the start of the previous segment and put the new
+                            // segment before.
+                            //
+                            // Case 1:
+                            //  prevSegment  : |------------|
+                            //  newSegment   : |==========|
+                            //  ===>         : |==========|-|
+                            log_1.default.debug("SI", "Segment pushed ends before another with the same start", {
+                                t: bufferType,
+                                ss: start,
+                                se: end,
+                                pse: segmentI.end,
+                            });
+                            inventory.splice(i, 0, newSegment);
+                            segmentI.start = newSegment.end;
+                            segmentI.bufferedStart = undefined;
+                            segmentI.precizeStart = segmentI.precizeStart && newSegment.precizeEnd;
+                            return;
+                        }
+                    }
+                    else {
+                        if (segmentI.end <= newSegment.end) {
+                            // our segment has a "complex" relation with this one,
+                            // update the old one end and add this one after it.
+                            //
+                            // Case 1:
+                            //  prevSegment  : |-------|
+                            //  newSegment   :    |======|
+                            //  ===>         : |--|======|
+                            //
+                            // Case 2:
+                            //  prevSegment  : |-------|
+                            //  newSegment   :    |====|
+                            //  ===>         : |--|====|
+                            log_1.default.debug("SI", "Segment pushed updates end of previous one", {
+                                t: bufferType,
+                                ss: start,
+                                se: end,
+                                pss: segmentI.start,
+                                pse: segmentI.end,
+                            });
+                            this._inventory.splice(i + 1, 0, newSegment);
+                            segmentI.end = newSegment.start;
+                            segmentI.bufferedEnd = undefined;
+                            segmentI.precizeEnd = segmentI.precizeEnd && newSegment.precizeStart;
+                            i += 2; // Go to segment immediately after newSegment
+                            while (i < inventory.length && inventory[i].start < newSegment.end) {
+                                if (inventory[i].end > newSegment.end) {
+                                    // The next segment ends after newSegment.
+                                    // Mutate the next segment.
+                                    //
+                                    // Case 1:
+                                    //   newSegment   : |======|
+                                    //   nextSegment  :      |----|
+                                    //   ===>         : |======|--|
+                                    log_1.default.debug("SI", "Segment pushed updates the start of the next one", {
+                                        t: bufferType,
+                                        ss: start,
+                                        se: end,
+                                        pss: inventory[i].start,
+                                    });
+                                    inventory[i].start = newSegment.end;
+                                    inventory[i].bufferedStart = undefined;
+                                    inventory[i].precizeStart =
+                                        inventory[i].precizeStart && newSegment.precizeEnd;
+                                    return;
+                                }
+                                // The next segment was completely contained in newSegment.
+                                // Remove it.
+                                //
+                                // Case 1:
+                                //   newSegment   : |======|
+                                //   nextSegment  :   |---|
+                                //   ===>         : |======|
+                                //
+                                // Case 2:
+                                //   newSegment   : |======|
+                                //   nextSegment  :   |----|
+                                //   ===>         : |======|
+                                log_1.default.debug("SI", "Segment pushed removes the next one", {
+                                    t: bufferType,
+                                    ss: start,
+                                    se: end,
+                                    pss: inventory[i].start,
+                                    pse: inventory[i].end,
+                                });
+                                inventory.splice(i, 1);
+                            }
+                            return;
+                        }
+                        else {
+                            // The previous segment completely recovers the new segment.
+                            // Split the previous segment into two segments, before and after
+                            // the new segment.
+                            //
+                            // Case 1:
+                            //  prevSegment  : |---------|
+                            //  newSegment   :    |====|
+                            //  ===>         : |--|====|-|
+                            log_1.default.warn("SI", "Segment pushed is contained in a previous one", {
+                                t: bufferType,
+                                ss: start,
+                                se: end,
+                                pss: segmentI.start,
+                                pse: segmentI.end,
+                            });
+                            var nextSegment = {
+                                status: segmentI.status,
+                                insertionTs: segmentI.insertionTs,
+                                /**
+                                 * Note: this sadly means we're doing as if
+                                 * that chunk is present two times.
+                                 * Thankfully, this scenario should be
+                                 * fairly rare.
+                                 */
+                                chunkSize: segmentI.chunkSize,
+                                splitted: true,
+                                start: newSegment.end,
+                                end: segmentI.end,
+                                precizeStart: segmentI.precizeStart && segmentI.precizeEnd && newSegment.precizeEnd,
+                                precizeEnd: segmentI.precizeEnd,
+                                bufferedStart: undefined,
+                                bufferedEnd: segmentI.end,
+                                infos: segmentI.infos,
+                            };
+                            segmentI.end = newSegment.start;
+                            segmentI.splitted = true;
+                            segmentI.bufferedEnd = undefined;
+                            segmentI.precizeEnd = segmentI.precizeEnd && newSegment.precizeStart;
+                            inventory.splice(i + 1, 0, newSegment);
+                            inventory.splice(i + 2, 0, nextSegment);
+                            return;
+                        }
+                    }
+                }
+            }
+        }
+        // if we got here, we are at the first segment
+        // check bounds of the previous first segment
+        var firstSegment = this._inventory[0];
+        if (firstSegment === undefined) {
+            // we do not have any segment yet
+            log_1.default.debug("SI", "first segment pushed", { t: bufferType, ss: start, se: end });
+            this._inventory.push(newSegment);
+            return;
+        }
+        if (firstSegment.start >= end) {
+            // our segment is before, put it before
+            //
+            // Case 1:
+            //  firstSegment :      |----|
+            //  newSegment   : |====|
+            //  ===>         : |====|----|
+            //
+            // Case 2:
+            //  firstSegment :        |----|
+            //  newSegment   : |====|
+            //  ===>         : |====| |----|
+            log_1.default.debug("SI", "Segment pushed comes before all previous ones", {
+                t: bufferType,
+                ss: start,
+                se: end,
+                pss: firstSegment.start,
+            });
+            this._inventory.splice(0, 0, newSegment);
+        }
+        else if (firstSegment.end <= end) {
+            // Our segment is bigger, replace the first
+            //
+            // Case 1:
+            //  firstSegment :   |---|
+            //  newSegment   : |=======|
+            //  ===>         : |=======|
+            //
+            // Case 2:
+            //  firstSegment :   |-----|
+            //  newSegment   : |=======|
+            //  ===>         : |=======|
+            log_1.default.debug("SI", "Segment pushed starts before and completely " +
+                "recovers the previous first one", {
+                t: bufferType,
+                ss: start,
+                se: end,
+                pss: firstSegment.start,
+                pse: firstSegment.end,
+            });
+            this._inventory.splice(0, 1, newSegment);
+            while (inventory.length > 1 && inventory[1].start < newSegment.end) {
+                if (inventory[1].end > newSegment.end) {
+                    // The next segment ends after newSegment.
+                    // Mutate the next segment.
+                    //
+                    // Case 1:
+                    //   newSegment   : |======|
+                    //   nextSegment  :      |----|
+                    //   ===>         : |======|--|
+                    log_1.default.debug("SI", "Segment pushed updates the start of the next one", {
+                        t: bufferType,
+                        ss: start,
+                        se: end,
+                        pss: inventory[1].start,
+                        pse: inventory[1].end,
+                    });
+                    inventory[1].start = newSegment.end;
+                    inventory[1].bufferedStart = undefined;
+                    inventory[1].precizeStart = newSegment.precizeEnd;
+                    return;
+                }
+                // The next segment was completely contained in newSegment.
+                // Remove it.
+                //
+                // Case 1:
+                //   newSegment   : |======|
+                //   nextSegment  :   |---|
+                //   ===>         : |======|
+                //
+                // Case 2:
+                //   newSegment   : |======|
+                //   nextSegment  :   |----|
+                //   ===>         : |======|
+                log_1.default.debug("SI", "Segment pushed removes the next one", {
+                    t: bufferType,
+                    ss: start,
+                    se: end,
+                    pss: inventory[1].start,
+                    pse: inventory[1].end,
+                });
+                inventory.splice(1, 1);
+            }
+            return;
+        }
+        else {
+            // our segment has a "complex" relation with the first one,
+            // update the old one start and add this one before it.
+            //
+            // Case 1:
+            //  firstSegment :    |------|
+            //  newSegment   : |======|
+            //  ===>         : |======|--|
+            log_1.default.debug("SI", "Segment pushed start of the next one", bufferType, {
+                ss: start,
+                se: end,
+                pss: firstSegment.start,
+                pse: firstSegment.end,
+            });
+            firstSegment.start = end;
+            firstSegment.bufferedStart = undefined;
+            firstSegment.precizeStart = newSegment.precizeEnd;
+            this._inventory.splice(0, 0, newSegment);
+            return;
+        }
+    };
+    /**
+     * Indicate that inserted chunks can now be considered as a fully-loaded
+     * segment.
+     * Take in argument the same content than what was given to `insertChunk` for
+     * the corresponding chunks.
+     * @param {Object} content
+     */
+    SegmentInventory.prototype.completeSegment = function (content) {
+        var e_2, _a;
+        if (content.segment.isInit) {
+            return;
+        }
+        var inventory = this._inventory;
+        var resSegments = [];
+        for (var i = 0; i < inventory.length; i++) {
+            if ((0, manifest_1.areSameContent)(inventory[i].infos, content)) {
+                var splitted = false;
+                if (resSegments.length > 0) {
+                    splitted = true;
+                    if (resSegments.length === 1) {
+                        log_1.default.warn("SI", "Completed Segment is splitted.", (0, manifest_1.getLoggableSegmentId)(content));
+                        resSegments[0].splitted = true;
+                    }
+                }
+                var firstI = i;
+                var segmentSize = inventory[i].chunkSize;
+                i += 1;
+                while (i < inventory.length && (0, manifest_1.areSameContent)(inventory[i].infos, content)) {
+                    var chunkSize = inventory[i].chunkSize;
+                    if (segmentSize !== undefined && chunkSize !== undefined) {
+                        segmentSize += chunkSize;
+                    }
+                    i++;
+                }
+                var lastI = i - 1;
+                var length_1 = lastI - firstI;
+                var lastEnd = inventory[lastI].end;
+                var lastBufferedEnd = inventory[lastI].bufferedEnd;
+                if (length_1 > 0) {
+                    this._inventory.splice(firstI + 1, length_1);
+                    i -= length_1;
+                }
+                if (this._inventory[firstI].status === 0 /* ChunkStatus.PartiallyPushed */) {
+                    this._inventory[firstI].status = 1 /* ChunkStatus.FullyLoaded */;
+                }
+                this._inventory[firstI].chunkSize = segmentSize;
+                this._inventory[firstI].end = lastEnd;
+                this._inventory[firstI].bufferedEnd = lastBufferedEnd;
+                this._inventory[firstI].splitted = splitted;
+                resSegments.push(this._inventory[firstI]);
+            }
+        }
+        if (resSegments.length === 0) {
+            log_1.default.warn("SI", "Completed Segment not found", (0, manifest_1.getLoggableSegmentId)(content));
+        }
+        else {
+            try {
+                for (var resSegments_1 = __values(resSegments), resSegments_1_1 = resSegments_1.next(); !resSegments_1_1.done; resSegments_1_1 = resSegments_1.next()) {
+                    var seg = resSegments_1_1.value;
+                    if (seg.bufferedStart !== undefined && seg.bufferedEnd !== undefined) {
+                        if (seg.status !== 2 /* ChunkStatus.Failed */) {
+                            this._bufferedHistory.addBufferedSegment(seg.infos, {
+                                start: seg.bufferedStart,
+                                end: seg.bufferedEnd,
+                            });
+                        }
+                    }
+                    else {
+                        // TODO FIXME There might be a false positive here when the
+                        // `SEGMENT_SYNCHRONIZATION_DELAY` config value is at play
+                        log_1.default.debug("SI", "buffered range not known after sync. Skipping history.", {
+                            ss: seg.start,
+                            se: seg.end,
+                        });
+                    }
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (resSegments_1_1 && !resSegments_1_1.done && (_a = resSegments_1.return)) _a.call(resSegments_1);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+        }
+    };
+    /**
+     * Returns the whole inventory.
+     *
+     * To get a list synchronized with what a media buffer actually has buffered
+     * you might want to call `synchronizeBuffered` before calling this method.
+     * @returns {Array.<Object>}
+     */
+    SegmentInventory.prototype.getInventory = function () {
+        return this._inventory;
+    };
+    /**
+     * Returns a recent history of registered operations performed and event
+     * received linked to the segment given in argument.
+     *
+     * Not all operations and events are registered in the returned history.
+     * Please check the return type for more information on what is available.
+     *
+     * Note that history is short-lived for memory usage and performance reasons.
+     * You may not receive any information on operations that happened too long
+     * ago.
+     * @param {Object} context
+     * @returns {Array.<Object>}
+     */
+    SegmentInventory.prototype.getHistoryFor = function (context) {
+        return this._bufferedHistory.getHistoryFor(context);
+    };
+    return SegmentInventory;
+}());
+exports.default = SegmentInventory;
+/**
+ * Returns `true` if the buffered start of the given chunk looks coherent enough
+ * relatively to what is announced in the Manifest.
+ * @param {Object} thisSegment
+ * @returns {Boolean}
+ */
+function bufferedStartLooksCoherent(thisSegment) {
+    if (thisSegment.bufferedStart === undefined ||
+        thisSegment.status !== 1 /* ChunkStatus.FullyLoaded */) {
+        return false;
+    }
+    var start = thisSegment.start, end = thisSegment.end;
+    var duration = end - start;
+    var _a = config_1.default.getCurrent(), MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE = _a.MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE, MAX_MANIFEST_BUFFERED_DURATION_DIFFERENCE = _a.MAX_MANIFEST_BUFFERED_DURATION_DIFFERENCE;
+    return (Math.abs(start - thisSegment.bufferedStart) <=
+        MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE &&
+        (thisSegment.bufferedEnd === undefined ||
+            (thisSegment.bufferedEnd > thisSegment.bufferedStart &&
+                Math.abs(thisSegment.bufferedEnd - thisSegment.bufferedStart - duration) <=
+                    Math.min(MAX_MANIFEST_BUFFERED_DURATION_DIFFERENCE, duration / 3))));
+}
+/**
+ * Returns `true` if the buffered end of the given chunk looks coherent enough
+ * relatively to what is announced in the Manifest.
+ * @param {Object} thisSegment
+ * @returns {Boolean}
+ */
+function bufferedEndLooksCoherent(thisSegment) {
+    if (thisSegment.bufferedEnd === undefined ||
+        !thisSegment.infos.segment.complete ||
+        thisSegment.status !== 1 /* ChunkStatus.FullyLoaded */) {
+        return false;
+    }
+    var start = thisSegment.start, end = thisSegment.end;
+    var duration = end - start;
+    var _a = config_1.default.getCurrent(), MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE = _a.MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE, MAX_MANIFEST_BUFFERED_DURATION_DIFFERENCE = _a.MAX_MANIFEST_BUFFERED_DURATION_DIFFERENCE;
+    return (Math.abs(end - thisSegment.bufferedEnd) <=
+        MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE &&
+        thisSegment.bufferedStart !== undefined &&
+        thisSegment.bufferedEnd > thisSegment.bufferedStart &&
+        Math.abs(thisSegment.bufferedEnd - thisSegment.bufferedStart - duration) <=
+            Math.min(MAX_MANIFEST_BUFFERED_DURATION_DIFFERENCE, duration / 3));
+}
+/**
+ * Evaluate the given buffered Chunk's buffered start from its range's start,
+ * considering that this chunk is the first one in it.
+ * @param {Object} firstSegmentInRange
+ * @param {number} rangeStart
+ * @param {Object} lastDeletedSegmentInfos
+ */
+function guessBufferedStartFromRangeStart(firstSegmentInRange, rangeStart, lastDeletedSegmentInfos, bufferType) {
+    var _a = config_1.default.getCurrent(), MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE = _a.MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE, MISSING_DATA_TRIGGER_SYNC_DELAY = _a.MISSING_DATA_TRIGGER_SYNC_DELAY, SEGMENT_SYNCHRONIZATION_DELAY = _a.SEGMENT_SYNCHRONIZATION_DELAY;
+    if (firstSegmentInRange.bufferedStart !== undefined) {
+        if (firstSegmentInRange.bufferedStart < rangeStart) {
+            log_1.default.debug("SI", "Segment partially GCed at the start", {
+                t: bufferType,
+                firstsbs: firstSegmentInRange.bufferedStart,
+                rs: rangeStart,
+            });
+            firstSegmentInRange.bufferedStart = rangeStart;
+        }
+        if (!firstSegmentInRange.precizeStart &&
+            bufferedStartLooksCoherent(firstSegmentInRange)) {
+            firstSegmentInRange.start = firstSegmentInRange.bufferedStart;
+            firstSegmentInRange.precizeStart = true;
+        }
+    }
+    else if (firstSegmentInRange.precizeStart) {
+        log_1.default.debug("SI", "buffered start is precize start", {
+            t: bufferType,
+            firstss: firstSegmentInRange.start,
+        });
+        firstSegmentInRange.bufferedStart = firstSegmentInRange.start;
+    }
+    else if (lastDeletedSegmentInfos !== null &&
+        lastDeletedSegmentInfos.end > rangeStart &&
+        (lastDeletedSegmentInfos.precizeEnd ||
+            firstSegmentInRange.start - lastDeletedSegmentInfos.end <=
+                MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE)) {
+        log_1.default.debug("SI", "buffered start is end of previous segment", {
+            t: bufferType,
+            rs: rangeStart,
+            firstss: firstSegmentInRange.start,
+            lastdelse: lastDeletedSegmentInfos.end,
+        });
+        firstSegmentInRange.bufferedStart = lastDeletedSegmentInfos.end;
+        if (bufferedStartLooksCoherent(firstSegmentInRange)) {
+            firstSegmentInRange.start = lastDeletedSegmentInfos.end;
+            firstSegmentInRange.precizeStart = true;
+        }
+    }
+    else if (firstSegmentInRange.start - rangeStart <=
+        MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE) {
+        var now = (0, monotonic_timestamp_1.default)();
+        if (firstSegmentInRange.start - rangeStart >= MISSING_DATA_TRIGGER_SYNC_DELAY &&
+            now - firstSegmentInRange.insertionTs < SEGMENT_SYNCHRONIZATION_DELAY) {
+            log_1.default.debug("SI", "Ignored bufferedStart synchronization", {
+                t: bufferType,
+                rs: rangeStart,
+                firstss: firstSegmentInRange.start,
+                delta: now - firstSegmentInRange.insertionTs,
+            });
+            return;
+        }
+        log_1.default.debug("SI", "found true buffered start", {
+            t: bufferType,
+            rs: rangeStart,
+            firstss: firstSegmentInRange.start,
+        });
+        firstSegmentInRange.bufferedStart = rangeStart;
+        if (bufferedStartLooksCoherent(firstSegmentInRange)) {
+            firstSegmentInRange.start = rangeStart;
+            firstSegmentInRange.precizeStart = true;
+        }
+    }
+    else if (rangeStart < firstSegmentInRange.start) {
+        log_1.default.debug("SI", "range start too far from expected start", {
+            t: bufferType,
+            rs: rangeStart,
+            firstss: firstSegmentInRange.start,
+        });
+        firstSegmentInRange.bufferedStart = firstSegmentInRange.start;
+    }
+    else {
+        var now = (0, monotonic_timestamp_1.default)();
+        if (firstSegmentInRange.start - rangeStart >= MISSING_DATA_TRIGGER_SYNC_DELAY &&
+            now - firstSegmentInRange.insertionTs < SEGMENT_SYNCHRONIZATION_DELAY) {
+            log_1.default.debug("SI", "Ignored bufferedStart synchronization", {
+                t: bufferType,
+                rs: rangeStart,
+                firstss: firstSegmentInRange.start,
+                delta: now - firstSegmentInRange.insertionTs,
+            });
+            return;
+        }
+        log_1.default.debug("SI", "Segment appears immediately garbage collected at the start", {
+            t: bufferType,
+            rs: rangeStart,
+            firstss: firstSegmentInRange.start,
+        });
+        firstSegmentInRange.bufferedStart = rangeStart;
+    }
+}
+/**
+ * Evaluate the given buffered Chunk's buffered end from its range's end,
+ * considering that this chunk is the last one in it.
+ * @param {Object} lastSegmentInRange
+ * @param {number} rangeEnd
+ * @param {string} bufferType
+ */
+function guessBufferedEndFromRangeEnd(lastSegmentInRange, rangeEnd, bufferType) {
+    var _a = config_1.default.getCurrent(), MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE = _a.MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE, MISSING_DATA_TRIGGER_SYNC_DELAY = _a.MISSING_DATA_TRIGGER_SYNC_DELAY, SEGMENT_SYNCHRONIZATION_DELAY = _a.SEGMENT_SYNCHRONIZATION_DELAY;
+    if (lastSegmentInRange.bufferedEnd !== undefined) {
+        if (lastSegmentInRange.bufferedEnd > rangeEnd) {
+            log_1.default.debug("SI", "Segment partially GCed at the end", {
+                t: bufferType,
+                lastsbe: lastSegmentInRange.bufferedEnd,
+                re: rangeEnd,
+            });
+            lastSegmentInRange.bufferedEnd = rangeEnd;
+        }
+        if (!lastSegmentInRange.precizeEnd &&
+            rangeEnd - lastSegmentInRange.end <= MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE &&
+            bufferedEndLooksCoherent(lastSegmentInRange)) {
+            lastSegmentInRange.precizeEnd = true;
+            lastSegmentInRange.end = rangeEnd;
+        }
+    }
+    else if (lastSegmentInRange.precizeEnd) {
+        log_1.default.debug("SI", "buffered end is precize end", {
+            t: bufferType,
+            lastse: lastSegmentInRange.end,
+        });
+        lastSegmentInRange.bufferedEnd = lastSegmentInRange.end;
+    }
+    else if (rangeEnd - lastSegmentInRange.end <= MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE ||
+        !lastSegmentInRange.infos.segment.complete) {
+        var now = (0, monotonic_timestamp_1.default)();
+        if (rangeEnd - lastSegmentInRange.end >= MISSING_DATA_TRIGGER_SYNC_DELAY &&
+            now - lastSegmentInRange.insertionTs < SEGMENT_SYNCHRONIZATION_DELAY) {
+            log_1.default.debug("SI", "Ignored bufferedEnd synchronization", {
+                t: bufferType,
+                re: rangeEnd,
+                lastse: lastSegmentInRange.end,
+                delta: now - lastSegmentInRange.insertionTs,
+            });
+            return;
+        }
+        log_1.default.debug("SI", "found true buffered end", {
+            t: bufferType,
+            re: rangeEnd,
+            lastse: lastSegmentInRange.end,
+        });
+        lastSegmentInRange.bufferedEnd = rangeEnd;
+        if (bufferedEndLooksCoherent(lastSegmentInRange)) {
+            lastSegmentInRange.end = rangeEnd;
+            lastSegmentInRange.precizeEnd = true;
+        }
+    }
+    else if (rangeEnd > lastSegmentInRange.end) {
+        log_1.default.debug("SI", "range end too far from expected end", {
+            t: bufferType,
+            re: rangeEnd,
+            lastse: lastSegmentInRange.end,
+        });
+        lastSegmentInRange.bufferedEnd = lastSegmentInRange.end;
+    }
+    else {
+        var now = (0, monotonic_timestamp_1.default)();
+        if (rangeEnd - lastSegmentInRange.end >= MISSING_DATA_TRIGGER_SYNC_DELAY &&
+            now - lastSegmentInRange.insertionTs < SEGMENT_SYNCHRONIZATION_DELAY) {
+            log_1.default.debug("SI", "Ignored bufferedEnd synchronization", {
+                t: bufferType,
+                re: rangeEnd,
+                lastse: lastSegmentInRange.end,
+                delta: now - lastSegmentInRange.insertionTs,
+            });
+            return;
+        }
+        log_1.default.debug("SI", "Segment appears immediately garbage collected at the end", {
+            t: bufferType,
+            lastsbe: lastSegmentInRange.bufferedEnd,
+            re: rangeEnd,
+        });
+        lastSegmentInRange.bufferedEnd = rangeEnd;
+    }
+}
+/**
+ * Pretty print the inventory, to easily note which segments are where in the
+ * current buffer.
+ *
+ * This is mostly useful when logging.
+ *
+ * @example
+ * This function is called by giving it the inventory, such as:
+ * ```js
+ * prettyPrintInventory(inventory);
+ * ```
+ *
+ * Let's consider this possible return:
+ * ```
+ * 0.00|A|9.00 ~ 9.00|B|45.08 ~ 282.08|B|318.08
+ * [A] P: gen-dash-period-0 || R: video/5(2362822)
+ * [B] P: gen-dash-period-0 || R: video/6(2470094)
+ * ```
+ * We have a first part, from 0 to 9 seconds, which contains segments for
+ * the Representation with the id "video/5" and an associated bitrate of
+ * 2362822 bits per seconds (in the Period with the id "gen-dash-period-0").
+ *
+ * Then from 9.00 seconds to 45.08 seconds, we have segments from another
+ * Representation from the same Period (with the id "video/6" and a bitrate
+ * of 2470094 bits per seconds).
+ *
+ * At last we have a long time between 45.08 and 282.08 with no segment followed
+ * by a segment from that same Representation between 282.08 seconds and 318.08
+ * seconds.
+ * @param {Array.<Object>} inventory
+ * @returns {string}
+ */
+function prettyPrintInventory(inventory) {
+    var e_3, _a, _b;
+    var roundingError = 1 / 60;
+    var encounteredReps = {};
+    var letters = [];
+    var lastChunk = null;
+    var lastLetter = null;
+    function generateNewLetter(infos) {
+        var currentLetter = String.fromCharCode(letters.length + 65);
+        letters.push({
+            letter: currentLetter,
+            periodId: infos.period.id,
+            representationId: infos.representation.id,
+            bitrate: infos.representation.bitrate,
+        });
+        return currentLetter;
+    }
+    var str = "";
+    try {
+        for (var inventory_1 = __values(inventory), inventory_1_1 = inventory_1.next(); !inventory_1_1.done; inventory_1_1 = inventory_1.next()) {
+            var chunk = inventory_1_1.value;
+            if (chunk.bufferedStart !== undefined && chunk.bufferedEnd !== undefined) {
+                var periodId = chunk.infos.period.id;
+                var representationId = chunk.infos.representation.id;
+                var encounteredPeriod = encounteredReps[periodId];
+                var currentLetter = void 0;
+                if (encounteredPeriod === undefined) {
+                    currentLetter = generateNewLetter(chunk.infos);
+                    encounteredReps[periodId] = (_b = {}, _b[representationId] = currentLetter, _b);
+                }
+                else {
+                    var previousLetter = encounteredPeriod[representationId];
+                    if (previousLetter === undefined) {
+                        currentLetter = generateNewLetter(chunk.infos);
+                        encounteredPeriod[representationId] = currentLetter;
+                    }
+                    else {
+                        currentLetter = previousLetter;
+                    }
+                }
+                if (lastChunk === null) {
+                    str += "".concat(chunk.bufferedStart.toFixed(2), "|").concat(currentLetter, "|");
+                }
+                else if (lastLetter === currentLetter) {
+                    if (lastChunk.bufferedEnd + roundingError < chunk.bufferedStart) {
+                        str +=
+                            "".concat(lastChunk.bufferedEnd.toFixed(2), " ~ ") +
+                                "".concat(chunk.bufferedStart.toFixed(2), "|").concat(currentLetter, "|");
+                    }
+                }
+                else {
+                    str +=
+                        "".concat(lastChunk.bufferedEnd.toFixed(2), " ~ ") +
+                            "".concat(chunk.bufferedStart.toFixed(2), "|").concat(currentLetter, "|");
+                }
+                lastChunk = chunk;
+                lastLetter = currentLetter;
+            }
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (inventory_1_1 && !inventory_1_1.done && (_a = inventory_1.return)) _a.call(inventory_1);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    if (lastChunk !== null) {
+        str += String(lastChunk.end.toFixed(2));
+    }
+    letters.forEach(function (letterInfo) {
+        var _a;
+        str +=
+            "\n[".concat(letterInfo.letter, "] ") +
+                "P: ".concat(letterInfo.periodId, " || R: ").concat(letterInfo.representationId) +
+                "(".concat((_a = letterInfo.bitrate) !== null && _a !== void 0 ? _a : "unknown bitrate", ")");
+    });
+    return str;
+}