rx-player 3.33.4 → 3.33.5-dev.2025040100

package/CHANGELOG.md

@@ -1,6 +1,34 @@
 # Changelog
 
-## v3.33.4 (2024-10-16)
+## Current dev build: v3.33.5-dev.2025040100
+
+### Bug fixes
+
+- DRM: fix typo which prevented `MediaKeys` reusage on some devices including desktop
+  browsers [#1679]
+- DRM: Only ask for `"persistent-license"` `MediaKeySession` (and not also for
+  `"temporary"` license) when the `keySystems[].persistentLicense` option is set to `true`
+- DRM: Fix reusage of some `keySystems[]` option changing when reusing a
+  `MediaKeySystemAccess` with a different `keySystems[]` configuration [#1678]
+- DRM: Fix `KEY_UPDATE_ERROR` which was mistakenly inheriting the code `KEY_LOAD_ERROR`
+  [#1682]
+- Fix minor memory leak when switching RepresentationStream through ABR [#1681]
+- fix rare infinite rebuffering issues that may happen when updating tracks in a
+  `newAvailablePeriods` event [#1680]
+
+### Other improvements
+
+- Compat: Limit long "FREEZING" issues on Tizen (samsung) by awaiting for browser action
+  before seeking ourselves over a discontinuity [#1673]
+- DRM: Only reuse cached `MediaKeySystemAccess` if none is more wanted for the current
+  content [#1674]
+- DRM: Reuse cache even if key system type given in API is not the same
+- DEBUG_ELEMENT: Add buffer size estimate to debug buffer content graph [#1672]
+- DEBUG_ELEMENT: Add `hdr` information to video Representation [#1671]
+- Avoid error log when stopping a stream with a pending `BufferGarbageCollector` buffer
+  removal [#1685]
+
+## v3.33.4
 
 ### Bug fixes
 

package/VERSION

@@ -1 +1 @@
-3.33.4
+3.33.5-dev.2025040100

package/dist/_esm5.processed/compat/browser_detection.js

@@ -126,7 +126,7 @@ var isA1KStb40xx = false;
     else if (navigator.userAgent.indexOf("Xbox") !== -1) {
         isXbox = true;
     }
-    else if (navigator.userAgent.indexOf("Model/a1-kstb40xx")) {
+    else if (navigator.userAgent.indexOf("Model/a1-kstb40xx") !== -1) {
         isA1KStb40xx = true;
     }
 })();

package/dist/_esm5.processed/compat/eme/eme-api-implementation.js

@@ -136,7 +136,7 @@ function getEmeApiImplementation(preferredApiType) {
                         initDataTypes: ["cenc"],
                         distinctiveIdentifier: "not-allowed",
                         persistentState: "required",
-                        sessionTypes: ["temporary", "persistent-license"],
+                        sessionTypes: ["persistent-license"],
                     };
                     if (videoCapabilities !== undefined) {
                         keySystemConfigurationResponse.videoCapabilities = videoCapabilities;

package/dist/_esm5.processed/core/api/debug/modules/segment_buffer_content.js

@@ -6,6 +6,7 @@ export default function createSegmentBufferGraph(instance, bufferType, title, pa
     var bufferGraphWrapper = createElement("div");
     var bufferTitle = createMetricTitle(title);
     var canvasElt = createGraphCanvas();
+    var bufferSizeElt = document.createElement("span");
     var currentRangeRepInfoElt = createElement("div");
     var loadingRangeRepInfoElt = createElement("div");
     var bufferGraph = new SegmentBufferGraph(canvasElt);
@@ -15,8 +16,11 @@ export default function createSegmentBufferGraph(instance, bufferType, title, pa
     });
     bufferGraphWrapper.appendChild(bufferTitle);
     bufferGraphWrapper.appendChild(canvasElt);
+    bufferGraphWrapper.appendChild(bufferSizeElt);
     bufferGraphWrapper.appendChild(currentRangeRepInfoElt);
     bufferGraphWrapper.appendChild(loadingRangeRepInfoElt);
+    bufferSizeElt.style.marginLeft = "5px";
+    bufferSizeElt.style.fontSize = "0.9em";
     bufferGraphWrapper.style.padding = "5px 0px";
     update();
     return bufferGraphWrapper;
@@ -33,11 +37,42 @@ export default function createSegmentBufferGraph(instance, bufferType, title, pa
         var inventory = instance.__priv_getSegmentBufferContent(bufferType);
         if (inventory === null) {
             bufferGraphWrapper.style.display = "none";
+            bufferSizeElt.innerHTML = "";
             currentRangeRepInfoElt.innerHTML = "";
             loadingRangeRepInfoElt.innerHTML = "";
         }
         else {
+            var sizeEstimate = void 0;
+            for (var _i = 0, inventory_1 = inventory; _i < inventory_1.length; _i++) {
+                var segment = inventory_1[_i];
+                if (segment.chunkSize === undefined) {
+                    sizeEstimate = undefined;
+                    break;
+                }
+                else if (sizeEstimate === undefined) {
+                    sizeEstimate = segment.chunkSize;
+                }
+                else {
+                    sizeEstimate += segment.chunkSize;
+                }
+            }
             bufferGraphWrapper.style.display = "block";
+            if (sizeEstimate !== undefined) {
+                var sizeStr = void 0;
+                if (sizeEstimate > 2e6) {
+                    sizeStr = (sizeEstimate / 1e6).toFixed(2) + "MB";
+                }
+                else if (sizeEstimate > 2e3) {
+                    sizeStr = (sizeEstimate / 1e3).toFixed(2) + "kB";
+                }
+                else {
+                    sizeStr = sizeEstimate + "B";
+                }
+                bufferSizeElt.innerHTML = sizeStr;
+            }
+            else {
+                bufferSizeElt.innerHTML = "";
+            }
             var currentTime = instance.getPosition();
             var width = Math.min(parentElt.clientWidth - 150, 600);
             bufferGraph.update({
@@ -92,7 +127,7 @@ function constructRepresentationInfo(content) {
     var _a;
     var period = content.period;
     var _b = content.adaptation, language = _b.language, isAudioDescription = _b.isAudioDescription, isClosedCaption = _b.isClosedCaption, isTrickModeTrack = _b.isTrickModeTrack, isSignInterpreted = _b.isSignInterpreted, bufferType = _b.type;
-    var _c = content.representation, id = _c.id, height = _c.height, width = _c.width, bitrate = _c.bitrate, codec = _c.codec;
+    var _c = content.representation, id = _c.id, height = _c.height, width = _c.width, bitrate = _c.bitrate, codec = _c.codec, hdrInfo = _c.hdrInfo;
     var representationInfo = "\"".concat(id, "\" ");
     if (height !== undefined && width !== undefined) {
         representationInfo += "".concat(width, "x").concat(height, " ");
@@ -106,6 +141,9 @@ function constructRepresentationInfo(content) {
     if (language !== undefined) {
         representationInfo += "l:\"".concat(language, "\" ");
     }
+    if (bufferType === "video" && hdrInfo !== undefined) {
+        representationInfo += "hdr:1 ";
+    }
     if (bufferType === "video" && typeof isSignInterpreted === "boolean") {
         representationInfo += "si:".concat(isSignInterpreted ? 1 : 0, " ");
     }

package/dist/_esm5.processed/core/api/public_api.js

@@ -88,7 +88,7 @@ var Player = /** @class */ (function (_super) {
         // Workaround to support Firefox autoplay on FF 42.
         // See: https://bugzilla.mozilla.org/show_bug.cgi?id=1194624
         videoElement.preload = "auto";
-        _this.version = /* PLAYER_VERSION */ "3.33.4";
+        _this.version = /* PLAYER_VERSION */ "3.33.5-dev.2025040100";
         _this.log = log;
         _this.state = "STOPPED";
         _this.videoElement = videoElement;
@@ -2520,5 +2520,5 @@ var Player = /** @class */ (function (_super) {
     Player._priv_currentlyUsedVideoElements = new WeakSet();
     return Player;
 }(EventEmitter));
-Player.version = /* PLAYER_VERSION */ "3.33.4";
+Player.version = /* PLAYER_VERSION */ "3.33.5-dev.2025040100";
 export default Player;

package/dist/_esm5.processed/core/api/tracks_management/track_choice_manager.js

@@ -121,12 +121,14 @@ var TrackChoiceManager = /** @class */ (function () {
      */
     TrackChoiceManager.prototype.addPeriod = function (bufferType, period, adaptationRef) {
         var _a;
+        var _b;
+        log.debug("TCM: Adding Track Reference", bufferType, period.id);
         var periodItem = getPeriodItem(this._periods, period);
         var adaptations = period.getSupportedAdaptations(bufferType);
         if (periodItem !== undefined) {
             if (periodItem[bufferType] !== undefined) {
                 log.warn("TrackChoiceManager: ".concat(bufferType, " already added for period"), period.start);
-                return;
+                (_b = periodItem[bufferType]) === null || _b === void 0 ? void 0 : _b.adaptationRef.finish();
             }
             else {
                 periodItem[bufferType] = { adaptations: adaptations, adaptationRef: adaptationRef };
@@ -143,6 +145,7 @@ var TrackChoiceManager = /** @class */ (function () {
      * @param {Period} period - The concerned Period.
      */
     TrackChoiceManager.prototype.removePeriod = function (bufferType, period) {
+        log.debug("TCM: Removing Track Reference", bufferType, period.id);
         var periodIndex = findPeriodIndex(this._periods, period);
         if (periodIndex === undefined) {
             log.warn("TrackChoiceManager: ".concat(bufferType, " not found for period"), period.start);
@@ -161,6 +164,7 @@ var TrackChoiceManager = /** @class */ (function () {
         }
     };
     TrackChoiceManager.prototype.resetPeriods = function () {
+        log.debug("TCM: Resetting Period Objects");
         while (this._periods.length() > 0) {
             this._periods.pop();
         }

package/dist/_esm5.processed/core/decrypt/find_key_system.js

@@ -72,40 +72,71 @@ import flatMap from "../../utils/flat_map";
 import isNullOrUndefined from "../../utils/is_null_or_undefined";
 import MediaKeysInfosStore from "./utils/media_keys_infos_store";
 /**
- * @param {Array.<Object>} keySystems
- * @param {Object} askedConfiguration
- * @param {MediaKeySystemAccess} currentKeySystemAccess
- * @param {Object} currentKeySystemOptions
- * @returns {null|Object}
+ * Takes a `newConfiguration` `MediaKeySystemConfiguration`, that is intended
+ * for the creation of a `MediaKeySystemAccess`, and a `prevConfiguration`
+ * `MediaKeySystemConfiguration`, that was the one used at creation of the
+ * current `MediaKeySystemAccess`.
+ *
+ * This function will then return `true` if it determined that the new
+ * configuration is conceptually compatible with the one used before, and
+ * `false` otherwise.
+ * @param {Object} newConfiguration - New wanted `MediaKeySystemConfiguration`
+ * @param {Object} prevConfiguration - The `MediaKeySystemConfiguration` that is
+ * relied on util now.
+ * @returns {boolean} - `true` if `newConfiguration` is compatible with
+ * `prevConfiguration`.
  */
-function checkCachedMediaKeySystemAccess(keySystems, askedConfiguration, currentKeySystemAccess, currentKeySystemOptions) {
-    var mksConfiguration = currentKeySystemAccess.getConfiguration();
-    if (shouldRenewMediaKeySystemAccess() || mksConfiguration == null) {
-        return null;
+function isNewMediaKeySystemConfigurationCompatibleWithPreviousOne(newConfiguration, prevConfiguration) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+    if (newConfiguration.label !== prevConfiguration.label) {
+        return false;
     }
-    var firstCompatibleOption = keySystems.filter(function (ks) {
-        // TODO Do it with MediaKeySystemAccess.prototype.keySystem instead
-        if (ks.type !== currentKeySystemOptions.type) {
-            return false;
-        }
-        if ((ks.persistentLicense === true || ks.persistentStateRequired === true) &&
-            mksConfiguration.persistentState !== "required") {
-            return false;
-        }
-        if (ks.distinctiveIdentifierRequired === true &&
-            mksConfiguration.distinctiveIdentifier !== "required") {
+    var prevDistinctiveIdentifier = (_a = prevConfiguration.distinctiveIdentifier) !== null && _a !== void 0 ? _a : "optional";
+    var newDistinctiveIdentifier = (_b = newConfiguration.distinctiveIdentifier) !== null && _b !== void 0 ? _b : "optional";
+    if (prevDistinctiveIdentifier !== newDistinctiveIdentifier) {
+        return false;
+    }
+    var prevPersistentState = (_c = prevConfiguration.persistentState) !== null && _c !== void 0 ? _c : "optional";
+    var newPersistentState = (_d = newConfiguration.persistentState) !== null && _d !== void 0 ? _d : "optional";
+    if (prevPersistentState !== newPersistentState) {
+        return false;
+    }
+    var prevInitDataTypes = (_e = prevConfiguration.initDataTypes) !== null && _e !== void 0 ? _e : [];
+    var newInitDataTypes = (_f = newConfiguration.initDataTypes) !== null && _f !== void 0 ? _f : [];
+    if (!isArraySubsetOf(newInitDataTypes, prevInitDataTypes)) {
+        return false;
+    }
+    var prevSessionTypes = (_g = prevConfiguration.sessionTypes) !== null && _g !== void 0 ? _g : [];
+    var newSessionTypes = (_h = newConfiguration.sessionTypes) !== null && _h !== void 0 ? _h : [];
+    if (!isArraySubsetOf(newSessionTypes, prevSessionTypes)) {
+        return false;
+    }
+    var _loop_1 = function (prop) {
+        var newCapabilities = (_j = newConfiguration[prop]) !== null && _j !== void 0 ? _j : [];
+        var prevCapabilities = (_k = prevConfiguration[prop]) !== null && _k !== void 0 ? _k : [];
+        var wasFound = newCapabilities.every(function (n) {
+            var _a, _b, _c, _d, _e, _f;
+            for (var i = 0; i < prevCapabilities.length; i++) {
+                var prevCap = prevCapabilities[i];
+                if (((_a = prevCap.robustness) !== null && _a !== void 0 ? _a : "") === ((_b = n.robustness) !== null && _b !== void 0 ? _b : "") ||
+                    ((_c = prevCap.encryptionScheme) !== null && _c !== void 0 ? _c : null) === ((_d = n.encryptionScheme) !== null && _d !== void 0 ? _d : null) ||
+                    ((_e = prevCap.robustness) !== null && _e !== void 0 ? _e : "") === ((_f = n.robustness) !== null && _f !== void 0 ? _f : "")) {
+                    return true;
+                }
+            }
             return false;
+        });
+        if (!wasFound) {
+            return { value: false };
         }
-        return true;
-    })[0];
-    if (firstCompatibleOption != null) {
-        return {
-            keySystemOptions: firstCompatibleOption,
-            keySystemAccess: currentKeySystemAccess,
-            askedConfiguration: askedConfiguration,
-        };
+    };
+    for (var _i = 0, _l = ["audioCapabilities", "videoCapabilities"]; _i < _l.length; _i++) {
+        var prop = _l[_i];
+        var state_1 = _loop_1(prop);
+        if (typeof state_1 === "object")
+            return state_1.value;
     }
-    return null;
+    return true;
 }
 /**
  * Find key system canonical name from key system type.
@@ -140,7 +171,7 @@ function buildKeySystemConfigurations(ksName, ksType, keySystem) {
     var distinctiveIdentifier = "optional";
     if (keySystem.persistentLicense === true) {
         persistentState = "required";
-        sessionTypes.push("persistent-license");
+        sessionTypes = ["persistent-license"];
     }
     if (keySystem.persistentStateRequired === true) {
         persistentState = "required";
@@ -246,33 +277,7 @@ function buildKeySystemConfigurations(ksName, ksType, keySystem) {
  */
 export default function getMediaKeySystemAccess(mediaElement, keySystemsConfigs, cancelSignal) {
     log.info("DRM: Searching for compatible MediaKeySystemAccess");
-    var currentState = MediaKeysInfosStore.getState(mediaElement);
-    if (currentState !== null) {
-        if (eme.implementation === currentState.emeImplementation.implementation) {
-            // Fast way to find a compatible keySystem if the currently loaded
-            // one as exactly the same compatibility options.
-            var cachedKeySystemAccess = checkCachedMediaKeySystemAccess(keySystemsConfigs, currentState.askedConfiguration, currentState.mediaKeySystemAccess, currentState.keySystemOptions);
-            if (cachedKeySystemAccess !== null) {
-                log.info("DRM: Found cached compatible keySystem");
-                return Promise.resolve({
-                    type: "reuse-media-key-system-access",
-                    value: {
-                        mediaKeySystemAccess: cachedKeySystemAccess.keySystemAccess,
-                        askedConfiguration: cachedKeySystemAccess.askedConfiguration,
-                        options: cachedKeySystemAccess.keySystemOptions,
-                    },
-                });
-            }
-        }
-    }
-    /**
-     * Array of set keySystems for this content.
-     * Each item of this array is an object containing the following keys:
-     *   - keyName {string}: keySystem canonical name (e.g. "widevine")
-     *   - keyType {string}: keySystem type (e.g. "com.widevine.alpha")
-     *   - keySystem {Object}: the original keySystem object
-     * @type {Array.<Object>}
-     */
+    /** Array of set keySystems for this content. */
     var keySystemsType = keySystemsConfigs.reduce(function (arr, keySystemOptions) {
         var EME_KEY_SYSTEMS = config.getCurrent().EME_KEY_SYSTEMS;
         var managedRDNs = EME_KEY_SYSTEMS[keySystemOptions.type];
@@ -303,9 +308,9 @@ export default function getMediaKeySystemAccess(mediaElement, keySystemsConfigs,
      */
     function recursivelyTestKeySystems(index) {
         return __awaiter(this, void 0, void 0, function () {
-            var _a, keyName, keyType, keySystemOptions, keySystemConfigurations, keySystemAccess, configIdx, keySystemConfiguration, _1;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
+            var chosenType, keyName, keyType, keySystemOptions, keySystemConfigurations, keySystemAccess, currentState, configIdx, keySystemConfiguration, _1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
                     case 0:
                         // if we iterated over the whole keySystemsType Array, quit on error
                         if (index >= keySystemsType.length) {
@@ -316,21 +321,40 @@ export default function getMediaKeySystemAccess(mediaElement, keySystemsConfigs,
                         if (eme.requestMediaKeySystemAccess == null) {
                             throw new Error("requestMediaKeySystemAccess is not implemented in your browser.");
                         }
-                        _a = keySystemsType[index], keyName = _a.keyName, keyType = _a.keyType, keySystemOptions = _a.keySystemOptions;
+                        chosenType = keySystemsType[index];
+                        keyName = chosenType.keyName, keyType = chosenType.keyType, keySystemOptions = chosenType.keySystemOptions;
                         keySystemConfigurations = buildKeySystemConfigurations(keyName, keyType, keySystemOptions);
                         log.debug("DRM: Request keysystem access ".concat(keyType, ",") +
                             "".concat(index + 1, " of ").concat(keySystemsType.length));
+                        currentState = MediaKeysInfosStore.getState(mediaElement);
                         configIdx = 0;
-                        _b.label = 1;
+                        _a.label = 1;
                     case 1:
                         if (!(configIdx < keySystemConfigurations.length)) return [3 /*break*/, 6];
                         keySystemConfiguration = keySystemConfigurations[configIdx];
-                        _b.label = 2;
+                        // Check if the current `MediaKeySystemAccess` created cannot be reused here
+                        if (currentState !== null &&
+                            !shouldRenewMediaKeySystemAccess() &&
+                            // TODO: Do it with MediaKeySystemAccess.prototype.keySystem instead?
+                            keyType === currentState.mediaKeySystemAccess.keySystem &&
+                            eme.implementation === currentState.emeImplementation.implementation &&
+                            isNewMediaKeySystemConfigurationCompatibleWithPreviousOne(keySystemConfiguration, currentState.askedConfiguration)) {
+                            log.info("DRM: Found cached compatible keySystem");
+                            return [2 /*return*/, Promise.resolve({
+                                    type: "reuse-media-key-system-access",
+                                    value: {
+                                        mediaKeySystemAccess: currentState.mediaKeySystemAccess,
+                                        askedConfiguration: currentState.askedConfiguration,
+                                        options: keySystemOptions,
+                                    },
+                                })];
+                        }
+                        _a.label = 2;
                     case 2:
-                        _b.trys.push([2, 4, , 5]);
+                        _a.trys.push([2, 4, , 5]);
                         return [4 /*yield*/, testKeySystem(keyType, [keySystemConfiguration])];
                     case 3:
-                        keySystemAccess = _b.sent();
+                        keySystemAccess = _a.sent();
                         log.info("DRM: Found compatible keysystem", keyType, index + 1);
                         return [2 /*return*/, {
                                 type: "create-media-key-system-access",
@@ -341,7 +365,7 @@ export default function getMediaKeySystemAccess(mediaElement, keySystemsConfigs,
                                 },
                             }];
                     case 4:
-                        _1 = _b.sent();
+                        _1 = _a.sent();
                         log.debug("DRM: Rejected access to keysystem", keyType, index + 1, configIdx);
                         if (cancelSignal.cancellationError !== null) {
                             throw cancelSignal.cancellationError;
@@ -395,3 +419,17 @@ export function testKeySystem(keyType, keySystemConfigurations) {
         });
     });
 }
+/**
+ * Returns `true` if `arr1`'s values are entirely contained in `arr2`.
+ * @param {string} arr1
+ * @param {string} arr2
+ * @return {boolean}
+ */
+function isArraySubsetOf(arr1, arr2) {
+    for (var i = 0; i < arr1.length; i++) {
+        if (!arrayIncludes(arr2, arr1[i])) {
+            return false;
+        }
+    }
+    return true;
+}

package/dist/_esm5.processed/core/decrypt/session_events_listener.js

@@ -83,6 +83,7 @@ var onKeyError = events.onKeyError, onKeyMessage = events.onKeyMessage, onKeySta
  * @param {Object} cancelSignal
  */
 export default function SessionEventsListener(session, keySystemOptions, keySystem, callbacks, cancelSignal) {
+    var _this = this;
     log.info("DRM: Binding session events", session.sessionId);
     var _a = keySystemOptions.getLicenseConfig, getLicenseConfig = _a === void 0 ? {} : _a;
     /** Allows to manually cancel everything the `SessionEventsListener` is doing. */
@@ -122,25 +123,32 @@ export default function SessionEventsListener(session, keySystemOptions, keySyst
             : "license-request";
         log.info("DRM: Received message event, type ".concat(messageType), session.sessionId);
         var backoffOptions = getLicenseBackoffOptions(getLicenseConfig.retry);
-        retryPromiseWithBackoff(function () { return runGetLicense(message, messageType); }, backoffOptions, manualCanceller.signal)
-            .then(function (licenseObject) {
-            if (manualCanceller.isUsed()) {
-                return Promise.resolve();
-            }
-            if (isNullOrUndefined(licenseObject)) {
-                log.info("DRM: No license given, skipping session.update");
-            }
-            else {
-                try {
-                    return updateSessionWithMessage(session, licenseObject);
-                }
-                catch (err) {
-                    manualCanceller.cancel();
-                    callbacks.onError(err);
+        retryPromiseWithBackoff(function () { return runGetLicense(message, messageType); }, backoffOptions, manualCanceller.signal).then(function (licenseObject) { return __awaiter(_this, void 0, void 0, function () {
+            var err_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (manualCanceller.isUsed()) {
+                            return [2 /*return*/];
+                        }
+                        if (!isNullOrUndefined(licenseObject)) return [3 /*break*/, 1];
+                        log.info("DRM: No license given, skipping session.update");
+                        return [3 /*break*/, 4];
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, updateSessionWithMessage(session, licenseObject)];
+                    case 2:
+                        _a.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        err_1 = _a.sent();
+                        manualCanceller.cancel();
+                        callbacks.onError(err_1);
+                        return [3 /*break*/, 4];
+                    case 4: return [2 /*return*/];
                 }
-            }
-        })
-            .catch(function (err) {
+            });
+        }); }, function (err) {
             if (manualCanceller.isUsed()) {
                 return;
             }

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

@@ -180,7 +180,8 @@ var RebufferingController = /** @class */ (function (_super) {
             }
             ignoredStallTimeStamp = null;
             playbackRateUpdater.startRebuffering();
-            if (_this._manifest === null) {
+            if (_this._manifest === null ||
+                (isSeekingApproximate && performance.now() - rebuffering.timestamp <= 1000)) {
                 _this.trigger("stalled", stalledReason);
                 return;
             }
@@ -212,7 +213,8 @@ var RebufferingController = /** @class */ (function (_super) {
             // implementation that might drop an injected segment, or in
             // case of small discontinuity in the content.
             var nextBufferRangeGap = getNextRangeGap(buffered, freezePosition);
-            if (_this._speed.getValue() > 0 &&
+            if ((!isSeekingApproximate || performance.now() - rebuffering.timestamp > 1000) &&
+                _this._speed.getValue() > 0 &&
                 nextBufferRangeGap < BUFFER_DISCONTINUITY_THRESHOLD) {
                 var seekTo = freezePosition + nextBufferRangeGap + EPSILON;
                 if (_this._playbackObserver.getCurrentTime() < seekTo) {

package/dist/_esm5.processed/core/segment_buffers/garbage_collector.js

@@ -51,6 +51,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 };
 import log from "../../log";
 import { getInnerAndOuterTimeRanges } from "../../utils/ranges";
+import TaskCanceller from "../../utils/task_canceller";
 /**
  * Perform cleaning of the buffer according to the values set by the user
  * each time `playbackObserver` emits and each times the
@@ -71,6 +72,9 @@ export default function BufferGarbageCollector(_a, cancellationSignal) {
     }, { includeLastObservation: true, clearSignal: cancellationSignal });
     function clean() {
         clearBuffer(segmentBuffer, lastPosition, maxBufferBehind.getValue(), maxBufferAhead.getValue(), cancellationSignal).catch(function (e) {
+            if (cancellationSignal.isCancelled() && TaskCanceller.isCancellationError(e)) {
+                return;
+            }
             var errMsg = e instanceof Error ? e.message : "Unknown error";
             log.error("Could not run BufferGarbageCollector:", errMsg);
         });