rx-player 3.25.2 → 3.26.3-dev.2022021400

package/src/transports/dash/image_pipelines.ts

@@ -14,37 +14,51 @@
  * limitations under the License.
  */
 
-import {
-  Observable,
-  of as observableOf,
-} from "rxjs";
 import features from "../../features";
+import PPromise from "../../utils/promise";
 import request from "../../utils/request";
 import takeFirstSet from "../../utils/take_first_set";
+import { CancellationSignal } from "../../utils/task_canceller";
 import {
   IImageTrackSegmentData,
-  ISegmentLoaderArguments,
-  ISegmentLoaderEvent,
-  ISegmentParserArguments,
-  ISegmentParserInitSegment,
-  ISegmentParserSegment,
+  ILoadedImageSegmentFormat,
+  ISegmentContext,
+  ISegmentLoaderCallbacks,
+  ISegmentLoaderResultChunkedComplete,
+  ISegmentLoaderResultSegmentCreated,
+  ISegmentLoaderResultSegmentLoaded,
+  ISegmentParserParsedInitChunk,
+  ISegmentParserParsedMediaChunk,
 } from "../types";
 
 /**
  * Loads an image segment.
- * @param {Object} args
- * @returns {Observable}
+ * @param {string|null} url
+ * @param {Object} content
+ * @param {Object} cancelSignal
+ * @param {Object} callbacks
+ * @returns {Promise}
  */
 export function imageLoader(
-  { segment, url } : ISegmentLoaderArguments
-) : Observable< ISegmentLoaderEvent< ArrayBuffer | null > > {
+  url : string | null,
+  content : ISegmentContext,
+  cancelSignal : CancellationSignal,
+  callbacks : ISegmentLoaderCallbacks<ILoadedImageSegmentFormat>
+) : Promise<ISegmentLoaderResultSegmentLoaded<ILoadedImageSegmentFormat> |
+            ISegmentLoaderResultSegmentCreated<ILoadedImageSegmentFormat> |
+            ISegmentLoaderResultChunkedComplete>
+{
+  const { segment } = content;
   if (segment.isInit || url === null) {
-    return observableOf({ type: "data-created" as const,
-                          value: { responseData: null } });
+    return PPromise.resolve({ resultType: "segment-created",
+                              resultData: null });
   }
   return request({ url,
                    responseType: "arraybuffer",
-                   sendProgressEvents: true });
+                   onProgress: callbacks.onProgress,
+                   cancelSignal })
+    .then((data) => ({ resultType: "segment-loaded",
+                       resultData: data }));
 }
 
 /**
@@ -53,19 +67,19 @@ export function imageLoader(
  * @returns {Object}
  */
 export function imageParser(
-  { response,
-    content } : ISegmentParserArguments<Uint8Array|ArrayBuffer|null>
-) : Observable<ISegmentParserInitSegment<null> |
-               ISegmentParserSegment<IImageTrackSegmentData>>
-{
+  loadedSegment : { data : ArrayBuffer | Uint8Array | null;
+                    isChunked : boolean; },
+  content : ISegmentContext
+) : ISegmentParserParsedMediaChunk< IImageTrackSegmentData | null > |
+    ISegmentParserParsedInitChunk< null > {
   const { segment, period } = content;
-  const { data, isChunked } = response;
+  const { data, isChunked } = loadedSegment;
 
   if (content.segment.isInit) { // image init segment has no use
-    return observableOf({ type: "parsed-init-segment",
-                          value: { initializationData: null,
-                                   protectionDataUpdate: false,
-                                   initTimescale: undefined } });
+    return { segmentType: "init",
+             initializationData: null,
+             protectionDataUpdate: false,
+             initTimescale: undefined };
   }
 
   if (isChunked) {
@@ -76,27 +90,26 @@ export function imageParser(
 
   // TODO image Parsing should be more on the buffer side, no?
   if (data === null || features.imageParser === null) {
-    return observableOf({ type: "parsed-segment",
-                          value: { chunkData: null,
-                                   chunkInfos: { duration: segment.duration,
-                                                 time: segment.time },
-                                   chunkOffset,
-                                   appendWindow: [period.start, period.end],
-                                   protectionDataUpdate: false } });
+    return { segmentType: "media",
+             chunkData: null,
+             chunkInfos: { duration: segment.duration,
+                           time: segment.time },
+             chunkOffset,
+             protectionDataUpdate: false,
+             appendWindow: [period.start, period.end] };
   }
 
   const bifObject = features.imageParser(new Uint8Array(data));
   const thumbsData = bifObject.thumbs;
-  return observableOf({ type: "parsed-segment",
-                        value: { chunkData: { data: thumbsData,
-                                              start: 0,
-                                              end: Number.MAX_VALUE,
-                                              timescale: 1,
-                                              type: "bif" },
-                                 chunkInfos: { time: 0,
-                                               duration: Number.MAX_VALUE,
-                                               timescale: bifObject.timescale },
-                                 chunkOffset,
-                                 appendWindow: [period.start, period.end],
-                                 protectionDataUpdate: false } });
+  return { segmentType: "media",
+           chunkData: { data: thumbsData,
+                        start: 0,
+                        end: Number.MAX_VALUE,
+                        timescale: 1,
+                        type: "bif" },
+           chunkInfos: { time: 0,
+                         duration: Number.MAX_VALUE },
+           chunkOffset,
+           protectionDataUpdate: false,
+           appendWindow: [period.start, period.end] };
 }

package/src/transports/dash/init_segment_loader.ts

@@ -14,71 +14,94 @@
  * limitations under the License.
  */
 
-import {
-  combineLatest as observableCombineLatest,
-  Observable,
-} from "rxjs";
-import { map } from "rxjs/operators";
+import { ISegment } from "../../manifest";
 import { concat } from "../../utils/byte_parsing";
-import xhr from "../../utils/request";
+import PPromise from "../../utils/promise";
+import request from "../../utils/request";
+import { CancellationSignal } from "../../utils/task_canceller";
 import {
-  ISegmentLoaderArguments,
-  ISegmentLoaderEvent,
+  ISegmentLoaderCallbacks,
+  ISegmentLoaderResultChunkedComplete,
+  ISegmentLoaderResultSegmentCreated,
+  ISegmentLoaderResultSegmentLoaded,
 } from "../types";
 import byteRange from "../utils/byte_range";
 
 /**
  * Perform a request for an initialization segment, agnostic to the container.
  * @param {string} url
- * @param {Object} content
+ * @param {Object} segment
+ * @param {CancellationSignal} cancelSignal
+ * @param {Object} callbacks
+ * @returns {Promise}
  */
 export default function initSegmentLoader(
   url : string,
-  { segment } : ISegmentLoaderArguments
-) : Observable< ISegmentLoaderEvent< ArrayBuffer | Uint8Array >> {
+  segment : ISegment,
+  cancelSignal : CancellationSignal,
+  callbacks : ISegmentLoaderCallbacks<ArrayBuffer | Uint8Array>
+) : Promise<ISegmentLoaderResultSegmentLoaded<ArrayBuffer | Uint8Array> |
+            ISegmentLoaderResultSegmentCreated<ArrayBuffer | Uint8Array> |
+            ISegmentLoaderResultChunkedComplete>
+{
   if (segment.range === undefined) {
-    return xhr({ url, responseType: "arraybuffer", sendProgressEvents: true });
+    return request({ url,
+                     responseType: "arraybuffer",
+                     cancelSignal,
+                     onProgress: callbacks.onProgress })
+      .then(data => ({ resultType: "segment-loaded",
+                       resultData: data }));
   }
 
   if (segment.indexRange === undefined) {
-    return xhr({ url,
-                 headers: { Range: byteRange(segment.range) },
-                 responseType: "arraybuffer",
-                 sendProgressEvents: true });
+    return request({ url,
+                     headers: { Range: byteRange(segment.range) },
+                     responseType: "arraybuffer",
+                     cancelSignal,
+                     onProgress: callbacks.onProgress })
+      .then(data => ({ resultType: "segment-loaded",
+                       resultData: data }));
   }
 
   // range and indexRange are contiguous (99% of the cases)
   if (segment.range[1] + 1 === segment.indexRange[0]) {
-    return xhr({ url,
-                 headers: { Range: byteRange([segment.range[0],
-                                              segment.indexRange[1] ]) },
-                 responseType: "arraybuffer",
-                 sendProgressEvents: true });
+    return request({ url,
+                     headers: { Range: byteRange([segment.range[0],
+                                                  segment.indexRange[1] ]) },
+                     responseType: "arraybuffer",
+                     cancelSignal,
+                     onProgress: callbacks.onProgress })
+      .then(data => ({ resultType: "segment-loaded",
+                       resultData: data }));
   }
 
-  const rangeRequest$ = xhr({ url,
-                              headers: { Range: byteRange(segment.range) },
-                              responseType: "arraybuffer",
-                              sendProgressEvents: false });
-  const indexRequest$ = xhr({ url,
-                              headers: { Range: byteRange(segment.indexRange) },
-                              responseType: "arraybuffer",
-                              sendProgressEvents: false });
-  return observableCombineLatest([rangeRequest$, indexRequest$])
-    .pipe(map(([initData, indexData]) => {
-      const data = concat(new Uint8Array(initData.value.responseData),
-                          new Uint8Array(indexData.value.responseData));
+  const rangeRequest$ = request({ url,
+                                  headers: { Range: byteRange(segment.range) },
+                                  responseType: "arraybuffer",
+                                  cancelSignal,
+                                  onProgress: callbacks.onProgress });
+  const indexRequest$ = request({ url,
+                                  headers: { Range: byteRange(segment.indexRange) },
+                                  responseType: "arraybuffer",
+                                  cancelSignal,
+                                  onProgress: callbacks.onProgress });
+
+  return PPromise.all([rangeRequest$, indexRequest$])
+    .then(([ initData, indexData ]) => {
+      const data = concat(new Uint8Array(initData.responseData),
+                          new Uint8Array(indexData.responseData));
+
+      const sendingTime = Math.min(initData.sendingTime,
+                                   indexData.sendingTime);
+      const receivedTime = Math.max(initData.receivedTime,
+                                    indexData.receivedTime);
+      return { resultType: "segment-loaded" as const,
+               resultData: { url,
+                             responseData: data,
+                             size: initData.size + indexData.size,
+                             requestDuration: receivedTime - sendingTime,
+                             sendingTime,
+                             receivedTime } };
 
-      const sendingTime = Math.min(initData.value.sendingTime,
-                                   indexData.value.sendingTime);
-      const receivedTime = Math.max(initData.value.receivedTime,
-                                    indexData.value.receivedTime);
-      return { type: "data-loaded",
-               value: { url,
-                        responseData: data,
-                        size: initData.value.size + indexData.value.size,
-                        duration: receivedTime - sendingTime,
-                        sendingTime,
-                        receivedTime } };
-    }));
+    });
 }

package/src/transports/dash/low_latency_segment_loader.ts

@@ -14,86 +14,70 @@
  * limitations under the License.
  */
 
-import {
-  Observable,
-  of as observableOf,
-} from "rxjs";
-import {
-  mergeMap,
-  scan,
-} from "rxjs/operators";
-import log from "../../log";
 import { concat } from "../../utils/byte_parsing";
 import fetchRequest, {
-  IDataChunk,
-  IDataComplete,
+  IFetchedDataObject,
 } from "../../utils/request/fetch";
+import { CancellationSignal } from "../../utils/task_canceller";
 import {
-  ILoaderProgressEvent,
-  ISegmentLoaderArguments,
-  ISegmentLoaderChunkEvent,
-  ISegmentLoaderEvent,
+  ISegmentContext,
+  ISegmentLoaderCallbacks,
+  ISegmentLoaderResultChunkedComplete,
 } from "../types";
 import byteRange from "../utils/byte_range";
 import extractCompleteChunks from "./extract_complete_chunks";
 
+/**
+ * Load segments through a "chunk" mode (decodable chunk by decodable chunk).
+ *
+ * This method is particularly adapted to low-latency streams.
+ *
+ * @param {string} url - URL of the segment to download.
+ * @param {Object} content - Context of the segment needed.
+ * @param {Object} callbacks
+ * @param {CancellationSignal} cancelSignal
+ * @returns {Promise}
+ */
 export default function lowLatencySegmentLoader(
   url : string,
-  args : ISegmentLoaderArguments
-) : Observable< ISegmentLoaderEvent<ArrayBuffer> > {
-  // Items emitted after processing fetch events
-  interface IScannedChunk {
-    event: IDataChunk | IDataComplete | null; // Event received from fetch
-    completeChunks: Uint8Array[]; // Complete chunks received on the event
-    partialChunk: Uint8Array | null; // Remaining incomplete chunk received on the event
-  }
-
-  const { segment } = args;
+  content : ISegmentContext,
+  callbacks : ISegmentLoaderCallbacks<Uint8Array>,
+  cancelSignal : CancellationSignal
+) : Promise<ISegmentLoaderResultChunkedComplete> {
+  const { segment } = content;
   const headers = segment.range !== undefined ? { Range: byteRange(segment.range) } :
                                                 undefined;
+  let partialChunk : Uint8Array | null = null;
 
-  return fetchRequest({ url, headers })
-    .pipe(
-      scan<IDataChunk | IDataComplete, IScannedChunk>((acc, evt) => {
-        if (evt.type === "data-complete") {
-          if (acc.partialChunk !== null) {
-            log.warn("DASH Pipelines: remaining chunk does not belong to any segment");
-          }
-          return { event: evt, completeChunks: [], partialChunk: null };
-        }
-
-        const data = new Uint8Array(evt.value.chunk);
-        const concatenated = acc.partialChunk !== null ? concat(acc.partialChunk,
-                                                                data) :
-                                                         data;
-        const [ completeChunks,
-                partialChunk ] = extractCompleteChunks(concatenated);
-        return { event: evt, completeChunks, partialChunk };
-      }, { event: null, completeChunks: [], partialChunk: null }),
+  /**
+   * Called each time `fetch` has new data available.
+   * @param {Object} info
+   */
+  function onData(info : IFetchedDataObject) : void {
+    const chunk = new Uint8Array(info.chunk);
+    const concatenated = partialChunk !== null ? concat(partialChunk, chunk) :
+                                                 chunk;
+    const res = extractCompleteChunks(concatenated);
+    const completeChunks = res[0];
+    partialChunk = res[1];
+    for (let i = 0; i < completeChunks.length; i++) {
+      callbacks.onNewChunk(completeChunks[i]);
+      if (cancelSignal.isCancelled) {
+        return;
+      }
+    }
+    callbacks.onProgress({ duration: info.duration,
+                           size: info.size,
+                           totalSize: info.totalSize });
+    if (cancelSignal.isCancelled) {
+      return;
+    }
+  }
 
-      mergeMap((evt : IScannedChunk) => {
-        const emitted : Array<ISegmentLoaderChunkEvent |
-                              ILoaderProgressEvent> = [];
-        for (let i = 0; i < evt.completeChunks.length; i++) {
-          emitted.push({ type: "data-chunk",
-                         value: { responseData: evt.completeChunks[i] } });
-        }
-        const { event } = evt;
-        if (event !== null && event.type === "data-chunk") {
-          const { value } = event;
-          emitted.push({ type: "progress",
-                         value: { duration: value.duration,
-                                  size: value.size,
-                                  totalSize: value.totalSize } });
-        } else if (event !== null && event.type === "data-complete") {
-          const { value } = event;
-          emitted.push({ type: "data-chunk-complete",
-                         value: { duration: value.duration,
-                                  receivedTime: value.receivedTime,
-                                  sendingTime: value.sendingTime,
-                                  size: value.size,
-                                  url: value.url } });
-        }
-        return observableOf(...emitted);
-      }));
+  return fetchRequest({ url,
+                        headers,
+                        onData,
+                        cancelSignal })
+    .then((res) => ({ resultType: "chunk-complete" as const,
+                      resultData: res }));
 }