rx-player 4.0.0-dev.2023121900 → 4.0.0-rc.2

package/dist/commonjs/core/segment_buffers/implementations/text/text_segment_buffer.d.ts

@@ -0,0 +1,89 @@
+import { ITextDisplayer } from "../../../../text_displayer";
+import { IRange } from "../../../../utils/ranges";
+import { ICompleteSegmentInfo, IPushChunkInfos, ISBOperation, SegmentBuffer } from "../types";
+/**
+ * SegmentBuffer implementation to add text data, most likely subtitles.
+ * @class TextSegmentBuffer
+ */
+export default class TextSegmentBuffer extends SegmentBuffer {
+    readonly bufferType: "text";
+    private _sender;
+    private _pendingOperations;
+    /**
+     * @param {Object} textDisplayerSender
+     */
+    constructor(textDisplayerSender: ITextDisplayerInterface);
+    /**
+     * @param {string} uniqueId
+     */
+    declareInitSegment(uniqueId: string): void;
+    /**
+     * @param {string} uniqueId
+     */
+    freeInitSegment(uniqueId: string): void;
+    /**
+     * Push text segment to the TextSegmentBuffer.
+     * @param {Object} infos
+     * @returns {Promise}
+     */
+    pushChunk(infos: IPushChunkInfos<unknown>): Promise<IRange[]>;
+    /**
+     * Remove buffered data.
+     * @param {number} start - start position, in seconds
+     * @param {number} end - end position, in seconds
+     * @returns {Promise}
+     */
+    removeBuffer(start: number, end: number): Promise<IRange[]>;
+    /**
+     * @param {Object} infos
+     * @returns {Promise}
+     */
+    signalSegmentComplete(infos: ICompleteSegmentInfo): Promise<void>;
+    /**
+     * @returns {Array.<Object>}
+     */
+    getPendingOperations(): Array<ISBOperation<unknown>>;
+    dispose(): void;
+    private _addToOperationQueue;
+}
+/** Data of chunks that should be pushed to the HTMLTextSegmentBuffer. */
+export interface ITextTracksBufferSegmentData {
+    /** The text track data, in the format indicated in `type`. */
+    data: string;
+    /** The format of `data` (examples: "ttml", "srt" or "vtt") */
+    type: string;
+    /**
+     * Language in which the text track is, as a language code.
+     * This is mostly needed for "sami" subtitles, to know which cues can / should
+     * be parsed.
+     */
+    language?: string | undefined;
+    /** start time from which the segment apply, in seconds. */
+    start?: number | undefined;
+    /** end time until which the segment apply, in seconds. */
+    end?: number | undefined;
+}
+/**
+ * Abstraction over an `ITextDisplayer`, making parts of its initial API
+ * returning a result asynchronously, to allow a common interface for when
+ * the `ITextDisplayerInterface` runs in a main thread or in a WebWorker
+ * (considering that an `ITextDisplayer` always run in main thread).
+ */
+export interface ITextDisplayerInterface {
+    /**
+     * @see ITextDisplayer
+     */
+    pushTextData(...args: Parameters<ITextDisplayer["pushTextData"]>): Promise<ReturnType<ITextDisplayer["pushTextData"]>>;
+    /**
+     * @see ITextDisplayer
+     */
+    remove(...args: Parameters<ITextDisplayer["removeBuffer"]>): Promise<ReturnType<ITextDisplayer["removeBuffer"]>>;
+    /**
+     * @see ITextDisplayer
+     */
+    reset(): void;
+    /**
+     * @see ITextDisplayer
+     */
+    stop(): void;
+}

package/dist/commonjs/core/segment_buffers/implementations/text/text_segment_buffer.js

