rx-player 3.28.0-dev.2022062000 → 3.28.0-dev.2022063000

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Changelog
 
-## v3.28.0
+## /v3.28.0-dev.2022063000
 
 ### Features
 
@@ -16,6 +16,7 @@
   - After a `RELOADING` state, stay in `PAUSED` if the media element was paused synchronously before the side-effect which triggered the reloading (usually coming from the API) was perform [#1132]
   - Fix issue with `maxVideoBufferSize` setting which could lead to too much data being buffered [#1125]
   - Prevent possibility of requests loops and infinite rebuffering when a pushed segment is always completely and immediately garbage collected by the browser [#1123]
+  - DASH: Fix potential rare memory leak when stopping the content after it has reloaded at least once [#1135]
   - DASH: Fix issues that could arise if a segment is calculated to start at a negative position [#1122]
   - DASH: Fix possibility of wrong segments being requested when a SegmentTimeline in a given Period (whose Period@end is set) had an S@r set to `-1` at its end [#1098]
   - DASH: If the first `<S>` has its S@t attribute not set, make as if it is set to `0` [#1118]

package/VERSION

@@ -1 +1 @@
-3.28.0-dev.2022062000
+3.28.0-dev.2022063000

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

@@ -132,7 +132,7 @@ function getDocumentVisibilityRef(stopListening) {
     var visibilityChangeEvent = isNonEmptyString(prefix) ? prefix + "visibilitychange" :
         "visibilitychange";
     var isHidden = document[hidden];
-    var ref = createSharedReference(isHidden);
+    var ref = createSharedReference(!isHidden);
     addEventListener(document, visibilityChangeEvent, function () {
         var isVisible = !(document[hidden]);
         ref.setValueIfChanged(isVisible);

package/dist/_esm5.processed/core/adaptive/adaptive_representation_selector.js

@@ -170,13 +170,8 @@ function getEstimateReference(_a, stopAllEstimates) {
          * Only used in very specific scenarios.
          */
         var guessBasedChooser = new GuessBasedChooser(scoreCalculator, prevEstimate);
-        var lastPlaybackObservation;
         // get initial observation for initial estimate
-        var unregisterInitial = playbackObserver.listen(function (obs) {
-            lastPlaybackObservation = obs;
-        }, { includeLastObservation: true });
-        unregisterInitial(); // The initial is emitted synchronously, we can now remove it
-        // TODO cleaner playbackObserver.getLast() or something?
+        var lastPlaybackObservation = playbackObserver.getReference().getValue();
         /** Reference through which estimates are emitted. */
         var innerEstimateRef = createSharedReference(getCurrentEstimate());
         // subscribe to subsequent playback observations

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

@@ -13,7 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Observable } from "rxjs";
+import noop from "../../utils/noop";
+import { IReadOnlySharedReference } from "../../utils/reference";
 import { CancellationSignal } from "../../utils/task_canceller";
 /**
  * Class allowing to "observe" current playback conditions so the RxPlayer is
@@ -55,21 +56,36 @@ export default class PlaybackObserver {
      */
     private _internalSeekingEventsIncomingCounter;
     /**
-     * Last playback observation made by the `PlaybackObserver`.
-     *
-     * `null` if no observation has been made yet.
+     * Stores the last playback observation produced by the `PlaybackObserver`.:
      */
-    private _lastObservation;
+    private _observationRef;
     /**
-     * Lazily-created shared Observable that will emit playback observations.
-     * Set to `null` until the first time it is generated.
+     * `TaskCanceller` allowing to free all resources and stop producing playback
+     * observations.
      */
-    private _observation$;
+    private _canceller;
     /**
+     * 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
      */
     constructor(mediaElement: HTMLMediaElement, options: IPlaybackObserverOptions);
+    /**
+     * 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.
+     */
+    stop(): void;
     /**
      * Returns the current position advertised by the `HTMLMediaElement`, in
      * seconds.
@@ -101,18 +117,16 @@ export default class PlaybackObserver {
      */
     getReadyState(): number;
     /**
-     * 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}
      */
-    observe(includeLastObservation: boolean): Observable<IPlaybackObservation>;
+    getReference(): IReadOnlySharedReference<IPlaybackObservation>;
     /**
      * Register a callback so it regularly receives playback observations.
      * @param {Function} cb
@@ -121,12 +135,11 @@ export default class PlaybackObserver {
      *     be first emitted synchronously.
      *   - `clearSignal`: If set, the callback will be unregistered when this
      *     CancellationSignal emits.
-     * @returns {Function} - Allows to easily unregister the callback
      */
     listen(cb: (observation: IPlaybackObservation) => void, options?: {
         includeLastObservation?: boolean | undefined;
         clearSignal?: CancellationSignal | undefined;
-    }): () => void;
+    }): typeof noop | undefined;
     /**
      * Generate a new playback observer which can listen to other
      * properties and which can only be accessed to read observations (e.g.
@@ -138,15 +151,16 @@ export default class PlaybackObserver {
      *
      * 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}
      */
-    deriveReadOnlyObserver<TDest>(mapObservable: (observation$: Observable<IPlaybackObservation>) => Observable<TDest>): IReadOnlyPlaybackObserver<TDest>;
+    deriveReadOnlyObserver<TDest>(transform: (observationRef: IReadOnlySharedReference<IPlaybackObservation>, cancellationSignal: CancellationSignal) => IReadOnlySharedReference<TDest>): IReadOnlyPlaybackObserver<TDest>;
     /**
-     * Creates the observable that will generate playback observations.
+     * Creates the `IReadOnlySharedReference` that will generate playback
+     * observations.
      * @returns {Observable}
      */
-    private _createInnerObservable;
+    private _createSharedReference;
     private _generateInitialObservation;
 }
 /** "Event" that triggered the playback observation. */
@@ -286,18 +300,16 @@ export interface IReadOnlyPlaybackObserver<TObservationType> {
      */
     getIsPaused(): boolean;
     /**
-     * Returns an Observable regularly emitting playback observation, optionally
-     * starting with the last one.
+     * Returns an `IReadOnlySharedReference` storing the last playback observation
+     * produced by the `IReadOnlyPlaybackObserver` 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}
      */
-    observe(includeLastObservation: boolean): Observable<TObservationType>;
+    getReference(): IReadOnlySharedReference<TObservationType>;
     /**
      * Register a callback so it regularly receives playback observations.
      * @param {Function} cb
@@ -311,16 +323,16 @@ export interface IReadOnlyPlaybackObserver<TObservationType> {
     listen(cb: (observation: TObservationType) => void, options?: {
         includeLastObservation?: boolean | undefined;
         clearSignal?: CancellationSignal | undefined;
-    }): () => void;
+    }): void;
     /**
      * Generate a new `IReadOnlyPlaybackObserver` from this one.
      *
      * 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}
      */
-    deriveReadOnlyObserver<TDest>(mapObservable: (observation$: Observable<TObservationType>) => Observable<TDest>, mapObservation: (observation: TObservationType) => TDest): IReadOnlyPlaybackObserver<TDest>;
+    deriveReadOnlyObserver<TDest>(transform: (observationRef: IReadOnlySharedReference<TObservationType>, cancellationSignal: CancellationSignal) => IReadOnlySharedReference<TDest>): IReadOnlyPlaybackObserver<TDest>;
 }
 export interface IPlaybackObserverOptions {
     withMediaSource: boolean;

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.2022062000";
+        _this.version = /* PLAYER_VERSION */ "3.28.0-dev.2022063000";
         _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.2022062000";
+Player.version = /* PLAYER_VERSION */ "3.28.0-dev.2022063000";
 export default Player;

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;