rx-player 3.25.2 → 3.26.3-dev.2022021400

package/src/transports/metaplaylist/pipelines.ts

@@ -14,18 +14,6 @@
  * limitations under the License.
  */
 
-import {
-  combineLatest,
-  merge as observableMerge,
-  Observable,
-  of as observableOf,
-} from "rxjs";
-import {
-  filter,
-  map,
-  mergeMap,
-  share,
-} from "rxjs/operators";
 import features from "../../features";
 import Manifest, {
   Adaptation,
@@ -38,21 +26,27 @@ import parseMetaPlaylist, {
   IParserResponse as IMPLParserResponse,
 } from "../../parsers/manifest/metaplaylist";
 import { IParsedManifest } from "../../parsers/manifest/types";
-import deferSubscriptions from "../../utils/defer_subscriptions";
 import isNullOrUndefined from "../../utils/is_null_or_undefined";
 import objectAssign from "../../utils/object_assign";
+import PPromise from "../../utils/promise";
+import { CancellationSignal } from "../../utils/task_canceller";
 import {
   IChunkTimeInfo,
   IImageTrackSegmentData,
-  ILoaderDataLoadedValue,
-  IManifestParserArguments,
-  IManifestParserResponseEvent,
-  IManifestParserWarningEvent,
-  ISegmentLoaderArguments,
-  ISegmentParserArguments,
-  ISegmentParserInitSegment,
-  ISegmentParserParsedSegment,
-  ISegmentParserSegment,
+  ILoadedAudioVideoSegmentFormat,
+  ILoadedImageSegmentFormat,
+  ILoadedTextSegmentFormat,
+  IManifestParserOptions,
+  IManifestParserRequestScheduler,
+  IManifestParserResult,
+  IRequestedData,
+  ISegmentContext,
+  ISegmentLoaderCallbacks,
+  ISegmentLoaderResultChunkedComplete,
+  ISegmentLoaderResultSegmentCreated,
+  ISegmentLoaderResultSegmentLoaded,
+  ISegmentParserParsedInitChunk,
+  ISegmentParserParsedMediaChunk,
   ITextTrackSegmentData,
   ITransportOptions,
   ITransportPipelines,
@@ -86,36 +80,6 @@ function getOriginalContent(segment : ISegment) : { manifest : Manifest;
             segment: originalSegment };
 }
 
-/**
- * Prepare any wrapped segment loader's arguments.
- * @param {Object} segment
- * @param {number} offset
- * @returns {Object}
- */
-function getLoaderArguments(
-  segment : ISegment,
-  url : string | null
-) : ISegmentLoaderArguments {
-  const content = getOriginalContent(segment);
-  return objectAssign({ url }, content);
-}
-
-/**
- * Prepare any wrapped segment parser's arguments.
- * @param {Object} arguments
- * @param {Object} segment
- * @param {number} offset
- * @returns {Object}
- */
-function getParserArguments<T>(
-  { initTimescale, response } : ISegmentParserArguments<T>,
-  segment : ISegment
-) : ISegmentParserArguments<T> {
-  return { initTimescale,
-           response,
-           content: getOriginalContent(segment) };
-}
-
 /**
  * @param {Object} transports
  * @param {string} transportName
@@ -169,73 +133,54 @@ export default function(options : ITransportOptions): ITransportPipelines {
                                                supplementaryImageTracks: [] });
 
   const manifestPipeline = {
-    loader: manifestLoader,
-    parser(
-      { response,
-        url: loaderURL,
-        previousManifest,
-        scheduleRequest,
-        unsafeMode,
-        externalClockOffset } : IManifestParserArguments
-    ) : Observable<IManifestParserWarningEvent | IManifestParserResponseEvent> {
-      const url = response.url === undefined ? loaderURL :
-                                               response.url;
-      const { responseData } = response;
-
-      const parserOptions = { url,
-                              serverSyncInfos: options.serverSyncInfos };
-
-      return handleParsedResult(parseMetaPlaylist(responseData, parserOptions));
+    loadManifest: manifestLoader,
+
+    parseManifest(
+      manifestData : IRequestedData<unknown>,
+      parserOptions : IManifestParserOptions,
+      onWarnings : (warnings: Error[]) => void,
+      cancelSignal : CancellationSignal,
+      scheduleRequest : IManifestParserRequestScheduler
+    ) : Promise<IManifestParserResult> {
+      const url = manifestData.url ?? parserOptions.originalUrl;
+      const { responseData } = manifestData;
+
+      const mplParserOptions = { url,
+                                 serverSyncInfos: options.serverSyncInfos };
+      const parsed = parseMetaPlaylist(responseData, mplParserOptions);
+
+      return handleParsedResult(parsed);
 
       function handleParsedResult(
         parsedResult : IMPLParserResponse<IParsedManifest>
-      ) : Observable<IManifestParserWarningEvent | IManifestParserResponseEvent> {
+      ) : Promise<IManifestParserResult> {
         if (parsedResult.type === "done") {
           const manifest = new Manifest(parsedResult.value, options);
-          return observableOf({ type: "parsed",
-                                value: { manifest } });
+          return PPromise.resolve({ manifest });
         }
 
-        const loaders$ = parsedResult.value.ressources.map((ressource) => {
+        const parsedValue = parsedResult.value;
+        const loaderProms = parsedValue.ressources.map((resource) => {
           const transport = getTransportPipelines(transports,
-                                                  ressource.transportType,
+                                                  resource.transportType,
                                                   otherTransportOptions);
-          const request$ = scheduleRequest(() =>
-            transport.manifest.loader({ url : ressource.url }).pipe(
-              filter(
-                (e): e is { type : "data-loaded";
-                            value : ILoaderDataLoadedValue<Document | string>; } =>
-                  e.type === "data-loaded"
-              ),
-              map((e) : ILoaderDataLoadedValue< Document | string > => e.value)
-            ));
-
-          return request$.pipe(mergeMap((responseValue) => {
-            return transport.manifest.parser({ response: responseValue,
-                                               url: ressource.url,
-                                               scheduleRequest,
-                                               previousManifest,
-                                               unsafeMode,
-                                               externalClockOffset });
-          })).pipe(deferSubscriptions(), share());
+          return scheduleRequest(loadSubManifest)
+            .then((data) =>
+              transport.manifest.parseManifest(data,
+                                               { ...parserOptions,
+                                                 originalUrl: resource.url },
+                                               onWarnings,
+                                               cancelSignal,
+                                               scheduleRequest));
+          function loadSubManifest() {
+            return transport.manifest.loadManifest(resource.url, cancelSignal);
+          }
         });
 
-        const warnings$ : Array<Observable<IManifestParserWarningEvent>> =
-          loaders$.map(loader =>
-            loader.pipe(filter((evt) : evt is IManifestParserWarningEvent =>
-              evt.type === "warning")));
-
-        const responses$ : Array<Observable<IManifestParserResponseEvent>> =
-          loaders$.map(loader =>
-            loader.pipe(filter((evt) : evt is IManifestParserResponseEvent =>
-              evt.type === "parsed")));
-
-        return observableMerge(
-          combineLatest(responses$).pipe(mergeMap((evt) => {
-            const loadedRessources = evt.map(e => e.value.manifest);
-            return handleParsedResult(parsedResult.value.continue(loadedRessources));
-          })),
-          ...warnings$);
+        return PPromise.all(loaderProms).then(parsedReqs => {
+          const loadedRessources = parsedReqs.map(e => e.manifest);
+          return handleParsedResult(parsedResult.value.continue(loadedRessources));
+        });
       }
     },
   };
@@ -262,7 +207,7 @@ export default function(options : ITransportOptions): ITransportPipelines {
   function offsetTimeInfos(
     contentOffset : number,
     contentEnd : number | undefined,
-    segmentResponse : ISegmentParserParsedSegment<unknown>
+    segmentResponse : ISegmentParserParsedMediaChunk<unknown>
   ) : { chunkInfos : IChunkTimeInfo | null;
         chunkOffset : number;
         appendWindow : [ number | undefined, number | undefined ]; } {
@@ -299,118 +244,150 @@ export default function(options : ITransportOptions): ITransportPipelines {
   }
 
   const audioPipeline = {
-    loader({ segment, url } : ISegmentLoaderArguments) {
+    loadSegment(
+      url : string | null,
+      content : ISegmentContext,
+      cancelToken : CancellationSignal,
+      callbacks : ISegmentLoaderCallbacks<ILoadedAudioVideoSegmentFormat>
+    ) : Promise<ISegmentLoaderResultSegmentLoaded<ILoadedAudioVideoSegmentFormat> |
+                ISegmentLoaderResultSegmentCreated<ILoadedAudioVideoSegmentFormat> |
+                ISegmentLoaderResultChunkedComplete>
+    {
+      const { segment } = content;
       const { audio } = getTransportPipelinesFromSegment(segment);
-      return audio.loader(getLoaderArguments(segment, url));
+      const ogContent = getOriginalContent(segment);
+      return audio.loadSegment(url, ogContent, cancelToken, callbacks);
     },
 
-    parser(
-      args : ISegmentParserArguments<Uint8Array|ArrayBuffer|null>
-    ) : Observable<ISegmentParserSegment<ArrayBuffer | Uint8Array | null>  |
-                   ISegmentParserInitSegment<ArrayBuffer | Uint8Array | null>>
+    parseSegment(
+      loadedSegment : { data : ILoadedAudioVideoSegmentFormat; isChunked : boolean },
+      content : ISegmentContext,
+      initTimescale : number | undefined
+    ) : ISegmentParserParsedInitChunk<ArrayBuffer | Uint8Array | null> |
+        ISegmentParserParsedMediaChunk<ArrayBuffer | Uint8Array | null>
     {
-      const { content } = args;
       const { segment } = content;
       const { contentStart, contentEnd } = getMetaPlaylistPrivateInfos(segment);
       const { audio } = getTransportPipelinesFromSegment(segment);
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-      return audio.parser(getParserArguments(args, segment))
-        .pipe(map(res => {
-          if (res.type === "parsed-init-segment") {
-            return res;
-          }
-          const timeInfos = offsetTimeInfos(contentStart, contentEnd, res.value);
-         // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-          return objectAssign({ type: "parsed-segment",
-                                value: objectAssign({}, res.value, timeInfos) });
-        }));
+      const ogContent = getOriginalContent(segment);
+
+      const parsed = audio.parseSegment(loadedSegment, ogContent, initTimescale);
+      if (parsed.segmentType === "init") {
+        return parsed;
+      }
+      const timeInfos = offsetTimeInfos(contentStart, contentEnd, parsed);
+      return objectAssign({}, parsed, timeInfos);
     },
   };
 
   const videoPipeline = {
-    loader({ segment, url } : ISegmentLoaderArguments) {
+    loadSegment(
+      url : string | null,
+      content : ISegmentContext,
+      cancelToken : CancellationSignal,
+      callbacks : ISegmentLoaderCallbacks<ILoadedAudioVideoSegmentFormat>
+    ) : Promise<ISegmentLoaderResultSegmentLoaded<ILoadedAudioVideoSegmentFormat> |
+                ISegmentLoaderResultSegmentCreated<ILoadedAudioVideoSegmentFormat> |
+                ISegmentLoaderResultChunkedComplete>
+    {
+      const { segment } = content;
       const { video } = getTransportPipelinesFromSegment(segment);
-      return video.loader(getLoaderArguments(segment, url));
+      const ogContent = getOriginalContent(segment);
+      return video.loadSegment(url, ogContent, cancelToken, callbacks);
     },
 
-    parser(
-      args : ISegmentParserArguments<Uint8Array|ArrayBuffer|null>
-    ) : Observable<ISegmentParserSegment<ArrayBuffer | Uint8Array | null>  |
-                   ISegmentParserInitSegment<ArrayBuffer | Uint8Array | null>>
+    parseSegment(
+      loadedSegment : { data : ILoadedAudioVideoSegmentFormat; isChunked : boolean },
+      content : ISegmentContext,
+      initTimescale : number | undefined
+    ) : ISegmentParserParsedInitChunk<ArrayBuffer | Uint8Array | null> |
+        ISegmentParserParsedMediaChunk<ArrayBuffer | Uint8Array | null>
     {
-      const { content } = args;
       const { segment } = content;
       const { contentStart, contentEnd } = getMetaPlaylistPrivateInfos(segment);
       const { video } = getTransportPipelinesFromSegment(segment);
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-      return video.parser(getParserArguments(args, segment))
-        .pipe(map(res => {
-          if (res.type === "parsed-init-segment") {
-            return res;
-          }
-          const timeInfos = offsetTimeInfos(contentStart, contentEnd, res.value);
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-          return objectAssign({ type: "parsed-segment",
-                                value: objectAssign({}, res.value, timeInfos) });
-        }));
+      const ogContent = getOriginalContent(segment);
+
+      const parsed = video.parseSegment(loadedSegment, ogContent, initTimescale);
+      if (parsed.segmentType === "init") {
+        return parsed;
+      }
+      const timeInfos = offsetTimeInfos(contentStart, contentEnd, parsed);
+      return objectAssign({}, parsed, timeInfos);
     },
   };
 
   const textTrackPipeline = {
-    loader({ segment, url } : ISegmentLoaderArguments) {
+    loadSegment(
+      url : string | null,
+      content : ISegmentContext,
+      cancelToken : CancellationSignal,
+      callbacks : ISegmentLoaderCallbacks<ILoadedTextSegmentFormat>
+    ) : Promise<ISegmentLoaderResultSegmentLoaded<ILoadedTextSegmentFormat> |
+                ISegmentLoaderResultSegmentCreated<ILoadedTextSegmentFormat> |
+                ISegmentLoaderResultChunkedComplete>
+    {
+      const { segment } = content;
       const { text } = getTransportPipelinesFromSegment(segment);
-      return text.loader(getLoaderArguments(segment, url));
+      const ogContent = getOriginalContent(segment);
+      return text.loadSegment(url, ogContent, cancelToken, callbacks);
     },
 
-    parser(
-      args: ISegmentParserArguments<ArrayBuffer|string|Uint8Array|null>
-    ) : Observable<ISegmentParserInitSegment<null> |
-                   ISegmentParserSegment<ITextTrackSegmentData>>
+    parseSegment(
+      loadedSegment : { data : ILoadedTextSegmentFormat; isChunked : boolean },
+      content : ISegmentContext,
+      initTimescale : number | undefined
+    ) : ISegmentParserParsedInitChunk<ITextTrackSegmentData | null> |
+        ISegmentParserParsedMediaChunk<ITextTrackSegmentData>
     {
-      const { content } = args;
       const { segment } = content;
       const { contentStart, contentEnd } = getMetaPlaylistPrivateInfos(segment);
       const { text } = getTransportPipelinesFromSegment(segment);
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-      return text.parser(getParserArguments(args, segment))
-        .pipe(map(res => {
-          if (res.type === "parsed-init-segment") {
-            return res;
-          }
-          const timeInfos = offsetTimeInfos(contentStart, contentEnd, res.value);
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-          return objectAssign({ type: "parsed-segment",
-                                value: objectAssign({}, res.value, timeInfos) });
-        }));
+      const ogContent = getOriginalContent(segment);
+
+      const parsed = text.parseSegment(loadedSegment, ogContent, initTimescale);
+      if (parsed.segmentType === "init") {
+        return parsed;
+      }
+      const timeInfos = offsetTimeInfos(contentStart, contentEnd, parsed);
+      return objectAssign({}, parsed, timeInfos);
     },
   };
 
   const imageTrackPipeline = {
-    loader({ segment, url } : ISegmentLoaderArguments) {
+    loadSegment(
+      url : string | null,
+      content : ISegmentContext,
+      cancelToken : CancellationSignal,
+      callbacks : ISegmentLoaderCallbacks<ILoadedImageSegmentFormat>
+    ) : Promise<ISegmentLoaderResultSegmentLoaded<ILoadedImageSegmentFormat> |
+                ISegmentLoaderResultSegmentCreated<ILoadedImageSegmentFormat> |
+                ISegmentLoaderResultChunkedComplete>
+    {
+      const { segment } = content;
       const { image } = getTransportPipelinesFromSegment(segment);
-      return image.loader(getLoaderArguments(segment, url));
+      const ogContent = getOriginalContent(segment);
+      return image.loadSegment(url, ogContent, cancelToken, callbacks);
     },
 
-    parser(
-      args : ISegmentParserArguments<ArrayBuffer|Uint8Array|null>
-    ) : Observable<ISegmentParserInitSegment<null>  |
-                   ISegmentParserSegment<IImageTrackSegmentData>>
+    parseSegment(
+      loadedSegment : { data : ILoadedImageSegmentFormat; isChunked : boolean },
+      content : ISegmentContext,
+      initTimescale : number | undefined
+    ) : ISegmentParserParsedInitChunk<IImageTrackSegmentData | null> |
+        ISegmentParserParsedMediaChunk<IImageTrackSegmentData>
     {
-      const { content } = args;
       const { segment } = content;
       const { contentStart, contentEnd } = getMetaPlaylistPrivateInfos(segment);
       const { image } = getTransportPipelinesFromSegment(segment);
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-      return image.parser(getParserArguments(args, segment))
-        .pipe(map(res => {
-          if (res.type === "parsed-init-segment") {
-            return res;
-          }
-          const timeInfos = offsetTimeInfos(contentStart, contentEnd, res.value);
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-          return objectAssign({ type: "parsed-segment",
-                                value: objectAssign({}, res.value, timeInfos) });
-        }));
+      const ogContent = getOriginalContent(segment);
+
+      const parsed = image.parseSegment(loadedSegment, ogContent, initTimescale);
+      if (parsed.segmentType === "init") {
+        return parsed;
+      }
+      const timeInfos = offsetTimeInfos(contentStart, contentEnd, parsed);
+      return objectAssign({}, parsed, timeInfos);
     },
   };
 

package/src/transports/smooth/extract_timings_infos.ts

@@ -111,7 +111,7 @@ export default function extractTimingsInfos(
              scaledSegmentTime: tfxdSegment.time };
   }
 
-  if (isChunked) {
+  if (isChunked || !segment.complete) {
     return { nextSegments,
              chunkInfos: null,
              scaledSegmentTime: undefined };

package/src/transports/smooth/isobmff/create_boxes.ts

@@ -327,11 +327,11 @@ function createMDHDBox(timescale : number) : Uint8Array {
   return createBox("mdhd", concat(12, itobe4(timescale), 8));
 }
 
-  /**
-   * @param {Number} timescale
-   * @param {Number} trackId
-   * @returns {Uint8Array}
-   */
+/**
+ * @param {Number} timescale
+ * @param {Number} trackId
+ * @returns {Uint8Array}
+ */
 function createMVHDBox(timescale : number, trackId : number) : Uint8Array {
   return createBox("mvhd", concat(
     12,

package/src/transports/smooth/isobmff/create_video_init_segment.ts

@@ -38,10 +38,7 @@ import createInitSegment from "./create_init_segment";
  * @param {Number} vRes
  * @param {Number} nalLength (1, 2 or 4)
  * @param {string} codecPrivateData
- * @param {Uint8Array} keyId - hex string representing the key Id,
- * 32 chars. eg. a800dbed49c12c4cb8e0b25643844b9b
- * @param {Array.<Object>} [pssList] - List of dict, example:
- * {systemId: "DEADBEEF", codecPrivateData: "DEAFBEEF}
+ * @param {Uint8Array} [keyId]
  * @returns {Uint8Array}
  */
 export default function createVideoInitSegment(