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

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

@@ -16,6 +16,7 @@
 import config from "../../../config";
 import log from "../../../log";
 import { areSameContent, } from "../../../manifest";
+import getMonotonicTimeStamp from "../../../utils/monotonic_timestamp";
 import BufferedHistory from "./buffered_history";
 /**
  * Keep track of every chunk downloaded and currently in the linked media
@@ -40,17 +41,17 @@ export default class SegmentInventory {
     }
     /**
      * 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) {
+    synchronizeBuffered(ranges) {
         var _a, _b, _c, _d, _e, _f, _g;
         const inventory = this._inventory;
         let inventoryIndex = 0; // Current index considered.
@@ -58,20 +59,20 @@ export default class SegmentInventory {
         const { MINIMUM_SEGMENT_SIZE } = config.getCurrent();
         /** Type of buffer considered, used for logs */
         const bufferType = thisSegment === null || thisSegment === void 0 ? void 0 : thisSegment.infos.adaptation.type;
-        const rangesLength = buffered.length;
+        const rangesLength = ranges.length;
         for (let i = 0; i < rangesLength; i++) {
             if (thisSegment === undefined) { // we arrived at the end of our inventory
                 return;
             }
-            // take the i'nth contiguous buffered TimeRange
-            const rangeStart = buffered.start(i);
-            const rangeEnd = buffered.end(i);
+            // take the i'nth contiguous buffered range
+            const rangeStart = ranges[i].start;
+            const rangeEnd = ranges[i].end;
             if (rangeEnd - rangeStart < MINIMUM_SEGMENT_SIZE) {
-                log.warn("SI: skipped TimeRange when synchronizing because it was too small", bufferType, rangeStart, rangeEnd);
+                log.warn("SI: skipped range when synchronizing because it was too small", bufferType, rangeStart, rangeEnd);
                 continue;
             }
             const 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.
@@ -84,7 +85,7 @@ export default class SegmentInventory {
             // `thisSegment`.
             let 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)
             const numberOfSegmentToDelete = inventoryIndex - indexBefore;
             if (numberOfSegmentToDelete > 0) {
                 const lastDeletedSegment = // last garbage-collected segment
@@ -122,7 +123,7 @@ export default class SegmentInventory {
                 // Make contiguous until first segment outside that range
                 let thisSegmentStart = (_d = thisSegment.bufferedStart) !== null && _d !== void 0 ? _d : thisSegment.start;
                 let thisSegmentEnd = (_e = thisSegment.bufferedEnd) !== null && _e !== void 0 ? _e : thisSegment.end;
-                const nextRangeStart = i < rangesLength - 1 ? buffered.start(i + 1) :
+                const nextRangeStart = i < rangesLength - 1 ? ranges[i + 1].start :
                     undefined;
                 while (thisSegment !== undefined &&
                     (rangeEnd - thisSegmentStart) >= MINIMUM_SEGMENT_SIZE &&
@@ -174,8 +175,12 @@ export default class SegmentInventory {
      * 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 }, succeed) {
+    insertChunk({ period, adaptation, representation, segment, chunkSize, start, end }, succeed, insertionTs) {
         if (segment.isInit) {
             return;
         }
@@ -187,6 +192,7 @@ export default class SegmentInventory {
         const inventory = this._inventory;
         const newSegment = { status: succeed ? 0 /* ChunkStatus.PartiallyPushed */ :
                 2 /* ChunkStatus.Failed */,
+            insertionTs,
             chunkSize,
             splitted: false,
             start,
@@ -385,6 +391,7 @@ export default class SegmentInventory {
                             //  ===>         : |--|====|-|
                             log.warn("SI: Segment pushed is contained in a previous one", bufferType, start, end, segmentI.start, segmentI.end);
                             const nextSegment = { status: segmentI.status,
+                                insertionTs: segmentI.insertionTs,
                                 /**
                                  * Note: this sadly means we're doing as if
                                  * that chunk is present two times.
@@ -507,7 +514,7 @@ export default class SegmentInventory {
      * the corresponding chunks.
      * @param {Object} content
      */
-    completeSegment(content, newBuffered) {
+    completeSegment(content) {
         if (content.segment.isInit) {
             return;
         }
@@ -556,7 +563,6 @@ export default class SegmentInventory {
             log.warn("SI: Completed Segment not found", content.segment.id, content.segment.time);
         }
         else {
-            this.synchronizeBuffered(newBuffered);
             for (const seg of resSegments) {
                 if (seg.bufferedStart !== undefined && seg.bufferedEnd !== undefined) {
                     if (seg.status !== 2 /* ChunkStatus.Failed */) {
@@ -565,6 +571,8 @@ export default class SegmentInventory {
                     }
                 }
                 else {
+                    // TODO FIXME There might be a false positive here when the
+                    // `SEGMENT_SYNCHRONIZATION_DELAY` config value is at play
                     log.debug("SI: buffered range not known after sync. Skipping history.", seg.start, seg.end);
                 }
             }
@@ -647,7 +655,7 @@ function bufferedEndLooksCoherent(thisSegment) {
  * @param {Object} lastDeletedSegmentInfos
  */
 function guessBufferedStartFromRangeStart(firstSegmentInRange, rangeStart, lastDeletedSegmentInfos, bufferType) {
-    const { MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE } = config.getCurrent();
+    const { MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE, MISSING_DATA_TRIGGER_SYNC_DELAY, SEGMENT_SYNCHRONIZATION_DELAY } = config.getCurrent();
     if (firstSegmentInRange.bufferedStart !== undefined) {
         if (firstSegmentInRange.bufferedStart < rangeStart) {
             log.debug("SI: Segment partially GCed at the start", bufferType, firstSegmentInRange.bufferedStart, rangeStart);
@@ -677,6 +685,12 @@ function guessBufferedStartFromRangeStart(firstSegmentInRange, rangeStart, lastD
     }
     else if (firstSegmentInRange.start - rangeStart <=
         MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE) {
+        const now = getMonotonicTimeStamp();
+        if (firstSegmentInRange.start - rangeStart >= MISSING_DATA_TRIGGER_SYNC_DELAY &&
+            now - firstSegmentInRange.insertionTs < SEGMENT_SYNCHRONIZATION_DELAY) {
+            log.debug("SI: Ignored bufferedStart synchronization", bufferType, rangeStart, firstSegmentInRange.start, now - firstSegmentInRange.insertionTs);
+            return;
+        }
         log.debug("SI: found true buffered start", bufferType, rangeStart, firstSegmentInRange.start);
         firstSegmentInRange.bufferedStart = rangeStart;
         if (bufferedStartLooksCoherent(firstSegmentInRange)) {
@@ -689,7 +703,13 @@ function guessBufferedStartFromRangeStart(firstSegmentInRange, rangeStart, lastD
         firstSegmentInRange.bufferedStart = firstSegmentInRange.start;
     }
     else {
-        log.debug("SI: Segment appears immediately garbage collected at the start", bufferType, firstSegmentInRange.bufferedStart, rangeStart);
+        const now = getMonotonicTimeStamp();
+        if (firstSegmentInRange.start - rangeStart >= MISSING_DATA_TRIGGER_SYNC_DELAY &&
+            now - firstSegmentInRange.insertionTs < SEGMENT_SYNCHRONIZATION_DELAY) {
+            log.debug("SI: Ignored bufferedStart synchronization", bufferType, rangeStart, firstSegmentInRange.start, now - firstSegmentInRange.insertionTs);
+            return;
+        }
+        log.debug("SI: Segment appears immediately garbage collected at the start", bufferType, rangeStart, firstSegmentInRange.start);
         firstSegmentInRange.bufferedStart = rangeStart;
     }
 }
@@ -701,7 +721,7 @@ function guessBufferedStartFromRangeStart(firstSegmentInRange, rangeStart, lastD
  * @param {string} bufferType
  */
 function guessBufferedEndFromRangeEnd(lastSegmentInRange, rangeEnd, bufferType) {
-    const { MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE } = config.getCurrent();
+    const { MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE, MISSING_DATA_TRIGGER_SYNC_DELAY, SEGMENT_SYNCHRONIZATION_DELAY } = config.getCurrent();
     if (lastSegmentInRange.bufferedEnd !== undefined) {
         if (lastSegmentInRange.bufferedEnd > rangeEnd) {
             log.debug("SI: Segment partially GCed at the end", bufferType, lastSegmentInRange.bufferedEnd, rangeEnd);
@@ -720,6 +740,12 @@ function guessBufferedEndFromRangeEnd(lastSegmentInRange, rangeEnd, bufferType)
     }
     else if (rangeEnd - lastSegmentInRange.end <=
         MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE) {
+        const now = getMonotonicTimeStamp();
+        if (rangeEnd - lastSegmentInRange.end >= MISSING_DATA_TRIGGER_SYNC_DELAY &&
+            now - lastSegmentInRange.insertionTs < SEGMENT_SYNCHRONIZATION_DELAY) {
+            log.debug("SI: Ignored bufferedEnd synchronization", bufferType, rangeEnd, lastSegmentInRange.end, now - lastSegmentInRange.insertionTs);
+            return;
+        }
         log.debug("SI: found true buffered end", bufferType, rangeEnd, lastSegmentInRange.end);
         lastSegmentInRange.bufferedEnd = rangeEnd;
         if (bufferedEndLooksCoherent(lastSegmentInRange)) {
@@ -732,6 +758,12 @@ function guessBufferedEndFromRangeEnd(lastSegmentInRange, rangeEnd, bufferType)
         lastSegmentInRange.bufferedEnd = lastSegmentInRange.end;
     }
     else {
+        const now = getMonotonicTimeStamp();
+        if (rangeEnd - lastSegmentInRange.end >= MISSING_DATA_TRIGGER_SYNC_DELAY &&
+            now - lastSegmentInRange.insertionTs < SEGMENT_SYNCHRONIZATION_DELAY) {
+            log.debug("SI: Ignored bufferedEnd synchronization", bufferType, rangeEnd, lastSegmentInRange.end, now - lastSegmentInRange.insertionTs);
+            return;
+        }
         log.debug("SI: Segment appears immediately garbage collected at the end", bufferType, lastSegmentInRange.bufferedEnd, rangeEnd);
         lastSegmentInRange.bufferedEnd = rangeEnd;
     }

package/dist/es2017/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/es2017/core/segment_buffers/segment_buffers_store.js

@@ -14,10 +14,10 @@
  * limitations under the License.
  */
 import { MediaError } from "../../errors";
-import features from "../../features";
 import log from "../../log";
 import createCancellablePromise from "../../utils/create_cancellable_promise";
 import { AudioVideoSegmentBuffer, } from "./implementations";
+import TextSegmentBuffer from "./implementations/text";
 const POSSIBLE_BUFFER_TYPES = ["audio",
     "video",
     "text"];
@@ -56,13 +56,13 @@ export default class SegmentBuffersStore {
         return shouldHaveNativeBuffer(bufferType);
     }
     /**
-     * @param {HTMLMediaElement} mediaElement
      * @param {MediaSource} mediaSource
      * @constructor
      */
-    constructor(mediaElement, mediaSource) {
-        this._mediaElement = mediaElement;
+    constructor(mediaSource, hasVideo, textDisplayerInterface) {
         this._mediaSource = mediaSource;
+        this._textInterface = textDisplayerInterface;
+        this._hasVideo = hasVideo;
         this._initializedSegmentBuffers = {};
         this._onNativeBufferAddedOrDisabled = [];
     }
@@ -73,8 +73,7 @@ export default class SegmentBuffersStore {
      */
     getBufferTypes() {
         const bufferTypes = this.getNativeBufferTypes();
-        if (features.nativeTextTracksBuffer != null ||
-            features.htmlTextTracksBuffer != null) {
+        if (this._textInterface !== null) {
             bufferTypes.push("text");
         }
         return bufferTypes;
@@ -85,8 +84,7 @@ export default class SegmentBuffersStore {
      * @returns {Array.<string>}
      */
     getNativeBufferTypes() {
-        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
@@ -161,7 +159,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) {
         const currentValue = this._initializedSegmentBuffers[bufferType];
@@ -187,10 +185,9 @@ export default class SegmentBuffersStore {
      * type.
      * @param {string} bufferType
      * @param {string} codec
-     * @param {Object|undefined} options
      * @returns {Object}
      */
-    createSegmentBuffer(bufferType, codec, options = {}) {
+    createSegmentBuffer(bufferType, codec) {
         const memorizedSegmentBuffer = this._initializedSegmentBuffers[bufferType];
         if (shouldHaveNativeBuffer(bufferType)) {
             if (memorizedSegmentBuffer != null) {
@@ -204,7 +201,9 @@ export default class SegmentBuffersStore {
                 return memorizedSegmentBuffer;
             }
             log.info("SB: Adding native SegmentBuffer with codec", codec);
-            const nativeSegmentBuffer = new AudioVideoSegmentBuffer(bufferType, codec, this._mediaSource);
+            const sourceBufferType = bufferType === "audio" ? "audio" /* SourceBufferType.Audio */ :
+                "video" /* SourceBufferType.Video */;
+            const nativeSegmentBuffer = new AudioVideoSegmentBuffer(sourceBufferType, codec, this._mediaSource);
             this._initializedSegmentBuffers[bufferType] = nativeSegmentBuffer;
             this._onNativeBufferAddedOrDisabled.forEach(cb => cb());
             return nativeSegmentBuffer;
@@ -216,18 +215,10 @@ export default class SegmentBuffersStore {
         let segmentBuffer;
         if (bufferType === "text") {
             log.info("SB: Creating a new text SegmentBuffer");
-            if (options.textTrackMode === "html") {
-                if (features.htmlTextTracksBuffer == null) {
-                    throw new Error("HTML Text track feature not activated");
-                }
-                segmentBuffer = new features.htmlTextTracksBuffer(this._mediaElement, options.textTrackElement);
-            }
-            else {
-                if (features.nativeTextTracksBuffer == null) {
-                    throw new Error("Native Text track feature not activated");
-                }
-                segmentBuffer = new features.nativeTextTracksBuffer(this._mediaElement);
+            if (this._textInterface === null) {
+                throw new Error("HTML Text track feature not activated");
             }
+            segmentBuffer = new TextSegmentBuffer(this._textInterface);
             this._initializedSegmentBuffers.text = segmentBuffer;
             return segmentBuffer;
         }

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

@@ -1,7 +1,8 @@
 import config from "../../../config";
 import { formatError } from "../../../errors";
 import log from "../../../log";
-import assertUnreachable from "../../../utils/assert_unreachable";
+import arrayIncludes from "../../../utils/array_includes";
+import { assertUnreachable } from "../../../utils/assert";
 import cancellableSleep from "../../../utils/cancellable_sleep";
 import noop from "../../../utils/noop";
 import objectAssign from "../../../utils/object_assign";
@@ -61,8 +62,12 @@ export default function AdaptationStream({ playbackObserver, content, options, r
     const currentRepresentation = new SharedReference(null, adapStreamCanceller.signal);
     /** Stores the last emitted bitrate. */
     let previouslyEmittedBitrate;
+    const initialRepIds = content.representations.getValue().representationIds;
+    const initialRepresentations = content.adaptation.representations.filter(r => arrayIncludes(initialRepIds, r.id) &&
+        r.decipherable !== false &&
+        r.isSupported !== false);
     /** Emit the list of Representation for the adaptive logic. */
-    const representationsList = new SharedReference(content.representations.getValue().representations, adapStreamCanceller.signal);
+    const representationsList = new SharedReference(initialRepresentations, adapStreamCanceller.signal);
     // Start-up Adaptive logic
     const { estimates: estimateRef, callbacks: abrCallbacks } = representationEstimator({ manifest, period, adaptation }, currentRepresentation, representationsList, playbackObserver, adapStreamCanceller.signal);
     /** Allows a `RepresentationStream` to easily fetch media segments. */
@@ -97,7 +102,9 @@ export default function AdaptationStream({ playbackObserver, content, options, r
         if (cancelCurrentStreams !== undefined) {
             cancelCurrentStreams.cancel();
         }
-        representationsList.setValueIfChanged(val.representations);
+        const newRepIds = content.representations.getValue().representationIds;
+        const newRepresentations = content.adaptation.representations.filter(r => arrayIncludes(newRepIds, r.id));
+        representationsList.setValueIfChanged(newRepresentations);
         cancelCurrentStreams = new TaskCanceller();
         cancelCurrentStreams.linkToSignal(adapStreamCanceller.signal);
         onRepresentationsChoiceChange(val, cancelCurrentStreams.signal).catch((err) => {
@@ -149,7 +156,7 @@ export default function AdaptationStream({ playbackObserver, content, options, r
             case "flush-buffer": // Clean + flush
             case "clean-buffer": // Just clean
                 for (const range of switchStrat.value) {
-                    await segmentBuffer.removeBuffer(range.start, range.end, fnCancelSignal);
+                    await segmentBuffer.removeBuffer(range.start, range.end);
                     if (fnCancelSignal.isCancelled()) {
                         return;
                     }
@@ -207,7 +214,7 @@ export default function AdaptationStream({ playbackObserver, content, options, r
                 return terminateCurrentStream.setValue({ urgent: false });
             }
         }, { clearSignal: repStreamTerminatingCanceller.signal, emitCurrentValue: true });
-        const repInfo = { type: adaptation.type, period, representation };
+        const repInfo = { type: adaptation.type, adaptation, period, representation };
         currentRepresentation.setValue(representation);
         if (adapStreamCanceller.isUsed()) {
             return; // previous callback has stopped everything by side-effect
@@ -310,9 +317,9 @@ export default function AdaptationStream({ playbackObserver, content, options, r
             for (const element of updates.updatedPeriods) {
                 if (element.period.id === period.id) {
                     for (const updated of element.result.updatedAdaptations) {
-                        if (updated.adaptation.id === adaptation.id) {
+                        if (updated.adaptation === adaptation.id) {
                             for (const rep of updated.removedRepresentations) {
-                                if (rep.id === representation.id) {
+                                if (rep === representation.id) {
                                     if (fnCancelSignal.isCancelled()) {
                                         return;
                                     }

package/dist/es2017/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;
 };

package/dist/es2017/core/stream/adaptation/get_representations_switch_strategy.js

@@ -14,53 +14,44 @@
  * limitations under the License.
  */
 import config from "../../../config";
-import { convertToRanges, excludeFromRanges, isTimeInRange, isTimeInRanges, keepRangeIntersection, } from "../../../utils/ranges";
-import { getFirstSegmentAfterPeriod, getLastSegmentBeforePeriod, } from "../../segment_buffers";
+import arrayIncludes from "../../../utils/array_includes";
+import { excludeFromRanges, insertInto, } from "../../../utils/ranges";
+import { getFirstSegmentAfterPeriod, getLastSegmentBeforePeriod, SegmentBufferOperation, } from "../../segment_buffers";
 export default function getRepresentationsSwitchingStrategy(period, adaptation, settings, segmentBuffer, playbackObserver) {
+    var _a, _b;
     if (settings.switchingMode === "lazy") {
         return { type: "continue", value: undefined };
     }
-    const buffered = segmentBuffer.getBufferedRanges();
-    if (buffered.length === 0) {
-        return { type: "continue", value: undefined };
+    const inventory = segmentBuffer.getLastKnownInventory();
+    const unwantedRange = [];
+    for (const elt of inventory) {
+        if (elt.infos.period.id === period.id && (elt.infos.adaptation.id !== adaptation.id ||
+            !arrayIncludes(settings.representationIds, elt.infos.representation.id))) {
+            insertInto(unwantedRange, { start: (_a = elt.bufferedStart) !== null && _a !== void 0 ? _a : elt.start,
+                end: (_b = elt.bufferedEnd) !== null && _b !== void 0 ? _b : elt.end });
+        }
     }
-    const bufferedRanges = convertToRanges(buffered);
-    const start = period.start;
-    const end = period.end == null ? Infinity :
-        period.end;
-    const intersection = keepRangeIntersection(bufferedRanges, [{ start, end }]);
-    if (intersection.length === 0) {
-        return { type: "continue", value: undefined };
+    const pendingOperations = segmentBuffer.getPendingOperations();
+    for (const operation of pendingOperations) {
+        if (operation.type === SegmentBufferOperation.Push) {
+            const info = operation.value.inventoryInfos;
+            if (info.period.id === period.id && (info.adaptation.id !== adaptation.id ||
+                !arrayIncludes(settings.representationIds, info.representation.id))) {
+                const start = info.segment.time;
+                const end = start + info.segment.duration;
+                insertInto(unwantedRange, { start, end });
+            }
+        }
     }
-    segmentBuffer.synchronizeInventory();
-    const inventory = segmentBuffer.getInventory();
-    /** Data already in the right Adaptation */
-    const rangesWithReps = getBufferedRangesFromRepresentations(inventory, period, adaptation, settings.representations);
-    /**
-     * Data different from the wanted Adaptation in the Period's range.
-     * /!\ Could contain some data at the end of the previous Period or at the
-     * beginning of the next one.
-     */
-    const unwantedRange = excludeFromRanges(intersection, rangesWithReps);
+    // Continue if we have no other Adaptation buffered in the current Period
     if (unwantedRange.length === 0) {
         return { type: "continue", value: undefined };
     }
-    const readyState = playbackObserver.getReadyState();
-    if (settings.switchingMode === "reload" && readyState > 1) {
-        const lastObservation = playbackObserver.getReference().getValue();
-        if (lastObservation.position.isAwaitingFuturePosition()) {
-            // We are not at the position we want to reach (e.g. initial seek, tizen
-            // seek-back...), just reload as checks here would be too complex
+    if (settings.switchingMode === "reload") {
+        const readyState = playbackObserver.getReadyState();
+        if (readyState === undefined || readyState > 1) {
             return { type: "needs-reload", value: undefined };
         }
-        else {
-            const currentTime = playbackObserver.getCurrentTime();
-            if (isTimeInRange({ start, end }, currentTime) &&
-                // We're not playing the current wanted video Adaptation
-                !isTimeInRanges(rangesWithReps, currentTime)) {
-                return { type: "needs-reload", value: undefined };
-            }
-        }
     }
     // From here, clean-up data from the previous Adaptation, if one
     const shouldFlush = settings.switchingMode === "direct";
@@ -91,7 +82,12 @@ export default function getRepresentationsSwitchingStrategy(period, adaptation,
         if (paddingAfter == null) {
             paddingAfter = 0;
         }
-        const currentTime = playbackObserver.getCurrentTime();
+        let currentTime = playbackObserver.getCurrentTime();
+        if (currentTime === undefined) {
+            // TODO current position might be old. A better solution should be found.
+            const lastObservation = playbackObserver.getReference().getValue();
+            currentTime = lastObservation.position.getPolled();
+        }
         rangesToExclude.push({ start: currentTime - paddingBefore,
             end: currentTime + paddingAfter });
     }
@@ -115,26 +111,3 @@ export default function getRepresentationsSwitchingStrategy(period, adaptation,
     return shouldFlush ? { type: "flush-buffer", value: toRemove } :
         { type: "clean-buffer", value: toRemove };
 }
-/**
- * Returns buffered ranges of what we know correspond to the given `adaptation`
- * in the SegmentBuffer.
- * @param {Array.<Object>} inventory
- * @param {Object} period
- * @param {Object} adaptation
- * @returns {Array.<Object>}
- */
-function getBufferedRangesFromRepresentations(inventory, period, adaptation, representations) {
-    return inventory.reduce((acc, chunk) => {
-        if (chunk.infos.period.id !== period.id ||
-            chunk.infos.adaptation.id !== adaptation.id ||
-            !representations.some(rep => rep.id === chunk.infos.representation.id)) {
-            return acc;
-        }
-        const { bufferedStart, bufferedEnd } = chunk;
-        if (bufferedStart === undefined || bufferedEnd === undefined) {
-            return acc;
-        }
-        acc.push({ start: bufferedStart, end: bufferedEnd });
-        return acc;
-    }, []);
-}