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

package/dist/commonjs/core/segment_buffers/inventory/segment_inventory.d.ts

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 import { Adaptation, ISegment, Period, Representation } from "../../../manifest";
+import { IRange } from "../../../utils/ranges";
 import { IBufferedHistoryEntry } from "./buffered_history";
 import { IChunkContext } from "./types";
 /** Categorization of a given chunk in the `SegmentInventory`. */
@@ -39,6 +40,15 @@ export declare const enum ChunkStatus {
 }
 /** Information stored on a single chunk by the SegmentInventory. */
 export interface IBufferedChunk {
+    /**
+     * Value of the monotonically-increasing timestamp used by the RxPlayer at
+     * the time the segment was succesfully pushed to the buffer.
+     *
+     * We add this value here as we may want to wait for some time before
+     * synchronizing the buffer to ensure the browser has properly considered the
+     * full segment in its `buffered` value.
+     */
+    insertionTs: number;
     /**
      * Complete size of the pushed chunk, in bytes.
      * Note that this does not always reflect the memory imprint of the segment in
@@ -168,25 +178,29 @@ export default class SegmentInventory {
     reset(): void;
     /**
      * Infer each segment's `bufferedStart` and `bufferedEnd` properties from the
-     * TimeRanges given.
+     * ranges given.
      *
-     * The TimeRanges object given should come from the media buffer linked to
-     * that SegmentInventory.
+     * 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 a TimeRanges
-     * coming from the same buffer.
-     * @param {TimeRanges} buffered
+     * at a time, so each `synchronizeBuffered` call should be given ranges coming
+     * from the same buffer.
+     * @param {Array.<Object>} ranges
      */
-    synchronizeBuffered(buffered: TimeRanges): void;
+    synchronizeBuffered(ranges: IRange[]): void;
     /**
      * 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.
      */
-    insertChunk({ period, adaptation, representation, segment, chunkSize, start, end }: IInsertedChunkInfos, succeed: boolean): void;
+    insertChunk({ period, adaptation, representation, segment, chunkSize, start, end }: IInsertedChunkInfos, succeed: boolean, insertionTs: number): void;
     /**
      * Indicate that inserted chunks can now be considered as a complete segment.
      * Take in argument the same content than what was given to `insertChunk` for
@@ -198,7 +212,7 @@ export default class SegmentInventory {
         adaptation: Adaptation;
         representation: Representation;
         segment: ISegment;
-    }, newBuffered: TimeRanges): void;
+    }): void;
     /**
      * Returns the whole inventory.
      *

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

@@ -29,6 +29,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 var config_1 = require("../../../config");
 var log_1 = require("../../../log");
 var manifest_1 = require("../../../manifest");
+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
@@ -53,17 +54,17 @@ var SegmentInventory = /** @class */ (function () {
     };
     /**
      * Infer each segment's `bufferedStart` and `bufferedEnd` properties from the
-     * TimeRanges given.
+     * ranges given.
      *
-     * The TimeRanges object given should come from the media buffer linked to
-     * that SegmentInventory.
+     * 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 a TimeRanges
-     * coming from the same buffer.
-     * @param {TimeRanges} buffered
+     * at a time, so each `synchronizeBuffered` call should be given ranges coming
+     * from the same buffer.
+     * @param {Array.<Object>} ranges
      */
-    SegmentInventory.prototype.synchronizeBuffered = function (buffered) {
+    SegmentInventory.prototype.synchronizeBuffered = function (ranges) {
         var e_1, _a, e_2, _b;
         var _c, _d, _e, _f, _g, _h, _j;
         var inventory = this._inventory;
@@ -72,20 +73,20 @@ var SegmentInventory = /** @class */ (function () {
         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;
-        var rangesLength = buffered.length;
+        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 TimeRange
-            var rangeStart = buffered.start(i);
-            var rangeEnd = buffered.end(i);
+            // 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 TimeRange when synchronizing because it was too small", bufferType, rangeStart, rangeEnd);
+                log_1.default.warn("SI: skipped range when synchronizing because it was too small", bufferType, rangeStart, rangeEnd);
                 continue;
             }
             var indexBefore = inventoryIndex; // keep track of that number
-            // Find the first segment either within this TimeRange or completely past
+            // 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.
@@ -98,7 +99,7 @@ var SegmentInventory = /** @class */ (function () {
             // `thisSegment`.
             var lastDeletedSegmentInfos = null;
             // remove garbage-collected segments
-            // (Those not in that TimeRange nor in the previous one)
+            // (Those not in that range nor in the previous one)
             var numberOfSegmentToDelete = inventoryIndex - indexBefore;
             if (numberOfSegmentToDelete > 0) {
                 var lastDeletedSegment = // last garbage-collected segment
@@ -146,7 +147,7 @@ var SegmentInventory = /** @class */ (function () {
                 // Make contiguous until first segment outside that range
                 var thisSegmentStart = (_f = thisSegment.bufferedStart) !== null && _f !== void 0 ? _f : thisSegment.start;
                 var thisSegmentEnd = (_g = thisSegment.bufferedEnd) !== null && _g !== void 0 ? _g : thisSegment.end;
-                var nextRangeStart = i < rangesLength - 1 ? buffered.start(i + 1) :
+                var nextRangeStart = i < rangesLength - 1 ? ranges[i + 1].start :
                     undefined;
                 while (thisSegment !== undefined &&
                     (rangeEnd - thisSegmentStart) >= MINIMUM_SEGMENT_SIZE &&
@@ -208,8 +209,12 @@ var SegmentInventory = /** @class */ (function () {
      * 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) {
+    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;
@@ -221,7 +226,7 @@ var SegmentInventory = /** @class */ (function () {
         }
         var inventory = this._inventory;
         var newSegment = { status: succeed ? 0 /* ChunkStatus.PartiallyPushed */ :
-                2 /* ChunkStatus.Failed */, chunkSize: chunkSize, splitted: false, start: start, end: end, precizeStart: false,
+                2 /* ChunkStatus.Failed */, insertionTs: insertionTs, chunkSize: chunkSize, splitted: false, start: start, end: end, precizeStart: false,
             precizeEnd: false,
             bufferedStart: undefined,
             bufferedEnd: undefined,
@@ -415,6 +420,7 @@ var SegmentInventory = /** @class */ (function () {
                             //  ===>         : |--|====|-|
                             log_1.default.warn("SI: Segment pushed is contained in a previous one", bufferType, start, end, segmentI.start, 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.
@@ -537,7 +543,7 @@ var SegmentInventory = /** @class */ (function () {
      * the corresponding chunks.
      * @param {Object} content
      */
-    SegmentInventory.prototype.completeSegment = function (content, newBuffered) {
+    SegmentInventory.prototype.completeSegment = function (content) {
         var e_3, _a;
         if (content.segment.isInit) {
             return;
@@ -587,7 +593,6 @@ var SegmentInventory = /** @class */ (function () {
             log_1.default.warn("SI: Completed Segment not found", content.segment.id, content.segment.time);
         }
         else {
-            this.synchronizeBuffered(newBuffered);
             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;
@@ -598,6 +603,8 @@ var SegmentInventory = /** @class */ (function () {
                         }
                     }
                     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.", seg.start, seg.end);
                     }
                 }
@@ -690,7 +697,7 @@ function bufferedEndLooksCoherent(thisSegment) {
  * @param {Object} lastDeletedSegmentInfos
  */
 function guessBufferedStartFromRangeStart(firstSegmentInRange, rangeStart, lastDeletedSegmentInfos, bufferType) {
-    var MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE = config_1.default.getCurrent().MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE;
+    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", bufferType, firstSegmentInRange.bufferedStart, rangeStart);
@@ -720,6 +727,12 @@ function guessBufferedStartFromRangeStart(firstSegmentInRange, rangeStart, lastD
     }
     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", bufferType, rangeStart, firstSegmentInRange.start, now - firstSegmentInRange.insertionTs);
+            return;
+        }
         log_1.default.debug("SI: found true buffered start", bufferType, rangeStart, firstSegmentInRange.start);
         firstSegmentInRange.bufferedStart = rangeStart;
         if (bufferedStartLooksCoherent(firstSegmentInRange)) {
@@ -732,7 +745,13 @@ function guessBufferedStartFromRangeStart(firstSegmentInRange, rangeStart, lastD
         firstSegmentInRange.bufferedStart = firstSegmentInRange.start;
     }
     else {
-        log_1.default.debug("SI: Segment appears immediately garbage collected at the start", bufferType, firstSegmentInRange.bufferedStart, rangeStart);
+        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", bufferType, rangeStart, firstSegmentInRange.start, now - firstSegmentInRange.insertionTs);
+            return;
+        }
+        log_1.default.debug("SI: Segment appears immediately garbage collected at the start", bufferType, rangeStart, firstSegmentInRange.start);
         firstSegmentInRange.bufferedStart = rangeStart;
     }
 }
@@ -744,7 +763,7 @@ function guessBufferedStartFromRangeStart(firstSegmentInRange, rangeStart, lastD
  * @param {string} bufferType
  */
 function guessBufferedEndFromRangeEnd(lastSegmentInRange, rangeEnd, bufferType) {
-    var MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE = config_1.default.getCurrent().MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE;
+    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", bufferType, lastSegmentInRange.bufferedEnd, rangeEnd);
@@ -763,6 +782,12 @@ function guessBufferedEndFromRangeEnd(lastSegmentInRange, rangeEnd, bufferType)
     }
     else if (rangeEnd - lastSegmentInRange.end <=
         MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE) {
+        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", bufferType, rangeEnd, lastSegmentInRange.end, now - lastSegmentInRange.insertionTs);
+            return;
+        }
         log_1.default.debug("SI: found true buffered end", bufferType, rangeEnd, lastSegmentInRange.end);
         lastSegmentInRange.bufferedEnd = rangeEnd;
         if (bufferedEndLooksCoherent(lastSegmentInRange)) {
@@ -775,6 +800,12 @@ function guessBufferedEndFromRangeEnd(lastSegmentInRange, rangeEnd, bufferType)
         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", bufferType, rangeEnd, lastSegmentInRange.end, now - lastSegmentInRange.insertionTs);
+            return;
+        }
         log_1.default.debug("SI: Segment appears immediately garbage collected at the end", bufferType, lastSegmentInRange.bufferedEnd, rangeEnd);
         lastSegmentInRange.bufferedEnd = rangeEnd;
     }

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

@@ -13,17 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { IMediaSourceInterface } from "../../mse";
 import { CancellationSignal } from "../../utils/task_canceller";
 import { IBufferType, SegmentBuffer } from "./implementations";
-/** Options available for a "text" SegmentBuffer */
-export type ITextTrackSegmentBufferOptions = {
-    textTrackMode?: "native";
-} | {
-    textTrackMode: "html";
-    textTrackElement: HTMLElement;
-};
-/** General Options available for any SegmentBuffer */
-export type ISegmentBufferOptions = ITextTrackSegmentBufferOptions;
+import { ITextDisplayerInterface } from "./implementations/text";
 /** Types of "native" media buffers (i.e. which rely on a SourceBuffer) */
 type INativeMediaBufferType = "audio" | "video";
 /**
@@ -58,8 +51,6 @@ export default class SegmentBuffersStore {
      * @returns {Boolean}
      */
     static isNative(bufferType: string): bufferType is INativeMediaBufferType;
-    /** HTMLMediaElement on which the MediaSource is attached.  */
-    private readonly _mediaElement;
     /** MediaSource on which SourceBuffer objects will be attached. */
     private readonly _mediaSource;
     /**
@@ -75,12 +66,13 @@ export default class SegmentBuffersStore {
      * Promise.
      */
     private _onNativeBufferAddedOrDisabled;
+    private _textInterface;
+    private _hasVideo;
     /**
-     * @param {HTMLMediaElement} mediaElement
      * @param {MediaSource} mediaSource
      * @constructor
      */
-    constructor(mediaElement: HTMLMediaElement, mediaSource: MediaSource);
+    constructor(mediaSource: IMediaSourceInterface, hasVideo: boolean, textDisplayerInterface: ITextDisplayerInterface | null);
     /**
      * Get all currently available buffer types.
      * /!\ This list can evolve at runtime depending on feature switching.
@@ -145,7 +137,7 @@ export default class SegmentBuffersStore {
      * A call to this function is needed at least for unused native buffer types
      * (usually "audio" and "video"), to be able to emit through
      * `waitForUsableBuffers` when conditions are met.
-     * @param {string}
+     * @param {string} bufferType
      */
     disableSegmentBuffer(bufferType: IBufferType): void;
     /**
@@ -158,10 +150,9 @@ export default class SegmentBuffersStore {
      * type.
      * @param {string} bufferType
      * @param {string} codec
-     * @param {Object|undefined} options
      * @returns {Object}
      */
-    createSegmentBuffer(bufferType: IBufferType, codec: string, options?: ISegmentBufferOptions): SegmentBuffer;
+    createSegmentBuffer(bufferType: IBufferType, codec: string): SegmentBuffer;
     /**
      * Dispose of the active SegmentBuffer for the given type.
      * @param {string} bufferType

package/dist/commonjs/core/segment_buffers/segment_buffers_store.js

@@ -16,10 +16,10 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 var errors_1 = require("../../errors");
-var features_1 = require("../../features");
 var log_1 = require("../../log");
 var create_cancellable_promise_1 = require("../../utils/create_cancellable_promise");
 var implementations_1 = require("./implementations");
+var text_1 = require("./implementations/text");
 var POSSIBLE_BUFFER_TYPES = ["audio",
     "video",
     "text"];
@@ -46,13 +46,13 @@ var POSSIBLE_BUFFER_TYPES = ["audio",
  */
 var SegmentBuffersStore = /** @class */ (function () {
     /**
-     * @param {HTMLMediaElement} mediaElement
      * @param {MediaSource} mediaSource
      * @constructor
      */
-    function SegmentBuffersStore(mediaElement, mediaSource) {
-        this._mediaElement = mediaElement;
+    function SegmentBuffersStore(mediaSource, hasVideo, textDisplayerInterface) {
         this._mediaSource = mediaSource;
+        this._textInterface = textDisplayerInterface;
+        this._hasVideo = hasVideo;
         this._initializedSegmentBuffers = {};
         this._onNativeBufferAddedOrDisabled = [];
     }
@@ -75,8 +75,7 @@ var SegmentBuffersStore = /** @class */ (function () {
      */
     SegmentBuffersStore.prototype.getBufferTypes = function () {
         var bufferTypes = this.getNativeBufferTypes();
-        if (features_1.default.nativeTextTracksBuffer != null ||
-            features_1.default.htmlTextTracksBuffer != null) {
+        if (this._textInterface !== null) {
             bufferTypes.push("text");
         }
         return bufferTypes;
@@ -87,8 +86,7 @@ var SegmentBuffersStore = /** @class */ (function () {
      * @returns {Array.<string>}
      */
     SegmentBuffersStore.prototype.getNativeBufferTypes = function () {
-        return this._mediaElement.nodeName === "AUDIO" ? ["audio"] :
-            ["video", "audio"];
+        return this._hasVideo ? ["video", "audio"] : ["audio"];
     };
     /**
      * Returns the current "status" of the SegmentBuffer linked to the buffer
@@ -164,7 +162,7 @@ var SegmentBuffersStore = /** @class */ (function () {
      * A call to this function is needed at least for unused native buffer types
      * (usually "audio" and "video"), to be able to emit through
      * `waitForUsableBuffers` when conditions are met.
-     * @param {string}
+     * @param {string} bufferType
      */
     SegmentBuffersStore.prototype.disableSegmentBuffer = function (bufferType) {
         var currentValue = this._initializedSegmentBuffers[bufferType];
@@ -190,11 +188,9 @@ var SegmentBuffersStore = /** @class */ (function () {
      * type.
      * @param {string} bufferType
      * @param {string} codec
-     * @param {Object|undefined} options
      * @returns {Object}
      */
-    SegmentBuffersStore.prototype.createSegmentBuffer = function (bufferType, codec, options) {
-        if (options === void 0) { options = {}; }
+    SegmentBuffersStore.prototype.createSegmentBuffer = function (bufferType, codec) {
         var memorizedSegmentBuffer = this._initializedSegmentBuffers[bufferType];
         if (shouldHaveNativeBuffer(bufferType)) {
             if (memorizedSegmentBuffer != null) {
@@ -208,7 +204,9 @@ var SegmentBuffersStore = /** @class */ (function () {
                 return memorizedSegmentBuffer;
             }
             log_1.default.info("SB: Adding native SegmentBuffer with codec", codec);
-            var nativeSegmentBuffer = new implementations_1.AudioVideoSegmentBuffer(bufferType, codec, this._mediaSource);
+            var sourceBufferType = bufferType === "audio" ? "audio" /* SourceBufferType.Audio */ :
+                "video" /* SourceBufferType.Video */;
+            var nativeSegmentBuffer = new implementations_1.AudioVideoSegmentBuffer(sourceBufferType, codec, this._mediaSource);
             this._initializedSegmentBuffers[bufferType] = nativeSegmentBuffer;
             this._onNativeBufferAddedOrDisabled.forEach(function (cb) { return cb(); });
             return nativeSegmentBuffer;
@@ -220,18 +218,10 @@ var SegmentBuffersStore = /** @class */ (function () {
         var segmentBuffer;
         if (bufferType === "text") {
             log_1.default.info("SB: Creating a new text SegmentBuffer");
-            if (options.textTrackMode === "html") {
-                if (features_1.default.htmlTextTracksBuffer == null) {
-                    throw new Error("HTML Text track feature not activated");
-                }
-                segmentBuffer = new features_1.default.htmlTextTracksBuffer(this._mediaElement, options.textTrackElement);
-            }
-            else {
-                if (features_1.default.nativeTextTracksBuffer == null) {
-                    throw new Error("Native Text track feature not activated");
-                }
-                segmentBuffer = new features_1.default.nativeTextTracksBuffer(this._mediaElement);
+            if (this._textInterface === null) {
+                throw new Error("HTML Text track feature not activated");
             }
+            segmentBuffer = new text_1.default(this._textInterface);
             this._initializedSegmentBuffers.text = segmentBuffer;
             return segmentBuffer;
         }

package/dist/commonjs/core/stream/adaptation/adaptation_stream.js

@@ -50,7 +50,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 var config_1 = require("../../../config");
 var errors_1 = require("../../../errors");
 var log_1 = require("../../../log");
-var assert_unreachable_1 = require("../../../utils/assert_unreachable");
+var array_includes_1 = require("../../../utils/array_includes");
+var assert_1 = require("../../../utils/assert");
 var cancellable_sleep_1 = require("../../../utils/cancellable_sleep");
 var noop_1 = require("../../../utils/noop");
 var object_assign_1 = require("../../../utils/object_assign");
@@ -111,8 +112,12 @@ function AdaptationStream(_a, callbacks, parentCancelSignal) {
     var currentRepresentation = new reference_1.default(null, adapStreamCanceller.signal);
     /** Stores the last emitted bitrate. */
     var previouslyEmittedBitrate;
+    var initialRepIds = content.representations.getValue().representationIds;
+    var initialRepresentations = content.adaptation.representations.filter(function (r) { return (0, array_includes_1.default)(initialRepIds, r.id) &&
+        r.decipherable !== false &&
+        r.isSupported !== false; });
     /** Emit the list of Representation for the adaptive logic. */
-    var representationsList = new reference_1.default(content.representations.getValue().representations, adapStreamCanceller.signal);
+    var representationsList = new reference_1.default(initialRepresentations, adapStreamCanceller.signal);
     // Start-up Adaptive logic
     var _b = representationEstimator({ manifest: manifest, period: period, adaptation: adaptation }, currentRepresentation, representationsList, playbackObserver, adapStreamCanceller.signal), estimateRef = _b.estimates, abrCallbacks = _b.callbacks;
     /** Allows a `RepresentationStream` to easily fetch media segments. */
@@ -148,7 +153,9 @@ function AdaptationStream(_a, callbacks, parentCancelSignal) {
         if (cancelCurrentStreams !== undefined) {
             cancelCurrentStreams.cancel();
         }
-        representationsList.setValueIfChanged(val.representations);
+        var newRepIds = content.representations.getValue().representationIds;
+        var newRepresentations = content.adaptation.representations.filter(function (r) { return (0, array_includes_1.default)(newRepIds, r.id); });
+        representationsList.setValueIfChanged(newRepresentations);
         cancelCurrentStreams = new task_canceller_1.default();
         cancelCurrentStreams.linkToSignal(adapStreamCanceller.signal);
         onRepresentationsChoiceChange(val, cancelCurrentStreams.signal).catch(function (err) {
@@ -211,7 +218,7 @@ function AdaptationStream(_a, callbacks, parentCancelSignal) {
                     case 4:
                         if (!!_c.done) return [3 /*break*/, 7];
                         range = _c.value;
-                        return [4 /*yield*/, segmentBuffer.removeBuffer(range.start, range.end, fnCancelSignal)];
+                        return [4 /*yield*/, segmentBuffer.removeBuffer(range.start, range.end)];
                     case 5:
                         _e.sent();
                         if (fnCancelSignal.isCancelled()) {
@@ -241,7 +248,7 @@ function AdaptationStream(_a, callbacks, parentCancelSignal) {
                         }
                         return [3 /*break*/, 12];
                     case 11:
-                        (0, assert_unreachable_1.default)(switchStrat);
+                        (0, assert_1.assertUnreachable)(switchStrat);
                         _e.label = 12;
                     case 12:
                         recursivelyCreateRepresentationStreams(fnCancelSignal);
@@ -291,7 +298,7 @@ function AdaptationStream(_a, callbacks, parentCancelSignal) {
                 return terminateCurrentStream.setValue({ urgent: false });
             }
         }, { clearSignal: repStreamTerminatingCanceller.signal, emitCurrentValue: true });
-        var repInfo = { type: adaptation.type, period: period, representation: representation };
+        var repInfo = { type: adaptation.type, adaptation: adaptation, period: period, representation: representation };
         currentRepresentation.setValue(representation);
         if (adapStreamCanceller.isUsed()) {
             return; // previous callback has stopped everything by side-effect
@@ -389,11 +396,11 @@ function AdaptationStream(_a, callbacks, parentCancelSignal) {
                         try {
                             for (var _f = (e_3 = void 0, __values(element.result.updatedAdaptations)), _g = _f.next(); !_g.done; _g = _f.next()) {
                                 var updated = _g.value;
-                                if (updated.adaptation.id === adaptation.id) {
+                                if (updated.adaptation === adaptation.id) {
                                     try {
                                         for (var _h = (e_4 = void 0, __values(updated.removedRepresentations)), _j = _h.next(); !_j.done; _j = _h.next()) {
                                             var rep = _j.value;
-                                            if (rep.id === representation.id) {
+                                            if (rep === representation.id) {
                                                 if (fnCancelSignal.isCancelled()) {
                                                     return;
                                                 }

package/dist/commonjs/core/stream/adaptation/get_representations_switch_strategy.d.ts

@@ -16,24 +16,38 @@
 import { Adaptation, Period } from "../../../manifest";
 import { IReadOnlyPlaybackObserver } from "../../api";
 import { SegmentBuffer } from "../../segment_buffers";
-import { IRepresentationStreamPlaybackObservation, IRepresentationsChoice } from "../representation";
+import { IRepresentationsChoice, IRepresentationStreamPlaybackObservation } from "../representation";
 export default function getRepresentationsSwitchingStrategy(period: Period, adaptation: Adaptation, settings: IRepresentationsChoice, segmentBuffer: SegmentBuffer, playbackObserver: IReadOnlyPlaybackObserver<IRepresentationStreamPlaybackObservation>): IRepresentationSwitchStrategy;
-export type IRepresentationSwitchStrategy = {
+export type IRepresentationSwitchStrategy = 
+/** Do nothing special. */
+{
     type: "continue";
     value: undefined;
-} | {
+} | 
+/**
+ * Clean the given ranges of time from the buffer, preferably avoiding time
+ * around the current position to continue playback smoothly.
+ */
+{
     type: "clean-buffer";
     value: Array<{
         start: number;
         end: number;
     }>;
-} | {
+} | 
+/**
+ * Clean the given ranges of time from the buffer and try to flush the buffer
+ * so that it is taken in account directly.
+ */
+{
     type: "flush-buffer";
     value: Array<{
         start: number;
         end: number;
     }>;
-} | {
+} | 
+/** Reload completely the media buffers. */
+{
     type: "needs-reload";
     value: undefined;
 };