rx-player 3.26.1 → 3.26.2

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

@@ -13,8 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { merge as observableMerge, of as observableOf, Subject, } from "rxjs";
-import { distinctUntilChanged, map, switchMap, } from "rxjs/operators";
+import { Subject, distinctUntilChanged, map, merge as observableMerge, of as observableOf, switchMap, } from "rxjs";
 import { MediaError } from "../../../errors";
 import { fromEvent } from "../../../utils/event_emitter";
 /**
@@ -22,29 +21,21 @@ import { fromEvent } from "../../../utils/event_emitter";
  * the given `Adaptation`) is the best fit (see `IABREstimate` type definition)
  * corresponding to the current network and playback conditions.
  *
- * This function also returns two subjects that should be used to add feedback
- * helping the estimator to make its choices:
+ * This function also returns a subject that should be used to add feedback
+ * helping the estimator to make its choices.
  *
- *   - `requestFeedback$`: Subject through which information about new requests
- *     and network metrics should be emitted.
- *
- *   - `streamFeedback$`: Subject through which stream-related events should be
- *      emitted.
- *
- * You can look at the types defined for both of those Subjects to have more
- * information on what data is expected. The idea is to provide as much data as
- * possible so the estimation is as adapted as possible.
+ * You can look at the types defined for this Subject to have more information
+ * on what data is expected. The idea is to provide as much data as possible so
+ * the estimation is as adapted as possible.
  *
  * @param {Object} content
  * @param {Object} abrManager
- * @param {Observable} clock$
+ * @param {Observable} observation$
  * @returns {Object}
  */
-export default function createRepresentationEstimator(_a, abrManager, clock$) {
+export default function createRepresentationEstimator(_a, abrManager, observation$) {
     var manifest = _a.manifest, adaptation = _a.adaptation;
-    var streamFeedback$ = new Subject();
-    var requestFeedback$ = new Subject();
-    var abrEvents$ = observableMerge(streamFeedback$, requestFeedback$);
+    var abrFeedbacks$ = new Subject();
     var estimator$ = observableMerge(
     // subscribe "first" (hack as it is a merge here) to event
     fromEvent(manifest, "decipherabilityUpdate"), 
@@ -69,7 +60,7 @@ export default function createRepresentationEstimator(_a, abrManager, clock$) {
         }
         return true;
     }), switchMap(function (playableRepresentations) {
-        return abrManager.get$(adaptation.type, playableRepresentations, clock$, abrEvents$);
+        return abrManager.get$(adaptation.type, playableRepresentations, observation$, abrFeedbacks$);
     }));
-    return { estimator$: estimator$, streamFeedback$: streamFeedback$, requestFeedback$: requestFeedback$ };
+    return { estimator$: estimator$, abrFeedbacks$: abrFeedbacks$ };
 }

package/dist/_esm5.processed/core/stream/adaptation/index.d.ts

@@ -13,6 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import AdaptationStream, { IAdaptationStreamArguments, IAdaptationStreamClockTick, IAdaptationStreamOptions } from "./adaptation_stream";
+import AdaptationStream, { IAdaptationStreamArguments, IAdaptationStreamPlaybackObservation, IAdaptationStreamOptions } from "./adaptation_stream";
 export default AdaptationStream;
-export { IAdaptationStreamArguments, IAdaptationStreamClockTick, IAdaptationStreamOptions, };
+export { IAdaptationStreamArguments, IAdaptationStreamPlaybackObservation, IAdaptationStreamOptions, };

package/dist/_esm5.processed/core/stream/index.d.ts

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import StreamOrchestrator, { IStreamOrchestratorClockTick, IStreamOrchestratorOptions } from "./orchestrator";
+import StreamOrchestrator, { IStreamOrchestratorOptions, IStreamOrchestratorPlaybackObservation } from "./orchestrator";
 export * from "./types";
 export default StreamOrchestrator;
-export { IStreamOrchestratorClockTick, IStreamOrchestratorOptions, };
+export { IStreamOrchestratorPlaybackObservation, IStreamOrchestratorOptions, };

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

