rx-player 3.26.1 → 3.26.2

package/src/core/stream/reload_after_switch.ts

@@ -14,15 +14,19 @@
  * limitations under the License.
  */
 
-import { Observable } from "rxjs";
-import { map } from "rxjs/operators";
+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 `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`.
@@ -32,7 +36,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
@@ -44,16 +48,15 @@ import { IWaitingMediaSourceReloadInternalEvent } from "./types";
 export default function reloadAfterSwitch(
   period : Period,
   bufferType : IBufferType,
-  clock$ : Observable<{
-    getCurrentTime : () => number;
+  playbackObserver : IReadOnlyPlaybackObserver<{
     position : number;
     isPaused : boolean;
   }>,
   deltaPos : number
 ) : Observable<IWaitingMediaSourceReloadInternalEvent> {
-  return clock$.pipe(
-    map((tick) => {
-      const currentTime = tick.getCurrentTime();
+  return playbackObserver.observe(true).pipe(
+    map((observation) => {
+      const currentTime = playbackObserver.getCurrentTime();
       const pos = currentTime + deltaPos;
 
       // Bind to Period start and end
@@ -62,6 +65,6 @@ export default function reloadAfterSwitch(
       return EVENTS.waitingMediaSourceReload(bufferType,
                                              period,
                                              reloadAt,
-                                             !tick.isPaused);
+                                             !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,13 +38,14 @@ 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 }>,
+  playbackObserver : IReadOnlyPlaybackObserver<{ position : number;
+                                                 wantedTimeOffset: number; }>,
   segmentBuffer : SegmentBuffer,
   dataInfos : IPushChunkInfos<T>
 ) : Observable<unknown> {
@@ -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);
+          })
+        );
+      }));
     }));
 }

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

