rx-player 3.33.2 → 3.33.3

package/dist/_esm5.processed/core/init/media_source_content_initializer.js

@@ -65,6 +65,8 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     }
 };
 import { shouldReloadMediaSourceOnDecipherabilityUpdate } from "../../compat";
+/* eslint-disable-next-line max-len */
+import mayMediaElementFailOnUndecipherableData from "../../compat/may_media_element_fail_on_undecipherable_data";
 import config from "../../config";
 import { MediaError } from "../../errors";
 import log from "../../log";
@@ -353,6 +355,14 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
         }, { clearSignal: cancelSignal, emitCurrentValue: true });
         var streamObserver = createStreamPlaybackObserver(playbackObserver, { autoPlay: autoPlay, manifest: manifest, initialPlayPerformed: initialPlayPerformed, initialSeekPerformed: initialSeekPerformed, speed: speed, startTime: initialTime }, cancelSignal);
         var rebufferingController = this._createRebufferingController(playbackObserver, manifest, speed, cancelSignal);
+        if (mayMediaElementFailOnUndecipherableData) {
+            // On some devices, just reload immediately when data become undecipherable
+            manifest.addEventListener("decipherabilityUpdate", function (elts) {
+                if (elts.some(function (e) { return e.representation.decipherable !== true; })) {
+                    reloadMediaSource(0, undefined, undefined);
+                }
+            }, cancelSignal);
+        }
         var contentTimeBoundariesObserver = this
             ._createContentTimeBoundariesObserver(manifest, mediaSource, streamObserver, segmentBuffersStore, cancelSignal);
         /**
@@ -487,18 +497,7 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
                 },
                 addedSegment: function (value) { return self.trigger("addedSegment", value); },
                 needsMediaSourceReload: function (payload) {
-                    var _a, _b;
-                    var lastObservation = streamObserver.getReference().getValue();
-                    var currentPosition = (_a = lastObservation.position.pending) !== null && _a !== void 0 ? _a : streamObserver.getCurrentTime();
-                    var isPaused = (_b = lastObservation.paused.pending) !== null && _b !== void 0 ? _b : streamObserver.getIsPaused();
-                    var position = currentPosition + payload.timeOffset;
-                    if (payload.minimumPosition !== undefined) {
-                        position = Math.max(payload.minimumPosition, position);
-                    }
-                    if (payload.maximumPosition !== undefined) {
-                        position = Math.min(payload.maximumPosition, position);
-                    }
-                    onReloadOrder({ position: position, autoPlay: !isPaused });
+                    reloadMediaSource(payload.timeOffset, payload.minimumPosition, payload.maximumPosition);
                 },
                 needsDecipherabilityFlush: function () {
                     var _a, _b, _c;
@@ -534,6 +533,29 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
                 error: function (err) { return self._onFatalError(err); },
             };
         }
+        /**
+         * Callback allowing to reload the current content.
+         * @param {number} deltaPosition - Position you want to seek to after
+         * reloading, as a delta in seconds from the last polled playing position.
+         * @param {number|undefined} minimumPosition - If set, minimum time bound
+         * in seconds after `deltaPosition` has been applied.
+         * @param {number|undefined} maximumPosition - If set, minimum time bound
+         * in seconds after `deltaPosition` has been applied.
+         */
+        function reloadMediaSource(deltaPosition, minimumPosition, maximumPosition) {
+            var _a, _b;
+            var lastObservation = streamObserver.getReference().getValue();
+            var currentPosition = (_a = lastObservation.position.pending) !== null && _a !== void 0 ? _a : streamObserver.getCurrentTime();
+            var isPaused = (_b = lastObservation.paused.pending) !== null && _b !== void 0 ? _b : streamObserver.getIsPaused();
+            var position = currentPosition + deltaPosition;
+            if (minimumPosition !== undefined) {
+                position = Math.max(minimumPosition, position);
+            }
+            if (maximumPosition !== undefined) {
+                position = Math.min(maximumPosition, position);
+            }
+            onReloadOrder({ position: position, autoPlay: !isPaused });
+        }
     };
     /**
      * Creates a `ContentTimeBoundariesObserver`, a class indicating various

package/dist/_esm5.processed/core/init/utils/get_loaded_reference.js

@@ -35,7 +35,12 @@ export default function getLoadedReference(playbackObserver, mediaElement, isDir
             observation.readyState === 0) {
             return;
         }
-        if (!shouldWaitForDataBeforeLoaded(isDirectfile, mediaElement.hasAttribute("playsinline"))) {
+        if (!shouldWaitForDataBeforeLoaded(isDirectfile)) {
+            // The duration is NaN if no media data is available,
+            // which means media is not loaded yet.
+            if (isNaN(mediaElement.duration)) {
+                return;
+            }
             if (mediaElement.duration > 0) {
                 isLoaded.setValue(true);
                 listenCanceller.cancel();

package/dist/_esm5.processed/core/init/utils/initial_seek_and_play.js

@@ -101,7 +101,10 @@ export default function performInitialSeekAndPlay(mediaElement, playbackObserver
          */
         var isAwaitingSeek = hasAskedForInitialSeek;
         playbackObserver.listen(function (observation, stopListening) {
-            if (hasAskedForInitialSeek && observation.seeking) {
+            if (hasAskedForInitialSeek &&
+                (observation.seeking ||
+                    observation.event === "seeking" ||
+                    observation.event === "internal-seeking")) {
                 isAwaitingSeek = false;
                 return;
             }

package/dist/_esm5.processed/core/segment_buffers/implementations/audio_video/audio_video_segment_buffer.js

@@ -125,8 +125,10 @@ var AudioVideoSegmentBuffer = /** @class */ (function (_super) {
     AudioVideoSegmentBuffer.prototype.pushChunk = function (infos, cancellationSignal) {
         assertDataIsBufferSource(infos.data.chunk);
         log.debug("AVSB: receiving order to push data to the SourceBuffer", this.bufferType, getLoggableSegmentId(infos.inventoryInfos));
-        return this._addToQueue({ type: SegmentBufferOperation.Push,
-            value: infos }, cancellationSignal);
+        return this._addToQueue({
+            type: SegmentBufferOperation.Push,
+            value: infos,
+        }, cancellationSignal);
     };
     /**
      * Remove buffered data (added to the same FIFO queue than `pushChunk`).
@@ -137,8 +139,7 @@ var AudioVideoSegmentBuffer = /** @class */ (function (_super) {
      */
     AudioVideoSegmentBuffer.prototype.removeBuffer = function (start, end, cancellationSignal) {
         log.debug("AVSB: receiving order to remove data from the SourceBuffer", this.bufferType, start, end);
-        return this._addToQueue({ type: SegmentBufferOperation.Remove,
-            value: { start: start, end: end } }, cancellationSignal);
+        return this._addToQueue({ type: SegmentBufferOperation.Remove, value: { start: start, end: end } }, cancellationSignal);
     };
     /**
      * Indicate that every chunks from a Segment has been given to pushChunk so
@@ -151,8 +152,7 @@ var AudioVideoSegmentBuffer = /** @class */ (function (_super) {
      */
     AudioVideoSegmentBuffer.prototype.endOfSegment = function (infos, cancellationSignal) {
         log.debug("AVSB: receiving order for validating end of segment", this.bufferType, getLoggableSegmentId(infos));
-        return this._addToQueue({ type: SegmentBufferOperation.EndOfSegment,
-            value: infos }, cancellationSignal);
+        return this._addToQueue({ type: SegmentBufferOperation.EndOfSegment, value: infos }, cancellationSignal);
     };
     /**
      * Returns the currently buffered data, in a TimeRanges object.
@@ -180,9 +180,9 @@ var AudioVideoSegmentBuffer = /** @class */ (function (_super) {
             }
         };
         var queued = this._queue.map(parseQueuedOperation);
-        return this._pendingTask === null ?
-            queued :
-            [parseQueuedOperation(this._pendingTask)].concat(queued);
+        return this._pendingTask === null
+            ? queued
+            : [parseQueuedOperation(this._pendingTask)].concat(queued);
     };
     /**
      * Dispose of the resources used by this AudioVideoSegmentBuffer.
@@ -220,15 +220,15 @@ var AudioVideoSegmentBuffer = /** @class */ (function (_super) {
     AudioVideoSegmentBuffer.prototype._onPendingTaskError = function (err) {
         this._lastInitSegmentUniqueId = null; // initialize init segment as a security
         if (this._pendingTask !== null) {
-            var error = err instanceof Error ?
-                err :
-                new Error("An unknown error occured when doing operations " +
+            var error = err instanceof Error
+                ? err
+                : new Error("An unknown error occured when doing operations " +
                     "on the SourceBuffer");
             var task = this._pendingTask;
             if (task.type === SegmentBufferOperation.Push &&
                 task.data.length === 0 &&
                 task.inventoryData !== null) {
-                this._segmentInventory.insertChunk(task.inventoryData, false);
+                this._segmentInventory.insertChunk(task.inventoryData, false, performance.now());
             }
             this._pendingTask = null;
             task.reject(error);
@@ -243,8 +243,7 @@ var AudioVideoSegmentBuffer = /** @class */ (function (_super) {
     AudioVideoSegmentBuffer.prototype._addToQueue = function (operation, cancellationSignal) {
         var _this = this;
         return createCancellablePromise(cancellationSignal, function (resolve, reject) {
-            var shouldRestartQueue = _this._queue.length === 0 &&
-                _this._pendingTask === null;
+            var shouldRestartQueue = _this._queue.length === 0 && _this._pendingTask === null;
             var queueItem = objectAssign({ resolve: resolve, reject: reject }, operation);
             _this._queue.push(queueItem);
             if (shouldRestartQueue) {
@@ -279,7 +278,7 @@ var AudioVideoSegmentBuffer = /** @class */ (function (_super) {
                 switch (task.type) {
                     case SegmentBufferOperation.Push:
                         if (task.inventoryData !== null) {
-                            this._segmentInventory.insertChunk(task.inventoryData, true);
+                            this._segmentInventory.insertChunk(task.inventoryData, true, performance.now());
                         }
                         break;
                     case SegmentBufferOperation.EndOfSegment:
@@ -298,7 +297,8 @@ var AudioVideoSegmentBuffer = /** @class */ (function (_super) {
                 return;
             }
         }
-        else { // if this._pendingTask is null, go to next item in queue
+        else {
+            // if this._pendingTask is null, go to next item in queue
             var nextItem = this._queue.shift();
             if (nextItem === undefined) {
                 return; // we have nothing left to do
@@ -313,17 +313,15 @@ var AudioVideoSegmentBuffer = /** @class */ (function (_super) {
                     dataToPush = this._preparePushOperation(itemValue.data);
                 }
                 catch (e) {
-                    this._pendingTask = objectAssign({ data: [],
-                        inventoryData: itemValue.inventoryInfos }, nextItem);
-                    var error = e instanceof Error ?
-                        e :
-                        new Error("An unknown error occured when preparing a push operation");
+                    this._pendingTask = objectAssign({ data: [], inventoryData: itemValue.inventoryInfos }, nextItem);
+                    var error = e instanceof Error
+                        ? e
+                        : new Error("An unknown error occured when preparing a push operation");
                     this._lastInitSegmentUniqueId = null; // initialize init segment as a security
                     nextItem.reject(error);
                     return;
                 }
-                this._pendingTask = objectAssign({ data: dataToPush,
-                    inventoryData: itemValue.inventoryInfos }, nextItem);
+                this._pendingTask = objectAssign({ data: dataToPush, inventoryData: itemValue.inventoryInfos }, nextItem);
             }
         }
         try {
@@ -450,7 +448,8 @@ export default AudioVideoSegmentBuffer;
  * @param {Object} data
  */
 function assertDataIsBufferSource(data) {
-    if (0 /* __ENVIRONMENT__.CURRENT_ENV */ === 0 /* __ENVIRONMENT__.PRODUCTION */) {
+    if (0 /* __ENVIRONMENT__.CURRENT_ENV */ ===
+        0 /* __ENVIRONMENT__.PRODUCTION */) {
         return;
     }
     if (typeof data !== "object" ||

package/dist/_esm5.processed/core/segment_buffers/implementations/image/image_segment_buffer.js

@@ -80,7 +80,7 @@ var ImageSegmentBuffer = /** @class */ (function (_super) {
         try {
             this._buffered.insert(startTime, endTime);
             if (infos.inventoryInfos !== null) {
-                this._segmentInventory.insertChunk(infos.inventoryInfos, true);
+                this._segmentInventory.insertChunk(infos.inventoryInfos, true, performance.now());
             }
         }
         catch (err) {

package/dist/_esm5.processed/core/segment_buffers/implementations/text/html/html_text_segment_buffer.js

@@ -231,7 +231,7 @@ var HTMLTextSegmentBuffer = /** @class */ (function (_super) {
             return;
         }
         if (infos.inventoryInfos !== null) {
-            this._segmentInventory.insertChunk(infos.inventoryInfos, true);
+            this._segmentInventory.insertChunk(infos.inventoryInfos, true, performance.now());
         }
         this._buffer.insert(cues, start, end);
         this._buffered.insert(start, end);

package/dist/_esm5.processed/core/segment_buffers/implementations/text/html/text_track_cues_store.js

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 import assert from "../../../../../utils/assert";
-import { areNearlyEqual, getCuesAfter, getCuesBefore, removeCuesInfosBetween, } from "./utils";
+import { areNearlyEqual, getCuesAfter, getCuesBefore, removeCuesInfosBetween, areCuesStartNearlyEqual, } from "./utils";
 /**
  * first or last IHTMLCue in a group can have a slighlty different start
  * or end time than the start or end time of the ICuesGroup due to parsing
@@ -223,7 +223,7 @@ var TextTrackCuesStore = /** @class */ (function () {
         for (var cueIdx = 0; cueIdx < cuesBuffer.length; cueIdx++) {
             var cuesInfos = cuesBuffer[cueIdx];
             if (start < cuesInfos.end) {
-                if (areNearlyEqual(start, cuesInfos.start, relativeDelta)) {
+                if (areCuesStartNearlyEqual(cuesInfosToInsert, cuesInfos)) {
                     if (areNearlyEqual(end, cuesInfos.end, relativeDelta)) {
                         // exact same segment
                         //   ours:            |AAAAA|

package/dist/_esm5.processed/core/segment_buffers/implementations/text/html/utils.d.ts

@@ -22,6 +22,21 @@ import { ICuesGroup, IHTMLCue } from "./types";
  * @returns {Boolean}
  */
 export declare function areNearlyEqual(a: number, b: number, delta?: number): boolean;
+/**
+ * Check if two cues start are almost the same.
+ * It should depend on there relative length:
+ *
+ * [0, 2] and [2, 4] start are NOT equals
+ * [0, 2] and [0, 4]  start are equals
+ * [0, 0.1] and [0.101, 2] start are NOT equals
+ * [0, 2] and [0.01, 4]  start are equals
+ * [0, 100] and [1, 200]  start are NOT equals
+ * @see MAX_DELTA_BUFFER_TIME
+ * @param {Number} firstCue the existing cue
+ * @param {Number} secondCue the cue that we test if it follow firstCue
+ * @returns {Boolean}
+ */
+export declare function areCuesStartNearlyEqual(firstCue: ICuesGroup, secondCue: ICuesGroup): boolean;
 /**
  * Get all cues which have data before the given time.
  * @param {Object} cues

package/dist/_esm5.processed/core/segment_buffers/implementations/text/html/utils.js

@@ -73,6 +73,29 @@ export function areNearlyEqual(a, b, delta) {
     if (delta === void 0) { delta = MAX_DELTA_BUFFER_TIME; }
     return Math.abs(a - b) <= Math.min(delta, MAX_DELTA_BUFFER_TIME);
 }
+var EPSILON = 5e-2; // 5%
+/**
+ * Check if two cues start are almost the same.
+ * It should depend on there relative length:
+ *
+ * [0, 2] and [2, 4] start are NOT equals
+ * [0, 2] and [0, 4]  start are equals
+ * [0, 0.1] and [0.101, 2] start are NOT equals
+ * [0, 2] and [0.01, 4]  start are equals
+ * [0, 100] and [1, 200]  start are NOT equals
+ * @see MAX_DELTA_BUFFER_TIME
+ * @param {Number} firstCue the existing cue
+ * @param {Number} secondCue the cue that we test if it follow firstCue
+ * @returns {Boolean}
+ */
+export function areCuesStartNearlyEqual(firstCue, secondCue) {
+    var firstCueDuration = firstCue.end - firstCue.start;
+    var secondCueDuration = secondCue.end - secondCue.start;
+    var diffBetweenStart = Math.abs(firstCue.start - secondCue.start);
+    var minDuration = Math.min(firstCueDuration, secondCueDuration, MAX_DELTA_BUFFER_TIME);
+    // ratio diff/ minduration is bellow 5%
+    return diffBetweenStart / minDuration <= EPSILON;
+}
 /**
  * Get all cues which have data before the given time.
  * @param {Object} cues

package/dist/_esm5.processed/core/segment_buffers/implementations/text/native/native_text_segment_buffer.js

@@ -157,7 +157,7 @@ var NativeTextSegmentBuffer = /** @class */ (function (_super) {
             }
             this._buffered.insert(start, end);
             if (infos.inventoryInfos !== null) {
-                this._segmentInventory.insertChunk(infos.inventoryInfos, true);
+                this._segmentInventory.insertChunk(infos.inventoryInfos, true, performance.now());
             }
         }
         catch (err) {

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

@@ -24,11 +24,11 @@ export declare const enum ChunkStatus {
      * fully-loaded and pushed.
      *
      * Once and if the corresponding segment is fully-pushed, its `ChunkStatus`
-     * switches to `Complete`.
+     * switches to `FullyLoaded`.
      */
     PartiallyPushed = 0,
     /** This chunk corresponds to a fully-loaded segment. */
-    Complete = 1,
+    FullyLoaded = 1,
     /**
      * This chunk's push operation failed, in this scenario there is no certitude
      * about the presence of that chunk in the buffer: it may not be present,
@@ -39,6 +39,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
@@ -190,10 +199,15 @@ 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 }: 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.
+     * Indicate that inserted chunks can now be considered as a fully-loaded
+     * segment.
      * Take in argument the same content than what was given to `insertChunk` for
      * the corresponding chunks.
      * @param {Object} content

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

@@ -139,8 +139,19 @@ var SegmentInventory = /** @class */ (function () {
                     // those segments are contiguous, we have no way to infer their real
                     // end
                     if (prevSegment.bufferedEnd === undefined) {
-                        prevSegment.bufferedEnd = thisSegment.precizeStart ? thisSegment.start :
-                            prevSegment.end;
+                        if (thisSegment.precizeStart) {
+                            prevSegment.bufferedEnd = thisSegment.start;
+                        }
+                        else if (prevSegment.infos.segment.complete) {
+                            prevSegment.bufferedEnd = prevSegment.end;
+                        }
+                        else {
+                            // We cannot truly trust the anounced end here as the segment was
+                            // potentially not complete at its time of announce.
+                            // Just assume the next's segment announced start is right - as
+                            // `start` is in that scenario more "trustable" than `end`.
+                            prevSegment.bufferedEnd = thisSegment.start;
+                        }
                         log.debug("SI: calculating buffered end of contiguous segment", bufferType, prevSegment.bufferedEnd, prevSegment.end);
                     }
                     thisSegment.bufferedStart = prevSegment.bufferedEnd;
@@ -182,8 +193,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;
@@ -195,7 +210,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,
@@ -389,6 +404,7 @@ var SegmentInventory = /** @class */ (function () {
                             //  ===>         : |--|====|-|
                             log.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.
@@ -506,7 +522,8 @@ var SegmentInventory = /** @class */ (function () {
         }
     };
     /**
-     * Indicate that inserted chunks can now be considered as a complete segment.
+     * Indicate that inserted chunks can now be considered as a fully-loaded
+     * segment.
      * Take in argument the same content than what was given to `insertChunk` for
      * the corresponding chunks.
      * @param {Object} content
@@ -547,7 +564,7 @@ var SegmentInventory = /** @class */ (function () {
                     i -= length_1;
                 }
                 if (this._inventory[firstI].status === 0 /* ChunkStatus.PartiallyPushed */) {
-                    this._inventory[firstI].status = 1 /* ChunkStatus.Complete */;
+                    this._inventory[firstI].status = 1 /* ChunkStatus.FullyLoaded */;
                 }
                 this._inventory[firstI].chunkSize = segmentSize;
                 this._inventory[firstI].end = lastEnd;
@@ -570,6 +587,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.debug("SI: buffered range not known after sync. Skipping history.", seg.start, seg.end);
                 }
             }
@@ -612,7 +631,7 @@ export default SegmentInventory;
  */
 function bufferedStartLooksCoherent(thisSegment) {
     if (thisSegment.bufferedStart === undefined ||
-        thisSegment.status !== 1 /* ChunkStatus.Complete */) {
+        thisSegment.status !== 1 /* ChunkStatus.FullyLoaded */) {
         return false;
     }
     var start = thisSegment.start, end = thisSegment.end;
@@ -633,7 +652,8 @@ function bufferedStartLooksCoherent(thisSegment) {
  */
 function bufferedEndLooksCoherent(thisSegment) {
     if (thisSegment.bufferedEnd === undefined ||
-        thisSegment.status !== 1 /* ChunkStatus.Complete */) {
+        !thisSegment.infos.segment.complete ||
+        thisSegment.status !== 1 /* ChunkStatus.FullyLoaded */) {
         return false;
     }
     var start = thisSegment.start, end = thisSegment.end;
@@ -654,7 +674,7 @@ function bufferedEndLooksCoherent(thisSegment) {
  * @param {Object} lastDeletedSegmentInfos
  */
 function guessBufferedStartFromRangeStart(firstSegmentInRange, rangeStart, lastDeletedSegmentInfos, bufferType) {
-    var MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE = config.getCurrent().MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE;
+    var _a = config.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.debug("SI: Segment partially GCed at the start", bufferType, firstSegmentInRange.bufferedStart, rangeStart);
@@ -684,6 +704,12 @@ function guessBufferedStartFromRangeStart(firstSegmentInRange, rangeStart, lastD
     }
     else if (firstSegmentInRange.start - rangeStart <=
         MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE) {
+        var now = performance.now();
+        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)) {
@@ -696,7 +722,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);
+        var now = performance.now();
+        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;
     }
 }
@@ -708,7 +740,7 @@ function guessBufferedStartFromRangeStart(firstSegmentInRange, rangeStart, lastD
  * @param {string} bufferType
  */
 function guessBufferedEndFromRangeEnd(lastSegmentInRange, rangeEnd, bufferType) {
-    var MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE = config.getCurrent().MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE;
+    var _a = config.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.debug("SI: Segment partially GCed at the end", bufferType, lastSegmentInRange.bufferedEnd, rangeEnd);
@@ -725,8 +757,14 @@ function guessBufferedEndFromRangeEnd(lastSegmentInRange, rangeEnd, bufferType)
         log.debug("SI: buffered end is precize end", bufferType, lastSegmentInRange.end);
         lastSegmentInRange.bufferedEnd = lastSegmentInRange.end;
     }
-    else if (rangeEnd - lastSegmentInRange.end <=
-        MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE) {
+    else if (rangeEnd - lastSegmentInRange.end <= MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE ||
+        !lastSegmentInRange.infos.segment.complete) {
+        var now = performance.now();
+        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)) {
@@ -739,6 +777,12 @@ function guessBufferedEndFromRangeEnd(lastSegmentInRange, rangeEnd, bufferType)
         lastSegmentInRange.bufferedEnd = lastSegmentInRange.end;
     }
     else {
+        var now = performance.now();
+        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/_esm5.processed/core/stream/adaptation/adaptation_stream.js

@@ -200,6 +200,9 @@ export default function AdaptationStream(_a, callbacks, parentCancelSignal) {
             inbandEvent: callbacks.inbandEvent,
             warning: callbacks.warning,
             error: function (err) {
+                if (TaskCanceller.isCancellationError(err) && adapStreamCanceller.isUsed()) {
+                    return;
+                }
                 adapStreamCanceller.cancel();
                 callbacks.error(err);
             },

package/dist/_esm5.processed/core/stream/representation/utils/append_segment_to_buffer.js

@@ -53,6 +53,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
  * This file allows any Stream to push data to a SegmentBuffer.
  */
 import { MediaError } from "../../../../errors";
+import sleep from "../../../../utils/sleep";
 import { CancellationError } from "../../../../utils/task_canceller";
 import forceGarbageCollection from "./force_garbage_collection";
 /**
@@ -66,17 +67,17 @@ import forceGarbageCollection from "./force_garbage_collection";
  * @returns {Promise}
  */
 export default function appendSegmentToBuffer(playbackObserver, segmentBuffer, dataInfos, cancellationSignal) {
-    var _a;
     return __awaiter(this, void 0, void 0, function () {
         var appendError_1, reason, position, currentPos, err2_1, reason;
+        var _a;
         return __generator(this, function (_b) {
             switch (_b.label) {
                 case 0:
-                    _b.trys.push([0, 2, , 8]);
+                    _b.trys.push([0, 2, , 9]);
                     return [4 /*yield*/, segmentBuffer.pushChunk(dataInfos, cancellationSignal)];
                 case 1:
                     _b.sent();
-                    return [3 /*break*/, 8];
+                    return [3 /*break*/, 9];
                 case 2:
                     appendError_1 = _b.sent();
                     if (cancellationSignal.isCancelled() && appendError_1 instanceof CancellationError) {
@@ -93,21 +94,27 @@ export default function appendSegmentToBuffer(playbackObserver, segmentBuffer, d
                     currentPos = (_a = position.pending) !== null && _a !== void 0 ? _a : position.last;
                     _b.label = 3;
                 case 3:
-                    _b.trys.push([3, 6, , 7]);
+                    _b.trys.push([3, 7, , 8]);
                     return [4 /*yield*/, forceGarbageCollection(currentPos, segmentBuffer, cancellationSignal)];
                 case 4:
                     _b.sent();
-                    return [4 /*yield*/, segmentBuffer.pushChunk(dataInfos, cancellationSignal)];
+                    return [4 /*yield*/, sleep(200)];
                 case 5:
                     _b.sent();
-                    return [3 /*break*/, 7];
+                    if (cancellationSignal.cancellationError !== null) {
+                        throw cancellationSignal.cancellationError;
+                    }
+                    return [4 /*yield*/, segmentBuffer.pushChunk(dataInfos, cancellationSignal)];
                 case 6:
+                    _b.sent();
+                    return [3 /*break*/, 8];
+                case 7:
                     err2_1 = _b.sent();
                     reason = err2_1 instanceof Error ? err2_1.toString() :
                         "Could not clean the buffer";
                     throw new MediaError("BUFFER_FULL_ERROR", reason, { adaptation: dataInfos.inventoryInfos.adaptation });
-                case 7: return [3 /*break*/, 8];
-                case 8: return [2 /*return*/];
+                case 8: return [3 /*break*/, 9];
+                case 9: return [2 /*return*/];
             }
         });
     });