rx-player 3.26.1 → 3.26.2

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

@@ -25,25 +25,22 @@
 
 import nextTick from "next-tick";
 import {
-  BehaviorSubject,
   combineLatest as observableCombineLatest,
   concat as observableConcat,
   defer as observableDefer,
   EMPTY,
+  ignoreElements,
   merge as observableMerge,
+  mergeMap,
   Observable,
   of as observableOf,
-  Subject,
-} from "rxjs";
-import {
-  ignoreElements,
-  mergeMap,
   share,
   startWith,
+  Subject,
   take,
   takeWhile,
   withLatestFrom,
-} from "rxjs/operators";
+} from "rxjs";
 import log from "../../../log";
 import Manifest, {
   Adaptation,
@@ -53,10 +50,9 @@ import Manifest, {
 } from "../../../manifest";
 import assertUnreachable from "../../../utils/assert_unreachable";
 import objectAssign from "../../../utils/object_assign";
-import {
-  IPrioritizedSegmentFetcher,
-  ISegmentFetcherWarning,
-} from "../../fetchers";
+import { createSharedReference } from "../../../utils/reference";
+import { IReadOnlyPlaybackObserver } from "../../api";
+import { IPrioritizedSegmentFetcher } from "../../fetchers";
 import { SegmentBuffer } from "../../segment_buffers";
 import EVENTS from "../events_generators";
 import {
@@ -69,6 +65,7 @@ import {
   IStreamStatusEvent,
   IStreamTerminatingEvent,
   IInbandEventsEvent,
+  IStreamWarningEvent,
 } from "../types";
 import DownloadingQueue, {
   IDownloadingQueueEvent,
@@ -81,15 +78,13 @@ import getSegmentPriority from "./get_segment_priority";
 import pushInitSegment from "./push_init_segment";
 import pushMediaSegment from "./push_media_segment";
 
-/** Object emitted by the Stream's clock$ at each tick. */
-export interface IRepresentationStreamClockTick {
-  /** The position, in seconds, the media element was in at the time of the tick. */
+/** Object that should be emitted by the given `IReadOnlyPlaybackObserver`. */
+export interface IRepresentationStreamPlaybackObservation {
+  /**
+   * The position, in seconds, the media element was in at the time of the
+   * playback observation.
+   */
   position : number;
- /**
-  * Gap between the current position and the edge of a live content.
-  * Not set for non-live contents.
-  */
-  liveGap? : number;
   /**
    * Offset in seconds to add to the time to obtain the position we
    * actually want to download from.
@@ -98,8 +93,6 @@ export interface IRepresentationStreamClockTick {
    * starting position different from `0`.
    */
   wantedTimeOffset : number;
-  /** Fetch the precize position currently in the HTMLMediaElement. */
-  getCurrentTime() : number;
 }
 
 /** Item emitted by the `terminate$` Observable given to a RepresentationStream. */
@@ -115,8 +108,6 @@ export interface ITerminationOrder {
 
 /** Arguments to give to the RepresentationStream. */
 export interface IRepresentationStreamArguments<TSegmentDataType> {
-  /** Periodically emits the current playback conditions. */
-  clock$ : Observable<IRepresentationStreamClockTick>;
   /** The context of the Representation you want to load. */
   content: { adaptation : Adaptation;
              manifest : Manifest;
@@ -137,6 +128,8 @@ export interface IRepresentationStreamArguments<TSegmentDataType> {
    * Observable once the corresponding segments have been pushed).
    */
   terminate$ : Observable<ITerminationOrder>;
+  /** Periodically emits the current playback conditions. */
+  playbackObserver : IReadOnlyPlaybackObserver<IRepresentationStreamPlaybackObservation>;
   /** Supplementary arguments which configure the RepresentationStream's behavior. */
   options: IRepresentationStreamOptions;
 }
@@ -216,12 +209,12 @@ interface IInitSegmentState<T> {
  * @returns {Observable}
  */
 export default function RepresentationStream<TSegmentDataType>({
-  clock$,
   content,
+  options,
+  playbackObserver,
   segmentBuffer,
   segmentFetcher,
   terminate$,
-  options,
 } : IRepresentationStreamArguments<TSegmentDataType>
 ) : Observable<IRepresentationStreamEvent> {
   const { period,
@@ -243,14 +236,15 @@ export default function RepresentationStream<TSegmentDataType>({
   const reCheckNeededSegments$ = new Subject<void>();
 
   /** Emit the last scheduled downloading queue for segments. */
-  const lastSegmentQueue$ =
-    new BehaviorSubject<IDownloadQueueItem>({ initSegment: null,
-                                              segmentQueue: [] });
+  const lastSegmentQueue = createSharedReference<IDownloadQueueItem>({
+    initSegment: null,
+    segmentQueue: [],
+  });
   const hasInitSegment = initSegmentState.segment !== null;
 
-  /** Will load every segments in `lastSegmentQueue$` */
+  /** Will load every segments in `lastSegmentQueue` */
   const downloadingQueue = new DownloadingQueue(content,
-                                                lastSegmentQueue$,
+                                                lastSegmentQueue,
                                                 segmentFetcher,
                                                 hasInitSegment);
 
@@ -275,13 +269,13 @@ export default function RepresentationStream<TSegmentDataType>({
     }
   }
 
-  /** Observable loading and pushing segments scheduled through `lastSegmentQueue$`. */
+  /** Observable loading and pushing segments scheduled through `lastSegmentQueue`. */
   const queue$ = downloadingQueue.start()
     .pipe(mergeMap(onQueueEvent));
 
-  /** Observable emitting the stream "status" and filling `lastSegmentQueue$`. */
+  /** Observable emitting the stream "status" and filling `lastSegmentQueue`. */
   const status$ = observableCombineLatest([
-    clock$,
+    playbackObserver.observe(true),
     bufferGoal$,
     terminate$.pipe(take(1),
                     startWith(null)),
@@ -289,14 +283,16 @@ export default function RepresentationStream<TSegmentDataType>({
   ]).pipe(
     withLatestFrom(fastSwitchThreshold$),
     mergeMap(function (
-      [ [ tick, bufferGoal, terminate ],
+      [ [ observation, bufferGoal, terminate ],
         fastSwitchThreshold ]
     ) : Observable<IStreamStatusEvent |
                    IStreamNeedsManifestRefresh |
                    IStreamTerminatingEvent>
     {
+      const wantedStartPosition = observation.position + observation.wantedTimeOffset;
       const status = getBufferStatus(content,
-                                     tick,
+                                     wantedStartPosition,
+                                     playbackObserver,
                                      fastSwitchThreshold,
                                      bufferGoal,
                                      segmentBuffer);
@@ -312,8 +308,10 @@ export default function RepresentationStream<TSegmentDataType>({
           log.warn("Stream: Uninitialized index with an already loaded " +
                    "initialization segment");
         } else {
+          const wantedStart = observation.position + observation.wantedTimeOffset;
           neededInitSegment = { segment: initSegmentState.segment,
-                                priority: getSegmentPriority(period.start, tick) };
+                                priority: getSegmentPriority(period.start,
+                                                             wantedStart) };
         }
       } else if (neededSegments.length > 0 &&
                  !initSegmentState.isLoaded &&
@@ -325,12 +323,12 @@ export default function RepresentationStream<TSegmentDataType>({
       }
 
       if (terminate === null) {
-        lastSegmentQueue$.next({ initSegment: neededInitSegment,
-                                 segmentQueue: neededSegments });
+        lastSegmentQueue.setValue({ initSegment: neededInitSegment,
+                                    segmentQueue: neededSegments });
       } else if (terminate.urgent) {
         log.debug("Stream: Urgent switch, terminate now.", bufferType);
-        lastSegmentQueue$.next({ initSegment: null, segmentQueue: [] });
-        lastSegmentQueue$.complete();
+        lastSegmentQueue.setValue({ initSegment: null, segmentQueue: [] });
+        lastSegmentQueue.finish();
         return observableOf(EVENTS.streamTerminating());
       } else {
         // Non-urgent termination wanted:
@@ -350,11 +348,11 @@ export default function RepresentationStream<TSegmentDataType>({
 
         const nextInit = initSegmentRequest === null ? null :
                                                        neededInitSegment;
-        lastSegmentQueue$.next({ initSegment: nextInit,
-                                 segmentQueue: nextQueue });
+        lastSegmentQueue.setValue({ initSegment: nextInit,
+                                    segmentQueue: nextQueue });
         if (nextQueue.length === 0 && nextInit === null) {
           log.debug("Stream: No request left, terminate", bufferType);
-          lastSegmentQueue$.complete();
+          lastSegmentQueue.finish();
           return observableOf(EVENTS.streamTerminating());
         }
       }
@@ -362,7 +360,7 @@ export default function RepresentationStream<TSegmentDataType>({
       const bufferStatusEvt : Observable<IStreamStatusEvent> =
         observableOf({ type: "stream-status" as const,
                        value: { period,
-                                position: tick.position,
+                                position: observation.position,
                                 bufferType,
                                 imminentDiscontinuity: status.imminentDiscontinuity,
                                 hasFinishedLoading: status.hasFinishedLoading,
@@ -386,7 +384,7 @@ export default function RepresentationStream<TSegmentDataType>({
   function onQueueEvent(
     evt : IDownloadingQueueEvent<TSegmentDataType>
   ) : Observable<IStreamEventAddedSegment<TSegmentDataType> |
-                 ISegmentFetcherWarning |
+                 IStreamWarningEvent |
                  IEncryptionDataEncounteredEvent |
                  IInbandEventsEvent |
                  IStreamNeedsManifestRefresh |
@@ -414,6 +412,11 @@ export default function RepresentationStream<TSegmentDataType>({
       case "end-of-segment": {
         const { segment } = evt.value;
         return segmentBuffer.endOfSegment(objectAssign({ segment }, content))
+          // 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());
       }
 
@@ -457,7 +460,7 @@ export default function RepresentationStream<TSegmentDataType>({
         observableOf(...allEncryptionData.map(p =>
           EVENTS.encryptionDataEncountered(p))) :
         EMPTY;
-      const pushEvent$ = pushInitSegment({ clock$,
+      const pushEvent$ = pushInitSegment({ playbackObserver,
                                            content,
                                            segment: evt.segment,
                                            segmentData: evt.initializationData,
@@ -486,7 +489,7 @@ export default function RepresentationStream<TSegmentDataType>({
         EMPTY;
 
       const initSegmentData = initSegmentState.segmentData;
-      const pushMediaSegment$ = pushMediaSegment({ clock$,
+      const pushMediaSegment$ = pushMediaSegment({ playbackObserver,
                                                    content,
                                                    initSegmentData,
                                                    parsedSegment: evt,

package/src/experimental/features/__tests__/dash_wasm.test.ts

@@ -15,6 +15,7 @@
  */
 
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
 
 import DashWasmParser from "../../../parsers/manifest/dash/wasm-parser";
 import DASHFeature from "../../../transports/dash";

package/src/experimental/tools/VideoThumbnailLoader/create_request.ts

@@ -1,19 +1,18 @@
-import {
-  EMPTY,
-} from "rxjs";
 import {
   catchError,
+  EMPTY,
   filter,
   take,
-} from "rxjs/operators";
+} from "rxjs";
 import {
   ISegmentFetcher,
+  ISegmentFetcherChunkCompleteEvent,
   ISegmentFetcherChunkEvent,
 } from "../../../core/fetchers/segment/segment_fetcher";
 import { ISegment } from "../../../manifest";
 import {
-  ISegmentParserParsedInitSegment,
-  ISegmentParserParsedSegment,
+  ISegmentParserParsedInitChunk,
+  ISegmentParserParsedMediaChunk,
 } from "../../../transports";
 import getCompleteSegmentId from "./get_complete_segment_id";
 import { IContentInfos } from "./types";
@@ -21,11 +20,13 @@ import { IContentInfos } from "./types";
 const requests = new Map<string, ICancellableRequest>();
 
 export interface ICancellableRequest {
-  data?: ISegmentParserParsedInitSegment<Uint8Array | ArrayBuffer> |
-         ISegmentParserParsedSegment<Uint8Array | ArrayBuffer>;
+  data?: ISegmentParserParsedInitChunk<Uint8Array | ArrayBuffer> |
+         ISegmentParserParsedMediaChunk<Uint8Array | ArrayBuffer>;
+  isComplete: boolean;
   error?: Error;
-  onData?: (data: ISegmentParserParsedInitSegment<Uint8Array | ArrayBuffer> |
-                  ISegmentParserParsedSegment<Uint8Array | ArrayBuffer>) => void;
+  onData?: (data: ISegmentParserParsedInitChunk<Uint8Array | ArrayBuffer> |
+                  ISegmentParserParsedMediaChunk<Uint8Array | ArrayBuffer>) => void;
+  onComplete?: () => void;
   onError?: (err: Error) => void;
   cancel: () => void;
 }
@@ -50,7 +51,11 @@ export function createRequest(
   }
 
   const _request: ICancellableRequest = {
-    cancel: () => subscription.unsubscribe(),
+    cancel() {
+      subscription.unsubscribe();
+      this.isComplete = true;
+    },
+    isComplete: false,
   };
 
   const subscription = segmentFetcher({ manifest: contentInfos.manifest,
@@ -58,8 +63,10 @@ export function createRequest(
                                         adaptation: contentInfos.adaptation,
                                         representation: contentInfos.representation,
                                         segment }).pipe(
-    filter((evt): evt is ISegmentFetcherChunkEvent<ArrayBuffer | Uint8Array> =>
-      evt.type === "chunk"
+    filter((evt): evt is ISegmentFetcherChunkEvent<ArrayBuffer | Uint8Array> |
+                         ISegmentFetcherChunkCompleteEvent =>
+      evt.type === "chunk" ||
+      evt.type === "chunk-complete"
     ),
     take(1),
     catchError((err: Error) => {
@@ -67,13 +74,21 @@ export function createRequest(
       if (_request.onError !== undefined) {
         _request.onError(err);
       }
+      _request.isComplete = true;
       return EMPTY;
     })
   ).subscribe((evt) => {
-    const parsed = evt.parse();
-    _request.data = parsed;
-    if (_request.onData !== undefined) {
-      _request.onData(parsed);
+    if (evt.type === "chunk-complete") {
+      if (_request.onComplete !== undefined) {
+        _request.onComplete();
+        _request.isComplete = true;
+      }
+    } else {
+      const parsed = evt.parse();
+      _request.data = parsed;
+      if (_request.onData !== undefined) {
+        _request.onData(parsed);
+      }
     }
   });
 

package/src/experimental/tools/VideoThumbnailLoader/get_initialized_source_buffer.ts

@@ -16,19 +16,16 @@
 
 import {
   EMPTY,
+  map,
+  merge as observableMerge,
+  mergeMap,
   Observable,
   of as observableOf,
   ReplaySubject,
-  Subscription,
-  merge as observableMerge,
   Subject,
-} from "rxjs";
-import {
-  map,
-  mapTo,
-  mergeMap,
+  Subscription,
   tap,
-} from "rxjs/operators";
+} from "rxjs";
 import { ISegmentFetcher } from "../../../core/fetchers/segment/segment_fetcher";
 import { AudioVideoSegmentBuffer } from "../../../core/segment_buffers/implementations";
 import { ISegment } from "../../../manifest";
@@ -149,7 +146,7 @@ export function getInitializedSourceBuffer$(
                                  initSegment,
                                  sourceBuffer,
                                  segmentFetcher)
-        .pipe(mapTo(sourceBuffer));
+        .pipe(map(() => sourceBuffer));
     }),
     tap(() => { sourceBufferContent = contentInfos; })
   );

package/src/experimental/tools/VideoThumbnailLoader/load_segments.ts

@@ -2,8 +2,8 @@ import { combineLatest, Observable } from "rxjs";
 import { ISegmentFetcher } from "../../../core/fetchers/segment/segment_fetcher";
 import { ISegment } from "../../../manifest";
 import {
-  ISegmentParserParsedInitSegment,
-  ISegmentParserParsedSegment,
+  ISegmentParserParsedInitChunk,
+  ISegmentParserParsedMediaChunk,
 } from "../../../transports";
 import { createRequest, freeRequest } from "./create_request";
 import getCompleteSegmentId from "./get_complete_segment_id";
@@ -23,15 +23,15 @@ export default function loadSegments(
   contentInfos: IContentInfos
 ): Observable<Array<{
   segment: ISegment;
-  data: ISegmentParserParsedSegment<ArrayBuffer | Uint8Array> |
-        ISegmentParserParsedInitSegment<ArrayBuffer | Uint8Array>;
+  data: ISegmentParserParsedMediaChunk<ArrayBuffer | Uint8Array> |
+        ISegmentParserParsedInitChunk<ArrayBuffer | Uint8Array>;
 }>> {
   return combineLatest(
     segments.map((segment) => {
       return new Observable<{
         segment: ISegment;
-        data: ISegmentParserParsedSegment<ArrayBuffer | Uint8Array> |
-              ISegmentParserParsedInitSegment<ArrayBuffer | Uint8Array>; }
+        data: ISegmentParserParsedMediaChunk<ArrayBuffer | Uint8Array> |
+              ISegmentParserParsedInitChunk<ArrayBuffer | Uint8Array>; }
       >((obs) => {
         const completeSegmentId = getCompleteSegmentId(contentInfos, segment);
         const request = createRequest(segmentFetcher, contentInfos, segment);
@@ -49,12 +49,18 @@ export default function loadSegments(
 
         if (request.data !== undefined) {
           obs.next({ data: request.data, segment });
+        }
+
+        if (request.isComplete) {
           obs.complete();
           return;
         }
 
         request.onData = (data) => {
           obs.next({ data, segment });
+        };
+
+        request.onComplete = () => {
           obs.complete();
         };
       });

package/src/experimental/tools/VideoThumbnailLoader/prepare_source_buffer.ts

@@ -14,8 +14,10 @@
  * limitations under the License.
  */
 
-import { Observable } from "rxjs";
-import { map } from "rxjs/operators";
+import {
+  map,
+  Observable,
+} from "rxjs";
 import openMediaSource from "../../../core/init/create_media_source";
 import { AudioVideoSegmentBuffer } from "../../../core/segment_buffers/implementations";
 

package/src/experimental/tools/VideoThumbnailLoader/push_data.ts

@@ -8,7 +8,7 @@ import Manifest, {
   Period,
   Representation,
 } from "../../../manifest";
-import { ISegmentParserParsedSegment } from "../../../transports";
+import { ISegmentParserParsedMediaChunk } from "../../../transports";
 
 /**
  * Push data to the video source buffer.
@@ -26,7 +26,7 @@ export default function pushData(
                     segment: ISegment;
                     start: number;
                     end: number; },
-  parsed: ISegmentParserParsedSegment<Uint8Array | ArrayBuffer>,
+  parsed: ISegmentParserParsedMediaChunk<Uint8Array | ArrayBuffer>,
   videoSourceBuffer: AudioVideoSegmentBuffer
 ): Observable<void> {
   const { chunkData, appendWindow } = parsed;

package/src/experimental/tools/VideoThumbnailLoader/thumbnail_loader.ts

@@ -15,22 +15,20 @@
  */
 
 import pinkie from "pinkie";
-import {
-  combineLatest,
-  lastValueFrom,
-  merge as observableMerge,
-  race as observableRace,
-  Subject,
-} from "rxjs";
 import {
   catchError,
+  combineLatest,
   finalize,
   ignoreElements,
+  lastValueFrom,
   map,
+  merge as observableMerge,
   mergeMap,
+  race as observableRace,
+  Subject,
   take,
   tap,
-} from "rxjs/operators";
+} from "rxjs";
 import Player from "../../../core/api";
 import createSegmentFetcher, {
   ISegmentFetcher,
@@ -211,7 +209,8 @@ export default class VideoThumbnailLoader {
     const segmentFetcher = createSegmentFetcher(
       "video",
       loader.video,
-      new Subject(),
+      // We don't care about the SegmentFetcher's lifecycle events
+      {},
       { baseDelay: 0,
         maxDelay: 0,
         maxRetryOffline: 0,
@@ -241,8 +240,18 @@ export default class VideoThumbnailLoader {
                   if (data.segmentType === "init") {
                     throw new Error("Unexpected initialization segment parsed.");
                   }
-                  const start = segment.time / segment.timescale;
-                  const end = start + (segment.duration / segment.timescale);
+                  let start;
+                  let end;
+                  if (data.chunkInfos !== null) {
+                    start = data.chunkInfos.time;
+                    end = data.chunkInfos.duration;
+                  } else {
+                    start = segment.time / segment.timescale;
+                  }
+
+                  if (end === undefined) {
+                    end = start + (segment.duration / segment.timescale);
+                  }
                   const inventoryInfos = objectAssign({ segment,
                                                         start,
                                                         end }, contentInfos);
@@ -251,7 +260,7 @@ export default class VideoThumbnailLoader {
                                   videoSourceBuffer)
                     .pipe(tap(() => {
                       freeRequest(getCompleteSegmentId(inventoryInfos, segment));
-                      log.debug("VTL: Appended segment.", data);
+                      log.debug("VTL: Appended segment.");
                     }));
                 })
               );

package/src/experimental/tools/createMetaplaylist/get_duration_from_manifest.ts

@@ -15,10 +15,10 @@
  */
 
 import {
+  map,
   Observable,
   throwError,
 } from "rxjs";
-import { map } from "rxjs/operators";
 import { IMetaPlaylist } from "../../../parsers/manifest/metaplaylist";
 import isNonEmptyString from "../../../utils/is_non_empty_string";
 import request from "../../../utils/request/xhr";

package/src/experimental/tools/createMetaplaylist/index.ts

@@ -17,9 +17,9 @@
 import {
   combineLatest as observableCombineLatest,
   lastValueFrom,
+  map,
   of as observableOf,
 } from "rxjs";
-import { map } from "rxjs/operators";
 import { IMetaPlaylist } from "../../../parsers/manifest/metaplaylist";
 import getDurationFromManifest from "./get_duration_from_manifest";
 

package/src/experimental/tools/mediaCapabilitiesProber/__tests__/probers/DRMInfos.test.ts

@@ -21,8 +21,10 @@
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 
-import { of as observableOf } from "rxjs";
-import { map } from "rxjs/operators";
+import {
+  map,
+  of as observableOf,
+} from "rxjs";
 import { ProberStatus } from "../../types";