@@ -15,24 +15,21 @@
  */
 
 import {
-  BehaviorSubject,
   concat as observableConcat,
   defer as observableDefer,
-  Observable,
-  of as observableOf,
-  merge as observableMerge,
   EMPTY,
-  ReplaySubject,
-} from "rxjs";
-import {
   filter,
   finalize,
   map,
+  merge as observableMerge,
   mergeMap,
+  Observable,
+  of as observableOf,
+  ReplaySubject,
   share,
   switchMap,
   take,
-} from "rxjs/operators";
+} from "rxjs";
 import { ICustomError } from "../../../errors";
 import log from "../../../log";
 import Manifest, {
@@ -42,12 +39,13 @@ import Manifest, {
   Representation,
 } from "../../../manifest";
 import {
-  ISegmentParserParsedInitSegment,
-  ISegmentParserParsedSegment,
+  ISegmentParserParsedInitChunk,
+  ISegmentParserParsedMediaChunk,
 } from "../../../transports";
 import assert from "../../../utils/assert";
 import assertUnreachable from "../../../utils/assert_unreachable";
 import objectAssign from "../../../utils/object_assign";
+import { IReadOnlySharedReference } from "../../../utils/reference";
 import {
   IPrioritizedSegmentFetcher,
   IPrioritizedSegmentFetcherEvent,
@@ -75,7 +73,7 @@ export default class DownloadingQueue<T> {
    * Segments whose request are still pending are still in that queue. Segments
    * are only removed from it once their request has succeeded.
    */
-  private _downloadQueue$ : BehaviorSubject<IDownloadQueueItem>;
+  private _downloadQueue : IReadOnlySharedReference<IDownloadQueueItem>;
   /**
    * Pending request for the initialization segment.
    * `null` if no request is pending for it.
@@ -103,8 +101,7 @@ export default class DownloadingQueue<T> {
    *
    * @param {Object} content - The context of the Representation you want to
    * load segments for.
-   * @param {BehaviorSubject} downloadQueue$ - Emit the queue of segments you
-   * want to load.
+   * @param {Object} downloadQueue - Queue of segments you want to load.
    * @param {Object} segmentFetcher - Interface to facilitate the download of
    * segments.
    * @param {boolean} hasInitSegment - Declare that an initialization segment
@@ -122,13 +119,13 @@ export default class DownloadingQueue<T> {
    */
   constructor(
     content: IDownloadingQueueContext,
-    downloadQueue$ : BehaviorSubject<IDownloadQueueItem>,
+    downloadQueue : IReadOnlySharedReference<IDownloadQueueItem>,
     segmentFetcher : IPrioritizedSegmentFetcher<T>,
     hasInitSegment : boolean
   ) {
     this._content = content;
     this._currentObs$ = null;
-    this._downloadQueue$ = downloadQueue$;
+    this._downloadQueue = downloadQueue;
     this._initSegmentRequest = null;
     this._mediaSegmentRequest = null;
     this._segmentFetcher = segmentFetcher;
@@ -171,7 +168,7 @@ export default class DownloadingQueue<T> {
       return this._currentObs$;
     }
     const obs = observableDefer(() => {
-      const mediaQueue$ = this._downloadQueue$.pipe(
+      const mediaQueue$ = this._downloadQueue.asObservable().pipe(
         filter(({ segmentQueue }) => {
           // First, the first elements of the segmentQueue might be already
           // loaded but awaiting the initialization segment to be parsed.
@@ -204,7 +201,7 @@ export default class DownloadingQueue<T> {
           segmentQueue.length > 0 ? this._requestMediaSegments() :
                                     EMPTY));
 
-      const initSegmentPush$ = this._downloadQueue$.pipe(
+      const initSegmentPush$ = this._downloadQueue.asObservable().pipe(
         filter((next) => {
           const initSegmentRequest = this._initSegmentRequest;
           if (next.initSegment !== null && initSegmentRequest !== null) {
@@ -242,7 +239,7 @@ export default class DownloadingQueue<T> {
                  IParsedSegmentEvent<T> |
                  IEndOfSegmentEvent> {
 
-    const { segmentQueue } = this._downloadQueue$.getValue();
+    const { segmentQueue } = this._downloadQueue.getValue();
     const currentNeededSegment = segmentQueue[0];
     const recursivelyRequestSegments = (
       startingSegment : IQueuedSegment | undefined
@@ -263,7 +260,7 @@ export default class DownloadingQueue<T> {
       return request$
         .pipe(mergeMap((evt) => {
           switch (evt.type) {
-            case "warning":
+            case "retry":
               return observableOf({ type: "retry" as const,
                                     value: { segment, error: evt.value } });
             case "interrupted":
@@ -272,7 +269,7 @@ export default class DownloadingQueue<T> {
 
             case "ended":
               this._mediaSegmentRequest = null;
-              const lastQueue = this._downloadQueue$.getValue().segmentQueue;
+              const lastQueue = this._downloadQueue.getValue().segmentQueue;
               if (lastQueue.length === 0) {
                 return observableOf({ type : "end-of-queue" as const,
                                       value : null });
@@ -339,7 +336,7 @@ export default class DownloadingQueue<T> {
                                         IEndOfSegmentEvent> =>
       {
         switch (evt.type) {
-          case "warning":
+          case "retry":
             return observableOf({ type: "retry" as const,
                                   value: { segment, error: evt.value } });
           case "interrupted":
@@ -397,7 +394,7 @@ export type IDownloadingQueueEvent<T> = IParsedInitSegmentEvent<T> |
  * In that case, an `IParsedInitSegmentEvent` will always be sent before any
  * `IParsedSegmentEvent` event is sent.
  */
-export type IParsedInitSegmentEvent<T> = ISegmentParserParsedInitSegment<T> &
+export type IParsedInitSegmentEvent<T> = ISegmentParserParsedInitChunk<T> &
                                          { segment : ISegment;
                                            type : "parsed-init"; };
 
@@ -416,7 +413,7 @@ export type IParsedInitSegmentEvent<T> = ISegmentParserParsedInitSegment<T> &
  * You will know that all `IParsedSegmentEvent` have been loaded for a given
  * segment once you received the `IEndOfSegmentEvent` for that segment.
  */
-export type IParsedSegmentEvent<T> = ISegmentParserParsedSegment<T> &
+export type IParsedSegmentEvent<T> = ISegmentParserParsedMediaChunk<T> &
                                      { segment : ISegment;
                                        type : "parsed-media"; };
 
@@ -439,7 +436,7 @@ export interface ILoaderRetryEvent { type : "retry";
 export interface IEndOfQueueEvent { type : "end-of-queue"; value : null }
 
 /**
- * Structure of the object that has to be emitted through the `downloadQueue$`
+ * Structure of the object that has to be emitted through the `downloadQueue`
  * Observable, to signal which segments are currently needed.
  */
 export interface IDownloadQueueItem {

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

@@ -15,14 +15,11 @@
  */
 
 import {
+  concatAll,
+  defer as observableDefer,
   from as observableFrom,
   Observable,
 } from "rxjs";
-import {
-  concatAll,
-  mergeMap,
-  take,
-} from "rxjs/operators";
 import config from "../../../config";
 import log from "../../../log";
 import { getInnerAndOuterTimeRanges } from "../../../utils/ranges";
@@ -42,28 +39,24 @@ const GC_GAP_BEEFY = config.BUFFER_GC_GAPS.BEEFY;
  * @returns {Observable}
  */
 export default function forceGarbageCollection(
-  timings$ : Observable<{ position : number }>,
+  currentPosition : number,
   bufferingQueue : SegmentBuffer
 ) : Observable<unknown> {
-  // wait for next timing event
-  return timings$.pipe(
-    take(1),
-    mergeMap((timing) => {
-      log.warn("Stream: Running garbage collector");
-      const buffered = bufferingQueue.getBufferedRanges();
-      let cleanedupRanges = selectGCedRanges(timing.position, buffered, GC_GAP_CALM);
+  return observableDefer(() => {
+    log.warn("Stream: Running garbage collector");
+    const buffered = bufferingQueue.getBufferedRanges();
+    let cleanedupRanges = selectGCedRanges(currentPosition, buffered, GC_GAP_CALM);
 
-      // more aggressive GC if we could not find any range to clean
-      if (cleanedupRanges.length === 0) {
-        cleanedupRanges = selectGCedRanges(timing.position, buffered, GC_GAP_BEEFY);
-      }
+    // more aggressive GC if we could not find any range to clean
+    if (cleanedupRanges.length === 0) {
+      cleanedupRanges = selectGCedRanges(currentPosition, buffered, GC_GAP_BEEFY);
+    }
 
-      log.debug("Stream: GC cleaning", cleanedupRanges);
-      return observableFrom(
-        cleanedupRanges.map(({ start, end }) => bufferingQueue.removeBuffer(start, end))
-      ).pipe(concatAll());
-    })
-  );
+    log.debug("Stream: GC cleaning", cleanedupRanges);
+    return observableFrom(
+      cleanedupRanges.map(({ start, end }) => bufferingQueue.removeBuffer(start, end))
+    ).pipe(concatAll());
+  });
 }
 
 /**

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

@@ -20,6 +20,7 @@ import Manifest, {
   Period,
   Representation,
 } from "../../../manifest";
+import { IReadOnlyPlaybackObserver } from "../../api";
 import {
   IBufferedChunk,
   IEndOfSegmentOperation,
@@ -71,7 +72,7 @@ export interface IBufferStatus {
  * be filled by any segment, even in the future.
  *
  * @param {Object} content
- * @param {Object} tick
+ * @param {Object} playbackInfo
  * @param {number|undefined} fastSwitchThreshold
  * @param {number} bufferGoal
  * @param {Object} segmentBuffer
@@ -82,10 +83,8 @@ export default function getBufferStatus(
              manifest : Manifest;
              period : Period;
              representation : Representation; },
-  tick : { position : number;
-           wantedTimeOffset: number;
-           liveGap? : number;
-           getCurrentTime() : number; },
+  wantedStartPosition : number,
+  playbackObserver : IReadOnlyPlaybackObserver<unknown>,
   fastSwitchThreshold : number | undefined,
   bufferGoal : number,
   segmentBuffer : SegmentBuffer
@@ -93,7 +92,6 @@ export default function getBufferStatus(
   const { period, representation } = content;
   segmentBuffer.synchronizeInventory();
 
-  const wantedStartPosition = tick.position + tick.wantedTimeOffset;
   const wantedEndPosition = wantedStartPosition + bufferGoal;
   const neededRange = { start: Math.max(wantedStartPosition, period.start),
                         end: Math.min(wantedEndPosition, period.end ?? Infinity) };
@@ -115,6 +113,7 @@ export default function getBufferStatus(
     getPlayableBufferedSegments({ start: Math.max(neededRange.start - 0.5, 0),
                                   end: neededRange.end + 0.5 },
                                 segmentBuffer.getInventory());
+  const currentPlaybackTime = playbackObserver.getCurrentTime();
 
   /** Callback allowing to retrieve a segment's history in the buffer. */
   const getBufferedHistory = segmentBuffer.getSegmentHistory.bind(segmentBuffer);
@@ -122,12 +121,12 @@ export default function getBufferStatus(
   /** List of segments we will need to download. */
   const neededSegments = getNeededSegments({ content,
                                              bufferedSegments,
-                                             currentPlaybackTime: tick.getCurrentTime(),
+                                             currentPlaybackTime,
                                              fastSwitchThreshold,
                                              getBufferedHistory,
                                              neededRange,
                                              segmentsBeingPushed })
-    .map((segment) => ({ priority: getSegmentPriority(segment.time, tick),
+    .map((segment) => ({ priority: getSegmentPriority(segment.time, wantedStartPosition),
                          segment }));
 
   /**
@@ -228,10 +227,9 @@ function getPlayableBufferedSegments(
       const inventorySegment = eltInventory.infos.segment;
       const eltInventoryStart = inventorySegment.time /
                                 inventorySegment.timescale;
-      const eltInventoryEnd = inventorySegment.duration == null ?
+      const eltInventoryEnd = !inventorySegment.complete ?
         eltInventory.end :
-        eltInventoryStart + inventorySegment.duration /
-          inventorySegment.timescale;
+        eltInventoryStart + inventorySegment.duration / inventorySegment.timescale;
       if ((eltInventoryEnd > minEnd && eltInventoryStart < maxStart) ||
           (eltInventory.end > minEnd && eltInventory.start < maxStart))
       {

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

@@ -160,7 +160,7 @@ export default function getNeededSegments({
       return true; // never skip initialization segments
     }
 
-    if (duration < MINIMUM_SEGMENT_SIZE) {
+    if (segment.complete && duration < MINIMUM_SEGMENT_SIZE) {
       return false; // too small, don't download
     }
 

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

@@ -19,24 +19,22 @@ import config from "../../../config";
 const { SEGMENT_PRIORITIES_STEPS } = config;
 
 /**
- * Calculate the priority number for a given time, in function of the distance
- * with the current time.
+ * Calculate the priority number for a given segment start time, in function of
+ * the distance with the wanted starting timestamp.
  *
  * The lower is this number, the higher should be the priority of the request.
  *
- * Note that a `timeWanted` given behind the current time will always have the
+ * Note that a `segmentTime` given behind the current time will always have the
  * highest priority.
- * @param {number} timeWanted
- * @param {Object} clockTick
+ * @param {number} segmentTime
+ * @param {Object} wantedStartTimestamp
  * @returns {number}
  */
 export default function getSegmentPriority(
-  timeWanted : number,
-  clockTick : { position : number;
-                wantedTimeOffset : number; }
+  segmentTime : number,
+  wantedStartTimestamp : number
 ) : number {
-  const currentTime = clockTick.position + clockTick.wantedTimeOffset;
-  const distance = timeWanted - currentTime;
+  const distance = segmentTime - wantedStartTimestamp;
 
   for (let priority = 0; priority < SEGMENT_PRIORITIES_STEPS.length; priority++) {
     if (distance < SEGMENT_PRIORITIES_STEPS[priority]) {

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

@@ -16,13 +16,13 @@
 
 import RepresentationStream, {
   IRepresentationStreamArguments,
-  IRepresentationStreamClockTick,
+  IRepresentationStreamPlaybackObservation,
   ITerminationOrder,
 } from "./representation_stream";
 
 export default RepresentationStream;
 export {
   IRepresentationStreamArguments,
-  IRepresentationStreamClockTick,
+  IRepresentationStreamPlaybackObservation,
   ITerminationOrder,
 };

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

@@ -17,15 +17,16 @@
 import {
   defer as observableDefer,
   EMPTY,
+  map,
   Observable,
 } from "rxjs";
-import { map } from "rxjs/operators";
 import Manifest, {
   Adaptation,
   ISegment,
   Period,
   Representation,
 } from "../../../manifest";
+import { IReadOnlyPlaybackObserver } from "../../api";
 import {
   IPushedChunkData,
   SegmentBuffer,
@@ -43,18 +44,20 @@ import appendSegmentToBuffer from "./append_segment_to_buffer";
  * @returns {Observable}
  */
 export default function pushInitSegment<T>(
-  { clock$,
+  { playbackObserver,
     content,
     segment,
     segmentData,
-    segmentBuffer } : { clock$ : Observable<{ position : number }>;
-                        content: { adaptation : Adaptation;
-                                   manifest : Manifest;
-                                   period : Period;
-                                   representation : Representation; };
-                        segmentData : T | null;
-                        segment : ISegment;
-                        segmentBuffer : SegmentBuffer; }
+    segmentBuffer } :
+  { playbackObserver : IReadOnlyPlaybackObserver<{ position : number;
+                                                   wantedTimeOffset : number; }>;
+    content: { adaptation : Adaptation;
+               manifest : Manifest;
+               period : Period;
+               representation : Representation; };
+    segmentData : T | null;
+    segment : ISegment;
+    segmentBuffer : SegmentBuffer; }
 ) : Observable< IStreamEventAddedSegment<T> > {
   return observableDefer(() => {
     if (segmentData === null) {
@@ -66,11 +69,11 @@ export default function pushInitSegment<T>(
                                          timestampOffset: 0,
                                          appendWindow: [ undefined, undefined ],
                                          codec };
-    return appendSegmentToBuffer(clock$, segmentBuffer, { data,
-                                                          inventoryInfos: null })
-      .pipe(map(() => {
-        const buffered = segmentBuffer.getBufferedRanges();
-        return EVENTS.addedSegment(content, segment, buffered, segmentData);
-      }));
+    return appendSegmentToBuffer(playbackObserver,
+                                 segmentBuffer,
+                                 { data, inventoryInfos: null }).pipe(map(() => {
+      const buffered = segmentBuffer.getBufferedRanges();
+      return EVENTS.addedSegment(content, segment, buffered, segmentData);
+    }));
   });
 }

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

@@ -17,9 +17,9 @@
 import {
   defer as observableDefer,
   EMPTY,
+  map,
   Observable,
 } from "rxjs";
-import { map } from "rxjs/operators";
 import config from "../../../config";
 import Manifest, {
   Adaptation,
@@ -27,8 +27,9 @@ import Manifest, {
   Period,
   Representation,
 } from "../../../manifest";
-import { ISegmentParserParsedSegment } from "../../../transports";
+import { ISegmentParserParsedMediaChunk } from "../../../transports";
 import objectAssign from "../../../utils/object_assign";
+import { IReadOnlyPlaybackObserver } from "../../api";
 import { SegmentBuffer } from "../../segment_buffers";
 import EVENTS from "../events_generators";
 import { IStreamEventAddedSegment } from "../types";
@@ -45,20 +46,22 @@ const { APPEND_WINDOW_SECURITIES } = config;
  * @returns {Observable}
  */
 export default function pushMediaSegment<T>(
-  { clock$,
+  { playbackObserver,
     content,
     initSegmentData,
     parsedSegment,
     segment,
-    segmentBuffer } : { clock$ : Observable<{ position : number }>;
-                        content: { adaptation : Adaptation;
-                                   manifest : Manifest;
-                                   period : Period;
-                                   representation : Representation; };
-                        initSegmentData : T | null;
-                        parsedSegment : ISegmentParserParsedSegment<T>;
-                        segment : ISegment;
-                        segmentBuffer : SegmentBuffer; }
+    segmentBuffer } :
+  { playbackObserver : IReadOnlyPlaybackObserver<{ position : number;
+                                                   wantedTimeOffset : number; }>;
+    content: { adaptation : Adaptation;
+               manifest : Manifest;
+               period : Period;
+               representation : Representation; };
+    initSegmentData : T | null;
+    parsedSegment : ISegmentParserParsedMediaChunk<T>;
+    segment : ISegment;
+    segmentBuffer : SegmentBuffer; }
 ) : Observable< IStreamEventAddedSegment<T> > {
   return observableDefer(() => {
     if (parsedSegment.chunkData === null) {
@@ -103,10 +106,11 @@ export default function pushMediaSegment<T>(
                                           end: estimatedEnd },
                                         content);
 
-    return appendSegmentToBuffer(clock$, segmentBuffer, { data, inventoryInfos })
-      .pipe(map(() => {
-        const buffered = segmentBuffer.getBufferedRanges();
-        return EVENTS.addedSegment(content, segment, buffered, chunkData);
-      }));
+    return appendSegmentToBuffer(playbackObserver,
+                                 segmentBuffer,
+                                 { data, inventoryInfos }).pipe(map(() => {
+      const buffered = segmentBuffer.getBufferedRanges();
+      return EVENTS.addedSegment(content, segment, buffered, chunkData);
+    }));
   });
 }