rx-player 3.25.2 → 3.26.3-dev.2022021400

package/src/transports/dash/manifest_parser.ts

@@ -14,45 +14,39 @@
  * limitations under the License.
  */
 
-import {
-  combineLatest as observableCombineLatest,
-  concat as observableConcat,
-  from as observableFrom,
-  Observable,
-  of as observableOf,
-} from "rxjs";
-import {
-  filter,
-  map,
-  mergeMap,
-} from "rxjs/operators";
+import { formatError } from "../../errors";
 import features from "../../features";
 import log from "../../log";
 import Manifest from "../../manifest";
-import { IDashParserResponse } from "../../parsers/manifest/dash/parsers_types";
+import {
+  IDashParserResponse,
+  ILoadedResource,
+} from "../../parsers/manifest/dash/parsers_types";
 import objectAssign from "../../utils/object_assign";
+import PPromise from "../../utils/promise";
 import request from "../../utils/request";
 import {
   strToUtf8,
   utf8ToStr,
 } from "../../utils/string_parsing";
+import { CancellationSignal } from "../../utils/task_canceller";
 import {
-  ILoaderDataLoadedValue,
-  IManifestParserArguments,
-  IManifestParserResponseEvent,
-  IManifestParserWarningEvent,
+  IManifestParserOptions,
+  IManifestParserRequestScheduler,
+  IManifestParserResult,
+  IRequestedData,
   ITransportOptions,
 } from "../types";
-import returnParsedManifest from "../utils/return_parsed_manifest";
 
