rx-player 4.1.0 → 4.2.0-dev.2024080600

package/src/transports/dash/integrity_checks.ts

@@ -0,0 +1,170 @@
+import { OtherError } from "../../errors";
+import type { ILoadedManifestFormat } from "../../public_types";
+import globalScope from "../../utils/global_scope";
+import isNullOrUndefined from "../../utils/is_null_or_undefined";
+import TaskCanceller from "../../utils/task_canceller";
+import type { ISegmentLoader, ITransportManifestPipeline } from "../types";
+import checkISOBMFFIntegrity from "../utils/check_isobmff_integrity";
+import inferSegmentContainer from "../utils/infer_segment_container";
+
+/**
+ * Add multiple checks on the response given by the `segmentLoader` in argument.
+ * If the response appear to be corrupted, the returned Promise will reject with
+ * an error with an `INTEGRITY_ERROR` code.
+ * @param {Function} segmentLoader
+ * @returns {Function}
+ */
+export function addSegmentIntegrityChecks<T>(
+  segmentLoader: ISegmentLoader<T>,
+): ISegmentLoader<T> {
+  return (url, context, loaderOptions, initialCancelSignal, callbacks) => {
+    return new Promise((resolve, reject) => {
+      const requestCanceller = new TaskCanceller();
+      const unlinkCanceller = requestCanceller.linkToSignal(initialCancelSignal);
+      requestCanceller.signal.register(reject);
+
+      segmentLoader(url, context, loaderOptions, requestCanceller.signal, {
+        ...callbacks,
+        onNewChunk(data) {
+          try {
+            throwOnIntegrityError(data);
+            callbacks.onNewChunk(data);
+          } catch (err) {
+            // Do not reject with a `CancellationError` after cancelling the request
+            cleanUpCancellers();
+
+            // Cancel the request
+            requestCanceller.cancel();
+
+            // Reject with thrown error
+            reject(err);
+          }
+        },
+      }).then(
+        (info) => {
+          cleanUpCancellers();
+          if (requestCanceller.isUsed()) {
+            return;
+          }
+          if (info.resultType === "segment-loaded") {
+            try {
+              throwOnIntegrityError(info.resultData.responseData);
+            } catch (err) {
+              reject(err);
+              return;
+            }
+          }
+          resolve(info);
+        },
+        (err: unknown) => {
+          cleanUpCancellers();
+          reject(err);
+        },
+      );
+
+      function cleanUpCancellers() {
+        requestCanceller.signal.deregister(reject);
+        unlinkCanceller();
+      }
+    });
+
+    /**
+     * If the data's seems to be corrupted, throws an `INTEGRITY_ERROR` error.
+     * @param {*} data
+     */
+    function throwOnIntegrityError(data: T): void {
+      if (
+        (!(data instanceof ArrayBuffer) && !(data instanceof Uint8Array)) ||
+        inferSegmentContainer(context.type, context.mimeType) !== "mp4"
+      ) {
+        return;
+      }
+      checkISOBMFFIntegrity(new Uint8Array(data), context.segment.isInit);
+    }
+  };
+}
+
+/**
+ * Add multiple checks on the response given by the `manifestLoader` in argument.
+ * If the response appear to be corrupted, the returned Promise will reject with
+ * an error with an `INTEGRITY_ERROR` code.
+ * @param {Function} manifestLoader
+ * @returns {Function}
+ */
+export function addManifestIntegrityChecks(
+  manifestLoader: ITransportManifestPipeline["loadManifest"],
+): ITransportManifestPipeline["loadManifest"] {
+  return async (url, options, initialCancelSignal) => {
+    const res = await manifestLoader(url, options, initialCancelSignal);
+    throwOnIntegrityError(res.responseData);
+    return res;
+
+    /**
+     * If the data's seems to be corrupted, throws an `INTEGRITY_ERROR` error.
+     * @param {*} data
+     */
+    function throwOnIntegrityError(data: ILoadedManifestFormat): void {
+      if (typeof data === "string") {
+        let currOffset = data.length - 1;
+        const expectedStrings = ["</", "MPD", ">"];
+        for (let i = expectedStrings.length - 1; i >= 0; i--) {
+          const currentExpectedStr = expectedStrings[i];
+          while (isCharXmlWhiteSpace(data[currOffset])) {
+            currOffset--;
+          }
+          for (let j = currentExpectedStr.length - 1; j >= 0; j--) {
+            if (data[currOffset] !== currentExpectedStr[j]) {
+              throw new Error("INTEGRITY_ERROR MPD does not end with </MPD>");
+            } else {
+              currOffset--;
+            }
+          }
+        }
+      } else if (data instanceof ArrayBuffer) {
+        let currOffset = data.byteLength - 1;
+        const dv = new DataView(data);
+        const expectedCharGroups = [[0x3c, 0x2f], [0x4d, 0x50, 0x44], [0x3e]];
+        for (let i = expectedCharGroups.length - 1; i >= 0; i--) {
+          const currentExpectedCharGroup = expectedCharGroups[i];
+          while (isUtf8XmlWhiteSpace(dv.getUint8(currOffset))) {
+            currOffset--;
+          }
+          for (let j = currentExpectedCharGroup.length - 1; j >= 0; j--) {
+            if (dv.getUint8(currOffset) !== currentExpectedCharGroup[j]) {
+              throw new Error("INTEGRITY_ERROR MPD does not end with </MPD>");
+            } else {
+              currOffset--;
+            }
+          }
+        }
+      } else if (
+        !isNullOrUndefined(globalScope.Document) &&
+        data instanceof globalScope.Document
+      ) {
+        if (data.documentElement.nodeName !== "MPD") {
+          throw new OtherError("INTEGRITY_ERROR", "MPD does not end with </MPD>");
+        }
+      }
+    }
+  };
+}
+
+/**
+ * Returns `true` if the character given can be considered as
+ * whitespace according to the XML spec.
+ * @param {string} char
+ * @returns {boolean}
+ */
+function isCharXmlWhiteSpace(char: string): boolean {
+  return char === " " || char === "\t" || char === "\r" || char === "\n";
+}
+
+/**
+ * Returns `true` if the character given can be considered as an ASCII
+ * whitespace according to the HTML spec.
+ * @param {string} char
+ * @returns {boolean}
+ */
+function isUtf8XmlWhiteSpace(char: number): boolean {
+  return char === 0x20 || char === 0x9 || char === 0xd || char === 0xa;
+}

