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

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

@@ -13,19 +13,33 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { combineLatest as observableCombineLatest, map, } from "rxjs";
+import createSharedReference from "../../utils/reference";
 /**
  * Create PlaybackObserver for the `Stream` part of the code.
  * @param {Object} manifest
  * @param {Object} playbackObserver
  * @param {Object} args
- * @returns {Observable}
+ * @returns {Object}
  */
 export default function createStreamPlaybackObserver(manifest, playbackObserver, _a) {
     var autoPlay = _a.autoPlay, initialPlayPerformed = _a.initialPlayPerformed, initialSeekPerformed = _a.initialSeekPerformed, speed = _a.speed, startTime = _a.startTime;
-    return playbackObserver.deriveReadOnlyObserver(function mapObservable(observation$) {
-        return observableCombineLatest([observation$, speed.asObservable()]).pipe(map(function (_a) {
-            var observation = _a[0], lastSpeed = _a[1];
+    return playbackObserver.deriveReadOnlyObserver(function transform(observationRef, cancellationSignal) {
+        var newRef = createSharedReference(constructStreamPlaybackObservation());
+        speed.onUpdate(emitStreamPlaybackObservation, {
+            clearSignal: cancellationSignal,
+            emitCurrentValue: false,
+        });
+        observationRef.onUpdate(emitStreamPlaybackObservation, {
+            clearSignal: cancellationSignal,
+            emitCurrentValue: false,
+        });
+        cancellationSignal.register(function () {
+            newRef.finish();
+        });
+        return newRef;
+        function constructStreamPlaybackObservation() {
+            var observation = observationRef.getValue();
+            var lastSpeed = speed.getValue();
             var pendingPosition;
             if (!initialSeekPerformed.getValue()) {
                 pendingPosition = startTime;
@@ -61,6 +75,9 @@ export default function createStreamPlaybackObserver(manifest, playbackObserver,
                 readyState: observation.readyState,
                 speed: lastSpeed,
             };
-        }));
+        }
+        function emitStreamPlaybackObservation() {
+            newRef.setValue(constructStreamPlaybackObservation());
+        }
     });
 }

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

@@ -39,7 +39,7 @@ export function waitUntilPlayable(observation$) {
 }
 /**
  * Try to play content then handle autoplay errors.
- * @param {HTMLMediaElement} - mediaElement
+ * @param {HTMLMediaElement} mediaElement
  * @returns {Observable}
  */
 function autoPlay(mediaElement) {
@@ -75,12 +75,12 @@ export default function initialSeekAndPlay(_a) {
     }), shareReplay({ refCount: true }));
     var seekAndPlay$ = seek$.pipe(mergeMap(function () {
         if (!shouldValidateMetadata() || mediaElement.duration > 0) {
-            return waitUntilPlayable(playbackObserver.observe(true));
+            return waitUntilPlayable(playbackObserver.getReference().asObservable());
         }
         else {
             var error = new MediaError("MEDIA_ERR_NOT_LOADED_METADATA", "Cannot load automatically: your browser " +
                 "falsely announced having loaded the content.");
-            return waitUntilPlayable(playbackObserver.observe(true))
+            return waitUntilPlayable(playbackObserver.getReference().asObservable())
                 .pipe(startWith(EVENTS.warning(error)));
         }
     }), mergeMap(function (evt) {

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

@@ -99,7 +99,7 @@ export default function initializeDirectfileContent(_a) {
     // Translate errors coming from the media element into RxPlayer errors
     // through a throwing Observable.
     var mediaError$ = throwOnMediaError(mediaElement);
-    var observation$ = playbackObserver.observe(true);
+    var observation$ = playbackObserver.getReference().asObservable();
     // Set the speed set by the user on the media element while pausing a
     // little longer while the buffer is empty.
     var playbackRate$ = updatePlaybackRate(mediaElement, speed, observation$)

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

@@ -54,7 +54,7 @@ export default function createMediaSourceLoader(_a) {
         var segmentBuffersStore = new SegmentBuffersStore(mediaElement, mediaSource);
         var _b = initialSeekAndPlay({ mediaElement: mediaElement, playbackObserver: playbackObserver, startTime: initialTime,
             mustAutoPlay: autoPlay }), seekAndPlay$ = _b.seekAndPlay$, initialPlayPerformed = _b.initialPlayPerformed, initialSeekPerformed = _b.initialSeekPerformed;
-        var observation$ = playbackObserver.observe(true);
+        var observation$ = playbackObserver.getReference().asObservable();
         var streamEvents$ = initialPlayPerformed.asObservable().pipe(filter(function (hasPlayed) { return hasPlayed; }), mergeMap(function () { return streamEventsEmitter(manifest, mediaElement, observation$); }));
         var streamObserver = createStreamPlaybackObserver(manifest, playbackObserver, { autoPlay: autoPlay, initialPlayPerformed: initialPlayPerformed, initialSeekPerformed: initialSeekPerformed, speed: speed, startTime: initialTime });
         /** Cancel endOfStream calls when streams become active again. */

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

@@ -42,7 +42,7 @@ export default function StallAvoider(playbackObserver, manifest, lockedStream$,
      * Emit every known audio and video buffer discontinuities in chronological
      * order (first ordered by Period's start, then by bufferType in any order.
      */
-    var discontinuitiesStore$ = discontinuityUpdate$.pipe(withLatestFrom(playbackObserver.observe(true)), scan(function (discontinuitiesStore, _a) {
+    var discontinuitiesStore$ = discontinuityUpdate$.pipe(withLatestFrom(playbackObserver.getReference().asObservable()), scan(function (discontinuitiesStore, _a) {
         var evt = _a[0], observation = _a[1];
         return updateDiscontinuitiesStore(discontinuitiesStore, evt, observation);
     }, initialDiscontinuitiesStore));
@@ -76,7 +76,7 @@ export default function StallAvoider(playbackObserver, manifest, lockedStream$,
      * If we're rebuffering waiting on data of a "locked stream", seek into the
      * Period handled by that stream to unlock the situation.
      */
-    var unlock$ = lockedStream$.pipe(withLatestFrom(playbackObserver.observe(true)), tap(function (_a) {
+    var unlock$ = lockedStream$.pipe(withLatestFrom(playbackObserver.getReference().asObservable()), tap(function (_a) {
         var _b;
         var lockedStreamEvt = _a[0], observation = _a[1];
         // TODO(PaulB) also skip when the user's wanted speed is set to `0`, as we
@@ -102,7 +102,7 @@ export default function StallAvoider(playbackObserver, manifest, lockedStream$,
     // This is why we're disabling the eslint rule.
     /* eslint-disable-next-line @typescript-eslint/no-unsafe-argument */
     ignoreElements());
-    var stall$ = playbackObserver.observe(true).pipe(withLatestFrom(discontinuitiesStore$), map(function (_a) {
+    var stall$ = playbackObserver.getReference().asObservable().pipe(withLatestFrom(discontinuitiesStore$), map(function (_a) {
         var observation = _a[0], discontinuitiesStore = _a[1];
         var buffered = observation.buffered, position = observation.position, readyState = observation.readyState, rebuffering = observation.rebuffering, freezing = observation.freezing;
         var _b = config.getCurrent(), BUFFER_DISCONTINUITY_THRESHOLD = _b.BUFFER_DISCONTINUITY_THRESHOLD, FORCE_DISCONTINUITY_SEEK_DELAY = _b.FORCE_DISCONTINUITY_SEEK_DELAY, FREEZING_STALLED_DELAY = _b.FREEZING_STALLED_DELAY, UNFREEZING_SEEK_DELAY = _b.UNFREEZING_SEEK_DELAY, UNFREEZING_DELTA_POSITION = _b.UNFREEZING_DELTA_POSITION;
@@ -155,11 +155,15 @@ export default function StallAvoider(playbackObserver, manifest, lockedStream$,
             if (ignoredStallTimeStamp === null) {
                 ignoredStallTimeStamp = now;
             }
-            if (isSeekingApproximate &&
-                observation.position < lastSeekingPosition &&
-                now - ignoredStallTimeStamp < FORCE_DISCONTINUITY_SEEK_DELAY) {
-                return { type: "stalled",
-                    value: stalledReason };
+            if (isSeekingApproximate && observation.position < lastSeekingPosition) {
+                log.debug("Init: the device appeared to have seeked back by itself.");
+                if (now - ignoredStallTimeStamp < FORCE_DISCONTINUITY_SEEK_DELAY) {
+                    return { type: "stalled",
+                        value: stalledReason };
+                }
+                else {
+                    log.warn("Init: ignored stall for too long, checking discontinuity", now - ignoredStallTimeStamp);
+                }
             }
             lastSeekingPosition = null;
         }

package/dist/_esm5.processed/core/stream/adaptation/create_representation_estimator.js

@@ -39,7 +39,7 @@ export default function getRepresentationEstimate(content, representationEstimat
     updateRepresentationsReference();
     manifest.addEventListener("decipherabilityUpdate", updateRepresentationsReference);
     var unregisterCleanUp = cancellationSignal.register(cleanUp);
-    var _a = representationEstimator(content, currentRepresentation, representations, playbackObserver, cancellationSignal), estimateRef = _a[0], abrCallbacks = _a[1];
+    var _a = representationEstimator(content, currentRepresentation, representations, playbackObserver, cancellationSignal), estimateRef = _a.estimates, abrCallbacks = _a.callbacks;
     return { abrCallbacks: abrCallbacks, estimateRef: estimateRef };
     function updateRepresentationsReference() {
         /** Representations for which a `RepresentationStream` can be created. */

package/dist/_esm5.processed/core/stream/orchestrator/stream_orchestrator.js

@@ -79,7 +79,7 @@ export default function StreamOrchestrator(content, playbackObserver, representa
             Infinity;
         return BufferGarbageCollector({
             segmentBuffer: segmentBuffer,
-            currentTime$: playbackObserver.observe(true)
+            currentTime$: playbackObserver.getReference().asObservable()
                 .pipe(map(function (o) { var _a; return (_a = o.position.pending) !== null && _a !== void 0 ? _a : o.position.last; })),
             maxBufferBehind$: maxBufferBehind.asObservable().pipe(map(function (val) { return Math.min(val, defaultMaxBehind); })),
             maxBufferAhead$: maxBufferAhead.asObservable().pipe(map(function (val) { return Math.min(val, defaultMaxAhead); })),
@@ -175,7 +175,8 @@ export default function StreamOrchestrator(content, playbackObserver, representa
         }
         // Restart the current Stream when the wanted time is in another period
         // than the ones already considered
-        var restartStreamsWhenOutOfBounds$ = playbackObserver.observe(true).pipe(filterMap(function (_a) {
+        var observation$ = playbackObserver.getReference().asObservable();
+        var restartStreamsWhenOutOfBounds$ = observation$.pipe(filterMap(function (_a) {
             var _b, _c;
             var position = _a.position;
             var time = (_b = position.pending) !== null && _b !== void 0 ? _b : position.last;
@@ -228,7 +229,7 @@ export default function StreamOrchestrator(content, playbackObserver, representa
                 // to reduce the risk of race conditions where the next observation
                 // was going to be emitted synchronously.
                 nextTickObs().pipe(ignoreElements()),
-                playbackObserver.observe(true).pipe(take(1), mergeMap(function (observation) {
+                playbackObserver.getReference().asObservable().pipe(take(1), mergeMap(function (observation) {
                     var _a;
                     var shouldAutoPlay = !((_a = observation.paused.pending) !== null && _a !== void 0 ? _a : playbackObserver.getIsPaused());
                     return observableConcat(observableOf(EVENTS.needsDecipherabilityFlush(observation.position.last, shouldAutoPlay, observation.duration)), observableDefer(function () {
@@ -279,7 +280,7 @@ export default function StreamOrchestrator(content, playbackObserver, representa
         // created.
         var destroyNextStreams$ = new Subject();
         // Emits when the current position goes over the end of the current Stream.
-        var endOfCurrentStream$ = playbackObserver.observe(true)
+        var endOfCurrentStream$ = playbackObserver.getReference().asObservable()
             .pipe(filter(function (_a) {
             var _b;
             var position = _a.position;

package/dist/_esm5.processed/core/stream/period/create_empty_adaptation_stream.js

@@ -30,7 +30,7 @@ export default function createEmptyAdaptationStream(playbackObserver, wantedBuff
     var period = content.period;
     var hasFinishedLoading = false;
     var wantedBufferAhead$ = wantedBufferAhead.asObservable();
-    var observation$ = playbackObserver.observe(true);
+    var observation$ = playbackObserver.getReference().asObservable();
     return observableCombineLatest([observation$,
         wantedBufferAhead$]).pipe(mergeMap(function (_a) {
         var observation = _a[0], wba = _a[1];

package/dist/_esm5.processed/core/stream/period/period_stream.js

@@ -19,6 +19,7 @@ import { formatError, MediaError, } from "../../../errors";
 import log from "../../../log";
 import objectAssign from "../../../utils/object_assign";
 import { getLeftSizeOfRange } from "../../../utils/ranges";
+import createSharedReference from "../../../utils/reference";
 import SegmentBuffersStore from "../../segment_buffers";
 import AdaptationStream from "../adaptation";
 import EVENTS from "../events_generators";
@@ -181,9 +182,24 @@ function getFirstDeclaredMimeType(adaptation) {
  * @returns {Object}
  */
 function createAdaptationStreamPlaybackObserver(initialPlaybackObserver, segmentBuffer) {
-    return initialPlaybackObserver.deriveReadOnlyObserver(function (observation$) { return observation$.pipe(map(mapObservation)); }, mapObservation);
-    function mapObservation(baseObservation) {
-        var buffered = segmentBuffer.getBufferedRanges();
-        return objectAssign({}, baseObservation, { bufferGap: getLeftSizeOfRange(buffered, baseObservation.position.last) });
-    }
+    return initialPlaybackObserver.deriveReadOnlyObserver(function transform(observationRef, cancellationSignal) {
+        var newRef = createSharedReference(constructAdaptationStreamPlaybackObservation());
+        observationRef.onUpdate(emitAdaptationStreamPlaybackObservation, {
+            clearSignal: cancellationSignal,
+            emitCurrentValue: false,
+        });
+        cancellationSignal.register(function () {
+            newRef.finish();
+        });
+        return newRef;
+        function constructAdaptationStreamPlaybackObservation() {
+            var baseObservation = observationRef.getValue();
+            var buffered = segmentBuffer.getBufferedRanges();
+            var bufferGap = getLeftSizeOfRange(buffered, baseObservation.position.last);
+            return objectAssign({}, baseObservation, { bufferGap: bufferGap });
+        }
+        function emitAdaptationStreamPlaybackObservation() {
+            newRef.setValue(constructAdaptationStreamPlaybackObservation());
+        }
+    });
 }

package/dist/_esm5.processed/core/stream/reload_after_switch.js

@@ -44,7 +44,7 @@ export default function reloadAfterSwitch(period, bufferType, playbackObserver,
     // is actually received.
     // It can happen when `reloadAfterSwitch` is called as a side-effect of the
     // same event that triggers the playback observation to be emitted.
-    return nextTickObs().pipe(mergeMap(function () { return playbackObserver.observe(true); }), map(function (observation) {
+    return nextTickObs().pipe(mergeMap(function () { return playbackObserver.getReference().asObservable(); }), map(function (observation) {
         var _a, _b;
         var currentTime = playbackObserver.getCurrentTime();
         var pos = currentTime + deltaPos;

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

@@ -38,7 +38,7 @@ export default function appendSegmentToBuffer(playbackObserver, segmentBuffer, d
                 "An unknown error happened when pushing content";
             throw new MediaError("BUFFER_APPEND_ERROR", reason);
         }
-        return playbackObserver.observe(true).pipe(take(1), mergeMap(function (observation) {
+        return playbackObserver.getReference().asObservable().pipe(take(1), mergeMap(function (observation) {
             var _a;
             var currentPos = (_a = observation.position.pending) !== null && _a !== void 0 ? _a : observation.position.last;
             return observableConcat(forceGarbageCollection(currentPos, segmentBuffer).pipe(ignoreElements()), append$).pipe(catchError(function (forcedGCError) {

package/dist/_esm5.processed/core/stream/representation/representation_stream.js

@@ -97,7 +97,7 @@ export default function RepresentationStream(_a) {
         .pipe(mergeMap(onQueueEvent));
     /** Observable emitting the stream "status" and filling `lastSegmentQueue`. */
     var status$ = observableCombineLatest([
-        playbackObserver.observe(true),
+        playbackObserver.getReference().asObservable(),
         bufferGoal$,
         maxBufferSize$,
         terminate$.pipe(take(1), startWith(null)),

package/dist/_esm5.processed/utils/reference.d.ts

@@ -52,10 +52,24 @@ import { CancellationSignal } from "./task_canceller";
  * those use cases makes the intent of the corresponding code clearer.
  */
 export interface ISharedReference<T> {
-    /** Get the last set value for this shared reference. */
+    /**
+     * Get the last set value for this shared reference.
+     * @returns {*}
+     */
     getValue(): T;
-    /** Update the value of this shared reference. */
+    /**
+     * Update the value of this shared reference.
+     * @param {*} newVal
+     */
     setValue(newVal: T): void;
+    /**
+     * Update the value of this shared reference only if the value changed.
+     *
+     * Note that this function only performs a strict equality reference through
+     * the "===" operator. Different objects that are structurally the same will
+     * thus be considered different.
+     * @param {*} newVal
+     */
     setValueIfChanged(newVal: T): void;
     /**
      * Returns an Observable which synchronously emits the current value (unless
@@ -65,21 +79,6 @@ export interface ISharedReference<T> {
      * @returns {Observable}
      */
     asObservable(skipCurrentValue?: boolean): Observable<T>;
-    /**
-     * Triggers a callback each time this reference's value is updated.
-     *
-     * Can be given several options as argument:
-     *   - clearSignal: When the attach `CancellationSignal` emits, the given
-     *     callback will not be called anymore on reference updates.
-     *   - emitCurrentValue: If `true`, the callback will be called directly and
-     *     synchronously on this call with its current value.
-     * @param {Function} cb
-     * @param {Object} [options]
-     */
-    onUpdate(cb: (val: T) => void, options?: {
-        clearSignal?: CancellationSignal;
-        emitCurrentValue?: boolean;
-    }): void;
     /**
      * Allows to register a callback to be called each time the value inside the
      * reference is updated.
@@ -92,8 +91,8 @@ export interface ISharedReference<T> {
      * also be immediately called with the current value.
      */
     onUpdate(cb: (val: T) => void, options?: {
-        clearSignal?: CancellationSignal;
-        emitCurrentValue?: boolean;
+        clearSignal?: CancellationSignal | undefined;
+        emitCurrentValue?: boolean | undefined;
     }): void;
     /**
      * Indicate that no new values will be emitted.
@@ -160,5 +159,16 @@ export interface IReadOnlySharedReference<T> {
  * @returns {Observable}
  */
 export declare function createSharedReference<T>(initialValue: T): ISharedReference<T>;
+/**
+ * Create a new `ISharedReference` based on another one by mapping over its
+ * referenced value each time it is updated.
+ * @param {Object} originalRef - The Original `ISharedReference` you wish to map
+ * over.
+ * @param {Function} mappingFn - The mapping function which will receives
+ * `originalRef`'s value and outputs this new reference's value.
+ * @param {Object | undefined} [cancellationSignal] - Optionally, a
+ * `CancellationSignal` which will finish that reference when it emits.
+ * @returns {Object} - The new, mapped, reference.
+ */
 export declare function createMappedReference<T, U>(originalRef: IReadOnlySharedReference<T>, mappingFn: (x: T) => U, cancellationSignal?: CancellationSignal): IReadOnlySharedReference<U>;
 export default createSharedReference;

package/dist/_esm5.processed/utils/reference.js

@@ -53,16 +53,15 @@ export function createSharedReference(initialValue) {
         },
         /**
          * Update the value of this shared reference.
-         * @param {*}
+         * @param {*} newVal
          */
         setValue: function (newVal) {
             if (isFinished) {
                 if (0 /* __ENVIRONMENT__.CURRENT_ENV */ === 1 /* __ENVIRONMENT__.DEV */) {
-                    throw new Error("Finished shared references cannot be updated");
-                }
-                else {
-                    return;
+                    /* eslint-disable-next-line no-console */
+                    console.error("Finished shared references cannot be updated");
                 }
+                return;
             }
             value = newVal;
             if (cbs.length === 0) {
@@ -81,6 +80,10 @@ export function createSharedReference(initialValue) {
                 }
             }
         },
+        /**
+         * Update the value of this shared reference only if it changed.
+         * @param {*} newVal
+         */
         setValueIfChanged: function (newVal) {
             if (newVal !== value) {
                 this.setValue(newVal);
@@ -173,14 +176,27 @@ export function createSharedReference(initialValue) {
                     if (!cbObj.hasBeenCleared) {
                         cbObj.complete();
                     }
+                    cbObj.hasBeenCleared = true;
                 }
                 catch (_) {
                     /* nothing */
                 }
             }
+            cbs.length = 0;
         },
     };
 }
+/**
+ * Create a new `ISharedReference` based on another one by mapping over its
+ * referenced value each time it is updated.
+ * @param {Object} originalRef - The Original `ISharedReference` you wish to map
+ * over.
+ * @param {Function} mappingFn - The mapping function which will receives
+ * `originalRef`'s value and outputs this new reference's value.
+ * @param {Object | undefined} [cancellationSignal] - Optionally, a
+ * `CancellationSignal` which will finish that reference when it emits.
+ * @returns {Object} - The new, mapped, reference.
+ */
 export function createMappedReference(originalRef, mappingFn, cancellationSignal) {
     var newRef = createSharedReference(mappingFn(originalRef.getValue()));
     originalRef.onUpdate(function mapOriginalReference(x) {