-/**
- * @param {Object} options
- * @returns {Function}
- */
 export default function generateManifestParser(
   options : ITransportOptions
-) : (x : IManifestParserArguments) => Observable<IManifestParserWarningEvent |
-                                                 IManifestParserResponseEvent>
+) : (
+    manifestData : IRequestedData<unknown>,
+    parserOptions : IManifestParserOptions,
+    onWarnings : (warnings : Error[]) => void,
+    cancelSignal : CancellationSignal,
+    scheduleRequest : IManifestParserRequestScheduler
+  ) => IManifestParserResult | Promise<IManifestParserResult>
 {
   const { aggressiveMode,
           referenceDateTime } = options;
@@ -60,24 +54,26 @@ export default function generateManifestParser(
     options.serverSyncInfos.serverTimestamp - options.serverSyncInfos.clientTime :
     undefined;
   return function manifestParser(
-    args : IManifestParserArguments
-  ) : Observable<IManifestParserWarningEvent | IManifestParserResponseEvent> {
-    const { response,
-            scheduleRequest,
-            url: loaderURL,
-            externalClockOffset: argClockOffset } = args;
-    const url = response.url ?? loaderURL;
-    const { responseData } = response;
+    manifestData : IRequestedData<unknown>,
+    parserOptions : IManifestParserOptions,
+    onWarnings : (warnings : Error[]) => void,
+    cancelSignal : CancellationSignal,
+    scheduleRequest : IManifestParserRequestScheduler
+  ) : IManifestParserResult | Promise<IManifestParserResult> {
+    const { responseData } = manifestData;
+    const argClockOffset = parserOptions.externalClockOffset;
+    const url = manifestData.url ?? parserOptions.originalUrl;
 
     const optAggressiveMode = aggressiveMode === true;
     const externalClockOffset = serverTimeOffset ?? argClockOffset;
-    const unsafelyBaseOnPreviousManifest = args.unsafeMode ? args.previousManifest :
-                                                             null;
-    const parserOpts = { aggressiveMode: optAggressiveMode,
-                         unsafelyBaseOnPreviousManifest,
-                         url,
-                         referenceDateTime,
-                         externalClockOffset };
+    const unsafelyBaseOnPreviousManifest = parserOptions.unsafeMode ?
+      parserOptions.previousManifest :
+      null;
+    const dashParserOpts = { aggressiveMode: optAggressiveMode,
+                             unsafelyBaseOnPreviousManifest,
+                             url,
+                             referenceDateTime,
+                             externalClockOffset };
 
     const parsers = features.dashParsers;
     if (parsers.wasm === null ||
@@ -96,22 +92,22 @@ export default function generateManifestParser(
 
       if (parsers.wasm.status === "initialized") {
         log.debug("DASH: Running WASM MPD Parser.");
-        const parsed = parsers.wasm.runWasmParser(manifestAB, parserOpts);
+        const parsed = parsers.wasm.runWasmParser(manifestAB, dashParserOpts);
         return processMpdParserResponse(parsed);
       } else {
         log.debug("DASH: Awaiting WASM initialization before parsing the MPD.");
         const initProm = parsers.wasm.waitForInitialization()
           .catch(() => { /* ignore errors, we will check the status later */ });
-        return observableFrom(initProm).pipe(mergeMap(() => {
+        return initProm.then(() => {
           if (parsers.wasm === null || parsers.wasm.status !== "initialized") {
             log.warn("DASH: WASM MPD parser initialization failed. " +
                      "Running JS parser instead");
             return runDefaultJsParser();
           }
           log.debug("DASH: Running WASM MPD Parser.");
-          const parsed = parsers.wasm.runWasmParser(manifestAB, parserOpts);
+          const parsed = parsers.wasm.runWasmParser(manifestAB, dashParserOpts);
           return processMpdParserResponse(parsed);
-        }));
+        });
       }
     }
 
@@ -126,7 +122,7 @@ export default function generateManifestParser(
         throw new Error("No MPD parser is imported");
       }
       const manifestDoc = getManifestAsDocument(responseData);
-      const parsedManifest = parsers.js(manifestDoc, parserOpts);
+      const parsedManifest = parsers.js(manifestDoc, dashParserOpts);
       return processMpdParserResponse(parsedManifest);
     }
 
@@ -138,54 +134,128 @@ export default function generateManifestParser(
      */
     function processMpdParserResponse(
       parserResponse : IDashParserResponse<string> | IDashParserResponse<ArrayBuffer>
-    ) : Observable<IManifestParserWarningEvent | IManifestParserResponseEvent> {
+    ) : IManifestParserResult | Promise<IManifestParserResult> {
       if (parserResponse.type === "done") {
-        const { warnings, parsed } = parserResponse.value;
-        const warningEvents = warnings.map(warning => ({ type: "warning" as const,
-                                                         value: warning }));
-        const manifest = new Manifest(parsed, options);
-        return observableConcat(observableOf(...warningEvents),
-                                returnParsedManifest(manifest, url));
+        if (parserResponse.value.warnings.length > 0) {
+          onWarnings(parserResponse.value.warnings);
+        }
+        if (cancelSignal.isCancelled) {
+          return PPromise.reject(cancelSignal.cancellationError);
+        }
+        const manifest = new Manifest(parserResponse.value.parsed, options);
+        return { manifest, url };
       }
 
       const { value } = parserResponse;
 
-      const externalResources$ = value.urls.map(resourceUrl =>
-        scheduleRequest(() =>
-          request<string | ArrayBuffer>({
-            url: resourceUrl,
-            responseType: value.format === "string" ? "text" :
-                                                      "arraybuffer",
-          }).pipe(
-            filter((e) => e.type === "data-loaded"),
-            map((e) : ILoaderDataLoadedValue<string | ArrayBuffer> => e.value))));
-
-      return observableCombineLatest(externalResources$)
-        .pipe(mergeMap(loadedResources => {
+      const externalResources = value.urls.map(resourceUrl => {
+        return scheduleRequest(() => {
+          return value.format === "string" ? request({ url: resourceUrl,
+                                                       responseType: "text",
+                                                       cancelSignal }) :
+
+                                             request({ url: resourceUrl,
+                                                       responseType: "arraybuffer",
+                                                       cancelSignal });
+        }).then((res) => {
           if (value.format === "string") {
-            const resources = loadedResources.map(resource => {
-              if (typeof resource.responseData !== "string") {
-                throw new Error("External DASH resources should have been a string");
-              }
-              // Normally not needed but TypeScript is just dumb here
-              return objectAssign(resource, { responseData: resource.responseData });
+            if (typeof res.responseData !== "string") {
+              throw new Error("External DASH resources should have been a string");
+            }
+            return objectAssign(res, {
+              responseData: {
+                success: true as const,
+                data: res.responseData },
             });
-            return processMpdParserResponse(value.continue(resources));
           } else {
-            const resources = loadedResources.map(resource => {
-              if (!(resource.responseData instanceof ArrayBuffer)) {
-                throw new Error("External DASH resources should have been ArrayBuffers");
-              }
-              // Normally not needed but TypeScript is just dumb here
-              return objectAssign(resource, { responseData: resource.responseData });
+            if (!(res.responseData instanceof ArrayBuffer)) {
+              throw new Error("External DASH resources should have been ArrayBuffers");
+            }
+            return objectAssign(res, {
+              responseData: {
+                success: true as const,
+                data: res.responseData },
             });
-            return processMpdParserResponse(value.continue(resources));
           }
-        }));
+        }, (err) => {
+          const error = formatError(err, {
+            defaultCode: "PIPELINE_PARSE_ERROR",
+            defaultReason: "An unknown error occured when parsing ressources.",
+          });
+          return objectAssign({}, {
+            size: undefined,
+            requestDuration: undefined,
+            responseData: {
+              success: false as const,
+              error },
+          });
+        });
+      });
+
+      return PPromise.all(externalResources).then(loadedResources => {
+        if (value.format === "string") {
+          assertLoadedResourcesFormatString(loadedResources);
+          return processMpdParserResponse(value.continue(loadedResources));
+        } else {
+          assertLoadedResourcesFormatArrayBuffer(loadedResources);
+          return processMpdParserResponse(value.continue(loadedResources));
+        }
+      });
     }
   };
 }
 
+/**
+ * Throw if the given input is not in the expected format.
+ * Allows to enforce runtime type-checking as compile-time type-checking here is
+ * difficult to enforce.
+ *
+ * @param loadedResource
+ * @returns
+ */
+function assertLoadedResourcesFormatString(
+  loadedResources : Array<ILoadedResource<string | ArrayBuffer>>
+) : asserts loadedResources is Array<ILoadedResource<string>> {
+  if (__ENVIRONMENT__.CURRENT_ENV === __ENVIRONMENT__.PRODUCTION as number) {
+    return;
+  }
+  loadedResources.forEach((loadedResource) => {
+    const { responseData } = loadedResource;
+    if (responseData.success && typeof responseData.data === "string") {
+      return;
+    } else if (!responseData.success) {
+      return;
+    }
+    throw new Error("Invalid data given to the LoadedRessource");
+  });
+}
+
+/**
+ * Throw if the given input is not in the expected format.
+ * Allows to enforce runtime type-checking as compile-time type-checking here is
+ * difficult to enforce.
+ *
+ * @param loadedResource
+ * @returns
+ */
+function assertLoadedResourcesFormatArrayBuffer(
+  loadedResources : Array<ILoadedResource<string | ArrayBuffer>>
+) : asserts loadedResources is Array<ILoadedResource<ArrayBuffer>> {
+  if (__ENVIRONMENT__.CURRENT_ENV === __ENVIRONMENT__.PRODUCTION as number) {
+    return;
+  }
+
+  loadedResources.forEach((loadedResource) => {
+    const { responseData } = loadedResource;
+    if (responseData.success && responseData.data instanceof ArrayBuffer) {
+      return;
+    } else if (!responseData.success) {
+      return;
+    }
+    throw new Error("Invalid data given to the LoadedRessource");
+  });
+}
+
 /**
  * Try to convert a Manifest from an unknown format to a `Document` format.
  * Useful to exploit DOM-parsing APIs to quickly parse an XML Manifest.

package/src/transports/dash/pipelines.ts

@@ -48,16 +48,16 @@ export default function(options : ITransportOptions) : ITransportPipelines {
   const textTrackLoader = generateTextTrackLoader(options);
   const textTrackParser = generateTextTrackParser(options);
 
-  return { manifest: { loader: manifestLoader,
-                       parser: manifestParser },
-           audio: { loader: segmentLoader,
-                    parser: audioVideoSegmentParser },
-           video: { loader: segmentLoader,
-                    parser: audioVideoSegmentParser },
-           text: { loader: textTrackLoader,
-                   parser: textTrackParser },
-           image: { loader: imageLoader,
-                    parser: imageParser } };
+  return { manifest: { loadManifest: manifestLoader,
+                       parseManifest: manifestParser },
+           audio: { loadSegment: segmentLoader,
+                    parseSegment: audioVideoSegmentParser },
+           video: { loadSegment: segmentLoader,
+                    parseSegment: audioVideoSegmentParser },
+           text: { loadSegment: textTrackLoader,
+                   parseSegment: textTrackParser },
+           image: { loadSegment: imageLoader,
+                    parseSegment: imageParser } };
 }
 
 /**

package/src/transports/dash/segment_loader.ts

@@ -14,23 +14,25 @@
  * limitations under the License.
  */
 
-import {
-  Observable,
-  Observer,
-  of as observableOf,
-} from "rxjs";
 import { CustomLoaderError } from "../../errors";
-import xhr, {
+import PPromise from "../../utils/promise";
+import request, {
   fetchIsSupported,
 } from "../../utils/request";
+import {
+  CancellationError,
+  CancellationSignal,
+} from "../../utils/task_canceller";
 import warnOnce from "../../utils/warn_once";
 import {
-  CustomSegmentLoader,
-  ILoaderProgressEvent,
+  ICustomSegmentLoader,
+  ILoadedAudioVideoSegmentFormat,
+  ISegmentContext,
   ISegmentLoader,
-  ISegmentLoaderArguments,
-  ISegmentLoaderDataLoadedEvent,
-  ISegmentLoaderEvent,
+  ISegmentLoaderCallbacks,
+  ISegmentLoaderResultChunkedComplete,
+  ISegmentLoaderResultSegmentCreated,
+  ISegmentLoaderResultSegmentLoaded,
 } from "../types";
 import byteRange from "../utils/byte_range";
 import inferSegmentContainer from "../utils/infer_segment_container";
@@ -38,42 +40,50 @@ import addSegmentIntegrityChecks from "./add_segment_integrity_checks_to_loader"
 import initSegmentLoader from "./init_segment_loader";
 import lowLatencySegmentLoader from "./low_latency_segment_loader";
 
-type ICustomSegmentLoaderObserver =
-  Observer<ILoaderProgressEvent |
-           ISegmentLoaderDataLoadedEvent<Uint8Array|ArrayBuffer>>;
-
 /**
  * Segment loader triggered if there was no custom-defined one in the API.
- * @param {Object} opt
- * @returns {Observable}
+ * @param {string} uri
+ * @param {Object} content
+ * @param {boolean} lowLatencyMode
+ * @param {Object} callbacks
+ * @param {Object} cancelSignal
+ * @returns {Promise}
  */
-function regularSegmentLoader(
+export function regularSegmentLoader(
   url : string,
-  args : ISegmentLoaderArguments,
-  lowLatencyMode : boolean
-) : Observable< ISegmentLoaderEvent<ArrayBuffer | Uint8Array>> {
-
-  if (args.segment.isInit) {
-    return initSegmentLoader(url, args);
+  content : ISegmentContext,
+  lowLatencyMode : boolean,
+  callbacks : ISegmentLoaderCallbacks<ILoadedAudioVideoSegmentFormat>,
+  cancelSignal : CancellationSignal
+) : Promise<ISegmentLoaderResultSegmentLoaded<ILoadedAudioVideoSegmentFormat> |
+            ISegmentLoaderResultSegmentCreated<ILoadedAudioVideoSegmentFormat> |
+            ISegmentLoaderResultChunkedComplete>
+{
+  if (content.segment.isInit) {
+    return initSegmentLoader(url, content.segment, cancelSignal, callbacks);
   }
 
-  const containerType = inferSegmentContainer(args.adaptation.type, args.representation);
+  const containerType = inferSegmentContainer(content.adaptation.type,
+                                              content.representation);
   if (lowLatencyMode && (containerType === "mp4" || containerType === undefined)) {
     if (fetchIsSupported()) {
-      return lowLatencySegmentLoader(url, args);
+      return lowLatencySegmentLoader(url, content, callbacks, cancelSignal);
     } else {
       warnOnce("DASH: Your browser does not have the fetch API. You will have " +
                "a higher chance of rebuffering when playing close to the live edge");
     }
   }
 
-  const { segment } = args;
-  return xhr({ url,
-               responseType: "arraybuffer",
-               sendProgressEvents: true,
-               headers: segment.range !== undefined ?
-                 { Range: byteRange(segment.range) } :
-                 undefined });
+  const { segment } = content;
+  return request({ url,
+                   responseType: "arraybuffer",
+                   headers: segment.range !== undefined ?
+                     { Range: byteRange(segment.range) } :
+                     undefined,
+                   cancelSignal,
+                   onProgress: callbacks.onProgress })
+    .then((data) => ({ resultType: "segment-loaded",
+                       resultData: data }));
 }
 
 /**
@@ -84,9 +94,9 @@ export default function generateSegmentLoader(
   { lowLatencyMode,
     segmentLoader: customSegmentLoader,
     checkMediaSegmentIntegrity } : { lowLatencyMode: boolean;
-                                     segmentLoader? : CustomSegmentLoader;
-                                     checkMediaSegmentIntegrity? : boolean; }
-) : ISegmentLoader< Uint8Array | ArrayBuffer | null > {
+                                     segmentLoader? : ICustomSegmentLoader | undefined;
+                                     checkMediaSegmentIntegrity? : boolean | undefined; }
+) : ISegmentLoader<Uint8Array | ArrayBuffer | null> {
   return checkMediaSegmentIntegrity !== true ? segmentLoader :
                                                addSegmentIntegrityChecks(segmentLoader);
 
@@ -95,16 +105,21 @@ export default function generateSegmentLoader(
    * @returns {Observable}
    */
   function segmentLoader(
-    content : ISegmentLoaderArguments
-  ) : Observable< ISegmentLoaderEvent< Uint8Array | ArrayBuffer | null > > {
-    const { url } = content;
+    url : string | null,
+    content : ISegmentContext,
+    cancelSignal : CancellationSignal,
+    callbacks : ISegmentLoaderCallbacks<Uint8Array | ArrayBuffer | null>
+  ) : Promise<ISegmentLoaderResultSegmentLoaded<ILoadedAudioVideoSegmentFormat> |
+              ISegmentLoaderResultSegmentCreated<ILoadedAudioVideoSegmentFormat> |
+              ISegmentLoaderResultChunkedComplete>
+  {
     if (url == null) {
-      return observableOf({ type: "data-created" as const,
-                            value: { responseData: null } });
+      return PPromise.resolve({ resultType: "segment-created",
+                                resultData: null });
     }
 
     if (lowLatencyMode || customSegmentLoader === undefined) {
-      return regularSegmentLoader(url, content, lowLatencyMode);
+      return regularSegmentLoader(url, content, lowLatencyMode, callbacks, cancelSignal);
     }
 
     const args = { adaptation: content.adaptation,
@@ -115,9 +130,9 @@ export default function generateSegmentLoader(
                    transport: "dash",
                    url };
 
-    return new Observable((obs : ICustomSegmentLoaderObserver) => {
+    return new PPromise((res, rej) => {
+      /** `true` when the custom segmentLoader should not be active anymore. */
       let hasFinished = false;
-      let hasFallbacked = false;
 
       /**
        * Callback triggered when the custom segment loader has a response.
@@ -125,53 +140,57 @@ export default function generateSegmentLoader(
        */
       const resolve = (
         _args : { data : ArrayBuffer|Uint8Array;
-                  size? : number;
-                  duration? : number; }
+                  size? : number | undefined;
+                  duration? : number | undefined; }
       ) => {
-        if (!hasFallbacked) {
-          hasFinished = true;
-          obs.next({ type: "data-loaded" as const,
-                     value: { responseData: _args.data,
-                              size: _args.size,
-                              duration: _args.duration } });
-          obs.complete();
+        if (hasFinished || cancelSignal.isCancelled) {
+          return;
         }
+        hasFinished = true;
+        cancelSignal.deregister(abortCustomLoader);
+        res({ resultType: "segment-loaded",
+              resultData: { responseData: _args.data,
+                            size: _args.size,
+                            requestDuration: _args.duration } });
       };
 
       /**
        * Callback triggered when the custom segment loader fails
        * @param {*} err - The corresponding error encountered
        */
-      const reject = (err = {}) : void => {
-        if (!hasFallbacked) {
-          hasFinished = true;
-
-          // Format error and send it
-          const castedErr = err as (null | undefined | { message? : string;
-                                                         canRetry? : boolean;
-                                                         isOfflineError? : boolean;
-                                                         xhr? : XMLHttpRequest; });
-          const message = castedErr?.message ??
-                          "Unknown error when fetching a DASH segment through a " +
-                          "custom segmentLoader.";
-          const emittedErr = new CustomLoaderError(message,
-                                                   castedErr?.canRetry ?? false,
-                                                   castedErr?.isOfflineError ?? false,
-                                                   castedErr?.xhr);
-          obs.error(emittedErr);
+      const reject = (err : unknown) : void => {
+        if (hasFinished || cancelSignal.isCancelled) {
+          return;
         }
+        hasFinished = true;
+        cancelSignal.deregister(abortCustomLoader);
+
+        // Format error and send it
+        const castedErr = err as (null | undefined | { message? : string;
+                                                       canRetry? : boolean;
+                                                       isOfflineError? : boolean;
+                                                       xhr? : XMLHttpRequest; });
+        const message = castedErr?.message ??
+                        "Unknown error when fetching a DASH segment through a " +
+                        "custom segmentLoader.";
+        const emittedErr = new CustomLoaderError(message,
+                                                 castedErr?.canRetry ?? false,
+                                                 castedErr?.isOfflineError ?? false,
+                                                 castedErr?.xhr);
+        rej(emittedErr);
       };
 
       const progress = (
         _args : { duration : number;
                   size : number;
-                  totalSize? : number; }
+                  totalSize? : number | undefined; }
       ) => {
-        if (!hasFallbacked) {
-          obs.next({ type: "progress", value: { duration: _args.duration,
-                                                size: _args.size,
-                                                totalSize: _args.totalSize } });
+        if (hasFinished || cancelSignal.isCancelled) {
+          return;
         }
+        callbacks.onProgress({ duration: _args.duration,
+                               size: _args.size,
+                               totalSize: _args.totalSize });
       };
 
       /**
@@ -179,26 +198,34 @@ export default function generateSegmentLoader(
        * the "regular" implementation
        */
       const fallback = () => {
-        hasFallbacked = true;
-        const regular$ = regularSegmentLoader(url, content, lowLatencyMode);
-
-        // HACK What is TypeScript/RxJS doing here??????
-        /* eslint-disable import/no-deprecated */
-        /* eslint-disable @typescript-eslint/ban-ts-comment */
-        // @ts-ignore
-        regular$.subscribe(obs);
-        /* eslint-enable import/no-deprecated */
-        /* eslint-enable @typescript-eslint/ban-ts-comment */
+        if (hasFinished || cancelSignal.isCancelled) {
+          return;
+        }
+        hasFinished = true;
+        cancelSignal.deregister(abortCustomLoader);
+        regularSegmentLoader(url, content, lowLatencyMode, callbacks, cancelSignal)
+          .then(res, rej);
       };
 
-      const callbacks = { reject, resolve, progress, fallback };
-      const abort = customSegmentLoader(args, callbacks);
+      const customCallbacks = { reject, resolve, progress, fallback };
+      const abort = customSegmentLoader(args, customCallbacks);
 
-      return () => {
-        if (!hasFinished && !hasFallbacked && typeof abort === "function") {
+      cancelSignal.register(abortCustomLoader);
+
+      /**
+       * The logic to run when the custom loader is cancelled while pending.
+       * @param {Error} err
+       */
+      function abortCustomLoader(err : CancellationError) {
+        if (hasFinished) {
+          return;
+        }
+        hasFinished = true;
+        if (typeof abort === "function") {
           abort();
         }
-      };
+        rej(err);
+      }
     });
   }
 }