rx-player 3.25.2 → 3.26.3-dev.2022021400

package/src/core/stream/types.ts

@@ -24,7 +24,6 @@ import {
 } from "../../manifest";
 import { IEMSG } from "../../parsers/containers/isobmff";
 import { IContentProtection } from "../eme";
-import { INeedsBufferFlush } from "../init";
 import { IBufferType } from "../segment_buffers";
 
 /** Information about a Segment waiting to be loaded by the Stream. */
@@ -345,21 +344,63 @@ export interface INeedsMediaSourceReload {
      * If `false`, we want to stay in a paused state at that point.
      */
     autoPlay : boolean;
+  };
+}
 
+/**
+ * A stream cannot go forward loading segments because it needs the
+ * `MediaSource` to be reloaded first.
+ *
+ * This is a Stream internal event before being translated into either an
+ * `INeedsMediaSourceReload` event or an `ILockedStreamEvent` depending on if
+ * the reloading action has to be taken now or when the corresponding Period
+ * becomes active.
+ */
+export interface IWaitingMediaSourceReloadInternalEvent {
+  type: "waiting-media-source-reload";
+  value: {
+    /** Period concerned. */
+    period : Period;
+    /** Buffer type concerned. */
+    bufferType : IBufferType;
     /**
-     * A `INeedsMediaSourceReload` is an event sent by a Stream (e.g. a
-     * `PeriodStream`, `AdaptationStream` or `RepresentationStream`) which is
-     * linked to a given `Period` in the `Manifest`.
-     *
-     * This property indicates the linked Period in question.
-     *
-     * This property is used internally by the Stream to filter out
-     * `INeedsMediaSourceReload` until the corresponding Period is the active
-     * one. Without it, we might reload the MediaSource too soon.
-     *
-     * Outside of the Stream's code, you probably don't need this information.
+     * The position in seconds and the time at which the MediaSource should be
+     * reset once it has been reloaded.
+     */
+    position : number;
+    /**
+     * If `true`, we want the HTMLMediaElement to play right after the reload is
+     * done.
+     * If `false`, we want to stay in a paused state at that point.
      */
+    autoPlay : boolean;
+  };
+}
+
+/**
+ * The stream is unable to load segments for a particular Period and buffer
+ * type until that Period becomes the currently-played Period.
+ *
+ * This might be the case for example when a track change happened for an
+ * upcoming Period, which necessitates the reloading of the media source -
+ * through a `INeedsMediaSourceReload` event once the Period is the current one.
+ * Here, the stream might stay in a locked mode for segments linked to that
+ * Period and buffer type, meaning it will not load any such segment until that
+ * next Period becomes the current one (in which case it will probably ask to
+ * reload).
+ *
+ * This event can be useful when investigating rebuffering situation: one might
+ * be due to the next Period not loading segment of a certain type because of a
+ * locked stream. In that case, playing until or seeking at the start of the
+ * corresponding Period should be enough to "unlock" the stream.
+ */
+export interface ILockedStreamEvent {
+  type : "locked-stream";
+  value : {
+    /** Period concerned. */
     period : Period;
+    /** Buffer type concerned. */
+    bufferType : IBufferType;
   };
 }
 
@@ -395,42 +436,52 @@ export interface INeedsDecipherabilityFlush {
   };
 }
 
+/**
+ * Some situations might require the browser's buffers to be refreshed.
+ * This event is emitted when such situation arised.
+ */
+export interface INeedsBufferFlushEvent {
+  type: "needs-buffer-flush";
+  value: undefined;
+}
+
 /** Event sent by a `RepresentationStream`. */
