rx-player 3.25.2 → 3.26.3-dev.2022021400

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<any>, 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

@@ -13,13 +13,16 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var __spreadArray = (this && this.__spreadArray) || function (to, from) {
-    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
-        to[j] = from[i];
-    return to;
+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 { 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";
@@ -51,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
@@ -60,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) {
@@ -75,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()) {
@@ -105,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());
@@ -118,15 +122,15 @@ export default function StreamOrchestrator(content, clock$, abrManager, segmentB
     }), distinctUntilChanged(), map(function (emitEndOfStream) {
         return emitEndOfStream ? EVENTS.endOfStream() : EVENTS.resumeStream();
     }));
-    return observableMerge.apply(void 0, __spreadArray(__spreadArray([], streamsArray), [activePeriodChanged$,
+    return observableMerge.apply(void 0, __spreadArray(__spreadArray([], streamsArray, false), [activePeriodChanged$,
         endOfStream$,
-        outOfManifest$]));
+        outOfManifest$], false));
     /**
      * 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}
@@ -146,17 +150,20 @@ export default function StreamOrchestrator(content, clock$, abrManager, segmentB
          * @returns {Observable}
          */
         function launchConsecutiveStreamsForPeriod(period) {
-            return manageConsecutivePeriodStreams(bufferType, period, destroyStreams$).pipe(filterMap(function (message) {
+            return manageConsecutivePeriodStreams(bufferType, period, destroyStreams$).pipe(map(function (message) {
                 switch (message.type) {
-                    case "needs-media-source-reload":
+                    case "waiting-media-source-reload":
                         // Only reload the MediaSource when the more immediately required
                         // Period is the one asking for it
                         var firstPeriod = periodList.head();
                         if (firstPeriod === undefined ||
                             firstPeriod.id !== message.value.period.id) {
-                            return null;
+                            return EVENTS.lockedStream(message.value.bufferType, message.value.period);
+                        }
+                        else {
+                            var _a = message.value, position = _a.position, autoPlay = _a.autoPlay;
+                            return EVENTS.needsMediaSourceReload(position, autoPlay);
                         }
-                        break;
                     case "periodStreamReady":
                         enableOutOfBoundsCheck = true;
                         periodList.add(message.value.period);
@@ -166,7 +173,7 @@ export default function StreamOrchestrator(content, clock$, abrManager, segmentB
                         break;
                 }
                 return message;
-            }, null), share());
+            }), share());
         }
         /**
          * Returns true if the given time is either:
@@ -187,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;
@@ -234,16 +241,17 @@ 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());
-            })), [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.");
                         }
                         return launchConsecutiveStreamsForPeriod(newInitialPeriod);
                     }));
-                }))]));
+                }))], false));
         }));
         return observableMerge(restartStreamsWhenOutOfBounds$, handleDecipherabilityUpdate$, launchConsecutiveStreamsForPeriod(basePeriod));
     }
@@ -259,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
@@ -275,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 &&
@@ -307,15 +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);
@@ -335,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,37 +13,34 @@
  * 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,
-                imminentDiscontinuity: null,
-                hasFinishedLoading: hasFinishedLoading,
-                neededSegments: [],
+            value: { period: period, bufferType: bufferType, position: observation.position,
+                imminentDiscontinuity: null, hasFinishedLoading: hasFinishedLoading, neededSegments: [],
                 shouldRefreshManifest: false } });
     }));
 }

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

@@ -58,7 +58,7 @@ export interface IAdaptationSwitchOptions {
  * @param {Object} playbackInfo
  * @returns {Object}
  */
-export default function getAdaptationSwitchStrategy(segmentBuffer: SegmentBuffer<unknown>, period: Period, adaptation: Adaptation, playbackInfo: {
+export default function getAdaptationSwitchStrategy(segmentBuffer: SegmentBuffer, period: Period, adaptation: Adaptation, playbackInfo: {
     currentTime: number;
     readyState: number;
 }, options: IAdaptationSwitchOptions): IAdaptationSwitchStrategy;

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,39 +13,53 @@
  * 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 { IStalledStatus } from "../../api";
+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;
-    stalled: IStalledStatus | null;
+    /**
+     * 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;
     };
-    garbageCollectors: WeakMapMemory<SegmentBuffer<unknown>, Observable<never>>;
-    segmentFetcherCreator: SegmentFetcherCreator<any>;
+    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 & {
@@ -75,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";
@@ -23,7 +22,7 @@ import { getLeftSizeOfRange } from "../../../utils/ranges";
 import SegmentBuffersStore from "../../segment_buffers";
 import AdaptationStream from "../adaptation";
 import EVENTS from "../events_generators";
-import reloadAfterSwitch from "../utils";
+import reloadAfterSwitch from "../reload_after_switch";
 import createEmptyStream from "./create_empty_adaptation_stream";
 import getAdaptationSwitchStrategy from "./get_adaptation_switch_strategy";
 var DELTA_POSITION_AFTER_RELOAD = config.DELTA_POSITION_AFTER_RELOAD;
@@ -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, clock$, relativePosAfterSwitch);
+                    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, 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, 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,30 +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;
         }));
     }
@@ -170,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

@@ -0,0 +1,45 @@
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+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 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`.
+ * This can be useful for example when switching the audio/video track, where
+ * you might want to give back some context if that was the currently played
+ * track.
+ *
+ * @param {Object} period - The Period linked to the Adaptation or
+ * Representation that you want to switch to.
+ * @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
+ * position to indicate the position we should reload at.
+ * This value allows to give back context (by replaying some media data) after
+ * a switch.
+ * @returns {Observable}
+ */
+export default function reloadAfterSwitch(period: Period, bufferType: IBufferType, playbackObserver: IReadOnlyPlaybackObserver<{
+    position: number;
+    isPaused: boolean;
+}>, deltaPos: number): Observable<IWaitingMediaSourceReloadInternalEvent>;