package/src/transports/dash/{low_latency_segment_loader.ts → load_chunked_segment_data.ts}

@@ -20,12 +20,9 @@ import type { IFetchedDataObject } from "../../utils/request/fetch";
 import fetchRequest from "../../utils/request/fetch";
 import type { CancellationSignal } from "../../utils/task_canceller";
 import type {
-  ISegmentContext,
   ISegmentLoaderCallbacks,
-  ISegmentLoaderOptions,
   ISegmentLoaderResultChunkedComplete,
 } from "../types";
-import byteRange from "../utils/byte_range";
 
 /**
  * Load segments through a "chunk" mode (decodable chunk by decodable chunk).
@@ -33,22 +30,27 @@ import byteRange from "../utils/byte_range";
  * 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} options
+ * @param {Object} requestOptions
+ * @param {Object|undefined} requestOptions.headers - Headers for the
+ * low-latency request
+ * @param {number|undefined} requestOptions.timeout - Request timeout for the
+ * low-latency request.
+ * @param {number|undefined} requestOptions.connectionTimeout - HTTP connection
+ * timeout for the low-latency request.
  * @param {Object} callbacks
  * @param {CancellationSignal} cancelSignal
  * @returns {Promise}
  */
-export default function lowLatencySegmentLoader(
+export default async function loadChunkedSegmentData(
   url: string,
-  content: ISegmentContext,
-  options: ISegmentLoaderOptions,
+  requestOptions: {
+    headers: Record<string, string> | undefined;
+    timeout: number | undefined;
+    connectionTimeout: number | undefined;
+  },
   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;
 
   /**
@@ -79,15 +81,16 @@ export default function lowLatencySegmentLoader(
     }
   }
 
-  return fetchRequest({
+  const res = await fetchRequest({
     url,
-    headers,
+    headers: requestOptions.headers,
     onData,
-    timeout: options.timeout,
-    connectionTimeout: options.connectionTimeout,
+    timeout: requestOptions.timeout,
+    connectionTimeout: requestOptions.connectionTimeout,
     cancelSignal,
-  }).then((res) => ({
+  });
+  return {
     resultType: "chunk-complete" as const,
     resultData: res,
-  }));
+  };
 }

package/src/transports/dash/pipelines.ts

@@ -17,6 +17,7 @@
 import features from "../../features";
 import type { ITransportOptions, ITransportPipelines } from "../types";
 import generateManifestLoader from "../utils/generate_manifest_loader";
+import { addManifestIntegrityChecks } from "./integrity_checks";
 import generateManifestParser from "./manifest_parser";
 import generateSegmentLoader from "./segment_loader";
 import generateAudioVideoSegmentParser from "./segment_parser";
@@ -33,6 +34,7 @@ export default function (options: ITransportOptions): ITransportPipelines {
   const manifestLoader = generateManifestLoader(
     { customManifestLoader: options.manifestLoader },
     mightUseDashWasmFeature() ? "text" : "arraybuffer",
+    options.checkManifestIntegrity === true ? addManifestIntegrityChecks : null,
   );
 
   const manifestParser = generateManifestParser(options);
@@ -42,6 +44,7 @@ export default function (options: ITransportOptions): ITransportPipelines {
   const textTrackParser = generateTextTrackParser(options);
 
   return {
+    transportName: "dash",
     manifest: { loadManifest: manifestLoader, parseManifest: manifestParser },
     audio: {
       loadSegment: segmentLoader,

package/src/transports/dash/segment_loader.ts

@@ -30,16 +30,17 @@ import type {
   ISegmentLoaderResultSegmentCreated,
   ISegmentLoaderResultSegmentLoaded,
 } from "../types";
+import addQueryString from "../utils/add_query_string";
 import byteRange from "../utils/byte_range";
 import inferSegmentContainer from "../utils/infer_segment_container";
-import addSegmentIntegrityChecks from "./add_segment_integrity_checks_to_loader";
 import constructSegmentUrl from "./construct_segment_url";
 import initSegmentLoader from "./init_segment_loader";
-import lowLatencySegmentLoader from "./low_latency_segment_loader";
+import { addSegmentIntegrityChecks } from "./integrity_checks";
+import loadChunkedSegmentData from "./load_chunked_segment_data";
 
 /**
  * Segment loader triggered if there was no custom-defined one in the API.
- * @param {string} url
+ * @param {string} initialUrl
  * @param {Object} context
  * @param {boolean} lowLatencyMode
  * @param {Object} options
@@ -47,8 +48,8 @@ import lowLatencySegmentLoader from "./low_latency_segment_loader";
  * @param {Object} cancelSignal
  * @returns {Promise}
  */
-export function regularSegmentLoader(
-  url: string,
+export async function regularSegmentLoader(
+  initialUrl: string,
   context: ISegmentContext,
   lowLatencyMode: boolean,
   options: ISegmentLoaderOptions,
@@ -60,13 +61,47 @@ export function regularSegmentLoader(
   | ISegmentLoaderResultChunkedComplete
 > {
   if (context.segment.isInit) {
-    return initSegmentLoader(url, context.segment, options, cancelSignal, callbacks);
+    return initSegmentLoader(
+      initialUrl,
+      context.segment,
+      options,
+      cancelSignal,
+      callbacks,
+    );
+  }
+
+  const url =
+    options.cmcdPayload?.type === "query"
+      ? addQueryString(initialUrl, options.cmcdPayload.value)
+      : initialUrl;
+
+  const cmcdHeaders =
+    options.cmcdPayload?.type === "headers" ? options.cmcdPayload.value : undefined;
+
+  const { segment } = context;
+  let headers;
+  if (segment.range !== undefined) {
+    headers = {
+      ...cmcdHeaders,
+      Range: byteRange(segment.range),
+    };
+  } else if (cmcdHeaders !== undefined) {
+    headers = cmcdHeaders;
   }
 
   const containerType = inferSegmentContainer(context.type, context.mimeType);
   if (lowLatencyMode && (containerType === "mp4" || containerType === undefined)) {
     if (fetchIsSupported()) {
-      return lowLatencySegmentLoader(url, context, options, callbacks, cancelSignal);
+      return loadChunkedSegmentData(
+        url,
+        {
+          headers,
+          timeout: options.timeout,
+          connectionTimeout: options.connectionTimeout,
+        },
+        callbacks,
+        cancelSignal,
+      );
     } else {
       warnOnce(
         "DASH: Your browser does not have the fetch API. You will have " +
@@ -75,17 +110,16 @@ export function regularSegmentLoader(
     }
   }
 
-  const { segment } = context;
-  return request({
+  const data = await request({
     url,
     responseType: "arraybuffer",
-    headers:
-      segment.range !== undefined ? { Range: byteRange(segment.range) } : undefined,
+    headers,
     timeout: options.timeout,
     connectionTimeout: options.connectionTimeout,
     cancelSignal,
     onProgress: callbacks.onProgress,
-  }).then((data) => ({ resultType: "segment-loaded", resultData: data }));
+  });
+  return { resultType: "segment-loaded", resultData: data };
 }
 
 /**
@@ -249,6 +283,7 @@ export default function generateSegmentLoader({
         byteRanges,
         trackType: context.type,
         url,
+        cmcdPayload: options.cmcdPayload,
       };
       const abort = customSegmentLoader(args, customCallbacks);
 

package/src/transports/dash/text_loader.ts

@@ -28,12 +28,13 @@ import type {
   ISegmentLoaderResultSegmentCreated,
   ISegmentLoaderResultSegmentLoaded,
 } from "../types";
+import addQueryString from "../utils/add_query_string";
 import byteRange from "../utils/byte_range";
 import inferSegmentContainer from "../utils/infer_segment_container";
-import addSegmentIntegrityChecks from "./add_segment_integrity_checks_to_loader";
 import constructSegmentUrl from "./construct_segment_url";
 import initSegmentLoader from "./init_segment_loader";
-import lowLatencySegmentLoader from "./low_latency_segment_loader";
+import { addSegmentIntegrityChecks } from "./integrity_checks";
+import loadChunkedSegmentData from "./load_chunked_segment_data";
 
 /**
  * Perform requests for "text" segments
@@ -59,7 +60,7 @@ export default function generateTextTrackLoader({
    * @param {Object} callbacks
    * @returns {Promise}
    */
-  function textTrackLoader(
+  async function textTrackLoader(
     wantedCdn: ICdnMetadata | null,
     context: ISegmentContext,
     options: ISegmentLoaderOptions,
@@ -71,10 +72,9 @@ export default function generateTextTrackLoader({
     | ISegmentLoaderResultChunkedComplete
   > {
     const { segment } = context;
-    const { range } = segment;
 
-    const url = constructSegmentUrl(wantedCdn, segment);
-    if (url === null) {
+    const initialUrl = constructSegmentUrl(wantedCdn, segment);
+    if (initialUrl === null) {
       return Promise.resolve({
         resultType: "segment-created",
         resultData: null,
@@ -82,14 +82,41 @@ export default function generateTextTrackLoader({
     }
 
     if (segment.isInit) {
-      return initSegmentLoader(url, segment, options, cancelSignal, callbacks);
+      return initSegmentLoader(initialUrl, segment, options, cancelSignal, callbacks);
+    }
+
+    const url =
+      options.cmcdPayload?.type === "query"
+        ? addQueryString(initialUrl, options.cmcdPayload.value)
+        : initialUrl;
+
+    const cmcdHeaders =
+      options.cmcdPayload?.type === "headers" ? options.cmcdPayload.value : undefined;
+
+    let headers;
+    if (segment.range !== undefined) {
+      headers = {
+        ...cmcdHeaders,
+        Range: byteRange(segment.range),
+      };
+    } else if (cmcdHeaders !== undefined) {
+      headers = cmcdHeaders;
     }
 
     const containerType = inferSegmentContainer(context.type, context.mimeType);
     const seemsToBeMP4 = containerType === "mp4" || containerType === undefined;
     if (lowLatencyMode && seemsToBeMP4) {
       if (fetchIsSupported()) {
-        return lowLatencySegmentLoader(url, context, options, callbacks, cancelSignal);
+        return loadChunkedSegmentData(
+          url,
+          {
+            headers,
+            timeout: options.timeout,
+            connectionTimeout: options.connectionTimeout,
+          },
+          callbacks,
+          cancelSignal,
+        );
       } else {
         warnOnce(
           "DASH: Your browser does not have the fetch API. You will have " +
@@ -98,26 +125,28 @@ export default function generateTextTrackLoader({
       }
     }
 
+    let data;
     if (seemsToBeMP4) {
-      return request({
+      data = await request({
         url,
         responseType: "arraybuffer",
-        headers: Array.isArray(range) ? { Range: byteRange(range) } : null,
+        headers,
         timeout: options.timeout,
         connectionTimeout: options.connectionTimeout,
         onProgress: callbacks.onProgress,
         cancelSignal,
-      }).then((data) => ({ resultType: "segment-loaded", resultData: data }));
+      });
+    } else {
+      data = await request({
+        url,
+        responseType: "text",
+        headers,
+        timeout: options.timeout,
+        connectionTimeout: options.connectionTimeout,
+        onProgress: callbacks.onProgress,
+        cancelSignal,
+      });
     }
-
-    return request({
-      url,
-      responseType: "text",
-      headers: Array.isArray(range) ? { Range: byteRange(range) } : null,
-      timeout: options.timeout,
-      connectionTimeout: options.connectionTimeout,
-      onProgress: callbacks.onProgress,
-      cancelSignal,
-    }).then((data) => ({ resultType: "segment-loaded", resultData: data }));
+    return { resultType: "segment-loaded", resultData: data };
   }
 }

package/src/transports/local/pipelines.ts

@@ -88,6 +88,7 @@ export default function getLocalManifestPipelines(
   };
 
   return {
+    transportName: "local",
     manifest: manifestPipeline,
     audio: segmentPipeline,
     video: segmentPipeline,

package/src/transports/metaplaylist/manifest_loader.ts

@@ -18,24 +18,35 @@ import type { IManifestLoader, ILoadedManifestFormat } from "../../public_types"
 import request from "../../utils/request";
 import type { CancellationSignal } from "../../utils/task_canceller";
 import type { IManifestLoaderOptions, IRequestedData } from "../types";
+import addQueryString from "../utils/add_query_string";
 import callCustomManifestLoader from "../utils/call_custom_manifest_loader";
 
 /**
  * Manifest loader triggered if there was no custom-defined one in the API.
- * @param {string} url
+ * @param {string} initialUrl
  * @param {Object} loaderOptions
  * @param {Object} cancelSignal
  */
 function regularManifestLoader(
-  url: string | undefined,
+  initialUrl: string | undefined,
   loaderOptions: IManifestLoaderOptions,
   cancelSignal: CancellationSignal,
 ): Promise<IRequestedData<ILoadedManifestFormat>> {
-  if (url === undefined) {
+  if (initialUrl === undefined) {
     throw new Error("Cannot perform HTTP(s) request. URL not known");
   }
+
+  const url =
+    loaderOptions.cmcdPayload?.type === "query"
+      ? addQueryString(initialUrl, loaderOptions.cmcdPayload.value)
+      : initialUrl;
+
   return request({
     url,
+    headers:
+      loaderOptions.cmcdPayload?.type === "headers"
+        ? loaderOptions.cmcdPayload.value
+        : undefined,
     responseType: "text",
     timeout: loaderOptions.timeout,
     connectionTimeout: loaderOptions.connectionTimeout,

package/src/transports/metaplaylist/pipelines.ts

@@ -177,6 +177,7 @@ export default function (options: ITransportOptions): ITransportPipelines {
             const manOpts = {
               timeout: config.getCurrent().DEFAULT_REQUEST_TIMEOUT,
               connectionTimeout: config.getCurrent().DEFAULT_CONNECTION_TIMEOUT,
+              cmcdPayload: undefined,
             };
             return transport.manifest.loadManifest(resource.url, manOpts, cancelSignal);
           }
@@ -392,6 +393,7 @@ export default function (options: ITransportOptions): ITransportPipelines {
   };
 
   return {
+    transportName: "metaplaylist",
     manifest: manifestPipeline,
     audio: audioPipeline,
     video: videoPipeline,

package/src/transports/smooth/pipelines.ts

@@ -41,6 +41,7 @@ import type {
   ITransportOptions,
   ITransportPipelines,
 } from "../types";
+import addQueryString from "../utils/add_query_string";
 import checkISOBMFFIntegrity from "../utils/check_isobmff_integrity";
 import generateManifestLoader from "../utils/generate_manifest_loader";
 import extractTimingsInfos from "./extract_timings_infos";
@@ -56,7 +57,7 @@ export default function (transportOptions: ITransportOptions): ITransportPipelin
   const manifestLoaderOptions = {
     customManifestLoader: transportOptions.manifestLoader,
   };
-  const manifestLoader = generateManifestLoader(manifestLoaderOptions, "text");
+  const manifestLoader = generateManifestLoader(manifestLoaderOptions, "text", null);
 
   const manifestPipeline = {
     loadManifest: manifestLoader,
@@ -219,7 +220,14 @@ export default function (transportOptions: ITransportOptions): ITransportPipelin
       const isMP4 = isMP4EmbeddedTrack(context.mimeType);
       if (!isMP4) {
         return request({
-          url,
+          url:
+            loaderOptions.cmcdPayload?.type === "query"
+              ? addQueryString(url, loaderOptions.cmcdPayload.value)
+              : url,
+          headers:
+            loaderOptions.cmcdPayload?.type === "headers"
+              ? loaderOptions.cmcdPayload.value
+              : undefined,
           responseType: "text",
           timeout: loaderOptions.timeout,
           connectionTimeout: loaderOptions.connectionTimeout,
@@ -231,7 +239,14 @@ export default function (transportOptions: ITransportOptions): ITransportPipelin
         }));
       } else {
         return request({
-          url,
+          url:
+            loaderOptions.cmcdPayload?.type === "query"
+              ? addQueryString(url, loaderOptions.cmcdPayload.value)
+              : url,
+          headers:
+            loaderOptions.cmcdPayload?.type === "headers"
+              ? loaderOptions.cmcdPayload.value
+              : undefined,
           responseType: "arraybuffer",
           timeout: loaderOptions.timeout,
           connectionTimeout: loaderOptions.connectionTimeout,
@@ -408,6 +423,7 @@ export default function (transportOptions: ITransportOptions): ITransportPipelin
   };
 
   return {
+    transportName: "smooth",
     manifest: manifestPipeline,
     audio: audioVideoPipeline,
     video: audioVideoPipeline,