rx-player 4.1.0 → 4.2.0-dev.2024080600

package/src/transports/smooth/segment_loader.ts

@@ -26,6 +26,7 @@ import type {
   ISegmentLoaderResultSegmentCreated,
   ISegmentLoaderResultSegmentLoaded,
 } from "../types";
+import addQueryString from "../utils/add_query_string";
 import byteRange from "../utils/byte_range";
 import checkISOBMFFIntegrity from "../utils/check_isobmff_integrity";
 import isMP4EmbeddedTrack from "./is_mp4_embedded_track";
@@ -33,7 +34,7 @@ import { createAudioInitSegment, createVideoInitSegment } from "./isobmff";
 
 /**
  * Segment loader triggered if there was no custom-defined one in the API.
- * @param {string} url
+ * @param {string} initialUrl
  * @param {Object} context
  * @param {Object} loaderOptions
  * @param {Object} callbacks
@@ -41,21 +42,36 @@ import { createAudioInitSegment, createVideoInitSegment } from "./isobmff";
  * @param {boolean} checkMediaSegmentIntegrity
  * @returns {Promise}
  */
-function regularSegmentLoader(
-  url: string,
+async function regularSegmentLoader(
+  initialUrl: string,
   context: ISegmentContext,
   callbacks: ISegmentLoaderCallbacks<Uint8Array | ArrayBuffer | null>,
   loaderOptions: ISegmentLoaderOptions,
   cancelSignal: CancellationSignal,
   checkMediaSegmentIntegrity?: boolean | undefined,
 ): Promise<ISegmentLoaderResultSegmentLoaded<Uint8Array | ArrayBuffer | null>> {
-  let headers;
+  const cmcdHeaders =
+    loaderOptions.cmcdPayload?.type === "headers"
+      ? loaderOptions.cmcdPayload.value
+      : undefined;
   const range = context.segment.range;
+
+  let headers;
   if (Array.isArray(range)) {
-    headers = { Range: byteRange(range) };
+    headers = {
+      ...cmcdHeaders,
+      Range: byteRange(range),
+    };
+  } else if (cmcdHeaders !== undefined) {
+    headers = cmcdHeaders;
   }
 
-  return request({
+  const url =
+    loaderOptions.cmcdPayload?.type === "query"
+      ? addQueryString(initialUrl, loaderOptions.cmcdPayload.value)
+      : initialUrl;
+
+  const data = await request({
     url,
     responseType: "arraybuffer",
     headers,
@@ -63,18 +79,17 @@ function regularSegmentLoader(
     connectionTimeout: loaderOptions.connectionTimeout,
     cancelSignal,
     onProgress: callbacks.onProgress,
-  }).then((data) => {
-    const isMP4 = isMP4EmbeddedTrack(context.mimeType);
-    if (!isMP4 || checkMediaSegmentIntegrity !== true) {
-      return { resultType: "segment-loaded" as const, resultData: data };
-    }
-    const dataU8 = new Uint8Array(data.responseData);
-    checkISOBMFFIntegrity(dataU8, context.segment.isInit);
-    return {
-      resultType: "segment-loaded" as const,
-      resultData: { ...data, responseData: dataU8 },
-    };
   });
+  const isMP4 = isMP4EmbeddedTrack(context.mimeType);
+  if (!isMP4 || checkMediaSegmentIntegrity !== true) {
+    return { resultType: "segment-loaded" as const, resultData: data };
+  }
+  const dataU8 = new Uint8Array(data.responseData);
+  checkISOBMFFIntegrity(dataU8, context.segment.isInit);
+  return {
+    resultType: "segment-loaded" as const,
+    resultData: { ...data, responseData: dataU8 },
+  };
 }
 
 /**
@@ -300,6 +315,7 @@ const generateSegmentLoader =
           byteRanges,
           trackType: context.type,
           url,
+          cmcdPayload: loaderOptions.cmcdPayload,
         };
         const abort = segmentLoader(args, customCallbacks);
 

package/src/transports/types.ts

@@ -25,6 +25,7 @@ import type {
   ISegmentLoader as ICustomSegmentLoader,
   IServerSyncInfos,
   IPlayerError,
+  ICmcdPayload,
 } from "../public_types";
 import type { CancellationSignal } from "../utils/task_canceller";
 import type TaskCanceller from "../utils/task_canceller";
@@ -43,6 +44,9 @@ export type ITransportFunction = (options: ITransportOptions) => ITransportPipel
  * parse the Manifest or any segment.
  */
 export interface ITransportPipelines {
+  /** Name describing the current transport pipeline. */
+  transportName: ITransportName;
+
   /** Functions allowing to load an parse the Manifest for this transport. */
   manifest: ITransportManifestPipeline;
 
@@ -60,6 +64,9 @@ export interface ITransportPipelines {
   text: ISegmentPipeline<ILoadedTextSegmentFormat, ITextTrackSegmentData | null>;
 }
 
+/** Name describing the transport pipeline. */
+export type ITransportName = "dash" | "smooth" | "local" | "metaplaylist";
+
 /** Functions allowing to load and parse the Manifest. */
 export interface ITransportManifestPipeline {
   /**
@@ -69,6 +76,7 @@ export interface ITransportManifestPipeline {
    * @param {string|undefined} url - URL of the Manifest we want to load.
    * `undefined` if the Manifest doesn't have an URL linked to it, in which case
    * the Manifest should be loaded through another mean.
+   * @param {Object} options - Various options linked to the manifest request
    * @param {CancellationSignal} cancellationSignal - Signal which will allow to
    * cancel the loading operation if the Manifest is not needed anymore (for
    * example, if the content has just been stopped).
@@ -173,6 +181,11 @@ export interface IManifestLoaderOptions {
    * Do not set or set to "undefined" to disable it.
    */
   connectionTimeout?: number | undefined;
+  /**
+   * Optional "Common Media Client Data" (CMCD) payload that may be added to
+   * the request.
+   */
+  cmcdPayload: ICmcdPayload | undefined;
 }
 
 /** Functions allowing to load and parse segments of any type. */
@@ -225,6 +238,11 @@ export interface ISegmentLoaderOptions {
    * Do not set or set to "undefined" to disable it.
    */
   connectionTimeout?: number | undefined;
+  /**
+   * Optional "Common Media Client Data" (CMCD) payload that may be added to
+   * the request.
+   */
+  cmcdPayload: ICmcdPayload | undefined;
 }
 
 /**
@@ -791,6 +809,7 @@ export interface IRequestedData<T> {
 
 export interface ITransportOptions {
   checkMediaSegmentIntegrity?: boolean | undefined;
+  checkManifestIntegrity?: boolean | undefined;
   lowLatencyMode: boolean;
   manifestLoader?: IManifestLoader | undefined;
   referenceDateTime?: number | undefined;

package/src/transports/utils/__tests__/add_query_string.test.ts

@@ -0,0 +1,108 @@
+import { describe, it, expect } from "vitest";
+import addQueryString from "../add_query_string";
+
+describe("addQueryString", () => {
+  it("should do nothing if no query string is wanted", () => {
+    expect(addQueryString("https://www.example.com", [])).toEqual(
+      "https://www.example.com",
+    );
+  });
+  it("should add query string to a simple URL", () => {
+    expect(
+      addQueryString("https://www.example.com", [
+        ["first", "val"],
+        ["second", null],
+        ["third", "something"],
+      ]),
+    ).toEqual("https://www.example.com?first=val&second&third=something");
+  });
+
+  it("should add query string before present fragment", () => {
+    expect(
+      addQueryString("https://www.example.com#toto", [
+        ["first", "val"],
+        ["second", null],
+        ["third", "something"],
+      ]),
+    ).toEqual("https://www.example.com?first=val&second&third=something#toto");
+    expect(
+      addQueryString("https://www.example.com#t?oto", [
+        ["first", "val"],
+        ["second", null],
+        ["third", "something"],
+      ]),
+    ).toEqual("https://www.example.com?first=val&second&third=something#t?oto");
+    expect(
+      addQueryString("https://www.example.com#?toto", [
+        ["first", "val"],
+        ["second", null],
+        ["third", "something"],
+      ]),
+    ).toEqual("https://www.example.com?first=val&second&third=something#?toto");
+  });
+
+  it("should have special handling if only the ? character is already present in query string", () => {
+    expect(
+      addQueryString("https://www.example.com?#?toto", [
+        ["first", "val"],
+        ["second", null],
+        ["third", "something"],
+      ]),
+    ).toEqual("https://www.example.com?first=val&second&third=something#?toto");
+    expect(
+      addQueryString("https://www.example.com?", [
+        ["first", "val"],
+        ["second", null],
+        ["third", "something"],
+      ]),
+    ).toEqual("https://www.example.com?first=val&second&third=something");
+    expect(
+      addQueryString("https://www.example.com?#", [
+        ["first", "val"],
+        ["second", null],
+        ["third", "something"],
+      ]),
+    ).toEqual("https://www.example.com?first=val&second&third=something#");
+    expect(
+      addQueryString("https://www.example.com?#??????", [
+        ["first", "val"],
+        ["second", null],
+        ["third", "something"],
+      ]),
+    ).toEqual("https://www.example.com?first=val&second&third=something#??????");
+  });
+
+  it("should combine with already-present query string", () => {
+    expect(
+      addQueryString("https://www.example.com?before=5", [
+        ["first", "val"],
+        ["second", null],
+        ["third", "something"],
+      ]),
+    ).toEqual("https://www.example.com?before=5&first=val&second&third=something");
+    expect(
+      addQueryString("https://www.example.com?someBool", [
+        ["first", "val"],
+        ["second", null],
+        ["third", "something"],
+      ]),
+    ).toEqual("https://www.example.com?someBool&first=val&second&third=something");
+    expect(
+      addQueryString("https://www.example.com?a", [
+        ["first", "val"],
+        ["second", null],
+        ["third", "something"],
+      ]),
+    ).toEqual("https://www.example.com?a&first=val&second&third=something");
+  });
+
+  it("should combine with already-present query string and fragment", () => {
+    expect(
+      addQueryString("https://www.example.com?before=5#test", [
+        ["first", "val"],
+        ["second", null],
+        ["third", "something"],
+      ]),
+    ).toEqual("https://www.example.com?before=5&first=val&second&third=something#test");
+  });
+});

package/src/transports/utils/add_query_string.ts

@@ -0,0 +1,54 @@
+/**
+ * Add to an URL a query string corresponding to `supplementaryQueryStringData`,
+ * being tuples where the first element is a query string's property name and the
+ * second element is its value (or null if there's no associated value.
+ *
+ * If the given URL already has a query string, the new query string elements
+ * will just be appended.
+ * @param {string} baseUrl
+ * @param {Array.<Array.<string|null>>} supplementaryQueryStringData
+ * @returns {string}
+ */
+export default function addQueryString(
+  baseUrl: string,
+  supplementaryQueryStringData: Array<[string, string | null]>,
+): string {
+  if (supplementaryQueryStringData.length === 0) {
+    return baseUrl;
+  }
+  let queryStringStartingChar: "?" | "&" | "";
+
+  let urlFragment = "";
+  const indexOfFragment = baseUrl.indexOf("#");
+  let baseUrlWithoutFragment = baseUrl;
+  if (indexOfFragment >= 0) {
+    urlFragment = baseUrl.substring(indexOfFragment);
+    baseUrlWithoutFragment = baseUrl.substring(0, indexOfFragment);
+  }
+
+  const indexOfQueryString = baseUrlWithoutFragment.indexOf("?");
+  if (indexOfQueryString === -1) {
+    queryStringStartingChar = "?";
+  } else if (indexOfQueryString + 1 === baseUrlWithoutFragment.length) {
+    queryStringStartingChar = "";
+  } else {
+    queryStringStartingChar = "&";
+  }
+
+  let url = baseUrlWithoutFragment + queryStringStartingChar;
+  for (let i = 0; i < supplementaryQueryStringData.length; i++) {
+    const queryStringElt = supplementaryQueryStringData[i];
+    if (queryStringElt[1] === null) {
+      url += queryStringElt[0];
+    } else {
+      url += `${queryStringElt[0]}=${queryStringElt[1]}`;
+    }
+    if (i < supplementaryQueryStringData.length - 1) {
+      url += "&";
+    }
+  }
+  if (urlFragment.length > 0) {
+    url += urlFragment;
+  }
+  return url;
+}

package/src/transports/utils/call_custom_manifest_loader.ts

@@ -44,7 +44,7 @@ export default function callCustomManifestLoader(
 
       /**
        * Callback triggered when the custom manifest loader has a response.
-       * @param {Object} args
+       * @param {Object} _args
        */
       const resolve = (_args: {
         data: ILoadedManifestFormat;
@@ -120,7 +120,7 @@ export default function callCustomManifestLoader(
 
       const callbacks = { reject, resolve, fallback };
       const abort = customManifestLoader(
-        { url, timeout: loaderOptions.timeout },
+        { url, timeout: loaderOptions.timeout, cmcdPayload: loaderOptions.cmcdPayload },
         callbacks,
       );
 

package/src/transports/utils/generate_manifest_loader.ts

@@ -18,7 +18,12 @@ import type { IManifestLoader, ILoadedManifestFormat } from "../../public_types"
 import { assertUnreachable } from "../../utils/assert";
 import request from "../../utils/request";
 import type { CancellationSignal } from "../../utils/task_canceller";
-import type { IManifestLoaderOptions, IRequestedData } from "../types";
+import type {
+  IManifestLoaderOptions,
+  IRequestedData,
+  ITransportManifestPipeline,
+} from "../types";
+import addQueryString from "./add_query_string";
 import callCustomManifestLoader from "./call_custom_manifest_loader";
 
 /**
@@ -29,19 +34,29 @@ import callCustomManifestLoader from "./call_custom_manifest_loader";
 function generateRegularManifestLoader(
   preferredType: "arraybuffer" | "text" | "document",
 ): (
-  url: string | undefined,
+  initialUrl: string | undefined,
   loaderOptions: IManifestLoaderOptions,
   cancelSignal: CancellationSignal,
 ) => Promise<IRequestedData<ILoadedManifestFormat>> {
   return 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;
+
+    const cmcdHeaders =
+      loaderOptions.cmcdPayload?.type === "headers"
+        ? loaderOptions.cmcdPayload.value
+        : undefined;
+
     // What follows could be written in a single line, but TypeScript wouldn't
     // shut up.
     // So I wrote that instead, temporarily of course ;)
@@ -49,6 +64,7 @@ function generateRegularManifestLoader(
       case "arraybuffer":
         return request({
           url,
+          headers: cmcdHeaders,
           responseType: "arraybuffer",
           timeout: loaderOptions.timeout,
           connectionTimeout: loaderOptions.connectionTimeout,
@@ -57,6 +73,7 @@ function generateRegularManifestLoader(
       case "text":
         return request({
           url,
+          headers: cmcdHeaders,
           responseType: "text",
           timeout: loaderOptions.timeout,
           connectionTimeout: loaderOptions.connectionTimeout,
@@ -65,6 +82,7 @@ function generateRegularManifestLoader(
       case "document":
         return request({
           url,
+          headers: cmcdHeaders,
           responseType: "document",
           timeout: loaderOptions.timeout,
           connectionTimeout: loaderOptions.connectionTimeout,
@@ -79,19 +97,22 @@ function generateRegularManifestLoader(
 /**
  * Generate a manifest loader for the application
  * @param {Function} [customManifestLoader]
+ * @param {string} preferredType
  * @returns {Function}
  */
 export default function generateManifestLoader(
   { customManifestLoader }: { customManifestLoader?: IManifestLoader | undefined },
   preferredType: "arraybuffer" | "text" | "document",
-): (
-  url: string | undefined,
-  loaderOptions: IManifestLoaderOptions,
-  cancelSignal: CancellationSignal,
-) => Promise<IRequestedData<ILoadedManifestFormat>> {
+  integrityCheck:
+    | ((
+        loader: ITransportManifestPipeline["loadManifest"],
+      ) => ITransportManifestPipeline["loadManifest"])
+    | null,
+): ITransportManifestPipeline["loadManifest"] {
   const regularManifestLoader = generateRegularManifestLoader(preferredType);
-  if (typeof customManifestLoader !== "function") {
-    return regularManifestLoader;
-  }
-  return callCustomManifestLoader(customManifestLoader, regularManifestLoader);
+  const actualLoader =
+    typeof customManifestLoader !== "function"
+      ? regularManifestLoader
+      : callCustomManifestLoader(customManifestLoader, regularManifestLoader);
+  return integrityCheck !== null ? integrityCheck(actualLoader) : actualLoader;
 }

package/src/utils/__tests__/array_find.test.ts

@@ -5,7 +5,7 @@ import arrayFind from "../array_find";
 /* eslint-disable no-restricted-properties */
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* eslint-disable @typescript-eslint/ban-types */
+/* eslint-disable @typescript-eslint/no-restricted-types */
 
 /* eslint-disable @typescript-eslint/unbound-method */
 const initialArrayFind = (Array.prototype as { find: unknown }).find;
@@ -92,9 +92,9 @@ describe("utils - arrayFind", () => {
       let currentIndex = 0;
       const predicate = function (
         this: unknown,
-        obj: {},
+        obj: unknown,
         index: number,
-        cArr: Array<{}>,
+        cArr: unknown[],
       ): boolean {
         expect(this).toBe(context);
         expect(index).toBe(currentIndex++);

package/src/utils/__tests__/array_find_index.test.ts

@@ -5,7 +5,7 @@ import arrayFindIndex from "../array_find_index";
 /* eslint-disable no-restricted-properties */
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* eslint-disable @typescript-eslint/ban-types */
+/* eslint-disable @typescript-eslint/no-restricted-types */
 
 /* eslint-disable @typescript-eslint/unbound-method */
 const initialArrayFindIndex = (Array.prototype as { findIndex: unknown }).findIndex;
@@ -92,9 +92,9 @@ describe("utils - arrayFindIndex", () => {
       let currentIndex = 0;
       const predicate = function (
         this: unknown,
-        obj: {},
+        obj: unknown,
         index: number,
-        cArr: Array<{}>,
+        cArr: unknown[],
       ): boolean {
         expect(this).toBe(context);
         expect(index).toBe(currentIndex++);