-export type IRepresentationStreamEvent<T> = IStreamStatusEvent |
-                                            IStreamEventAddedSegment<T> |
-                                            IEncryptionDataEncounteredEvent |
-                                            IStreamManifestMightBeOutOfSync |
-                                            IStreamTerminatingEvent |
-                                            IStreamNeedsManifestRefresh |
-                                            IStreamWarningEvent |
-                                            IInbandEventsEvent;
+export type IRepresentationStreamEvent = IStreamStatusEvent |
+                                         IStreamEventAddedSegment<unknown> |
+                                         IEncryptionDataEncounteredEvent |
+                                         IStreamManifestMightBeOutOfSync |
+                                         IStreamTerminatingEvent |
+                                         IStreamNeedsManifestRefresh |
+                                         IStreamWarningEvent |
+                                         IInbandEventsEvent;
 
 /** Event sent by an `AdaptationStream`. */
-export type IAdaptationStreamEvent<T> = IBitrateEstimationChangeEvent |
-                                        INeedsMediaSourceReload |
-                                        INeedsDecipherabilityFlush |
-                                        IRepresentationChangeEvent |
-
-                                        // From a RepresentationStream
-
-                                        IStreamStatusEvent |
-                                        IStreamEventAddedSegment<T> |
-                                        IEncryptionDataEncounteredEvent |
-                                        IStreamManifestMightBeOutOfSync |
-                                        IStreamNeedsManifestRefresh |
-                                        IStreamWarningEvent |
-                                        IInbandEventsEvent;
+export type IAdaptationStreamEvent = IBitrateEstimationChangeEvent |
+                                     INeedsDecipherabilityFlush |
+                                     IRepresentationChangeEvent |
+                                     INeedsBufferFlushEvent |
+                                     IWaitingMediaSourceReloadInternalEvent |
+
+                                     // From a RepresentationStream
+
+                                     IStreamStatusEvent |
+                                     IStreamEventAddedSegment<unknown> |
+                                     IEncryptionDataEncounteredEvent |
+                                     IStreamManifestMightBeOutOfSync |
+                                     IStreamNeedsManifestRefresh |
+                                     IStreamWarningEvent |
+                                     IInbandEventsEvent;
 
 /** Event sent by a `PeriodStream`. */
 export type IPeriodStreamEvent = IPeriodStreamReadyEvent |
-                                 INeedsMediaSourceReload |
                                  IAdaptationChangeEvent |
+                                 IWaitingMediaSourceReloadInternalEvent |
 
                                  // From an AdaptationStream
 
                                  IBitrateEstimationChangeEvent |
                                  INeedsMediaSourceReload |
-                                 INeedsBufferFlush |
+                                 INeedsBufferFlushEvent |
                                  INeedsDecipherabilityFlush |
                                  IRepresentationChangeEvent |
 
@@ -451,9 +502,9 @@ export type IMultiplePeriodStreamsEvent = IPeriodStreamClearedEvent |
                                           // From a PeriodStream
 
                                           IPeriodStreamReadyEvent |
-                                          INeedsMediaSourceReload |
-                                          INeedsBufferFlush |
+                                          INeedsBufferFlushEvent |
                                           IAdaptationChangeEvent |
+                                          IWaitingMediaSourceReloadInternalEvent |
 
                                           // From an AdaptationStream
 
@@ -484,12 +535,13 @@ export type IStreamOrchestratorEvent = IActivePeriodChangedEvent |
 
                                        IPeriodStreamReadyEvent |
                                        IAdaptationChangeEvent |
+                                       ILockedStreamEvent |
 
                                        // From an AdaptationStream
 
                                        IBitrateEstimationChangeEvent |
                                        INeedsMediaSourceReload |
-                                       INeedsBufferFlush |
+                                       INeedsBufferFlushEvent |
                                        INeedsDecipherabilityFlush |
                                        IRepresentationChangeEvent |
 

package/src/errors/request_error.ts

