rx-player 3.28.0-dev.2022061700 → 3.28.0-dev.2022062700

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

@@ -13,21 +13,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-import { defer as observableDefer, fromEvent as observableFromEvent, interval as observableInterval, map, merge as observableMerge, share, shareReplay, skip, startWith, } from "rxjs";
 import config from "../../config";
 import log from "../../log";
 import noop from "../../utils/noop";
 import objectAssign from "../../utils/object_assign";
 import { getRange } from "../../utils/ranges";
+import createSharedReference from "../../utils/reference";
+import TaskCanceller from "../../utils/task_canceller";
 /**
  * HTMLMediaElement Events for which playback observations are calculated and
  * emitted.
@@ -56,6 +48,12 @@ var SCANNED_MEDIA_ELEMENTS_EVENTS = ["canplay",
  */
 var PlaybackObserver = /** @class */ (function () {
     /**
+     * Create a new `PlaybackObserver`, which allows to produce new "playback
+     * observations" on various media events and intervals.
+     *
+     * Note that creating a `PlaybackObserver` lead to the usage of resources,
+     * such as event listeners which will only be freed once the `stop` method is
+     * called.
      * @param {HTMLMediaElement} mediaElement
      * @param {Object} options
      */
@@ -64,9 +62,22 @@ var PlaybackObserver = /** @class */ (function () {
         this._mediaElement = mediaElement;
         this._withMediaSource = options.withMediaSource;
         this._lowLatencyMode = options.lowLatencyMode;
-        this._lastObservation = null;
-        this._observation$ = null;
+        this._canceller = new TaskCanceller();
+        this._observationRef = this._createSharedReference();
     }
+    /**
+     * Stop the `PlaybackObserver` from emitting playback observations and free all
+     * resources reserved to emitting them such as event listeners, intervals and
+     * subscribing callbacks.
+     *
+     * Once `stop` is called, no new playback observation will ever be emitted.
+     *
+     * Note that it is important to call stop once the `PlaybackObserver` is no
+     * more needed to avoid unnecessarily leaking resources.
+     */
+    PlaybackObserver.prototype.stop = function () {
+        this._canceller.cancel();
+    };
     /**
      * Returns the current position advertised by the `HTMLMediaElement`, in
      * seconds.
@@ -107,31 +118,17 @@ var PlaybackObserver = /** @class */ (function () {
         return this._mediaElement.readyState;
     };
     /**
-     * Returns an Observable regularly emitting playback observation, optionally
-     * starting with the last one.
+     * Returns an `IReadOnlySharedReference` storing the last playback observation
+     * produced by the `PlaybackObserver` and updated each time a new one is
+     * produced.
      *
-     * Note that this Observable is shared and unique, so that multiple `observe`
-     * call will return the exact same Observable and multiple concurrent
-     * `subscribe` will receive the same events at the same time.
-     * This was done for performance and simplicity reasons.
+     * This value can then be for example subscribed to to be notified of future
+     * playback observations.
      *
-     * @param {boolean} includeLastObservation
-     * @returns {Observable}
+     * @returns {Object}
      */
-    PlaybackObserver.prototype.observe = function (includeLastObservation) {
-        var _this = this;
-        return observableDefer(function () {
-            if (_this._observation$ === null || _this._lastObservation === null) {
-                _this._lastObservation = _this._generateInitialObservation();
-                _this._observation$ = _this._createInnerObservable().pipe(share());
-                return _this.observe(includeLastObservation);
-            }
-            else {
-                return includeLastObservation ?
-                    _this._observation$.pipe(startWith(_this._lastObservation)) :
-                    _this._observation$;
-            }
-        });
+    PlaybackObserver.prototype.getReference = function () {
+        return this._observationRef;
     };
     /**
      * Register a callback so it regularly receives playback observations.
@@ -141,22 +138,16 @@ var PlaybackObserver = /** @class */ (function () {
      *     be first emitted synchronously.
      *   - `clearSignal`: If set, the callback will be unregistered when this
      *     CancellationSignal emits.
-     * @returns {Function} - Allows to easily unregister the callback
      */
     PlaybackObserver.prototype.listen = function (cb, options) {
-        var _a, _b, _c, _d;
-        if (((_a = options === null || options === void 0 ? void 0 : options.clearSignal) === null || _a === void 0 ? void 0 : _a.isCancelled) === true) {
+        var _a;
+        if (this._canceller.isUsed || ((_a = options === null || options === void 0 ? void 0 : options.clearSignal) === null || _a === void 0 ? void 0 : _a.isCancelled) === true) {
             return noop;
         }
-        var sub = this.observe((_b = options === null || options === void 0 ? void 0 : options.includeLastObservation) !== null && _b !== void 0 ? _b : false)
-            .subscribe(cb);
-        var unregister = (_d = (_c = options === null || options === void 0 ? void 0 : options.clearSignal) === null || _c === void 0 ? void 0 : _c.register(function () {
-            sub.unsubscribe();
-        })) !== null && _d !== void 0 ? _d : noop;
-        return function () {
-            unregister();
-            sub.unsubscribe();
-        };
+        this._observationRef.onUpdate(cb, {
+            clearSignal: options === null || options === void 0 ? void 0 : options.clearSignal,
+            emitCurrentValue: options === null || options === void 0 ? void 0 : options.includeLastObservation,
+        });
     };
     /**
      * Generate a new playback observer which can listen to other
@@ -169,63 +160,84 @@ var PlaybackObserver = /** @class */ (function () {
      *
      * As argument, this method takes a function which will allow to produce
      * the new set of properties to be present on each observation.
-     * @param {Function} mapObservable
+     * @param {Function} transform
      * @returns {Object}
      */
-    PlaybackObserver.prototype.deriveReadOnlyObserver = function (mapObservable) {
-        return generateReadOnlyObserver(this, mapObservable);
+    PlaybackObserver.prototype.deriveReadOnlyObserver = function (transform) {
+        return generateReadOnlyObserver(this, transform, this._canceller.signal);
     };
     /**
-     * Creates the observable that will generate playback observations.
+     * Creates the `IReadOnlySharedReference` that will generate playback
+     * observations.
      * @returns {Observable}
      */
-    PlaybackObserver.prototype._createInnerObservable = function () {
+    PlaybackObserver.prototype._createSharedReference = function () {
         var _this = this;
-        return observableDefer(function () {
-            var _a = config.getCurrent(), SAMPLING_INTERVAL_MEDIASOURCE = _a.SAMPLING_INTERVAL_MEDIASOURCE, SAMPLING_INTERVAL_LOW_LATENCY = _a.SAMPLING_INTERVAL_LOW_LATENCY, SAMPLING_INTERVAL_NO_MEDIASOURCE = _a.SAMPLING_INTERVAL_NO_MEDIASOURCE;
-            var getCurrentObservation = function (event) {
-                var _a;
-                var tmpEvt = event;
-                if (tmpEvt === "seeking" && _this._internalSeekingEventsIncomingCounter > 0) {
-                    tmpEvt = "internal-seeking";
-                    _this._internalSeekingEventsIncomingCounter -= 1;
-                }
-                var lastObservation = (_a = _this._lastObservation) !== null && _a !== void 0 ? _a : _this._generateInitialObservation();
-                var mediaTimings = getMediaInfos(_this._mediaElement, tmpEvt);
-                var internalSeeking = mediaTimings.seeking &&
-                    // We've just received the event for internally seeking
-                    (tmpEvt === "internal-seeking" ||
-                        // or We're still waiting on the previous internal-seek
-                        (lastObservation.internalSeeking && tmpEvt !== "seeking"));
-                var rebufferingStatus = getRebufferingStatus(lastObservation, mediaTimings, { lowLatencyMode: _this._lowLatencyMode,
-                    withMediaSource: _this._withMediaSource });
-                var freezingStatus = getFreezingStatus(lastObservation, mediaTimings);
-                var timings = objectAssign({}, { rebuffering: rebufferingStatus,
-                    freezing: freezingStatus, internalSeeking: internalSeeking }, mediaTimings);
-                if (log.hasLevel("DEBUG")) {
-                    log.debug("API: current media element state tick", "event", timings.event, "position", timings.position, "seeking", timings.seeking, "internalSeeking", timings.internalSeeking, "rebuffering", timings.rebuffering !== null, "freezing", timings.freezing !== null, "ended", timings.ended, "paused", timings.paused, "playbackRate", timings.playbackRate, "readyState", timings.readyState);
-                }
-                return timings;
+        if (this._observationRef !== undefined) {
+            return this._observationRef;
+        }
+        var lastObservation;
+        var _a = config.getCurrent(), SAMPLING_INTERVAL_MEDIASOURCE = _a.SAMPLING_INTERVAL_MEDIASOURCE, SAMPLING_INTERVAL_LOW_LATENCY = _a.SAMPLING_INTERVAL_LOW_LATENCY, SAMPLING_INTERVAL_NO_MEDIASOURCE = _a.SAMPLING_INTERVAL_NO_MEDIASOURCE;
+        var getCurrentObservation = function (event) {
+            var tmpEvt = event;
+            if (tmpEvt === "seeking" && _this._internalSeekingEventsIncomingCounter > 0) {
+                tmpEvt = "internal-seeking";
+                _this._internalSeekingEventsIncomingCounter -= 1;
+            }
+            var _lastObservation = lastObservation !== null && lastObservation !== void 0 ? lastObservation : _this._generateInitialObservation();
+            var mediaTimings = getMediaInfos(_this._mediaElement, tmpEvt);
+            var internalSeeking = mediaTimings.seeking &&
+                // We've just received the event for internally seeking
+                (tmpEvt === "internal-seeking" ||
+                    // or We're still waiting on the previous internal-seek
+                    (_lastObservation.internalSeeking && tmpEvt !== "seeking"));
+            var rebufferingStatus = getRebufferingStatus(_lastObservation, mediaTimings, { lowLatencyMode: _this._lowLatencyMode,
+                withMediaSource: _this._withMediaSource });
+            var freezingStatus = getFreezingStatus(_lastObservation, mediaTimings);
+            var timings = objectAssign({}, { rebuffering: rebufferingStatus,
+                freezing: freezingStatus, internalSeeking: internalSeeking }, mediaTimings);
+            if (log.hasLevel("DEBUG")) {
+                log.debug("API: current media element state tick", "event", timings.event, "position", timings.position, "seeking", timings.seeking, "internalSeeking", timings.internalSeeking, "rebuffering", timings.rebuffering !== null, "freezing", timings.freezing !== null, "ended", timings.ended, "paused", timings.paused, "playbackRate", timings.playbackRate, "readyState", timings.readyState);
+            }
+            return timings;
+        };
+        var returnedSharedReference = createSharedReference(getCurrentObservation("init"));
+        var generateObservationForEvent = function (event) {
+            var newObservation = getCurrentObservation(event);
+            if (log.hasLevel("DEBUG")) {
+                log.debug("API: current playback timeline:\n" +
+                    prettyPrintBuffered(newObservation.buffered, newObservation.position), "\n".concat(event));
+            }
+            lastObservation = newObservation;
+            returnedSharedReference.setValue(newObservation);
+        };
+        var interval = this._lowLatencyMode ? SAMPLING_INTERVAL_LOW_LATENCY :
+            this._withMediaSource ? SAMPLING_INTERVAL_MEDIASOURCE :
+                SAMPLING_INTERVAL_NO_MEDIASOURCE;
+        var intervalId = setInterval(onInterval, interval);
+        var removeEventListeners = SCANNED_MEDIA_ELEMENTS_EVENTS.map(function (eventName) {
+            _this._mediaElement.addEventListener(eventName, onMediaEvent);
+            function onMediaEvent() {
+                restartInterval();
+                generateObservationForEvent(eventName);
+            }
+            return function () {
+                _this._mediaElement.removeEventListener(eventName, onMediaEvent);
             };
-            var eventObs = SCANNED_MEDIA_ELEMENTS_EVENTS.map(function (eventName) {
-                return observableFromEvent(_this._mediaElement, eventName)
-                    .pipe(map(function () { return eventName; }));
-            });
-            var interval = _this._lowLatencyMode ? SAMPLING_INTERVAL_LOW_LATENCY :
-                _this._withMediaSource ? SAMPLING_INTERVAL_MEDIASOURCE :
-                    SAMPLING_INTERVAL_NO_MEDIASOURCE;
-            var interval$ = observableInterval(interval)
-                .pipe(map(function () { return "timeupdate"; }));
-            return observableMerge.apply(void 0, __spreadArray([interval$], eventObs, false)).pipe(map(function (event) {
-                var newObservation = getCurrentObservation(event);
-                if (log.hasLevel("DEBUG")) {
-                    log.debug("API: current playback timeline:\n" +
-                        prettyPrintBuffered(newObservation.buffered, newObservation.position), "\n".concat(event));
-                }
-                _this._lastObservation = newObservation;
-                return newObservation;
-            }));
         });
+        this._canceller.signal.register(function () {
+            clearInterval(intervalId);
+            removeEventListeners.forEach(function (cb) { return cb(); });
+            returnedSharedReference.finish();
+        });
+        return returnedSharedReference;
+        function onInterval() {
+            generateObservationForEvent("timeupdate");
+        }
+        function restartInterval() {
+            clearInterval(intervalId);
+            intervalId = setInterval(onInterval, interval);
+        }
     };
     PlaybackObserver.prototype._generateInitialObservation = function () {
         return objectAssign(getMediaInfos(this._mediaElement, "init"), { rebuffering: null,
@@ -480,13 +492,11 @@ function prettyPrintBuffered(buffered, currentTime) {
  * Create `IReadOnlyPlaybackObserver` from a source `IReadOnlyPlaybackObserver`
  * and a mapping function.
  * @param {Object} src
- * @param {Function} mapObservable
+ * @param {Function} transform
  * @returns {Object}
  */
-function generateReadOnlyObserver(src, mapObservable) {
-    var newObs = observableDefer(function () {
-        return mapObservable(src.observe(true));
-    }).pipe(shareReplay({ bufferSize: 1, refCount: true }));
+function generateReadOnlyObserver(src, transform, cancellationSignal) {
+    var mappedRef = transform(src.getReference(), cancellationSignal);
     return {
         getCurrentTime: function () {
             return src.getCurrentTime();
@@ -497,28 +507,21 @@ function generateReadOnlyObserver(src, mapObservable) {
         getIsPaused: function () {
             return src.getIsPaused();
         },
-        observe: function (includeLastObservation) {
-            return includeLastObservation ? newObs :
-                newObs.pipe(skip(1));
+        getReference: function () {
+            return mappedRef;
         },
         listen: function (cb, options) {
-            var _a, _b, _c;
-            if (((_a = options === null || options === void 0 ? void 0 : options.clearSignal) === null || _a === void 0 ? void 0 : _a.isCancelled) === true) {
-                return noop;
+            var _a;
+            if (cancellationSignal.isCancelled || ((_a = options === null || options === void 0 ? void 0 : options.clearSignal) === null || _a === void 0 ? void 0 : _a.isCancelled) === true) {
+                return;
             }
-            var obs = (options === null || options === void 0 ? void 0 : options.includeLastObservation) === true ? newObs :
-                newObs.pipe(skip(1));
-            var sub = obs.subscribe(cb);
-            var unregister = (_c = (_b = options === null || options === void 0 ? void 0 : options.clearSignal) === null || _b === void 0 ? void 0 : _b.register(function () {
-                sub.unsubscribe();
-            })) !== null && _c !== void 0 ? _c : noop;
-            return function () {
-                unregister();
-                sub.unsubscribe();
-            };
+            mappedRef.onUpdate(cb, {
+                clearSignal: options === null || options === void 0 ? void 0 : options.clearSignal,
+                emitCurrentValue: options === null || options === void 0 ? void 0 : options.includeLastObservation,
+            });
         },
-        deriveReadOnlyObserver: function (newUdateObserver) {
-            return generateReadOnlyObserver(this, newUdateObserver);
+        deriveReadOnlyObserver: function (newTransformFn) {
+            return generateReadOnlyObserver(this, newTransformFn, cancellationSignal);
         },
     };
 }

package/dist/_esm5.processed/core/api/public_api.d.ts

@@ -29,7 +29,10 @@ declare class Player extends EventEmitter<IPublicAPIEvent> {
     static version: string;
     /** Current version of the RxPlayer.  */
     readonly version: string;
-    /** Media element attached to the RxPlayer.  */
+    /**
+     * Media element attached to the RxPlayer.
+     * Set to `null` when the RxPlayer is disposed.
+     */
     videoElement: HTMLMediaElement | null;
     /** Logger the RxPlayer uses.  */
     readonly log: Logger;
@@ -693,11 +696,6 @@ declare class Player extends EventEmitter<IPublicAPIEvent> {
      * @param {Error} error
      */
     private _priv_onPlaybackError;
-    /**
-     * Triggered when the playback Observable completes.
-     * Clean-up ressources and signal that the content has ended.
-     */
-    private _priv_onPlaybackFinished;
     /**
      * Triggered when we received a warning event during playback.
      * Trigger the right API event.

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.28.0-dev.2022061700";
+        _this.version = /* PLAYER_VERSION */ "3.28.0-dev.2022062700";
         _this.log = log;
         _this.state = "STOPPED";
         _this.videoElement = videoElement;
@@ -359,6 +359,9 @@ var Player = /** @class */ (function (_super) {
             withMediaSource: !isDirectFile,
             lowLatencyMode: lowLatencyMode,
         });
+        currentContentCanceller.signal.register(function () {
+            playbackObserver.stop();
+        });
         /** Emit playback events. */
         var playback$;
         if (!isDirectFile) {
@@ -534,7 +537,7 @@ var Player = /** @class */ (function (_super) {
             return evt.type === "reloading-media-source";
         }), share());
         /** Emit when the media element emits a "seeking" event. */
-        var observation$ = playbackObserver.observe(true);
+        var observation$ = playbackObserver.getReference().asObservable();
         var stateChangingEvent$ = observation$.pipe(filter(function (o) {
             return o.event === "seeking" || o.event === "ended" ||
                 o.event === "play" || o.event === "pause";
@@ -598,7 +601,14 @@ var Player = /** @class */ (function (_super) {
         playback$.subscribe({
             next: function (x) { return _this._priv_onPlaybackEvent(x); },
             error: function (err) { return _this._priv_onPlaybackError(err); },
-            complete: function () { return _this._priv_onPlaybackFinished(); },
+            complete: function () {
+                if (!contentInfos.currentContentCanceller.isUsed) {
+                    log.info("API: Previous playback finished. Stopping and cleaning-up...");
+                    contentInfos.currentContentCanceller.cancel();
+                    _this._priv_cleanUpCurrentContentState();
+                    _this._priv_setPlayerState(PLAYER_STATES.STOPPED);
+                }
+            },
         });
         // initialize the content only when the lock is inactive
         this._priv_contentLock.asObservable()
@@ -1758,8 +1768,10 @@ var Player = /** @class */ (function (_super) {
         this._priv_contentEventsMemory = {};
         // DRM-related clean-up
         var freeUpContentLock = function () {
-            log.debug("Unlocking `contentLock`. Next content can begin.");
-            _this._priv_contentLock.setValue(false);
+            if (_this.videoElement !== null) { // If not disposed
+                log.debug("Unlocking `contentLock`. Next content can begin.");
+                _this._priv_contentLock.setValue(false);
+            }
         };
         if (!isNullOrUndefined(this.videoElement)) {
             clearOnStop(this.videoElement).then(function () {
@@ -1878,18 +1890,6 @@ var Player = /** @class */ (function (_super) {
             this.trigger("error", formattedError);
         }
     };
-    /**
-     * Triggered when the playback Observable completes.
-     * Clean-up ressources and signal that the content has ended.
-     */
-    Player.prototype._priv_onPlaybackFinished = function () {
-        log.info("API: Previous playback finished. Stopping and cleaning-up...");
-        if (this._priv_contentInfos !== null) {
-            this._priv_contentInfos.currentContentCanceller.cancel();
-        }
-        this._priv_cleanUpCurrentContentState();
-        this._priv_setPlayerState(PLAYER_STATES.ENDED);
-    };
     /**
      * Triggered when we received a warning event during playback.
      * Trigger the right API event.
@@ -2295,5 +2295,5 @@ var Player = /** @class */ (function (_super) {
     };
     return Player;
 }(EventEmitter));
-Player.version = /* PLAYER_VERSION */ "3.28.0-dev.2022061700";
+Player.version = /* PLAYER_VERSION */ "3.28.0-dev.2022062700";
 export default Player;

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

@@ -428,18 +428,7 @@ var ContentDecryptor = /** @class */ (function (_super) {
                                         _this.trigger("warning", evt.value);
                                         return;
                                 }
-                                var linkedKeys;
-                                if (sessionInfo.source === "created-session" /* MediaKeySessionLoadingType.Created */) {
-                                    // When the license has been fetched, there might be implicit key ids
-                                    // linked to the session depending on the `singleLicensePer` option.
-                                    linkedKeys = getFetchedLicenseKeysInfo(initializationData, options.singleLicensePer, evt.value.whitelistedKeyIds, evt.value.blacklistedKeyIDs);
-                                }
-                                else {
-                                    // When the MediaKeySession is just a cached/persisted one, we don't
-                                    // have any concept of "implicit key id".
-                                    linkedKeys = { whitelisted: evt.value.whitelistedKeyIds,
-                                        blacklisted: evt.value.blacklistedKeyIDs };
-                                }
+                                var linkedKeys = getKeyIdsLinkedToSession(initializationData, sessionInfo.record, options.singleLicensePer, sessionInfo.source === "created-session" /* MediaKeySessionLoadingType.Created */, evt.value.whitelistedKeyIds, evt.value.blacklistedKeyIDs);
                                 sessionInfo.record.associateKeyIds(linkedKeys.whitelisted);
                                 sessionInfo.record.associateKeyIds(linkedKeys.blacklisted);
                                 sessionInfo.keyStatuses = { whitelisted: linkedKeys.whitelisted,
@@ -758,26 +747,63 @@ export var ContentDecryptorState;
     ContentDecryptorState[ContentDecryptorState["Disposed"] = 4] = "Disposed";
 })(ContentDecryptorState || (ContentDecryptorState = {}));
 /**
- * Returns information on all keys - explicit or implicit - that are linked to
- * a loaded license.
+ * Returns set of all usable and unusable keys - explicit or implicit - that are
+ * linked to a `MediaKeySession`.
  *
  * In the RxPlayer, there is a concept of "explicit" key ids, which are key ids
  * found in a license whose status can be known through the `keyStatuses`
  * property from a `MediaKeySession`, and of "implicit" key ids, which are key
  * ids which were expected to be in a fetched license, but apparently weren't.
- * @param {Object} initializationData
- * @param {string|undefined} singleLicensePer
- * @param {Array.<Uint8Array>} usableKeyIds
- * @param {Array.<Uint8Array>} unusableKeyIds
- * @returns {Object}
+ *
+ * @param {Object} initializationData - Initialization data object used to make
+ * the request for the current license.
+ * @param {Object} keySessionRecord - The `KeySessionRecord` associated with the
+ * session that has been loaded. It might give supplementary information on
+ * keys implicitly linked to the license.
+ * @param {string|undefined} singleLicensePer - Setting allowing to indicate the
+ * scope a given license should have.
+ * @param {boolean} isCurrentLicense - If `true` the license has been fetched
+ * especially for the current content.
+ *
+ * Knowing this allows to determine that if decryption keys that should have
+ * been referenced in the fetched license (according to the `singleLicensePer`
+ * setting) are missing, then the keys surely must have been voluntarly
+ * removed from the license.
+ *
+ * If it is however set to `false`, it means that the license is an older
+ * license that might have been linked to another content, thus we cannot make
+ * that assumption.
+ * @param {Array.<Uint8Array>} usableKeyIds - Key ids that are present in the
+ * license and can be used.
+ * @param {Array.<Uint8Array>} unusableKeyIds - Key ids that are present in the
+ * license yet cannot be used.
+ * @returns {Object} - Returns an object with the following properties:
+ *   - `whitelisted`: Array of key ids for keys that are known to be usable
+ *   - `blacklisted`: Array of key ids for keys that are considered unusable.
+ *     The qualities linked to those keys should not be played.
  */
-function getFetchedLicenseKeysInfo(initializationData, singleLicensePer, usableKeyIds, unusableKeyIds) {
+function getKeyIdsLinkedToSession(initializationData, keySessionRecord, singleLicensePer, isCurrentLicense, usableKeyIds, unusableKeyIds) {
     var _a;
     /**
      * Every key id associated with the MediaKeySession, starting with
      * whitelisted ones.
      */
     var associatedKeyIds = __spreadArray(__spreadArray([], usableKeyIds, true), unusableKeyIds, true);
+    // Add all key ids associated to the `KeySessionRecord` yet not in
+    // `usableKeyIds` nor in `unusableKeyIds`
+    var allKnownKeyIds = keySessionRecord.getAssociatedKeyIds();
+    var _loop_2 = function (kid) {
+        if (!associatedKeyIds.some(function (ak) { return areKeyIdsEqual(ak, kid); })) {
+            if (log.hasLevel("DEBUG")) {
+                log.debug("DRM: KeySessionRecord's key missing in the license, blacklisting it", bytesToHex(kid));
+            }
+            associatedKeyIds.push(kid);
+        }
+    };
+    for (var _i = 0, allKnownKeyIds_1 = allKnownKeyIds; _i < allKnownKeyIds_1.length; _i++) {
+        var kid = allKnownKeyIds_1[_i];
+        _loop_2(kid);
+    }
     if (singleLicensePer !== undefined && singleLicensePer !== "init-data") {
         // We want to add the current key ids in the blacklist if it is
         // not already there.
@@ -798,24 +824,27 @@ function getFetchedLicenseKeysInfo(initializationData, singleLicensePer, usableK
                 return !associatedKeyIds.some(function (k) { return areKeyIdsEqual(k, expected); });
             });
             if (missingKeyIds.length > 0) {
+                if (log.hasLevel("DEBUG")) {
+                    log.debug("DRM: init data keys missing in the license, blacklisting them", missingKeyIds.map(function (m) { return bytesToHex(m); }).join(", "));
+                }
                 associatedKeyIds.push.apply(associatedKeyIds, missingKeyIds);
             }
         }
-        if (content !== undefined) {
+        if (isCurrentLicense && content !== undefined) {
             if (singleLicensePer === "content") {
                 // Put it in a Set to automatically filter out duplicates (by ref)
                 var contentKeys = new Set();
                 var manifest = content.manifest;
-                for (var _i = 0, _b = manifest.periods; _i < _b.length; _i++) {
-                    var period = _b[_i];
+                for (var _b = 0, _c = manifest.periods; _b < _c.length; _b++) {
+                    var period = _c[_b];
                     addKeyIdsFromPeriod(contentKeys, period);
                 }
                 mergeKeyIdSetIntoArray(contentKeys, associatedKeyIds);
             }
             else if (singleLicensePer === "periods") {
                 var manifest = content.manifest;
-                for (var _c = 0, _d = manifest.periods; _c < _d.length; _c++) {
-                    var period = _d[_c];
+                for (var _d = 0, _e = manifest.periods; _d < _e.length; _d++) {
+                    var period = _e[_d];
                     var periodKeys = new Set();
                     addKeyIdsFromPeriod(periodKeys, period);
                     if (((_a = initializationData.content) === null || _a === void 0 ? void 0 : _a.period.id) === period.id) {
@@ -823,16 +852,16 @@ function getFetchedLicenseKeysInfo(initializationData, singleLicensePer, usableK
                     }
                     else {
                         var periodKeysArr = Array.from(periodKeys);
-                        var _loop_2 = function (kid) {
+                        var _loop_3 = function (kid) {
                             var isFound = associatedKeyIds.some(function (k) { return areKeyIdsEqual(k, kid); });
                             if (isFound) {
                                 mergeKeyIdSetIntoArray(periodKeys, associatedKeyIds);
                                 return "break";
                             }
                         };
-                        for (var _e = 0, periodKeysArr_3 = periodKeysArr; _e < periodKeysArr_3.length; _e++) {
-                            var kid = periodKeysArr_3[_e];
-                            var state_2 = _loop_2(kid);
+                        for (var _f = 0, periodKeysArr_3 = periodKeysArr; _f < periodKeysArr_3.length; _f++) {
+                            var kid = periodKeysArr_3[_f];
+                            var state_2 = _loop_3(kid);
                             if (state_2 === "break")
                                 break;
                         }
@@ -847,7 +876,7 @@ function getFetchedLicenseKeysInfo(initializationData, singleLicensePer, usableK
 }
 function mergeKeyIdSetIntoArray(set, arr) {
     var setArr = Array.from(set.values());
-    var _loop_3 = function (kid) {
+    var _loop_4 = function (kid) {
         var isFound = arr.some(function (k) { return areKeyIdsEqual(k, kid); });
         if (!isFound) {
             arr.push(kid);
@@ -855,7 +884,7 @@ function mergeKeyIdSetIntoArray(set, arr) {
     };
     for (var _i = 0, setArr_1 = setArr; _i < setArr_1.length; _i++) {
         var kid = setArr_1[_i];
-        _loop_3(kid);
+        _loop_4(kid);
     }
 }
 function addKeyIdsFromPeriod(set, period) {

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

@@ -45,7 +45,7 @@ export default function ContentTimeBoundariesObserver(manifest, streams, playbac
     var maximumPositionCalculator = new MaximumPositionCalculator(manifest);
     // trigger warnings when the wanted time is before or after the manifest's
     // segments
-    var outOfManifest$ = playbackObserver.observe(true).pipe(filterMap(function (_a) {
+    var outOfManifest$ = playbackObserver.getReference().asObservable().pipe(filterMap(function (_a) {
         var _b;
         var position = _a.position;
         var wantedPosition = (_b = position.pending) !== null && _b !== void 0 ? _b : position.last;

package/dist/_esm5.processed/core/init/create_stream_playback_observer.d.ts

@@ -35,6 +35,6 @@ export interface IStreamPlaybackObserverArguments {
  * @param {Object} manifest
  * @param {Object} playbackObserver
  * @param {Object} args
- * @returns {Observable}
+ * @returns {Object}
  */
 export default function createStreamPlaybackObserver(manifest: Manifest, playbackObserver: PlaybackObserver, { autoPlay, initialPlayPerformed, initialSeekPerformed, speed, startTime }: IStreamPlaybackObserverArguments): IReadOnlyPlaybackObserver<IStreamOrchestratorPlaybackObservation>;