@@ -13,8 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { merge as observableMerge, } from "rxjs";
-import { distinctUntilChanged, filter, map, scan, } from "rxjs/operators";
+import { distinctUntilChanged, filter, map, merge as observableMerge, scan, } from "rxjs";
 /**
  * Emit the active Period each times it changes.
  *
@@ -94,14 +93,14 @@ export default function ActivePeriodEmitter(buffers$) {
                 {
                     var _b = evt.value, period = _b.period, type = _b.type;
                     var currentInfos = acc[period.id];
-                    if (currentInfos !== undefined && !currentInfos.buffers.has(type)) {
-                        currentInfos.buffers.add(type);
-                    }
-                    else {
+                    if (currentInfos === undefined) {
                         var bufferSet = new Set();
                         bufferSet.add(type);
                         acc[period.id] = { period: period, buffers: bufferSet };
                     }
+                    else if (!currentInfos.buffers.has(type)) {
+                        currentInfos.buffers.add(type);
+                    }
                 }
                 break;
         }

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

@@ -13,8 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { combineLatest as observableCombineLatest, } from "rxjs";
-import { distinctUntilChanged, filter, map, startWith, } from "rxjs/operators";
+import { combineLatest as observableCombineLatest, distinctUntilChanged, filter, map, startWith, } from "rxjs";
 /**
  * Returns an Observable which emits ``true`` when all PeriodStreams given are
  * _complete_.

package/dist/_esm5.processed/core/stream/orchestrator/index.d.ts

@@ -13,6 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import StreamOrchestrator, { IStreamOrchestratorClockTick, IStreamOrchestratorOptions } from "./stream_orchestrator";
+import StreamOrchestrator, { IStreamOrchestratorOptions, IStreamOrchestratorPlaybackObservation } from "./stream_orchestrator";
 export default StreamOrchestrator;
-export { IStreamOrchestratorClockTick, IStreamOrchestratorOptions, };
+export { IStreamOrchestratorOptions, IStreamOrchestratorPlaybackObservation, };

package/dist/_esm5.processed/core/stream/orchestrator/stream_orchestrator.d.ts

@@ -13,19 +13,21 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { BehaviorSubject, Observable } from "rxjs";
+import { Observable } from "rxjs";
 import Manifest, { Period } from "../../../manifest";
+import { IReadOnlySharedReference } from "../../../utils/reference";
 import ABRManager from "../../abr";
+import type { IReadOnlyPlaybackObserver } from "../../api";
 import { SegmentFetcherCreator } from "../../fetchers";
 import SegmentBuffersStore from "../../segment_buffers";
-import { IPeriodStreamClockTick, IPeriodStreamOptions } from "../period";
+import { IPeriodStreamPlaybackObservation, IPeriodStreamOptions } from "../period";
 import { IStreamOrchestratorEvent } from "../types";
-export declare type IStreamOrchestratorClockTick = IPeriodStreamClockTick;
+export declare type IStreamOrchestratorPlaybackObservation = IPeriodStreamPlaybackObservation;
 /** Options tweaking the behavior of the StreamOrchestrator. */
 export declare type IStreamOrchestratorOptions = IPeriodStreamOptions & {
-    wantedBufferAhead$: BehaviorSubject<number>;
-    maxBufferAhead$: Observable<number>;
-    maxBufferBehind$: Observable<number>;
+    wantedBufferAhead: IReadOnlySharedReference<number>;
+    maxBufferAhead: IReadOnlySharedReference<number>;
+    maxBufferBehind: IReadOnlySharedReference<number>;
 };
 /**
  * Create and manage the various Stream Observables needed for the content to
@@ -43,7 +45,7 @@ export declare type IStreamOrchestratorOptions = IPeriodStreamOptions & {
  *   - Emit various events to notify of its health and issues
  *
  * @param {Object} content
- * @param {Observable} clock$ - Emit position information
+ * @param {Observable} playbackObserver - Emit position information
  * @param {Object} abrManager - Emit bitrate estimates and best Representation
  * to play.
  * @param {Object} segmentBuffersStore - Will be used to lazily create
@@ -55,4 +57,4 @@ export declare type IStreamOrchestratorOptions = IPeriodStreamOptions & {
 export default function StreamOrchestrator(content: {
     manifest: Manifest;
     initialPeriod: Period;
-}, clock$: Observable<IStreamOrchestratorClockTick>, abrManager: ABRManager, segmentBuffersStore: SegmentBuffersStore, segmentFetcherCreator: SegmentFetcherCreator, options: IStreamOrchestratorOptions): Observable<IStreamOrchestratorEvent>;
+}, playbackObserver: IReadOnlyPlaybackObserver<IStreamOrchestratorPlaybackObservation>, abrManager: ABRManager, segmentBuffersStore: SegmentBuffersStore, segmentFetcherCreator: SegmentFetcherCreator, options: IStreamOrchestratorOptions): Observable<IStreamOrchestratorEvent>;

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

@@ -22,8 +22,7 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     }
     return to.concat(ar || Array.prototype.slice.call(from));
 };
-import { combineLatest, concat as observableConcat, defer as observableDefer, EMPTY, merge as observableMerge, of as observableOf, Subject, } from "rxjs";
-import { distinctUntilChanged, exhaustMap, filter, ignoreElements, map, mergeMap, share, startWith, take, takeUntil, tap, } from "rxjs/operators";
+import { combineLatest, concat as observableConcat, defer as observableDefer, distinctUntilChanged, EMPTY, exhaustMap, filter, ignoreElements, map, merge as observableMerge, mergeMap, of as observableOf, share, startWith, Subject, take, takeUntil, tap, } from "rxjs";
 import config from "../../../config";
 import { MediaError } from "../../../errors";
 import log from "../../../log";
@@ -55,7 +54,7 @@ var MAXIMUM_MAX_BUFFER_AHEAD = config.MAXIMUM_MAX_BUFFER_AHEAD, MAXIMUM_MAX_BUFF
  *   - Emit various events to notify of its health and issues
  *
  * @param {Object} content
- * @param {Observable} clock$ - Emit position information
+ * @param {Observable} playbackObserver - Emit position information
  * @param {Object} abrManager - Emit bitrate estimates and best Representation
  * to play.
  * @param {Object} segmentBuffersStore - Will be used to lazily create
@@ -64,9 +63,9 @@ var MAXIMUM_MAX_BUFFER_AHEAD = config.MAXIMUM_MAX_BUFFER_AHEAD, MAXIMUM_MAX_BUFF
  * @param {Object} options
  * @returns {Observable}
  */
