rx-player 3.25.2 → 3.26.3-dev.2022021400

package/src/core/stream/period/create_empty_adaptation_stream.ts

@@ -16,12 +16,14 @@
 
 import {
   combineLatest as observableCombineLatest,
+  mergeMap,
   Observable,
   of as observableOf,
 } from "rxjs";
-import { mergeMap } from "rxjs/operators";
 import log from "../../../log";
 import { Period } from "../../../manifest";
+import { IReadOnlySharedReference } from "../../../utils/reference";
+import { IReadOnlyPlaybackObserver } from "../../api";
 import { IBufferType } from "../../segment_buffers";
 import { IStreamStatusEvent } from "../types";
 
@@ -30,31 +32,33 @@ 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<{ position : number }>,
-  wantedBufferAhead$ : Observable<number>,
+  playbackObserver : IReadOnlyPlaybackObserver<{ position : number }>,
+  wantedBufferAhead : IReadOnlySharedReference<number>,
   bufferType : IBufferType,
   content : { period : Period }
 ) : Observable<IStreamStatusEvent> {
   const { period } = content;
   let hasFinishedLoading = false;
-  return observableCombineLatest([streamClock$, wantedBufferAhead$]).pipe(
-    mergeMap(([clockTick, wantedBufferAhead]) => {
-      const { position } = clockTick;
-      if (period.end !== undefined && position + wantedBufferAhead >= period.end) {
+  const wantedBufferAhead$ = wantedBufferAhead.asObservable();
+  const observation$ = playbackObserver.observe(true);
+  return observableCombineLatest([observation$, wantedBufferAhead$]).pipe(
+    mergeMap(([observation, wba]) => {
+      const { position } = observation;
+      if (period.end !== undefined && position + wba >= period.end) {
         log.debug("Stream: full \"empty\" AdaptationStream", bufferType);
         hasFinishedLoading = true;
       }
       return observableOf({ type: "stream-status" as const,
                             value: { period,
                                      bufferType,
-                                     position: clockTick.position,
+                                     position: observation.position,
                                      imminentDiscontinuity: null,
                                      hasFinishedLoading,
                                      neededSegments: [],

package/src/core/stream/period/get_adaptation_switch_strategy.ts

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

package/src/core/stream/period/index.ts

@@ -16,14 +16,14 @@
 
 import PeriodStream, {
   IPeriodStreamArguments,
-  IPeriodStreamClockTick,
   IPeriodStreamOptions,
+  IPeriodStreamPlaybackObservation,
 } from "./period_stream";
 
 export default PeriodStream;
 
 export {
   IPeriodStreamArguments,
-  IPeriodStreamClockTick,
   IPeriodStreamOptions,
+  IPeriodStreamPlaybackObservation,
 };

package/src/core/stream/period/period_stream.ts

@@ -15,24 +15,20 @@
  */
 
 import {
-  BehaviorSubject,
+  catchError,
   concat as observableConcat,
+  defer as observableDefer,
   EMPTY,
+  ignoreElements,
+  map,
   merge as observableMerge,
+  mergeMap,
   Observable,
   of as observableOf,
   ReplaySubject,
-} from "rxjs";
-import {
-  catchError,
-  ignoreElements,
-  map,
-  mapTo,
-  mergeMap,
   startWith,
   switchMap,
-  take,
-} from "rxjs/operators";
+} from "rxjs";
 import config from "../../../config";
 import { formatError } from "../../../errors";
 import log from "../../../log";
@@ -42,9 +38,10 @@ import Manifest, {
 } from "../../../manifest";
 import objectAssign from "../../../utils/object_assign";
 import { getLeftSizeOfRange } from "../../../utils/ranges";
+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,
@@ -52,45 +49,56 @@ import SegmentBuffersStore, {
   SegmentBuffer,
 } from "../../segment_buffers";
 import AdaptationStream, {
-  IAdaptationStreamOptions,
+  IAdaptationStreamOptions, IAdaptationStreamPlaybackObservation,
 } from "../adaptation";
 import EVENTS from "../events_generators";
+import reloadAfterSwitch from "../reload_after_switch";
 import {
   IAdaptationStreamEvent,
   IPeriodStreamEvent,
   IStreamWarningEvent,
 } from "../types";
-import reloadAfterSwitch from "../utils";
 import createEmptyStream from "./create_empty_adaptation_stream";
 import getAdaptationSwitchStrategy from "./get_adaptation_switch_strategy";
 
 const { DELTA_POSITION_AFTER_RELOAD } = config;
 
-export interface IPeriodStreamClockTick {
-  position : number; // the position we are in the video in s at the time of the tic
-  getCurrentTime : () => number; // fetch the current time
-  duration : number; // duration of the HTMLMediaElement
-  isPaused: boolean; // If true, the player is on pause
-  liveGap? : number; // gap between the current position and the edge of a
-                     // live content. Not set for non-live contents
-  readyState : number; // readyState of the HTMLMediaElement
-  speed : number; // playback rate at which the content plays
-  stalled : IStalledStatus|null; // if set, the player is currently stalled
-  wantedTimeOffset : number; // offset in s to add to the time to obtain the
-                             // position we actually want to download from
+/** 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;
+  /** `duration` property of the HTMLMediaElement. */
+  duration : number;
+  /** If `true`, the player is currently paused. */
+  isPaused: boolean;
+  /** `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; };
-  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. */
@@ -128,13 +136,13 @@ export type IPeriodStreamOptions =
 export default function PeriodStream({
   abrManager,
   bufferType,
-  clock$,
   content,
   garbageCollectors,
+  playbackObserver,
   segmentFetcherCreator,
   segmentBuffersStore,
   options,
-  wantedBufferAhead$,
+  wantedBufferAhead,
 } : IPeriodStreamArguments) : Observable<IPeriodStreamEvent> {
   const { period } = content;
 
@@ -160,14 +168,14 @@ export default function PeriodStream({
                                  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 ${bufferType} Adaptation. P:`, period.start);
         const segmentBufferStatus = segmentBuffersStore.getStatus(bufferType);
         let cleanBuffer$ : Observable<unknown>;
 
         if (segmentBufferStatus.type === "initialized") {
           log.info(`Stream: Clearing previous ${bufferType} SegmentBuffer`);
           if (SegmentBuffersStore.isNative(bufferType)) {
-            return reloadAfterSwitch(period, clock$, relativePosAfterSwitch);
+            return reloadAfterSwitch(period, bufferType, playbackObserver, 0);
           }
           cleanBuffer$ = segmentBufferStatus.value
             .removeBuffer(period.start,
@@ -181,57 +189,69 @@ export default function PeriodStream({
         }
 
         return observableConcat(
-          cleanBuffer$.pipe(mapTo(EVENTS.adaptationChange(bufferType, null, period))),
-          createEmptyStream(clock$, wantedBufferAhead$, bufferType, { period })
+          cleanBuffer$.pipe(map(() => EVENTS.adaptationChange(bufferType, null, period))),
+          createEmptyStream(playbackObserver, wantedBufferAhead, bufferType, { 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);
+      log.info(`Stream: Updating ${bufferType} adaptation`,
+               `A: ${adaptation.id}`,
+               `P: ${period.start}`);
 
-      const newStream$ = clock$.pipe(
-        take(1),
-        mergeMap((tick) => {
-          const segmentBuffer = createOrReuseSegmentBuffer(segmentBuffersStore,
-                                                           bufferType,
-                                                           adaptation,
-                                                           options);
-          const playbackInfos = { currentTime: tick.getCurrentTime(),
-                                  readyState: tick.readyState };
-          const strategy = getAdaptationSwitchStrategy(segmentBuffer,
-                                                       period,
-                                                       adaptation,
-                                                       playbackInfos,
-                                                       options);
-          if (strategy.type === "needs-reload") {
-            return reloadAfterSwitch(period, clock$, relativePosAfterSwitch);
-          }
+      const newStream$ = observableDefer(() => {
+        const readyState = playbackObserver.getReadyState();
+        const segmentBuffer = createOrReuseSegmentBuffer(segmentBuffersStore,
+                                                         bufferType,
+                                                         adaptation,
+                                                         options);
+        const playbackInfos = { currentTime: playbackObserver.getCurrentTime(),
+                                readyState };
+        const strategy = getAdaptationSwitchStrategy(segmentBuffer,
+                                                     period,
+                                                     adaptation,
+                                                     playbackInfos,
+                                                     options);
+        if (strategy.type === "needs-reload") {
+          return reloadAfterSwitch(period,
+                                   bufferType,
+                                   playbackObserver,
+                                   relativePosAfterSwitch);
+        }
 
-          const needsBufferFlush$ = strategy.type === "flush-buffer"
-            ? observableOf(EVENTS.needsBufferFlush())
-            : EMPTY;
+        const needsBufferFlush$ = strategy.type === "flush-buffer"
+          ? observableOf(EVENTS.needsBufferFlush())
+          : EMPTY;
 
-          const cleanBuffer$ =
-            strategy.type === "clean-buffer" || strategy.type === "flush-buffer" ?
-              observableConcat(...strategy.value.map(({ start, end }) =>
-                segmentBuffer.removeBuffer(start, end))
-              ).pipe(ignoreElements()) : EMPTY;
+        const cleanBuffer$ =
+          strategy.type === "clean-buffer" || strategy.type === "flush-buffer" ?
+            observableConcat(...strategy.value.map(({ start, end }) =>
+              segmentBuffer.removeBuffer(start, end))
+            // 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;
 
-          const bufferGarbageCollector$ = garbageCollectors.get(segmentBuffer);
-          const adaptationStream$ = createAdaptationStream(adaptation, segmentBuffer);
+        const bufferGarbageCollector$ = garbageCollectors.get(segmentBuffer);
+        const adaptationStream$ = createAdaptationStream(adaptation, segmentBuffer);
 
-          return segmentBuffersStore.waitForUsableBuffers().pipe(mergeMap(() => {
-            return observableConcat(cleanBuffer$,
-                                    needsBufferFlush$,
-                                    observableMerge(adaptationStream$,
-                                                    bufferGarbageCollector$));
-          }));
+        return segmentBuffersStore.waitForUsableBuffers().pipe(mergeMap(() => {
+          return observableConcat(cleanBuffer$,
+                                  needsBufferFlush$,
+                                  observableMerge(adaptationStream$,
+                                                  bufferGarbageCollector$));
         }));
+      });
 
       return observableConcat(
         observableOf(EVENTS.adaptationChange(bufferType, adaptation, period)),
@@ -246,25 +266,20 @@ export default function PeriodStream({
    * @param {Object} segmentBuffer
    * @returns {Observable}
    */
-  function createAdaptationStream<T>(
+  function createAdaptationStream(
     adaptation : Adaptation,
-    segmentBuffer : SegmentBuffer<T>
-  ) : Observable<IAdaptationStreamEvent<T>|IStreamWarningEvent> {
+    segmentBuffer : SegmentBuffer
+  ) : Observable<IAdaptationStreamEvent|IStreamWarningEvent> {
     const { manifest } = content;
-    const adaptationStreamClock$ = clock$.pipe(map(tick => {
-      const buffered = segmentBuffer.getBufferedRanges();
-      return objectAssign({},
-                          tick,
-                          { bufferGap: getLeftSizeOfRange(buffered,
-                                                          tick.position) });
-    }));
+    const adaptationPlaybackObserver =
+      createAdaptationStreamPlaybackObserver(playbackObserver, segmentBuffer);
     return AdaptationStream({ abrManager,
-                              clock$: adaptationStreamClock$,
                               content: { manifest, period, adaptation },
                               options,
+                              playbackObserver: adaptationPlaybackObserver,
                               segmentBuffer,
                               segmentFetcherCreator,
-                              wantedBufferAhead$ }).pipe(
+                              wantedBufferAhead }).pipe(
       catchError((error : unknown) => {
         // 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
@@ -279,7 +294,7 @@ export default function PeriodStream({
           });
           return observableConcat(
             observableOf(EVENTS.warning(formattedError)),
-            createEmptyStream(clock$, wantedBufferAhead$, bufferType, { period })
+            createEmptyStream(playbackObserver, wantedBufferAhead, bufferType, { period })
           );
         }
         log.error(`Stream: ${bufferType} Stream crashed. Stopping playback.`, error);
@@ -293,12 +308,12 @@ export default function PeriodStream({
  * @param {Object} adaptation
  * @returns {Object}
  */
-function createOrReuseSegmentBuffer<T>(
+function createOrReuseSegmentBuffer(
   segmentBuffersStore : SegmentBuffersStore,
   bufferType : IBufferType,
   adaptation : Adaptation,
   options: { textTrackOptions? : ITextTrackSegmentBufferOptions }
-) : SegmentBuffer<T> {
+) : SegmentBuffer {
   const segmentBufferStatus = segmentBuffersStore.getStatus(bufferType);
   if (segmentBufferStatus.type === "initialized") {
     log.info("Stream: Reusing a previous SegmentBuffer for the type", bufferType);
@@ -324,3 +339,29 @@ function getFirstDeclaredMimeType(adaptation : Adaptation) : string {
   }
   return representations[0].getMimeTypeString();
 }
+
+/**
+ * Create AdaptationStream's version of a playback observer.
+ * @param {Object} initialPlaybackObserver
+ * @param {Object} segmentBuffer
+ * @returns {Object}
+ */
+function createAdaptationStreamPlaybackObserver(
+  initialPlaybackObserver : IReadOnlyPlaybackObserver<IPeriodStreamPlaybackObservation>,
+  segmentBuffer : SegmentBuffer
+) : IReadOnlyPlaybackObserver<IAdaptationStreamPlaybackObservation> {
+  return initialPlaybackObserver.deriveReadOnlyObserver(
+    (observation$) => observation$.pipe(map(mapObservation)),
+    mapObservation
+  );
+
+  function mapObservation(
+    baseObservation : IPeriodStreamPlaybackObservation
+  ) : IAdaptationStreamPlaybackObservation {
+    const buffered = segmentBuffer.getBufferedRanges();
+    return objectAssign({},
+                        baseObservation,
+                        { bufferGap: getLeftSizeOfRange(buffered,
+                                                        baseObservation.position) });
+  }
+}

package/src/core/stream/reload_after_switch.ts

@@ -0,0 +1,70 @@
+/**
+ * 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 {
+  map,
+  Observable,
+} from "rxjs";
+import { Period } from "../../manifest";
+import { IReadOnlyPlaybackObserver } from "../api";
+import { IBufferType } from "../segment_buffers";
+import EVENTS from "./events_generators";
+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> {
+  return playbackObserver.observe(true).pipe(
+    map((observation) => {
+      const currentTime = playbackObserver.getCurrentTime();
+      const pos = currentTime + deltaPos;
+
+      // Bind to Period start and end
+      const reloadAt = Math.min(Math.max(period.start, pos),
+                                period.end ?? Infinity);
+      return EVENTS.waitingMediaSourceReload(bufferType,
+                                             period,
+                                             reloadAt,
+                                             !observation.isPaused);
+    }));
+}

package/src/core/stream/representation/append_segment_to_buffer.ts

@@ -19,14 +19,14 @@
  */
 
 import {
+  catchError,
   concat as observableConcat,
+  mergeMap,
+  ignoreElements,
   Observable,
 } from "rxjs";
-import {
-  catchError,
-  ignoreElements,
-} from "rxjs/operators";
 import { MediaError } from "../../../errors";
+import { IReadOnlyPlaybackObserver } from "../../api";
 import {
   IPushChunkInfos,
   SegmentBuffer,
@@ -38,14 +38,15 @@ import forceGarbageCollection from "./force_garbage_collection";
  * If it leads to a QuotaExceededError, try to run our custom range
  * _garbage collector_ then retry.
  *
- * @param {Observable} clock$
+ * @param {Observable} playbackObserver
  * @param {Object} segmentBuffer
  * @param {Object} dataInfos
  * @returns {Observable}
  */
 export default function appendSegmentToBuffer<T>(
-  clock$ : Observable<{ position : number }>,
-  segmentBuffer : SegmentBuffer<T>,
+  playbackObserver : IReadOnlyPlaybackObserver<{ position : number;
+                                                 wantedTimeOffset: number; }>,
+  segmentBuffer : SegmentBuffer,
   dataInfos : IPushChunkInfos<T>
 ) : Observable<unknown> {
   const append$ = segmentBuffer.pushChunk(dataInfos);
@@ -59,16 +60,19 @@ export default function appendSegmentToBuffer<T>(
         throw new MediaError("BUFFER_APPEND_ERROR", reason);
       }
 
-      return observableConcat(
-        forceGarbageCollection(clock$, segmentBuffer).pipe(ignoreElements()),
-        append$
-      ).pipe(
-        catchError((forcedGCError : unknown) => {
-          const reason = forcedGCError instanceof Error ? forcedGCError.toString() :
-                                                          "Could not clean the buffer";
+      return playbackObserver.observe(true).pipe(mergeMap((observation) => {
+        const currentPos = observation.position + observation.wantedTimeOffset;
+        return observableConcat(
+          forceGarbageCollection(currentPos, segmentBuffer).pipe(ignoreElements()),
+          append$
+        ).pipe(
+          catchError((forcedGCError : unknown) => {
+            const reason = forcedGCError instanceof Error ? forcedGCError.toString() :
+                                                            "Could not clean the buffer";
 
-          throw new MediaError("BUFFER_FULL_ERROR", reason);
-        })
-      );
+            throw new MediaError("BUFFER_FULL_ERROR", reason);
+          })
+        );
+      }));
     }));
 }