@@ -0,0 +1,253 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var log_1 = require("../../../../log");
+var monotonic_timestamp_1 = require("../../../../utils/monotonic_timestamp");
+var types_1 = require("../types");
+/**
+ * SegmentBuffer implementation to add text data, most likely subtitles.
+ * @class TextSegmentBuffer
+ */
+var TextSegmentBuffer = /** @class */ (function (_super) {
+    __extends(TextSegmentBuffer, _super);
+    /**
+     * @param {Object} textDisplayerSender
+     */
+    function TextSegmentBuffer(textDisplayerSender) {
+        var _this = this;
+        log_1.default.debug("HTSB: Creating TextSegmentBuffer");
+        _this = _super.call(this) || this;
+        _this.bufferType = "text";
+        _this._sender = textDisplayerSender;
+        _this._pendingOperations = [];
+        _this._sender.reset();
+        return _this;
+    }
+    /**
+     * @param {string} uniqueId
+     */
+    TextSegmentBuffer.prototype.declareInitSegment = function (uniqueId) {
+        log_1.default.warn("HTSB: Declaring initialization segment for  Text SegmentBuffer", uniqueId);
+    };
+    /**
+     * @param {string} uniqueId
+     */
+    TextSegmentBuffer.prototype.freeInitSegment = function (uniqueId) {
+        log_1.default.warn("HTSB: Freeing initialization segment for  Text SegmentBuffer", uniqueId);
+    };
+    /**
+     * Push text segment to the TextSegmentBuffer.
+     * @param {Object} infos
+     * @returns {Promise}
+     */
+    TextSegmentBuffer.prototype.pushChunk = function (infos) {
+        return __awaiter(this, void 0, void 0, function () {
+            var data, promise, ranges;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        data = infos.data;
+                        assertChunkIsTextTrackSegmentData(data.chunk);
+                        promise = this._sender.pushTextData(__assign(__assign({}, data), { chunk: data.chunk }));
+                        this._addToOperationQueue(promise, { type: types_1.SegmentBufferOperation.Push,
+                            value: infos });
+                        return [4 /*yield*/, promise];
+                    case 1:
+                        ranges = _a.sent();
+                        if (infos.inventoryInfos !== null) {
+                            this._segmentInventory.insertChunk(infos.inventoryInfos, true, (0, monotonic_timestamp_1.default)());
+                        }
+                        this._segmentInventory.synchronizeBuffered(ranges);
+                        return [2 /*return*/, ranges];
+                }
+            });
+        });
+    };
+    /**
+     * Remove buffered data.
+     * @param {number} start - start position, in seconds
+     * @param {number} end - end position, in seconds
+     * @returns {Promise}
+     */
+    TextSegmentBuffer.prototype.removeBuffer = function (start, end) {
+        return __awaiter(this, void 0, void 0, function () {
+            var promise, ranges;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        promise = this._sender.remove(start, end);
+                        this._addToOperationQueue(promise, { type: types_1.SegmentBufferOperation.Remove,
+                            value: { start: start, end: end } });
+                        return [4 /*yield*/, promise];
+                    case 1:
+                        ranges = _a.sent();
+                        this._segmentInventory.synchronizeBuffered(ranges);
+                        return [2 /*return*/, ranges];
+                }
+            });
+        });
+    };
+    /**
+     * @param {Object} infos
+     * @returns {Promise}
+     */
+    TextSegmentBuffer.prototype.signalSegmentComplete = function (infos) {
+        return __awaiter(this, void 0, void 0, function () {
+            var promise, _1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!(this._pendingOperations.length > 0)) return [3 /*break*/, 4];
+                        promise = this._pendingOperations[this._pendingOperations.length - 1].promise;
+                        this._addToOperationQueue(promise, {
+                            type: types_1.SegmentBufferOperation.SignalSegmentComplete,
+                            value: infos,
+                        });
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, promise];
+                    case 2:
+                        _a.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        _1 = _a.sent();
+                        return [3 /*break*/, 4];
+                    case 4:
+                        this._segmentInventory.completeSegment(infos);
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * @returns {Array.<Object>}
+     */
+    TextSegmentBuffer.prototype.getPendingOperations = function () {
+        return this._pendingOperations.map(function (p) { return p.operation; });
+    };
+    TextSegmentBuffer.prototype.dispose = function () {
+        log_1.default.debug("HTSB: Disposing TextSegmentBuffer");
+        this._sender.reset();
+    };
+    TextSegmentBuffer.prototype._addToOperationQueue = function (promise, operation) {
+        var _this = this;
+        var queueObject = { operation: operation, promise: promise };
+        this._pendingOperations.push(queueObject);
+        var endOperation = function () {
+            var indexOf = _this._pendingOperations.indexOf(queueObject);
+            if (indexOf >= 0) {
+                _this._pendingOperations.splice(indexOf, 1);
+            }
+        };
+        promise.then(endOperation, endOperation); // `finally` not supported everywhere
+    };
+    return TextSegmentBuffer;
+}(types_1.SegmentBuffer));
+exports.default = TextSegmentBuffer;
+/**
+ * Throw if the given input is not in the expected format.
+ * Allows to enforce runtime type-checking as compile-time type-checking here is
+ * difficult to enforce.
+ * @param {Object} chunk
+ */
+function assertChunkIsTextTrackSegmentData(chunk) {
+    if (0 /* __ENVIRONMENT__.CURRENT_ENV */ === 0 /* __ENVIRONMENT__.PRODUCTION */) {
+        return;
+    }
+    if (typeof chunk !== "object" ||
+        chunk === null ||
+        typeof chunk.data !== "string" ||
+        typeof chunk.type !== "string" ||
+        (chunk.language !== undefined &&
+            typeof chunk.language !== "string") ||
+        (chunk.start !== undefined &&
+            typeof chunk.start !== "number") ||
+        (chunk.end !== undefined &&
+            typeof chunk.end !== "number")) {
+        throw new Error("Invalid format given to a TextSegmentBuffer");
+    }
+}
+/*
+ * The following ugly code is here to provide a compile-time check that an
+ * `ITextTracksBufferSegmentData` (type of data pushed to a
+ * `TextSegmentBuffer`) can be derived from a `ITextTrackSegmentData`
+ * (text track data parsed from a segment).
+ *
+ * It doesn't correspond at all to real code that will be called. This is just
+ * a hack to tell TypeScript to perform that check.
+ */
+if (0 /* __ENVIRONMENT__.CURRENT_ENV */ === 1 /* __ENVIRONMENT__.DEV */) {
+    /* eslint-disable @typescript-eslint/no-unused-vars */
+    /* eslint-disable @typescript-eslint/ban-ts-comment */
+    // @ts-ignore
+    function _checkType(input) {
+        function checkEqual(_arg) {
+            /* nothing */
+        }
+        checkEqual(input);
+    }
+    /* eslint-enable @typescript-eslint/no-unused-vars */
+    /* eslint-enable @typescript-eslint/ban-ts-comment */
+}