-export default function StreamOrchestrator(content, clock$, abrManager, segmentBuffersStore, segmentFetcherCreator, options) {
+export default function StreamOrchestrator(content, playbackObserver, abrManager, segmentBuffersStore, segmentFetcherCreator, options) {
     var manifest = content.manifest, initialPeriod = content.initialPeriod;
-    var maxBufferAhead$ = options.maxBufferAhead$, maxBufferBehind$ = options.maxBufferBehind$, wantedBufferAhead$ = options.wantedBufferAhead$;
+    var maxBufferAhead = options.maxBufferAhead, maxBufferBehind = options.maxBufferBehind, wantedBufferAhead = options.wantedBufferAhead;
     // Keep track of a unique BufferGarbageCollector created per
     // SegmentBuffer.
     var garbageCollectors = new WeakMapMemory(function (segmentBuffer) {
@@ -79,14 +78,15 @@ export default function StreamOrchestrator(content, clock$, abrManager, segmentB
             Infinity;
         return BufferGarbageCollector({
             segmentBuffer: segmentBuffer,
-            clock$: clock$.pipe(map(function (tick) { return tick.position + tick.wantedTimeOffset; })),
-            maxBufferBehind$: maxBufferBehind$.pipe(map(function (val) { return Math.min(val, defaultMaxBehind); })),
-            maxBufferAhead$: maxBufferAhead$.pipe(map(function (val) { return Math.min(val, defaultMaxAhead); })),
+            currentTime$: playbackObserver.observe(true)
+                .pipe(map(function (o) { return o.position + o.wantedTimeOffset; })),
+            maxBufferBehind$: maxBufferBehind.asObservable().pipe(map(function (val) { return Math.min(val, defaultMaxBehind); })),
+            maxBufferAhead$: maxBufferAhead.asObservable().pipe(map(function (val) { return Math.min(val, defaultMaxAhead); })),
         });
     });
     // trigger warnings when the wanted time is before or after the manifest's
     // segments
-    var outOfManifest$ = clock$.pipe(filterMap(function (_a) {
+    var outOfManifest$ = playbackObserver.observe(true).pipe(filterMap(function (_a) {
         var position = _a.position, wantedTimeOffset = _a.wantedTimeOffset;
         var offsetedPosition = wantedTimeOffset + position;
         if (offsetedPosition < manifest.getMinimumPosition()) {
@@ -109,7 +109,7 @@ export default function StreamOrchestrator(content, clock$, abrManager, segmentB
     });
     // Emits the activePeriodChanged events every time the active Period changes.
     var activePeriodChanged$ = ActivePeriodEmitter(streamsArray).pipe(filter(function (period) { return period !== null; }), map(function (period) {
-        log.info("Stream: New active period", period);
+        log.info("Stream: New active period", period.start);
         return EVENTS.activePeriodChanged(period);
     }));
     var isLastPeriodKnown$ = fromEvent(manifest, "manifestUpdate").pipe(map(function () { return manifest.isLastPeriodKnown; }), startWith(manifest.isLastPeriodKnown), distinctUntilChanged());
@@ -129,8 +129,8 @@ export default function StreamOrchestrator(content, clock$, abrManager, segmentB
      * Manage creation and removal of Streams for every Periods for a given type.
      *
      * Works by creating consecutive Streams through the
-     * `manageConsecutivePeriodStreams` function, and restarting it when the clock
-     * goes out of the bounds of these Streams.
+     * `manageConsecutivePeriodStreams` function, and restarting it when the
+     * current position goes out of the bounds of these Streams.
      * @param {string} bufferType - e.g. "audio" or "video"
      * @param {Period} basePeriod - Initial Period downloaded.
      * @returns {Observable}
@@ -194,7 +194,7 @@ export default function StreamOrchestrator(content, clock$, abrManager, segmentB
         }
         // Restart the current Stream when the wanted time is in another period
         // than the ones already considered
-        var restartStreamsWhenOutOfBounds$ = clock$.pipe(filterMap(function (_a) {
+        var restartStreamsWhenOutOfBounds$ = playbackObserver.observe(true).pipe(filterMap(function (_a) {
             var _b;
             var position = _a.position, wantedTimeOffset = _a.wantedTimeOffset;
             var time = wantedTimeOffset + position;
@@ -241,9 +241,10 @@ export default function StreamOrchestrator(content, clock$, abrManager, segmentB
             return observableConcat.apply(void 0, __spreadArray(__spreadArray([], rangesToClean.map(function (_a) {
                 var start = _a.start, end = _a.end;
                 return segmentBuffer.removeBuffer(start, end).pipe(ignoreElements());
-            }), false), [clock$.pipe(take(1), mergeMap(function (lastTick) {
-                    return observableConcat(observableOf(EVENTS.needsDecipherabilityFlush(lastTick.position, !lastTick.isPaused, lastTick.duration)), observableDefer(function () {
-                        var lastPosition = lastTick.position + lastTick.wantedTimeOffset;
+            }), false), [playbackObserver.observe(true).pipe(take(1), mergeMap(function (observation) {
+                    return observableConcat(observableOf(EVENTS.needsDecipherabilityFlush(observation.position, !observation.isPaused, observation.duration)), observableDefer(function () {
+                        var lastPosition = observation.position +
+                            observation.wantedTimeOffset;
                         var newInitialPeriod = manifest.getPeriodForTime(lastPosition);
                         if (newInitialPeriod == null) {
                             throw new MediaError("MEDIA_TIME_NOT_FOUND", "The wanted position is not found in the Manifest.");
@@ -266,7 +267,7 @@ export default function StreamOrchestrator(content, clock$, abrManager, segmentB
      * coming after it (from the last chronological one to the first).
      *
      * To clean-up PeriodStreams, each one of them are also automatically
-     * destroyed once the clock announces a time superior or equal to the end of
+     * destroyed once the current position is superior or equal to the end of
      * the concerned Period.
      *
      * A "periodStreamReady" event is sent each times a new PeriodStream is
@@ -282,14 +283,14 @@ export default function StreamOrchestrator(content, clock$, abrManager, segmentB
      * @returns {Observable}
      */
     function manageConsecutivePeriodStreams(bufferType, basePeriod, destroy$) {
-        log.info("SO: Creating new Stream for", bufferType, basePeriod);
+        log.info("SO: Creating new Stream for", bufferType, basePeriod.start);
         // Emits the Period of the next Period Stream when it can be created.
         var createNextPeriodStream$ = new Subject();
         // Emits when the Streams for the next Periods should be destroyed, if
         // created.
         var destroyNextStreams$ = new Subject();
         // Emits when the current position goes over the end of the current Stream.
-        var endOfCurrentStream$ = clock$
+        var endOfCurrentStream$ = playbackObserver.observe(true)
             .pipe(filter(function (_a) {
             var position = _a.position, wantedTimeOffset = _a.wantedTimeOffset;
             return basePeriod.end != null &&
@@ -314,7 +315,7 @@ export default function StreamOrchestrator(content, clock$, abrManager, segmentB
         );
         // Will emit when the current Stream should be destroyed.
         var killCurrentStream$ = observableMerge(endOfCurrentStream$, destroyAll$);
-        var periodStream$ = PeriodStream({ abrManager: abrManager, bufferType: bufferType, clock$: clock$, content: { manifest: manifest, period: basePeriod }, garbageCollectors: garbageCollectors, segmentFetcherCreator: segmentFetcherCreator, segmentBuffersStore: segmentBuffersStore, options: options, wantedBufferAhead$: wantedBufferAhead$ }).pipe(mergeMap(function (evt) {
+        var periodStream$ = PeriodStream({ abrManager: abrManager, bufferType: bufferType, content: { manifest: manifest, period: basePeriod }, garbageCollectors: garbageCollectors, segmentFetcherCreator: segmentFetcherCreator, segmentBuffersStore: segmentBuffersStore, options: options, playbackObserver: playbackObserver, wantedBufferAhead: wantedBufferAhead }).pipe(mergeMap(function (evt) {
             if (evt.type === "stream-status") {
                 if (evt.value.hasFinishedLoading) {
                     var nextPeriod = manifest.getPeriodAfter(basePeriod);
@@ -334,7 +335,7 @@ export default function StreamOrchestrator(content, clock$, abrManager, segmentB
         // Stream for the current Period.
         var currentStream$ = observableConcat(periodStream$.pipe(takeUntil(killCurrentStream$)), observableOf(EVENTS.periodStreamCleared(bufferType, basePeriod))
             .pipe(tap(function () {
-            log.info("SO: Destroying Stream for", bufferType, basePeriod);
+            log.info("SO: Destroying Stream for", bufferType, basePeriod.start);
         })));
         return observableMerge(currentStream$, nextPeriodStream$, destroyAll$.pipe(ignoreElements()));
     }

package/dist/_esm5.processed/core/stream/period/create_empty_adaptation_stream.d.ts

@@ -15,6 +15,8 @@
  */
 import { Observable } from "rxjs";
 import { Period } from "../../../manifest";
+import { IReadOnlySharedReference } from "../../../utils/reference";
+import { IReadOnlyPlaybackObserver } from "../../api";
 import { IBufferType } from "../../segment_buffers";
 import { IStreamStatusEvent } from "../types";
 /**
@@ -22,14 +24,14 @@ import { IStreamStatusEvent } from "../types";
  *
  * This observable will never download any segment and just emit a "full"
  * event when reaching the end.
- * @param {Observable} streamClock$
- * @param {Observable} wantedBufferAhead$
+ * @param {Observable} playbackObserver
+ * @param {Object} wantedBufferAhead
  * @param {string} bufferType
  * @param {Object} content
  * @returns {Observable}
  */
-export default function createEmptyAdaptationStream(streamClock$: Observable<{
+export default function createEmptyAdaptationStream(playbackObserver: IReadOnlyPlaybackObserver<{
     position: number;
-}>, wantedBufferAhead$: Observable<number>, bufferType: IBufferType, content: {
+}>, wantedBufferAhead: IReadOnlySharedReference<number>, bufferType: IBufferType, content: {
     period: Period;
 }): Observable<IStreamStatusEvent>;

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

@@ -13,32 +13,33 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { combineLatest as observableCombineLatest, of as observableOf, } from "rxjs";
-import { mergeMap } from "rxjs/operators";
+import { combineLatest as observableCombineLatest, mergeMap, of as observableOf, } from "rxjs";
 import log from "../../../log";
 /**
  * Create empty AdaptationStream Observable, linked to a Period.
  *
  * This observable will never download any segment and just emit a "full"
  * event when reaching the end.
- * @param {Observable} streamClock$
- * @param {Observable} wantedBufferAhead$
+ * @param {Observable} playbackObserver
+ * @param {Object} wantedBufferAhead
  * @param {string} bufferType
  * @param {Object} content
  * @returns {Observable}
  */
-export default function createEmptyAdaptationStream(streamClock$, wantedBufferAhead$, bufferType, content) {
+export default function createEmptyAdaptationStream(playbackObserver, wantedBufferAhead, bufferType, content) {
     var period = content.period;
     var hasFinishedLoading = false;
-    return observableCombineLatest([streamClock$, wantedBufferAhead$]).pipe(mergeMap(function (_a) {
-        var clockTick = _a[0], wantedBufferAhead = _a[1];
-        var position = clockTick.position;
-        if (period.end !== undefined && position + wantedBufferAhead >= period.end) {
+    var wantedBufferAhead$ = wantedBufferAhead.asObservable();
+    var observation$ = playbackObserver.observe(true);
+    return observableCombineLatest([observation$, wantedBufferAhead$]).pipe(mergeMap(function (_a) {
+        var observation = _a[0], wba = _a[1];
+        var position = observation.position;
+        if (period.end !== undefined && position + wba >= period.end) {
             log.debug("Stream: full \"empty\" AdaptationStream", bufferType);
             hasFinishedLoading = true;
         }
         return observableOf({ type: "stream-status",
-            value: { period: period, bufferType: bufferType, position: clockTick.position,
+            value: { period: period, bufferType: bufferType, position: observation.position,
                 imminentDiscontinuity: null, hasFinishedLoading: hasFinishedLoading, neededSegments: [],
                 shouldRefreshManifest: false } });
     }));

package/dist/_esm5.processed/core/stream/period/index.d.ts

@@ -13,6 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import PeriodStream, { IPeriodStreamArguments, IPeriodStreamClockTick, IPeriodStreamOptions } from "./period_stream";
+import PeriodStream, { IPeriodStreamArguments, IPeriodStreamOptions, IPeriodStreamPlaybackObservation } from "./period_stream";
 export default PeriodStream;
-export { IPeriodStreamArguments, IPeriodStreamClockTick, IPeriodStreamOptions, };
+export { IPeriodStreamArguments, IPeriodStreamOptions, IPeriodStreamPlaybackObservation, };

package/dist/_esm5.processed/core/stream/period/period_stream.d.ts

@@ -13,28 +13,43 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { BehaviorSubject, Observable } from "rxjs";
+import { Observable } from "rxjs";
 import Manifest, { Period } from "../../../manifest";
+import { IReadOnlySharedReference } from "../../../utils/reference";
 import WeakMapMemory from "../../../utils/weak_map_memory";
 import ABRManager from "../../abr";
+import { IReadOnlyPlaybackObserver } from "../../api";
 import { SegmentFetcherCreator } from "../../fetchers";
 import SegmentBuffersStore, { IBufferType, ITextTrackSegmentBufferOptions, SegmentBuffer } from "../../segment_buffers";
 import { IAdaptationStreamOptions } from "../adaptation";
 import { IPeriodStreamEvent } from "../types";
-export interface IPeriodStreamClockTick {
+/** Playback observation required by the `PeriodStream`. */
+export interface IPeriodStreamPlaybackObservation {
+    /** The position we are in the video in seconds at the time of the observation. */
     position: number;
-    getCurrentTime: () => number;
+    /** `duration` property of the HTMLMediaElement. */
     duration: number;
+    /** If `true`, the player is currently paused. */
     isPaused: boolean;
-    liveGap?: number;
+    /** `readyState` property of the HTMLMediaElement. */
     readyState: number;
+    /** Target playback rate at which we want to play the content. */
     speed: number;
+    /**
+     * Offset, in seconds to add to `position` to obtain the starting position at
+     * which we actually want to download segments for.
+     */
     wantedTimeOffset: number;
+    /**
+     * Only set for live contents.
+     * Difference between the live edge and the current position, in seconds.
+     */
+    liveGap: number | undefined;
 }
+/** Arguments required by the `PeriodStream`. */
 export interface IPeriodStreamArguments {
     abrManager: ABRManager;
     bufferType: IBufferType;
-    clock$: Observable<IPeriodStreamClockTick>;
     content: {
         manifest: Manifest;
         period: Period;
@@ -42,8 +57,9 @@ export interface IPeriodStreamArguments {
     garbageCollectors: WeakMapMemory<SegmentBuffer, Observable<never>>;
     segmentFetcherCreator: SegmentFetcherCreator;
     segmentBuffersStore: SegmentBuffersStore;
+    playbackObserver: IReadOnlyPlaybackObserver<IPeriodStreamPlaybackObservation>;
     options: IPeriodStreamOptions;
-    wantedBufferAhead$: BehaviorSubject<number>;
+    wantedBufferAhead: IReadOnlySharedReference<number>;
 }
 /** Options tweaking the behavior of the PeriodStream. */
 export declare type IPeriodStreamOptions = IAdaptationStreamOptions & {
@@ -73,4 +89,4 @@ export declare type IPeriodStreamOptions = IAdaptationStreamOptions & {
  * @param {Object} args
  * @returns {Observable}
  */
-export default function PeriodStream({ abrManager, bufferType, clock$, content, garbageCollectors, segmentFetcherCreator, segmentBuffersStore, options, wantedBufferAhead$, }: IPeriodStreamArguments): Observable<IPeriodStreamEvent>;
+export default function PeriodStream({ abrManager, bufferType, content, garbageCollectors, playbackObserver, segmentFetcherCreator, segmentBuffersStore, options, wantedBufferAhead, }: IPeriodStreamArguments): Observable<IPeriodStreamEvent>;

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

@@ -13,8 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { concat as observableConcat, EMPTY, merge as observableMerge, of as observableOf, ReplaySubject, } from "rxjs";
-import { catchError, ignoreElements, map, mapTo, mergeMap, startWith, switchMap, take, } from "rxjs/operators";
+import { catchError, concat as observableConcat, defer as observableDefer, EMPTY, ignoreElements, map, merge as observableMerge, mergeMap, of as observableOf, ReplaySubject, startWith, switchMap, } from "rxjs";
 import config from "../../../config";
 import { formatError } from "../../../errors";
 import log from "../../../log";
@@ -38,7 +37,7 @@ var DELTA_POSITION_AFTER_RELOAD = config.DELTA_POSITION_AFTER_RELOAD;
  * @returns {Observable}
  */
 export default function PeriodStream(_a) {
-    var abrManager = _a.abrManager, bufferType = _a.bufferType, clock$ = _a.clock$, content = _a.content, garbageCollectors = _a.garbageCollectors, segmentFetcherCreator = _a.segmentFetcherCreator, segmentBuffersStore = _a.segmentBuffersStore, options = _a.options, wantedBufferAhead$ = _a.wantedBufferAhead$;
+    var abrManager = _a.abrManager, bufferType = _a.bufferType, content = _a.content, garbageCollectors = _a.garbageCollectors, playbackObserver = _a.playbackObserver, segmentFetcherCreator = _a.segmentFetcherCreator, segmentBuffersStore = _a.segmentBuffersStore, options = _a.options, wantedBufferAhead = _a.wantedBufferAhead;
     var period = content.period;
     // Emits the chosen Adaptation for the current type.
     // `null` when no Adaptation is chosen (e.g. no subtitles)
@@ -56,13 +55,13 @@ export default function PeriodStream(_a) {
                 bufferType === "video" ? DELTA_POSITION_AFTER_RELOAD.trackSwitch.video :
                     DELTA_POSITION_AFTER_RELOAD.trackSwitch.other;
         if (adaptation === null) { // Current type is disabled for that Period
-            log.info("Stream: Set no " + bufferType + " Adaptation", period);
+            log.info("Stream: Set no ".concat(bufferType, " Adaptation. P:"), period.start);
             var segmentBufferStatus = segmentBuffersStore.getStatus(bufferType);
             var cleanBuffer$ = void 0;
             if (segmentBufferStatus.type === "initialized") {
-                log.info("Stream: Clearing previous " + bufferType + " SegmentBuffer");
+                log.info("Stream: Clearing previous ".concat(bufferType, " SegmentBuffer"));
                 if (SegmentBuffersStore.isNative(bufferType)) {
-                    return reloadAfterSwitch(period, bufferType, clock$, 0);
+                    return reloadAfterSwitch(period, bufferType, playbackObserver, 0);
                 }
                 cleanBuffer$ = segmentBufferStatus.value
                     .removeBuffer(period.start, period.end == null ? Infinity :
@@ -74,20 +73,20 @@ export default function PeriodStream(_a) {
                 }
                 cleanBuffer$ = observableOf(null);
             }
-            return observableConcat(cleanBuffer$.pipe(mapTo(EVENTS.adaptationChange(bufferType, null, period))), createEmptyStream(clock$, wantedBufferAhead$, bufferType, { period: period }));
+            return observableConcat(cleanBuffer$.pipe(map(function () { return EVENTS.adaptationChange(bufferType, null, period); })), createEmptyStream(playbackObserver, wantedBufferAhead, bufferType, { period: period }));
         }
         if (SegmentBuffersStore.isNative(bufferType) &&
             segmentBuffersStore.getStatus(bufferType).type === "disabled") {
-            return reloadAfterSwitch(period, bufferType, clock$, relativePosAfterSwitch);
+            return reloadAfterSwitch(period, bufferType, playbackObserver, relativePosAfterSwitch);
         }
-        log.info("Stream: Updating " + bufferType + " adaptation", adaptation, period);
-        var newStream$ = clock$.pipe(take(1), mergeMap(function (tick) {
+        log.info("Stream: Updating ".concat(bufferType, " adaptation"), "A: ".concat(adaptation.id), "P: ".concat(period.start));
+        var newStream$ = observableDefer(function () {
+            var readyState = playbackObserver.getReadyState();
             var segmentBuffer = createOrReuseSegmentBuffer(segmentBuffersStore, bufferType, adaptation, options);
-            var playbackInfos = { currentTime: tick.getCurrentTime(),
-                readyState: tick.readyState };
+            var playbackInfos = { currentTime: playbackObserver.getCurrentTime(), readyState: readyState };
             var strategy = getAdaptationSwitchStrategy(segmentBuffer, period, adaptation, playbackInfos, options);
             if (strategy.type === "needs-reload") {
-                return reloadAfterSwitch(period, bufferType, clock$, relativePosAfterSwitch);
+                return reloadAfterSwitch(period, bufferType, playbackObserver, relativePosAfterSwitch);
             }
             var needsBufferFlush$ = strategy.type === "flush-buffer"
                 ? observableOf(EVENTS.needsBufferFlush())
@@ -96,13 +95,19 @@ export default function PeriodStream(_a) {
                 observableConcat.apply(void 0, strategy.value.map(function (_a) {
                     var start = _a.start, end = _a.end;
                     return segmentBuffer.removeBuffer(start, end);
-                })).pipe(ignoreElements()) : EMPTY;
+                })
+                // NOTE As of now (RxJS 7.4.0), RxJS defines `ignoreElements` default
+                // first type parameter as `any` instead of the perfectly fine `unknown`,
+                // leading to linter issues, as it forbids the usage of `any`.
+                // This is why we're disabling the eslint rule.
+                /* eslint-disable-next-line @typescript-eslint/no-unsafe-argument */
+                ).pipe(ignoreElements()) : EMPTY;
             var bufferGarbageCollector$ = garbageCollectors.get(segmentBuffer);
             var adaptationStream$ = createAdaptationStream(adaptation, segmentBuffer);
             return segmentBuffersStore.waitForUsableBuffers().pipe(mergeMap(function () {
                 return observableConcat(cleanBuffer$, needsBufferFlush$, observableMerge(adaptationStream$, bufferGarbageCollector$));
             }));
-        }));
+        });
         return observableConcat(observableOf(EVENTS.adaptationChange(bufferType, adaptation, period)), newStream$);
     }), startWith(EVENTS.periodStreamReady(bufferType, period, adaptation$)));
     /**
@@ -112,25 +117,21 @@ export default function PeriodStream(_a) {
      */
     function createAdaptationStream(adaptation, segmentBuffer) {
         var manifest = content.manifest;
-        var adaptationStreamClock$ = clock$.pipe(map(function (tick) {
-            var buffered = segmentBuffer.getBufferedRanges();
-            return objectAssign({}, tick, { bufferGap: getLeftSizeOfRange(buffered, tick.position) });
-        }));
-        return AdaptationStream({ abrManager: abrManager, clock$: adaptationStreamClock$,
-            content: { manifest: manifest, period: period, adaptation: adaptation }, options: options, segmentBuffer: segmentBuffer, segmentFetcherCreator: segmentFetcherCreator, wantedBufferAhead$: wantedBufferAhead$ }).pipe(catchError(function (error) {
+        var adaptationPlaybackObserver = createAdaptationStreamPlaybackObserver(playbackObserver, segmentBuffer);
+        return AdaptationStream({ abrManager: abrManager, content: { manifest: manifest, period: period, adaptation: adaptation }, options: options, playbackObserver: adaptationPlaybackObserver, segmentBuffer: segmentBuffer, segmentFetcherCreator: segmentFetcherCreator, wantedBufferAhead: wantedBufferAhead }).pipe(catchError(function (error) {
             // Stream linked to a non-native media buffer should not impact the
             // stability of the player. ie: if a text buffer sends an error, we want
             // to continue playing without any subtitles
             if (!SegmentBuffersStore.isNative(bufferType)) {
-                log.error("Stream: " + bufferType + " Stream crashed. Aborting it.", error);
+                log.error("Stream: ".concat(bufferType, " Stream crashed. Aborting it."), error);
                 segmentBuffersStore.disposeSegmentBuffer(bufferType);
                 var formattedError = formatError(error, {
                     defaultCode: "NONE",
                     defaultReason: "Unknown `AdaptationStream` error",
                 });
-                return observableConcat(observableOf(EVENTS.warning(formattedError)), createEmptyStream(clock$, wantedBufferAhead$, bufferType, { period: period }));
+                return observableConcat(observableOf(EVENTS.warning(formattedError)), createEmptyStream(playbackObserver, wantedBufferAhead, bufferType, { period: period }));
             }
-            log.error("Stream: " + bufferType + " Stream crashed. Stopping playback.", error);
+            log.error("Stream: ".concat(bufferType, " Stream crashed. Stopping playback."), error);
             throw error;
         }));
     }
@@ -165,3 +166,16 @@ function getFirstDeclaredMimeType(adaptation) {
     }
     return representations[0].getMimeTypeString();
 }
+/**
+ * Create AdaptationStream's version of a playback observer.
+ * @param {Object} initialPlaybackObserver
+ * @param {Object} segmentBuffer
+ * @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) });
+    }
+}

package/dist/_esm5.processed/core/stream/reload_after_switch.d.ts

@@ -15,10 +15,12 @@
  */
 import { Observable } from "rxjs";
 import { Period } from "../../manifest";
+import { IReadOnlyPlaybackObserver } from "../api";
 import { IBufferType } from "../segment_buffers";
 import { IWaitingMediaSourceReloadInternalEvent } from "./types";
 /**
- * Regularly ask to reload the MediaSource on each `clock$` tick.
+ * Regularly ask to reload the MediaSource on each playback observation
+ * performed by the playback observer.
  *
  * If and only if the Period currently played corresponds to `Period`, applies
  * an offset to the reloaded position corresponding to `deltaPos`.
@@ -28,7 +30,7 @@ import { IWaitingMediaSourceReloadInternalEvent } from "./types";
  *
  * @param {Object} period - The Period linked to the Adaptation or
  * Representation that you want to switch to.
- * @param {Observable} clock$ - Observable emitting playback conditions.
+ * @param {Observable} playbackObserver - emit playback conditions.
  * Has to emit last playback conditions immediately on subscribe.
  * @param {number} deltaPos - If the concerned Period is playing at the time
  * this function is called, we will add this value, in seconds, to the current
@@ -37,8 +39,7 @@ import { IWaitingMediaSourceReloadInternalEvent } from "./types";
  * a switch.
  * @returns {Observable}
  */
-export default function reloadAfterSwitch(period: Period, bufferType: IBufferType, clock$: Observable<{
-    getCurrentTime: () => number;
+export default function reloadAfterSwitch(period: Period, bufferType: IBufferType, playbackObserver: IReadOnlyPlaybackObserver<{
     position: number;
     isPaused: boolean;
 }>, deltaPos: number): Observable<IWaitingMediaSourceReloadInternalEvent>;