rx-player 3.25.2 → 3.26.3-dev.2022021400

package/dist/_esm5.processed/core/segment_buffers/implementations/types.d.ts

@@ -15,7 +15,7 @@
  */
 import { Observable } from "rxjs";
 import { Adaptation, ISegment, Period, Representation } from "../../../manifest";
-import SegmentInventory, { IBufferedChunk, IInsertedChunkInfos } from "../segment_inventory";
+import SegmentInventory, { IBufferedChunk, IBufferedHistoryEntry, IChunkContext, IInsertedChunkInfos } from "../inventory";
 /**
  * Class allowing to push segments and remove data to a buffer to be able
  * to decode them in the future as well as retrieving information about which
@@ -53,7 +53,7 @@ import SegmentInventory, { IBufferedChunk, IInsertedChunkInfos } from "../segmen
  * If operations happens synchronously, this method will just return an empty
  * array.
  */
-export declare abstract class SegmentBuffer<T> {
+export declare abstract class SegmentBuffer {
     /** "Type" of the buffer (e.g. "audio", "video", "text", "image"). */
     abstract readonly bufferType: IBufferType;
     /** Default implementation of an inventory of segment metadata. */
@@ -95,7 +95,7 @@ export declare abstract class SegmentBuffer<T> {
      * @param {Object} infos
      * @returns {Observable}
      */
-    abstract pushChunk(infos: IPushChunkInfos<T>): Observable<void>;
+    abstract pushChunk(infos: IPushChunkInfos<unknown>): Observable<void>;
     /**
      * Remove buffered data (added to the same FIFO queue than `pushChunk`).
      * @param {number} start - start position, in seconds
@@ -142,7 +142,21 @@ export declare abstract class SegmentBuffer<T> {
      * processed)
      * @returns {Array.<Object>}
      */
-    getPendingOperations(): Array<ISBOperation<T>>;
+    getPendingOperations(): Array<ISBOperation<unknown>>;
+    /**
+     * 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>}
+     */
+    getSegmentHistory(context: IChunkContext): IBufferedHistoryEntry[];
     /**
      * Dispose of the resources used by this AudioVideoSegmentBuffer.
      * /!\ You won't be able to use the SegmentBuffer after calling this

package/dist/_esm5.processed/core/segment_buffers/implementations/types.js

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import SegmentInventory from "../segment_inventory";
+import SegmentInventory from "../inventory";
 /**
  * Class allowing to push segments and remove data to a buffer to be able
  * to decode them in the future as well as retrieving information about which
@@ -90,6 +90,22 @@ var SegmentBuffer = /** @class */ (function () {
         // Return no pending operation by default (for synchronous SegmentBuffers)
         return [];
     };
+    /**
+     * 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>}
+     */
+    SegmentBuffer.prototype.getSegmentHistory = function (context) {
+        return this._segmentInventory.getHistoryFor(context);
+    };
     return SegmentBuffer;
 }());
 export { SegmentBuffer };

package/dist/_esm5.processed/core/segment_buffers/implementations/utils/manual_time_ranges.js

@@ -26,7 +26,7 @@ var ManualTimeRanges = /** @class */ (function () {
         this.length = 0;
     }
     ManualTimeRanges.prototype.insert = function (start, end) {
-        if (false) {
+        if (0 /* CURRENT_ENV */ === 1 /* DEV */) {
             assert(start >= 0, "invalid start time");
             assert(end - start > 0, "invalid end time");
         }
@@ -34,7 +34,7 @@ var ManualTimeRanges = /** @class */ (function () {
         this.length = this._ranges.length;
     };
     ManualTimeRanges.prototype.remove = function (start, end) {
-        if (false) {
+        if (0 /* CURRENT_ENV */ === 1 /* DEV */) {
             assert(start >= 0, "invalid start time");
             assert(end - start > 0, "invalid end time");
         }

package/dist/_esm5.processed/core/segment_buffers/index.d.ts

@@ -15,7 +15,7 @@
  */
 import BufferGarbageCollector from "./garbage_collector";
 import { IBufferType, IEndOfSegmentInfos, IEndOfSegmentOperation, IPushChunkInfos, IPushedChunkData, IPushOperation, IRemoveOperation, ISBOperation, SegmentBuffer, SegmentBufferOperation } from "./implementations";
+import { IBufferedChunk, IChunkContext } from "./inventory";
 import SegmentBuffersStore, { ISegmentBufferOptions, ITextTrackSegmentBufferOptions } from "./segment_buffers_store";
-import { IBufferedChunk } from "./segment_inventory";
 export default SegmentBuffersStore;
-export { BufferGarbageCollector, ISegmentBufferOptions, ITextTrackSegmentBufferOptions, SegmentBuffer, IBufferType, IBufferedChunk, IPushChunkInfos, IPushedChunkData, IEndOfSegmentInfos, SegmentBufferOperation, ISBOperation, IEndOfSegmentOperation, IPushOperation, IRemoveOperation, };
+export { BufferGarbageCollector, ISegmentBufferOptions, ITextTrackSegmentBufferOptions, SegmentBuffer, IBufferType, IBufferedChunk, IChunkContext, IPushChunkInfos, IPushedChunkData, IEndOfSegmentInfos, SegmentBufferOperation, ISBOperation, IEndOfSegmentOperation, IPushOperation, IRemoveOperation, };

package/dist/_esm5.processed/core/segment_buffers/inventory/buffered_history.d.ts

@@ -0,0 +1,81 @@
+/**
+ * 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 { IChunkContext } from "./types";
+/**
+ * Entry of a `BufferedHistory`, added when the initial buffered range of a
+ * **full segment** (and not just of a sub-chunk of a segment like in some
+ * low-latency streaming usages) in the buffer becomes known.
+ */
+export interface IBufferedHistoryEntry {
+    /** `performance.now()` when the event happened. */
+    date: number;
+    /** Start time at which we observed that segment/chunk starts at, in seconds. */
+    bufferedStart: number;
+    /** *End time at which we observed that segment/chunk ends at, in seconds. */
+    bufferedEnd: number;
+    /** Content metadata linked to the segment, allowing to recognize it. */
+    context: IChunkContext;
+}
+/**
+ * Register a short-lived history of buffer information.
+ *
+ * This class can be useful to develop heuristics based on short-term buffer
+ * history, such as knowing the real start and end of a buffered segment once
+ * it has been pushed in a buffer.
+ *
+ * By storing in a history important recent actions and events, the
+ * `BufferedHistory` can help other RxPlayer modules detect and work-around
+ * unusual behavior.
+ *
+ * @class BufferedHistory
+ */
+export default class BufferedHistory {
+    /** Complete recent history in chronological order (from oldest to newest) */
+    private _history;
+    /** Maximum time a history entry should be retained. */
+    private _lifetime;
+    /** Maximum number of entries the `BufferedHistory`'s history should have. */
+    private _maxHistoryLength;
+    /**
+     * @param {number} lifetime - Maximum time a history entry should be retained.
+     * @param {number} maxHistoryLength - Maximum number of entries the history
+     * should have.
+     */
+    constructor(lifetime: number, maxHistoryLength: number);
+    /**
+     * Add an entry to the `BufferedHistory`'s history indicating the buffered
+     * range of a pushed segment.
+     *
+     * To call when the full range of a given segment becomes known.
+     *
+     * @param {Object} context
+     * @param {number} bufferedStart
+     * @param {number} bufferedEnd
+     */
+    addBufferedSegment(context: IChunkContext, bufferedStart: number, bufferedEnd: number): void;
+    /**
+     * Returns all entries linked to the given segment.
+     * @param {Object} context
+     * @returns {Array.<Object>}
+     */
+    getHistoryFor(context: IChunkContext): IBufferedHistoryEntry[];
+    /**
+     * If the current history does not satisfy `_lifetime` or `_maxHistoryLength`,
+     * clear older entries until it does.
+     * @param {number} now - Current `performance.now()` result.
+     */
+    private _cleanHistory;
+}

package/dist/_esm5.processed/core/segment_buffers/inventory/buffered_history.js

@@ -0,0 +1,91 @@
+/**
+ * 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 { areSameContent } from "../../../manifest";
+/**
+ * Register a short-lived history of buffer information.
+ *
+ * This class can be useful to develop heuristics based on short-term buffer
+ * history, such as knowing the real start and end of a buffered segment once
+ * it has been pushed in a buffer.
+ *
+ * By storing in a history important recent actions and events, the
+ * `BufferedHistory` can help other RxPlayer modules detect and work-around
+ * unusual behavior.
+ *
+ * @class BufferedHistory
+ */
+var BufferedHistory = /** @class */ (function () {
+    /**
+     * @param {number} lifetime - Maximum time a history entry should be retained.
+     * @param {number} maxHistoryLength - Maximum number of entries the history
+     * should have.
+     */
+    function BufferedHistory(lifetime, maxHistoryLength) {
+        this._history = [];
+        this._lifetime = lifetime;
+        this._maxHistoryLength = maxHistoryLength;
+    }
+    /**
+     * Add an entry to the `BufferedHistory`'s history indicating the buffered
+     * range of a pushed segment.
+     *
+     * To call when the full range of a given segment becomes known.
+     *
+     * @param {Object} context
+     * @param {number} bufferedStart
+     * @param {number} bufferedEnd
+     */
+    BufferedHistory.prototype.addBufferedSegment = function (context, bufferedStart, bufferedEnd) {
+        var now = performance.now();
+        this._history.push({ date: now, bufferedStart: bufferedStart, bufferedEnd: bufferedEnd, context: context });
+        this._cleanHistory(now);
+    };
+    /**
+     * Returns all entries linked to the given segment.
+     * @param {Object} context
+     * @returns {Array.<Object>}
+     */
+    BufferedHistory.prototype.getHistoryFor = function (context) {
+        return this._history.filter(function (el) { return areSameContent(el.context, context); });
+    };
+    /**
+     * If the current history does not satisfy `_lifetime` or `_maxHistoryLength`,
+     * clear older entries until it does.
+     * @param {number} now - Current `performance.now()` result.
+     */
+    BufferedHistory.prototype._cleanHistory = function (now) {
+        var historyEarliestLimit = now - this._lifetime;
+        var firstKeptIndex = 0;
+        for (var _i = 0, _a = this._history; _i < _a.length; _i++) {
+            var event_1 = _a[_i];
+            if (event_1.date < historyEarliestLimit) {
+                firstKeptIndex++;
+            }
+            else {
+                break;
+            }
+        }
+        if (firstKeptIndex > 0) {
+            this._history = this._history.splice(firstKeptIndex);
+        }
+        if (this._history.length > this._maxHistoryLength) {
+            var toRemove = this._history.length - this._maxHistoryLength;
+            this._history = this._history.splice(toRemove);
+        }
+    };
+    return BufferedHistory;
+}());
+export default BufferedHistory;

package/dist/_esm5.processed/core/{fetchers/utils/create_request_scheduler.d.ts → segment_buffers/inventory/index.d.ts}

@@ -13,7 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Observable, Subject } from "rxjs";
-import { ICustomError } from "../../../errors";
-import { IBackoffOptions } from "./try_urls_with_backoff";
-export default function createRequestScheduler<T>(backoffOptions: IBackoffOptions, warning$: Subject<ICustomError>): ((fn: () => Observable<T>) => Observable<T>);
+import SegmentInventory, { IBufferedChunk, IInsertedChunkInfos } from "./segment_inventory";
+export default SegmentInventory;
+export { IBufferedChunk, IInsertedChunkInfos, };
+export { IBufferedHistoryEntry } from "./buffered_history";
+export { IChunkContext } from "./types";

package/dist/_esm5.processed/core/{fetchers/manifest/get_manifest_backoff_options.d.ts → segment_buffers/inventory/index.js}

@@ -13,14 +13,5 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { IBackoffOptions } from "../utils/try_urls_with_backoff";
-/**
- * Parse config to replace missing manifest backoff options.
- * @param {Object} backoffOptions
- * @returns {Object}
- */
-export default function getManifestBackoffOptions({ maxRetryRegular, maxRetryOffline, lowLatencyMode }: {
-    maxRetryRegular?: number;
-    maxRetryOffline?: number;
-    lowLatencyMode: boolean;
-}): IBackoffOptions;
+import SegmentInventory from "./segment_inventory";
+export default SegmentInventory;

package/dist/_esm5.processed/core/segment_buffers/{segment_inventory.d.ts → inventory/segment_inventory.d.ts}

@@ -13,18 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Adaptation, ISegment, Period, Representation } from "../../manifest";
-/** Content information for a single buffered chunk */
-interface IBufferedChunkInfos {
-    /** Adaptation this chunk is related to. */
-    adaptation: Adaptation;
-    /** Period this chunk is related to. */
-    period: Period;
-    /** Representation this chunk is related to. */
-    representation: Representation;
-    /** Segment this chunk is related to. */
-    segment: ISegment;
-}
+import { Adaptation, ISegment, Period, Representation } from "../../../manifest";
+import { IBufferedHistoryEntry } from "./buffered_history";
+import { IChunkContext } from "./types";
 /** Information stored on a single chunk by the SegmentInventory. */
 export interface IBufferedChunk {
     /**
@@ -41,18 +32,7 @@ export interface IBufferedChunk {
      * synchronization for that chunk this value could be more or less precize.
      */
     bufferedStart: number | undefined;
-    /**
-     * Supposed end, in seconds, the chunk is expected to end at.
-     *
-     * It can correspond either to the end of the chunk or to the end of the whole
-     * segment the chunk is linked to. This should not matter as chunks linked to
-     * the same segment will all be merged once all chunks have been pushed and
-     * the `completeSegment` API call is done. Until then, this property should
-     * not be relied on.
-     *
-     * You can know whether the `completeSegment` API has been called by checking
-     * the `partiallyPushed` property.
-     */
+    /** Supposed end, in seconds, the chunk is expected to end at. */
     end: number;
     /**
      * If `true` the `end` property is an estimate the `SegmentInventory` has
@@ -73,11 +53,9 @@ export interface IBufferedChunk {
      */
     precizeStart: boolean;
     /** Information on what that chunk actually contains. */
-    infos: IBufferedChunkInfos;
+    infos: IChunkContext;
     /**
      * If `true`, this chunk is only a partial chunk of a whole segment.
-     * In this condition, `start` and `end` may be ignored, as they may either
-     * refer to the chunk or to the whole segment.
      *
      * Inversely, if `false`, this chunk is a whole segment whose inner chunks
      * have all been fully pushed.
@@ -86,16 +64,23 @@ export interface IBufferedChunk {
      */
     partiallyPushed: boolean;
     /**
-     * Supposed start, in seconds, the chunk is expected to start at.
+     * If `true`, the segment as a whole is divided into multiple parts in the
+     * buffer, with other segment(s) between them.
+     * If `false`, it is contiguous.
      *
-     * It can correspond either to the start of the chunk or to the start of the
-     * whole segment the chunk is linked to. This should not matter as chunks
-     * linked to the same segment will all be merged once all chunks have been
-     * pushed and the `completeSegment` API call is done. Until then, this
-     * property should not be relied on.
+     * Splitted segments are a rare occurence that is more complicated to handle
+     * than contiguous ones.
+     */
+    splitted: boolean;
+    /**
+     * Supposed start, in seconds, the chunk is expected to start at.
      *
-     * You can know whether the `completeSegment` API has been called by checking
-     * the `partiallyPushed` property.
+     * If the current `chunk` is part of a "partially pushed" segment (see
+     * `partiallyPushed`), the definition of this property is flexible in the way
+     * that it can correspond either to the start of the chunk or to the start of
+     * the whole segment the chunk is linked to.
+     * As such, this property should not be relied on until the segment has been
+     * fully-pushed.
      */
     start: number;
 }
@@ -142,14 +127,15 @@ export default class SegmentInventory {
      * chunk or segment which is at least partially added in the media buffer.
      */
     private _inventory;
+    private _bufferedHistory;
     constructor();
     /**
      * Reset the whole inventory.
      */
     reset(): void;
     /**
-     * Infer each segment's bufferedStart and bufferedEnd from the TimeRanges
-     * given.
+     * Infer each segment's `bufferedStart` and `bufferedEnd` properties from the
+     * TimeRanges given.
      *
      * The TimeRanges object given should come from the media buffer linked to
      * that SegmentInventory.
@@ -179,7 +165,7 @@ export default class SegmentInventory {
         adaptation: Adaptation;
         representation: Representation;
         segment: ISegment;
-    }): void;
+    }, newBuffered: TimeRanges): void;
     /**
      * Returns the whole inventory.
      *
@@ -188,5 +174,18 @@ export default class SegmentInventory {
      * @returns {Array.<Object>}
      */
     getInventory(): IBufferedChunk[];
+    /**
+     * 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>}
+     */
+    getHistoryFor(context: IChunkContext): IBufferedHistoryEntry[];
 }
-export {};

package/dist/_esm5.processed/core/segment_buffers/{segment_inventory.js → inventory/segment_inventory.js}

@@ -13,11 +13,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import config from "../../config";
-import log from "../../log";
-import { areSameContent, } from "../../manifest";
-import takeFirstSet from "../../utils/take_first_set";
-var MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE = config.MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE, MAX_MANIFEST_BUFFERED_DURATION_DIFFERENCE = config.MAX_MANIFEST_BUFFERED_DURATION_DIFFERENCE, MINIMUM_SEGMENT_SIZE = config.MINIMUM_SEGMENT_SIZE;
+import config from "../../../config";
+import log from "../../../log";
+import { areSameContent, } from "../../../manifest";
+import takeFirstSet from "../../../utils/take_first_set";
+import BufferedHistory from "./buffered_history";
+var BUFFERED_HISTORY_RETENTION_TIME = config.BUFFERED_HISTORY_RETENTION_TIME, BUFFERED_HISTORY_MAXIMUM_ENTRIES = config.BUFFERED_HISTORY_MAXIMUM_ENTRIES, MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE = config.MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE, MAX_MANIFEST_BUFFERED_DURATION_DIFFERENCE = config.MAX_MANIFEST_BUFFERED_DURATION_DIFFERENCE, MINIMUM_SEGMENT_SIZE = config.MINIMUM_SEGMENT_SIZE;
 /**
  * Keep track of every chunk downloaded and currently in the linked media
  * buffer.
@@ -30,6 +31,7 @@ var MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE = config.MAX_MANIFEST_BUFFERED_ST
 var SegmentInventory = /** @class */ (function () {
     function SegmentInventory() {
         this._inventory = [];
+        this._bufferedHistory = new BufferedHistory(BUFFERED_HISTORY_RETENTION_TIME, BUFFERED_HISTORY_MAXIMUM_ENTRIES);
     }
     /**
      * Reset the whole inventory.
@@ -38,8 +40,8 @@ var SegmentInventory = /** @class */ (function () {
         this._inventory.length = 0;
     };
     /**
-     * Infer each segment's bufferedStart and bufferedEnd from the TimeRanges
-     * given.
+     * Infer each segment's `bufferedStart` and `bufferedEnd` properties from the
+     * TimeRanges given.
      *
      * The TimeRanges object given should come from the media buffer linked to
      * that SegmentInventory.
@@ -81,7 +83,7 @@ var SegmentInventory = /** @class */ (function () {
             // `thisSegment`.
             var lastDeletedSegmentInfos = null;
             // remove garbage-collected segments
-            // (not in that TimeRange nor in the previous one)
+            // (Those not in that TimeRange nor in the previous one)
             var numberOfSegmentToDelete = inventoryIndex - indexBefore;
             if (numberOfSegmentToDelete > 0) {
                 var lastDeletedSegment = // last garbage-collected segment
@@ -90,7 +92,7 @@ var SegmentInventory = /** @class */ (function () {
                     end: takeFirstSet(lastDeletedSegment.bufferedEnd, lastDeletedSegment.end),
                     precizeEnd: lastDeletedSegment.precizeEnd,
                 };
-                log.debug("SI: " + numberOfSegmentToDelete + " segments GCed.", bufferType);
+                log.debug("SI: ".concat(numberOfSegmentToDelete, " segments GCed."), bufferType);
                 inventory.splice(indexBefore, numberOfSegmentToDelete);
                 inventoryIndex = indexBefore;
             }
@@ -104,6 +106,8 @@ var SegmentInventory = /** @class */ (function () {
                 >= 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;
                 }
@@ -146,7 +150,7 @@ var SegmentInventory = /** @class */ (function () {
             inventory.splice(inventoryIndex, inventory.length - inventoryIndex);
         }
         if (bufferType !== undefined && log.getLevel() === "DEBUG") {
-            log.debug("SI: current " + bufferType + " inventory timeline:\n" +
+            log.debug("SI: current ".concat(bufferType, " inventory timeline:\n") +
                 prettyPrintInventory(this._inventory));
         }
     };
@@ -169,10 +173,7 @@ var SegmentInventory = /** @class */ (function () {
         }
         var inventory = this._inventory;
         var newSegment = { partiallyPushed: true,
-            estimatedStart: start,
-            start: start,
-            end: end,
-            precizeStart: false,
+            splitted: false, start: start, end: end, precizeStart: false,
             precizeEnd: false,
             bufferedStart: undefined,
             bufferedEnd: undefined,
@@ -366,6 +367,7 @@ var SegmentInventory = /** @class */ (function () {
                             //  ===>         : |--|====|-|
                             log.debug("SI: Segment pushed is contained in a previous one", bufferType, start, end, segmentI.start, segmentI.end);
                             var nextSegment = { partiallyPushed: segmentI.partiallyPushed,
+                                splitted: true,
                                 start: newSegment.end,
                                 end: segmentI.end,
                                 precizeStart: segmentI.precizeStart &&
@@ -376,6 +378,7 @@ var SegmentInventory = /** @class */ (function () {
                                 bufferedEnd: segmentI.end,
                                 infos: segmentI.infos };
                             segmentI.end = newSegment.start;
+                            segmentI.splitted = true;
                             segmentI.bufferedEnd = undefined;
                             segmentI.precizeEnd = segmentI.precizeEnd &&
                                 newSegment.precizeStart;
@@ -479,18 +482,22 @@ var SegmentInventory = /** @class */ (function () {
      * the corresponding chunks.
      * @param {Object} content
      */
-    SegmentInventory.prototype.completeSegment = function (content) {
+    SegmentInventory.prototype.completeSegment = function (content, newBuffered) {
         if (content.segment.isInit) {
             return;
         }
         var inventory = this._inventory;
-        var foundIt = false;
+        var resSegments = [];
         for (var i = 0; i < inventory.length; i++) {
             if (areSameContent(inventory[i].infos, content)) {
-                if (foundIt) {
-                    log.warn("SI: Completed Segment is splitted.", content);
+                var splitted = false;
+                if (resSegments.length > 0) {
+                    splitted = true;
+                    if (resSegments.length === 1) {
+                        log.warn("SI: Completed Segment is splitted.", content);
+                        resSegments[0].splitted = true;
+                    }
                 }
-                foundIt = true;
                 var firstI = i;
                 i += 1;
                 while (i < inventory.length &&
@@ -508,11 +515,25 @@ var SegmentInventory = /** @class */ (function () {
                 this._inventory[firstI].partiallyPushed = false;
                 this._inventory[firstI].end = lastEnd;
                 this._inventory[firstI].bufferedEnd = lastBufferedEnd;
+                this._inventory[firstI].splitted = splitted;
+                resSegments.push(this._inventory[firstI]);
             }
         }
-        if (!foundIt) {
+        if (resSegments.length === 0) {
             log.warn("SI: Completed Segment not found", content);
         }
+        else {
+            this.synchronizeBuffered(newBuffered);
+            for (var _i = 0, resSegments_1 = resSegments; _i < resSegments_1.length; _i++) {
+                var seg = resSegments_1[_i];
+                if (seg.bufferedStart !== undefined && seg.bufferedEnd !== undefined) {
+                    this._bufferedHistory.addBufferedSegment(seg.infos, seg.bufferedStart, seg.bufferedEnd);
+                }
+                else {
+                    log.debug("SI: buffered range not known after sync. Skipping history.", seg);
+                }
+            }
+        }
     };
     /**
      * Returns the whole inventory.
@@ -524,6 +545,22 @@ var SegmentInventory = /** @class */ (function () {
     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;
 }());
 export default SegmentInventory;
@@ -728,17 +765,17 @@ function prettyPrintInventory(inventory) {
                 currentLetter = encounteredPeriod[representationId];
             }
             if (lastChunk === null) {
-                str += chunk.bufferedStart.toFixed(2) + "|" + currentLetter + "|";
+                str += "".concat(chunk.bufferedStart.toFixed(2), "|").concat(currentLetter, "|");
             }
             else if (lastLetter === currentLetter) {
                 if (lastChunk.bufferedEnd + roundingError < chunk.bufferedStart) {
-                    str += lastChunk.bufferedEnd.toFixed(2) + " ~ " +
-                        (chunk.bufferedStart.toFixed(2) + "|" + currentLetter + "|");
+                    str += "".concat(lastChunk.bufferedEnd.toFixed(2), " ~ ") +
+                        "".concat(chunk.bufferedStart.toFixed(2), "|").concat(currentLetter, "|");
                 }
             }
             else {
-                str += lastChunk.bufferedEnd.toFixed(2) + " ~ " +
-                    (chunk.bufferedStart.toFixed(2) + "|" + currentLetter + "|");
+                str += "".concat(lastChunk.bufferedEnd.toFixed(2), " ~ ") +
+                    "".concat(chunk.bufferedStart.toFixed(2), "|").concat(currentLetter, "|");
             }
             lastChunk = chunk;
             lastLetter = currentLetter;
@@ -749,9 +786,9 @@ function prettyPrintInventory(inventory) {
     }
     letters.forEach(function (letterInfo) {
         var _a;
-        str += "\n[" + letterInfo.letter + "] " +
-            ("P: " + letterInfo.periodId + " || R: " + letterInfo.representationId) +
-            ("(" + ((_a = letterInfo.bitrate) !== null && _a !== void 0 ? _a : "unknown bitrate") + ")");
+        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;
 }