package/dist/commonjs/core/segment_buffers/implementations/types.d.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 import { Adaptation, ISegment, Period, Representation } from "../../../manifest";
-import { CancellationSignal } from "../../../utils/task_canceller";
+import { IRange } from "../../../utils/ranges";
 import SegmentInventory, { IBufferedChunk, IBufferedHistoryEntry, IChunkContext, IInsertedChunkInfos } from "../inventory";
 /**
  * Class allowing to push segments and remove data to a buffer to be able
@@ -29,13 +29,13 @@ import SegmentInventory, { IBufferedChunk, IBufferedHistoryEntry, IChunkContext,
  * already-pushed segments for that type.
  *
  * Because a segment can be divided into multiple chunks, one should call the
- * `endOfSegment` method once all chunks of a given segment have been pushed
- * (through the `pushChunk` method) to validate that a segment has been
+ * `signalSegmentComplete` method once all chunks of a given segment have been
+ * pushed (through the `pushChunk` method) to validate that a segment has been
  * completely pushed.
  * It is expected to push chunks from only one segment at a time before calling
- * the `endOfSegment` function for that segment. Pushing chunks from multiple
- * segments in parallel could have unexpected result depending on the underlying
- * implementation.
+ * the `signalSegmentComplete` function for that segment. Pushing chunks from
+ * multiple segments in parallel could have unexpected result depending on the
+ * underlying implementation.
  * TODO reflect that in the API?
  *
  * A SegmentBuffer also maintains an "inventory", which is the current
@@ -45,9 +45,9 @@ import SegmentInventory, { IBufferedChunk, IBufferedHistoryEntry, IChunkContext,
  * `getInventory` method).
  *
  * Also depending on the underlying implementation, the various operations
- * performed on a `SegmentBuffer` (push/remove/endOfSegment) can happen
+ * performed on a `SegmentBuffer` (push/remove/segmentComplete) can happen
  * synchronously or asynchronously.
- * In the latter case, such operations are put in a FIFO Queue.
+ *
  * You can retrieve the current queue of operations by calling the
  * `getPendingOperations` method.
  * If operations happens synchronously, this method will just return an empty
@@ -71,12 +71,11 @@ export declare abstract class SegmentBuffer {
     abstract declareInitSegment(uniqueId: string, initSegmentData: unknown): void;
     abstract freeInitSegment(uniqueId: string): void;
     /**
-     * Push a chunk of the media segment given to the attached buffer, in a
-     * FIFO queue.
+     * Push a chunk of the media segment given to the attached buffer.
      *
      * Once all chunks of a single Segment have been given to `pushChunk`, you
-     * should call `endOfSegment` to indicate that the whole Segment has been
-     * pushed.
+     * should call `signalSegmentComplete` to indicate that the whole Segment has
+     * been pushed.
      *
      * Depending on the type of data appended, the pushed chunk might rely on an
      * initialization segment, which had to be previously declared through the
@@ -96,59 +95,56 @@ export declare abstract class SegmentBuffer {
      * `data.chunk` argument to null.
      *
      * @param {Object} infos
-     * @param {Object} cancellationSignal
      * @returns {Promise}
      */