@@ -50,7 +50,10 @@ export default class RequestError extends Error {
 
     this.name = "RequestError";
     this.url = url;
-    this.xhr = xhr;
+
+    if (xhr !== undefined) {
+      this.xhr = xhr;
+    }
     this.status = status;
     this.type = type;
     this.message = type;

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";
@@ -39,6 +40,7 @@ describe("Features list - DASH WASM Parser", () => {
 
     expect(initializeSpy).toHaveBeenCalledTimes(1);
 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const featureObject : any = { transports: {},
                                   dashParsers: { js: null,
                                                  wasm: null } };

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

@@ -1,26 +1,32 @@
-import {
-  EMPTY,
-  Observable,
-} from "rxjs";
 import {
   catchError,
+  EMPTY,
   filter,
   take,
-} from "rxjs/operators";
+} from "rxjs";
 import {
-  ISegmentLoaderContent,
-  ISegmentLoaderEvent,
-} from "../../../core/fetchers/segment/create_segment_loader";
+  ISegmentFetcher,
+  ISegmentFetcherChunkCompleteEvent,
+  ISegmentFetcherChunkEvent,
+} from "../../../core/fetchers/segment/segment_fetcher";
 import { ISegment } from "../../../manifest";
+import {
+  ISegmentParserParsedInitChunk,
+  ISegmentParserParsedMediaChunk,
+} from "../../../transports";
 import getCompleteSegmentId from "./get_complete_segment_id";
 import { IContentInfos } from "./types";
 
 const requests = new Map<string, ICancellableRequest>();
 
 export interface ICancellableRequest {
-  data?: Uint8Array;
+  data?: ISegmentParserParsedInitChunk<Uint8Array | ArrayBuffer> |
+         ISegmentParserParsedMediaChunk<Uint8Array | ArrayBuffer>;
+  isComplete: boolean;
   error?: Error;
-  onData?: (data: Uint8Array) => void;
+  onData?: (data: ISegmentParserParsedInitChunk<Uint8Array | ArrayBuffer> |
+                  ISegmentParserParsedMediaChunk<Uint8Array | ArrayBuffer>) => void;
+  onComplete?: () => void;
   onError?: (err: Error) => void;
   cancel: () => void;
 }
@@ -34,11 +40,7 @@ export interface ICancellableRequest {
  * @returns {Object}
  */
 export function createRequest(
-  segmentLoader: (
-    x : ISegmentLoaderContent
-  ) => Observable<ISegmentLoaderEvent<Uint8Array |
-                                      ArrayBuffer |
-                                      null>>,
+  segmentFetcher: ISegmentFetcher<ArrayBuffer | Uint8Array>,
   contentInfos: IContentInfos,
   segment: ISegment
 ): ICancellableRequest {
@@ -47,14 +49,24 @@ export function createRequest(
   if (lastRequest !== undefined) {
     return lastRequest;
   }
-  const subscription = segmentLoader({ manifest: contentInfos.manifest,
-                                       period: contentInfos.period,
-                                       adaptation: contentInfos.adaptation,
-                                       representation: contentInfos.representation,
-                                       segment }).pipe(
-    filter((evt): evt is { type: "data";
-                           value: { responseData: Uint8Array }; } =>
-      evt.type === "data"
+
+  const _request: ICancellableRequest = {
+    cancel() {
+      subscription.unsubscribe();
+      this.isComplete = true;
+    },
+    isComplete: false,
+  };
+
+  const subscription = segmentFetcher({ manifest: contentInfos.manifest,
+                                        period: contentInfos.period,
+                                        adaptation: contentInfos.adaptation,
+                                        representation: contentInfos.representation,
+                                        segment }).pipe(
+    filter((evt): evt is ISegmentFetcherChunkEvent<ArrayBuffer | Uint8Array> |
+                         ISegmentFetcherChunkCompleteEvent =>
+      evt.type === "chunk" ||
+      evt.type === "chunk-complete"
     ),
     take(1),
     catchError((err: Error) => {
@@ -62,19 +74,24 @@ export function createRequest(
       if (_request.onError !== undefined) {
         _request.onError(err);
       }
+      _request.isComplete = true;
       return EMPTY;
     })
   ).subscribe((evt) => {
-    _request.data = evt.value.responseData;
-    if (_request.onData !== undefined) {
-      _request.onData(evt.value.responseData);
+    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);
+      }
     }
   });
 
-  const _request: ICancellableRequest = {
-    cancel: () => subscription.unsubscribe(),
-  };
-
   requests.set(completeSegmentId, _request);
 
   return _request;

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

@@ -35,8 +35,7 @@ export default function getContentInfos(
       period.adaptations.video.length === 0) {
     return null;
   }
-  for (let i = 0; i < period.adaptations.video.length; i++) {
-    const videoAdaptation = period.adaptations.video[i];
+  for (const videoAdaptation of period.adaptations.video) {
     const representation = videoAdaptation.trickModeTracks?.[0].representations?.[0];
     if (!isNullOrUndefined(representation)) {
       return { manifest,

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

@@ -16,31 +16,21 @@
 
 import {
   EMPTY,
+  map,
+  merge as observableMerge,
+  mergeMap,
   Observable,
   of as observableOf,
   ReplaySubject,
-  Subscription,
-  merge as observableMerge,
   Subject,
-} from "rxjs";
-import {
-  filter,
-  map,
-  mapTo,
-  mergeMap,
+  Subscription,
   tap,
-} from "rxjs/operators";
-import {
-  ISegmentLoaderContent,
-  ISegmentLoaderEvent,
-} from "../../../core/fetchers/segment/create_segment_loader";
+} from "rxjs";
+import { ISegmentFetcher } from "../../../core/fetchers/segment/segment_fetcher";
 import { AudioVideoSegmentBuffer } from "../../../core/segment_buffers/implementations";
 import { ISegment } from "../../../manifest";
 import prepareSourceBuffer from "./prepare_source_buffer";
-import {
-  IContentInfos,
-  IThumbnailLoaderSegmentParser,
-} from "./types";
+import { IContentInfos } from "./types";
 
 let mediaSourceSubscription: Subscription | undefined;
 let sourceBufferContent: IContentInfos | undefined;
@@ -79,45 +69,33 @@ function hasAlreadyPushedInitData(contentInfos: IContentInfos): boolean {
 function loadAndPushInitData(contentInfos: IContentInfos,
                              initSegment: ISegment,
                              sourceBuffer: AudioVideoSegmentBuffer,
-                             segmentParser: IThumbnailLoaderSegmentParser,
-                             segmentLoader: (
-                               x : ISegmentLoaderContent
-                             ) => Observable<ISegmentLoaderEvent<Uint8Array |
-                                                                 ArrayBuffer |
-                                                                 null>>) {
-  const inventoryInfos = { manifest: contentInfos.manifest,
-                           period: contentInfos.period,
-                           adaptation: contentInfos.adaptation,
-                           representation: contentInfos.representation,
-                           segment: initSegment };
-  return segmentLoader(inventoryInfos).pipe(
-    filter((evt): evt is { type: "data"; value: { responseData: Uint8Array } } =>
-      evt.type === "data"),
+                             segmentFetcher: ISegmentFetcher<ArrayBuffer | Uint8Array>) {
+  const segmentInfos = { manifest: contentInfos.manifest,
+                         period: contentInfos.period,
+                         adaptation: contentInfos.adaptation,
+                         representation: contentInfos.representation,
+                         segment: initSegment };
+  return segmentFetcher(segmentInfos).pipe(
     mergeMap((evt) => {
-      return segmentParser({
-        response: {
-          data: evt.value.responseData,
-          isChunked: false,
-        },
-        content: inventoryInfos,
-      }).pipe(
-        mergeMap((parserEvent) => {
-          if (parserEvent.type !== "parsed-init-segment") {
-            return EMPTY;
-          }
-          const { initializationData } = parserEvent.value;
-          const initSegmentData = initializationData instanceof ArrayBuffer ?
-            new Uint8Array(initializationData) : initializationData;
-          return sourceBuffer
-            .pushChunk({ data: { initSegment: initSegmentData,
-                                 chunk: null,
-                                 appendWindow: [undefined, undefined],
-                                 timestampOffset: 0,
-                                 codec: contentInfos
-                                   .representation.getMimeTypeString() },
-                         inventoryInfos: null });
-        })
-      );
+      if (evt.type !== "chunk") {
+        return EMPTY;
+      }
+      const parsed = evt.parse();
+      if (parsed.segmentType !== "init") {
+        return EMPTY;
+      }
+      const { initializationData } = parsed;
+      const initSegmentData = initializationData instanceof ArrayBuffer ?
+        new Uint8Array(initializationData) :
+        initializationData;
+      return sourceBuffer
+        .pushChunk({ data: { initSegment: initSegmentData,
+                             chunk: null,
+                             appendWindow: [undefined, undefined],
+                             timestampOffset: 0,
+                             codec: contentInfos
+                               .representation.getMimeTypeString() },
+                     inventoryInfos: null });
     })
   );
 }
@@ -133,15 +111,7 @@ function loadAndPushInitData(contentInfos: IContentInfos,
 export function getInitializedSourceBuffer$(
   contentInfos: IContentInfos,
   element: HTMLVideoElement,
-  { segmentLoader,
-    segmentParser }: {
-    segmentLoader: (
-      x : ISegmentLoaderContent
-    ) => Observable<ISegmentLoaderEvent<Uint8Array |
-                                        ArrayBuffer |
-                                        null>>;
-    segmentParser: IThumbnailLoaderSegmentParser;
-  }
+  segmentFetcher : ISegmentFetcher<ArrayBuffer | Uint8Array>
 ): Observable<AudioVideoSegmentBuffer> {
   if (hasAlreadyPushedInitData(contentInfos)) {
     return sourceBuffer$;
@@ -153,15 +123,15 @@ export function getInitializedSourceBuffer$(
   if (mediaSourceSubscription === undefined) {
     mediaSourceSubscription =
       prepareSourceBuffer(element, representation.getMimeTypeString())
-        .subscribe(
-          (sourceBuffer) => sourceBuffer$.next(sourceBuffer),
-          (err: Error) => {
+        .subscribe({
+          next: (sourceBuffer) => sourceBuffer$.next(sourceBuffer),
+          error: (err: Error) => {
             mediaSourceError$.next(
               new Error("VideoThumbnailLoaderError: Error when creating" +
                       " media source or source buffer: " + err.toString())
             );
-          }
-        );
+          },
+        });
   }
 
   return observableMerge(sourceBuffer$,
@@ -175,9 +145,8 @@ export function getInitializedSourceBuffer$(
       return loadAndPushInitData(contentInfos,
                                  initSegment,
                                  sourceBuffer,
-                                 segmentParser,
-                                 segmentLoader)
-        .pipe(mapTo(sourceBuffer));
+                                 segmentFetcher)
+        .pipe(map(() => sourceBuffer));
     }),
     tap(() => { sourceBufferContent = contentInfos; })
   );

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

@@ -1,9 +1,10 @@
 import { combineLatest, Observable } from "rxjs";
-import {
-  ISegmentLoaderContent,
-  ISegmentLoaderEvent,
-} from "../../../core/fetchers/segment/create_segment_loader";
+import { ISegmentFetcher } from "../../../core/fetchers/segment/segment_fetcher";
 import { ISegment } from "../../../manifest";
+import {
+  ISegmentParserParsedInitChunk,
+  ISegmentParserParsedMediaChunk,
+} from "../../../transports";
 import { createRequest, freeRequest } from "./create_request";
 import getCompleteSegmentId from "./get_complete_segment_id";
 import { IContentInfos } from "./types";
@@ -18,22 +19,22 @@ import { IContentInfos } from "./types";
  */
 export default function loadSegments(
   segments: ISegment[],
-  segmentLoader: (
-    x : ISegmentLoaderContent
-  ) => Observable<ISegmentLoaderEvent<Uint8Array |
-                                      ArrayBuffer |
-                                      null>>,
+  segmentFetcher : ISegmentFetcher<ArrayBuffer | Uint8Array>,
   contentInfos: IContentInfos
-): Observable<Array<{ segment: ISegment;
-                      data: Uint8Array; }>> {
+): Observable<Array<{
+  segment: ISegment;
+  data: ISegmentParserParsedMediaChunk<ArrayBuffer | Uint8Array> |
+        ISegmentParserParsedInitChunk<ArrayBuffer | Uint8Array>;
+}>> {
   return combineLatest(
     segments.map((segment) => {
       return new Observable<{
         segment: ISegment;
-        data: Uint8Array; }
+        data: ISegmentParserParsedMediaChunk<ArrayBuffer | Uint8Array> |
+              ISegmentParserParsedInitChunk<ArrayBuffer | Uint8Array>; }
       >((obs) => {
         const completeSegmentId = getCompleteSegmentId(contentInfos, segment);
-        const request = createRequest(segmentLoader, contentInfos, segment);
+        const request = createRequest(segmentFetcher, contentInfos, segment);
 
         if (request.error !== undefined) {
           freeRequest(completeSegmentId);
@@ -48,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";
 
@@ -29,10 +31,8 @@ export default function prepareSourceBuffer(elt: HTMLVideoElement,
                                             codec: string
 ): Observable<AudioVideoSegmentBuffer> {
   return openMediaSource(elt).pipe(
-    map((mediaSource) => {
-      const segmentBuffer =
-        new AudioVideoSegmentBuffer("video", codec, mediaSource);
-      return segmentBuffer;
-    })
+    map((mediaSource) =>
+      new AudioVideoSegmentBuffer("video", codec, mediaSource)
+    )
   );
 }

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

@@ -1,8 +1,6 @@
 import {
-  EMPTY,
   Observable,
 } from "rxjs";
-import { mergeMap } from "rxjs/operators";
 import { AudioVideoSegmentBuffer } from "../../../core/segment_buffers/implementations";
 import Manifest, {
   Adaptation,
@@ -10,7 +8,7 @@ import Manifest, {
   Period,
   Representation,
 } from "../../../manifest";
-import { IThumbnailLoaderSegmentParser } from "./types";
+import { ISegmentParserParsedMediaChunk } from "../../../transports";
 
 /**
  * Push data to the video source buffer.
@@ -28,30 +26,18 @@ export default function pushData(
                     segment: ISegment;
                     start: number;
                     end: number; },
-  segmentParser: IThumbnailLoaderSegmentParser,
-  responseData: Uint8Array,
+  parsed: ISegmentParserParsedMediaChunk<Uint8Array | ArrayBuffer>,
   videoSourceBuffer: AudioVideoSegmentBuffer
 ): Observable<void> {
-  return segmentParser({
-    response: { data: responseData,
-                isChunked: false },
-    content: inventoryInfos,
-  }).pipe(
-    mergeMap((parserEvt) => {
-      if (parserEvt.type !== "parsed-segment") {
-        return EMPTY;
-      }
-      const { chunkData, appendWindow } = parserEvt.value;
-      const segmentData = chunkData instanceof ArrayBuffer ?
-        new Uint8Array(chunkData) : chunkData;
-      return videoSourceBuffer
-        .pushChunk({ data: { chunk: segmentData,
-                             timestampOffset: 0,
-                             appendWindow,
-                             initSegment: null,
-                             codec: inventoryInfos
-                               .representation.getMimeTypeString() },
-                     inventoryInfos });
-    })
-  );
+  const { chunkData, appendWindow } = parsed;
+  const segmentData = chunkData instanceof ArrayBuffer ?
+    new Uint8Array(chunkData) : chunkData;
+  return videoSourceBuffer
+    .pushChunk({ data: { chunk: segmentData,
+                         timestampOffset: 0,
+                         appendWindow,
+                         initSegment: null,
+                         codec: inventoryInfos
+                           .representation.getMimeTypeString() },
+                 inventoryInfos });
 }