-    abstract pushChunk(infos: IPushChunkInfos<unknown>, cancellationSignal: CancellationSignal): Promise<void>;
+    abstract pushChunk(infos: IPushChunkInfos<unknown>): Promise<IRange[]>;
     /**
-     * Remove buffered data (added to the same FIFO queue than `pushChunk`).
+     * Remove buffered data.
      * @param {number} start - start position, in seconds
      * @param {number} end - end position, in seconds
-     * @param {Object} cancellationSignal
      * @returns {Promise}
      */
-    abstract removeBuffer(start: number, end: number, cancellationSignal: CancellationSignal): Promise<void>;
+    abstract removeBuffer(start: number, end: number): Promise<IRange[] | undefined>;
     /**
-     * Indicate that every chunks from a Segment has been given to pushChunk so
+     * Indicate that every chunks from a segment has been given to pushChunk so
      * far.
      * This will update our internal Segment inventory accordingly.
      * The returned Promise will resolve once the whole segment has been pushed
      * and this indication is acknowledged.
      * @param {Object} infos
-     * @param {Object} cancellationSignal
      * @returns {Promise}
+     *
+     * TODO since switching to worker, this abstraction doesn't really work.
+     * Find better.
      */
-    abstract endOfSegment(infos: IEndOfSegmentInfos, cancellationSignal: CancellationSignal): Promise<void>;
-    /**
-     * Returns the currently buffered data, in a TimeRanges object.
-     * @returns {TimeRanges}
-     */
-    abstract getBufferedRanges(): TimeRanges;
+    abstract signalSegmentComplete(infos: ICompleteSegmentInfo): Promise<void>;
     /**
      * The maintained inventory can fall out of sync from garbage collection or
      * other events.
      *
-     * This methods allow to manually trigger a synchronization. It should be
-     * called before retrieving Segment information from it (e.g. with
-     * `getInventory`).
+     * This methods allow to manually trigger a synchronization by providing the
+     * buffered time ranges of the real SourceBuffer implementation.
      */
-    synchronizeInventory(): void;
+    synchronizeInventory(ranges: IRange[]): void;
     /**
-     * Returns the currently buffered data for which the content is known with
-     * the corresponding content information.
-     * /!\ This data can fall out of sync with the real buffered ranges. Please
-     * call `synchronizeInventory` before to make sure it is correctly
-     * synchronized.
+     * Returns an inventory of the last known segments to be currently contained in
+     * the SegmentBuffer.
+     *
+     * /!\ Note that this data may not be up-to-date with the real current content
+     * of the SegmentBuffer.
+     * Generally speaking, pushed segments are added right away to it but segments
+     * may have been since removed, which might not be known right away.
+     * Please consider this when using this method, by considering that it does
+     * not reflect the full reality of the underlying buffer.
      * @returns {Array.<Object>}
      */
-    getInventory(): IBufferedChunk[];
+    getLastKnownInventory(): IBufferedChunk[];
     /**
      * Returns the list of every operations that the `SegmentBuffer` is still
-     * processing. From the one with the highest priority (like the one being
-     * processed)
+     * processing. From the one with the highest priority to the lowest priority.
      * @returns {Array.<Object>}
      */
-    getPendingOperations(): Array<ISBOperation<unknown>>;
+    abstract getPendingOperations(): Array<ISBOperation<unknown>>;
     /**
      * Returns a recent history of registered operations performed and event
      * received linked to the segment given in argument.
@@ -164,7 +160,7 @@ export declare abstract class SegmentBuffer {
      */
     getSegmentHistory(context: IChunkContext): IBufferedHistoryEntry[];
     /**
-     * Dispose of the resources used by this AudioVideoSegmentBuffer.
+     * Dispose of the resources used by this SegmentBuffer.
      * /!\ You won't be able to use the SegmentBuffer after calling this
      * function.
      */
@@ -234,9 +230,9 @@ export interface IPushedChunkData<T> {
 }
 /**
  * Information to give when indicating a whole segment has been pushed via the
- * `endOfSegment` method.
+ * `signalSegmentComplete` method.
  */
-export interface IEndOfSegmentInfos {
+export interface ICompleteSegmentInfo {
     /** Adaptation object linked to the chunk. */
     adaptation: Adaptation;
     /** Period object linked to the chunk. */
@@ -256,18 +252,11 @@ export interface IPushChunkInfos<T> {
     /**
      * Context about the chunk that will be added to the inventory once it is
      * pushed.
-     *
-     * Can be set to `null` if you don't want to add an entry to the inventory
-     * after that segment is pushed (e.g. can be useful for initialization
-     * segments, as they take no place in a buffer).
-     * Please note that an inventory might become completely un-synchronized
-     * with the real media buffer if some buffered segments are not added to
-     * the inventory afterwise.
      */
-    inventoryInfos: IInsertedChunkInfos | null;
+    inventoryInfos: IInsertedChunkInfos;
 }
 /** "Operations" scheduled by a SegmentBuffer. */
-export type ISBOperation<T> = IPushOperation<T> | IRemoveOperation | IEndOfSegmentOperation;
+export type ISBOperation<T> = IPushOperation<T> | IRemoveOperation | ISignalCompleteSegmentOperation;
 /**
  * Enum used by a SegmentBuffer as a discriminant in its queue of
  * "operations".
@@ -275,7 +264,7 @@ export type ISBOperation<T> = IPushOperation<T> | IRemoveOperation | IEndOfSegme
 export declare enum SegmentBufferOperation {
     Push = 0,
     Remove = 1,
-    EndOfSegment = 2
+    SignalSegmentComplete = 2
 }
 /**
  * "Operation" created by a `SegmentBuffer` when asked to push a chunk.
@@ -308,13 +297,13 @@ export interface IRemoveOperation {
  * "Operation" created by a `SegmentBuffer` when asked to validate that a full
  * segment has been pushed through earlier `Push` operations.
  *
- * It represents a queued "EndOfSegment" operation (created due to a
- * `endOfSegment` method call) that is not yet fully processed by a
+ * It represents a queued "SignalSegmentComplete" operation (created due to a
+ * `signalSegmentComplete` method call) that is not yet fully processed by a
  * `SegmentBuffer.`
  */
-export interface IEndOfSegmentOperation {
-    /** Discriminant (allows to tell its an "EndOfSegment operation"). */
-    type: SegmentBufferOperation.EndOfSegment;
+export interface ISignalCompleteSegmentOperation {
+    /** Discriminant (allows to tell its an "SignalSegmentComplete operation"). */
+    type: SegmentBufferOperation.SignalSegmentComplete;
     /** Arguments for that operation. */
-    value: IEndOfSegmentInfos;
+    value: ICompleteSegmentInfo;
 }

package/dist/commonjs/core/segment_buffers/implementations/types.js

@@ -30,13 +30,13 @@ var inventory_1 = require("../inventory");
  * already-pushed segments for that type.
  *
  * Because a segment can be divided into multiple chunks, one should call the
- * `endOfSegment` method once all chunks of a given segment have been pushed
- * (through the `pushChunk` method) to validate that a segment has been
+ * `signalSegmentComplete` method once all chunks of a given segment have been
+ * pushed (through the `pushChunk` method) to validate that a segment has been
  * completely pushed.
  * It is expected to push chunks from only one segment at a time before calling
- * the `endOfSegment` function for that segment. Pushing chunks from multiple
- * segments in parallel could have unexpected result depending on the underlying
- * implementation.
+ * the `signalSegmentComplete` function for that segment. Pushing chunks from
+ * multiple segments in parallel could have unexpected result depending on the
+ * underlying implementation.
  * TODO reflect that in the API?
  *
  * A SegmentBuffer also maintains an "inventory", which is the current
@@ -46,9 +46,9 @@ var inventory_1 = require("../inventory");
  * `getInventory` method).
  *
  * Also depending on the underlying implementation, the various operations
- * performed on a `SegmentBuffer` (push/remove/endOfSegment) can happen
+ * performed on a `SegmentBuffer` (push/remove/segmentComplete) can happen
  * synchronously or asynchronously.
- * In the latter case, such operations are put in a FIFO Queue.
+ *
  * You can retrieve the current queue of operations by calling the
  * `getPendingOperations` method.
  * If operations happens synchronously, this method will just return an empty
@@ -63,36 +63,29 @@ var SegmentBuffer = /** @class */ (function () {
      * The maintained inventory can fall out of sync from garbage collection or
      * other events.
      *
-     * This methods allow to manually trigger a synchronization. It should be
-     * called before retrieving Segment information from it (e.g. with
-     * `getInventory`).
+     * This methods allow to manually trigger a synchronization by providing the
+     * buffered time ranges of the real SourceBuffer implementation.
      */
-    SegmentBuffer.prototype.synchronizeInventory = function () {
+    SegmentBuffer.prototype.synchronizeInventory = function (ranges) {
         // The default implementation just use the SegmentInventory
-        this._segmentInventory.synchronizeBuffered(this.getBufferedRanges());
+        this._segmentInventory.synchronizeBuffered(ranges);
     };
     /**
-     * Returns the currently buffered data for which the content is known with
-     * the corresponding content information.
-     * /!\ This data can fall out of sync with the real buffered ranges. Please
-     * call `synchronizeInventory` before to make sure it is correctly
-     * synchronized.
+     * Returns an inventory of the last known segments to be currently contained in
+     * the SegmentBuffer.
+     *
+     * /!\ Note that this data may not be up-to-date with the real current content
+     * of the SegmentBuffer.
+     * Generally speaking, pushed segments are added right away to it but segments
+     * may have been since removed, which might not be known right away.
+     * Please consider this when using this method, by considering that it does
+     * not reflect the full reality of the underlying buffer.
      * @returns {Array.<Object>}
      */
-    SegmentBuffer.prototype.getInventory = function () {
+    SegmentBuffer.prototype.getLastKnownInventory = function () {
         // The default implementation just use the SegmentInventory
         return this._segmentInventory.getInventory();
     };
-    /**
-     * Returns the list of every operations that the `SegmentBuffer` is still
-     * processing. From the one with the highest priority (like the one being
-     * processed)
-     * @returns {Array.<Object>}
-     */
-    SegmentBuffer.prototype.getPendingOperations = 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.
@@ -120,5 +113,5 @@ var SegmentBufferOperation;
 (function (SegmentBufferOperation) {
     SegmentBufferOperation[SegmentBufferOperation["Push"] = 0] = "Push";
     SegmentBufferOperation[SegmentBufferOperation["Remove"] = 1] = "Remove";
-    SegmentBufferOperation[SegmentBufferOperation["EndOfSegment"] = 2] = "EndOfSegment";
+    SegmentBufferOperation[SegmentBufferOperation["SignalSegmentComplete"] = 2] = "SignalSegmentComplete";
 })(SegmentBufferOperation || (exports.SegmentBufferOperation = SegmentBufferOperation = {}));

package/dist/commonjs/core/segment_buffers/index.d.ts

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 import BufferGarbageCollector from "./garbage_collector";
-import { IBufferType, IEndOfSegmentInfos, IEndOfSegmentOperation, IPushChunkInfos, IPushedChunkData, IPushOperation, IRemoveOperation, ISBOperation, SegmentBuffer, SegmentBufferOperation } from "./implementations";
+import { IBufferType, ICompleteSegmentInfo, ISignalCompleteSegmentOperation, IPushChunkInfos, IPushedChunkData, IPushOperation, IRemoveOperation, ISBOperation, ITextDisplayerInterface, SegmentBuffer, SegmentBufferOperation } from "./implementations";
 import { ChunkStatus, IBufferedChunk, IChunkContext, IInsertedChunkInfos, getFirstSegmentAfterPeriod, getLastSegmentBeforePeriod } from "./inventory";
-import SegmentBuffersStore, { ISegmentBufferOptions, ITextTrackSegmentBufferOptions } from "./segment_buffers_store";
+import SegmentBuffersStore from "./segment_buffers_store";
 export default SegmentBuffersStore;
-export { BufferGarbageCollector, ChunkStatus, ISegmentBufferOptions, ITextTrackSegmentBufferOptions, SegmentBuffer, IBufferType, IBufferedChunk, IChunkContext, IInsertedChunkInfos, IPushChunkInfos, IPushedChunkData, IEndOfSegmentInfos, SegmentBufferOperation, ISBOperation, IEndOfSegmentOperation, IPushOperation, IRemoveOperation, getFirstSegmentAfterPeriod, getLastSegmentBeforePeriod, };
+export { BufferGarbageCollector, ChunkStatus, SegmentBuffer, IBufferType, IBufferedChunk, IChunkContext, IInsertedChunkInfos, IPushChunkInfos, IPushedChunkData, ICompleteSegmentInfo, SegmentBufferOperation, ISBOperation, ISignalCompleteSegmentOperation, IPushOperation, IRemoveOperation, getFirstSegmentAfterPeriod, getLastSegmentBeforePeriod, ITextDisplayerInterface, };