rx-player 4.5.0-dev.2026012302 → 4.5.0-dev.2026031700

package/src/core/entry/utils.ts

@@ -1,6 +1,36 @@
+import { MediaSource_ } from "../../compat/browser_compatibility_types";
 import { formatError } from "../../errors";
+import type { ICorePlaybackObservation } from "../../main_thread/init/utils/create_core_playback_observer";
+import { createRepresentationFilterFromFnString } from "../../manifest";
+import type Manifest from "../../manifest/classes";
+import type {
+  IManifestLoader,
+  IRepresentationFilter,
+  ISegmentLoader,
+} from "../../public_types";
+import isNullOrUndefined from "../../utils/is_null_or_undefined";
+import type SegmentSinksStore from "../segment_sinks";
 import type { ISentError } from "../types";
 
+/**
+ * "Plugins" are a specific kind of API where an application can define complex
+ * functions that the RxPlayer will call in some normally-core aspects of media
+ * playback: e.g. loading segments.
+ *
+ * This interface lists them.
+ */
+export interface ICorePlugins {
+  representationFilters: Map<string, IRepresentationFilter>;
+  segmentLoaders: Map<string, ISegmentLoader>;
+  manifestLoaders: Map<string, IManifestLoader>;
+}
+
+/**
+ * Format an error, which may be of any form, into an Object than can easily be
+ * serialized - e.g. to be communicated through a postMessage-like API.
+ * @param {*} error - The error to serialized
+ * @returns {Object} - A serialization-safe error format
+ */
 export function formatErrorForSender(error: unknown): ISentError {
   const formattedError = formatError(error, {
     defaultCode: "NONE",
@@ -9,3 +39,124 @@ export function formatErrorForSender(error: unknown): ISentError {
 
   return formattedError.serialize();
 }
+
+/**
+ * Synchronize SegmentSinks with what has been buffered.
+ * @param {Object} observation - The just-received playback observation,
+ * including what has been buffered on lower-level buffers
+ * @param {Object} segmentSinksStore - Interface allowing to interact
+ * with `SegmentSink`s, so their inventory can be updated accordingly.
+ */
+export function synchronizeSegmentSinksOnObservation(
+  observation: ICorePlaybackObservation,
+  segmentSinksStore: SegmentSinksStore,
+): void {
+  // Synchronize SegmentSinks with what has been buffered.
+  ["video" as const, "audio" as const, "text" as const].forEach((tType) => {
+    const segmentSinkStatus = segmentSinksStore.getStatus(tType);
+    if (segmentSinkStatus.type === "initialized") {
+      segmentSinkStatus.value.synchronizeInventory(observation.buffered[tType] ?? []);
+    }
+  });
+}
+
+/**
+ * Set Representation.isCodecSupportedInWebWorker to true or false
+ * If the codec is supported in the current context.
+ * If MSE in worker is not available, the attribute is not set.
+ */
+export function updateCodecSupportInWorkerMode(manifestToUpdate: Manifest) {
+  if (isNullOrUndefined(MediaSource_)) {
+    return;
+  }
+
+  const codecsMap = new Map<string, boolean>();
+  for (const period of manifestToUpdate.periods) {
+    const checkedAdaptations = [
+      ...(period.adaptations.video ?? []),
+      ...(period.adaptations.audio ?? []),
+    ];
+    for (const adaptation of checkedAdaptations) {
+      for (const representation of adaptation.representations) {
+        const codec = `${representation.mimeType};codecs="${representation.codecs[0]}"`;
+        if (codecsMap.has(codec)) {
+          representation.isCodecSupportedInWebWorker = codecsMap.get(codec);
+        } else {
+          const supported = MediaSource_.isTypeSupported(codec);
+          representation.isCodecSupportedInWebWorker = supported;
+          codecsMap.set(codec, supported);
+        }
+      }
+    }
+  }
+}
+
+/**
+ * Some functions may be defined by the API, we call those "plugins".
+ * This function parses and extract the actual function from the different
+ * ways an application can provide it to us.
+ * @param {Object} input - The API input
+ * @param {Object} corePlugins - Context on what identified functions are
+ * defined right now.
+ * @returns {Function}
+ */
+export function extractExternalPlugins(
+  input: {
+    manifestLoader:
+      | {
+          fn?: IManifestLoader | undefined;
+          workerId?: string | undefined;
+        }
+      | undefined;
+    segmentLoader:
+      | {
+          fn?: ISegmentLoader | undefined;
+          workerId?: string | undefined;
+        }
+      | undefined;
+    representationFilter:
+      | undefined
+      | {
+          fn?: IRepresentationFilter | undefined;
+          eval?: string | undefined;
+          workerId?: string | undefined;
+        };
+  },
+  corePlugins: ICorePlugins,
+): {
+  manifestLoader: IManifestLoader | undefined;
+  segmentLoader: ISegmentLoader | undefined;
+  representationFilter: IRepresentationFilter | undefined;
+} {
+  let manifestLoader;
+  let segmentLoader;
+  let representationFilter;
+  if (typeof input.representationFilter?.fn === "function") {
+    representationFilter = input.representationFilter.fn;
+  } else if (typeof input.representationFilter?.eval === "string") {
+    representationFilter = createRepresentationFilterFromFnString(
+      input.representationFilter.eval,
+    );
+  } else if (typeof input.representationFilter?.workerId === "string") {
+    representationFilter = corePlugins.representationFilters.get(
+      input.representationFilter.workerId,
+    );
+  }
+
+  if (typeof input.manifestLoader?.fn === "function") {
+    manifestLoader = input.manifestLoader.fn;
+  } else if (typeof input.manifestLoader?.workerId === "string") {
+    manifestLoader = corePlugins.manifestLoaders.get(input.manifestLoader.workerId);
+  }
+
+  if (typeof input.segmentLoader?.fn === "function") {
+    segmentLoader = input.segmentLoader.fn;
+  } else if (typeof input.segmentLoader?.workerId === "string") {
+    segmentLoader = corePlugins.segmentLoaders.get(input.segmentLoader.workerId);
+  }
+  return {
+    manifestLoader,
+    segmentLoader,
+    representationFilter,
+  };
+}

package/src/core/fetchers/__tests__/cdn_prioritizer.test.ts

@@ -0,0 +1,166 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import CdnPrioritizer from "../cdn_prioritizer";
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+
+const mockGetCurrent = vi.hoisted(() => {
+  return vi.fn(() => ({ DEFAULT_CDN_DOWNGRADE_TIME: 60000 }));
+});
+
+vi.mock("../../../config", () => ({
+  default: { getCurrent: mockGetCurrent },
+}));
+
+vi.mock("../../../utils/array_find_index", () => ({
+  // eslint-disable-next-line no-restricted-properties
+  default: (arr: unknown[], fn: (elt: unknown) => boolean) => arr.findIndex(fn),
+}));
+
+vi.mock("../../../utils/event_emitter", () => {
+  class MockEventEmitter {
+    trigger = vi.fn();
+    addEventListener = vi.fn();
+    removeEventListener = vi.fn();
+  }
+  return { default: MockEventEmitter };
+});
+
+function makeCancellationSignal(): any {
+  let _cb: (() => void) | null = null;
+  return {
+    signal: {
+      register: (cb: () => void) => {
+        _cb = cb;
+      },
+    },
+    cancel: () => _cb?.(),
+  };
+}
+
+describe("CdnPrioritizer", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("returns single CDN as-is without prioritization", () => {
+    const { signal } = makeCancellationSignal();
+    const prioritizer = new CdnPrioritizer(signal);
+    const cdns = [{ id: "cdn1", baseUrl: "https://cdn1.example.com" }];
+    expect(prioritizer.getCdnPreferenceForResource(cdns)).toEqual(cdns);
+  });
+
+  it("returns multiple CDNs in original order when none are downgraded", () => {
+    const { signal } = makeCancellationSignal();
+    const prioritizer = new CdnPrioritizer(signal);
+    const cdns = [
+      { id: "cdn1", baseUrl: "https://cdn1.example.com" },
+      { id: "cdn2", baseUrl: "https://cdn2.example.com" },
+    ];
+    expect(prioritizer.getCdnPreferenceForResource(cdns)).toEqual(cdns);
+  });
+
+  it("puts downgraded CDN last", () => {
+    const { signal } = makeCancellationSignal();
+    const prioritizer = new CdnPrioritizer(signal);
+    const cdn1 = { id: "cdn1", baseUrl: "https://cdn1.example.com" };
+    const cdn2 = { id: "cdn2", baseUrl: "https://cdn2.example.com" };
+    prioritizer.downgradeCdn(cdn1);
+    const result = prioritizer.getCdnPreferenceForResource([cdn1, cdn2]);
+    expect(result).toEqual([cdn2, cdn1]);
+  });
+
+  it("triggers priorityChange when downgrading a CDN", () => {
+    const { signal } = makeCancellationSignal();
+    const prioritizer = new CdnPrioritizer(signal);
+    const cdn = { id: "cdn1", baseUrl: "https://cdn1.example.com" };
+    prioritizer.downgradeCdn(cdn);
+    expect((prioritizer as any).trigger).toHaveBeenCalledWith("priorityChange", null);
+  });
+
+  it("triggers priorityChange when downgrade expires", () => {
+    mockGetCurrent.mockReturnValue({ DEFAULT_CDN_DOWNGRADE_TIME: 5000 });
+    const { signal } = makeCancellationSignal();
+    const prioritizer = new CdnPrioritizer(signal);
+    const cdn = { id: "cdn1", baseUrl: "https://cdn1.example.com" };
+    prioritizer.downgradeCdn(cdn);
+    const triggerMock = (prioritizer as any).trigger;
+    const callCountBefore = triggerMock.mock.calls.length;
+    vi.advanceTimersByTime(5000);
+    expect(triggerMock.mock.calls.length).toBeGreaterThan(callCountBefore);
+  });
+
+  it("CDN is no longer downgraded after timeout expires", () => {
+    mockGetCurrent.mockReturnValue({ DEFAULT_CDN_DOWNGRADE_TIME: 5000 });
+    const { signal } = makeCancellationSignal();
+    const prioritizer = new CdnPrioritizer(signal);
+    const cdn1 = { id: "cdn1", baseUrl: "https://cdn1.example.com" };
+    const cdn2 = { id: "cdn2", baseUrl: "https://cdn2.example.com" };
+    prioritizer.downgradeCdn(cdn1);
+    vi.advanceTimersByTime(5000);
+    const result = prioritizer.getCdnPreferenceForResource([cdn1, cdn2]);
+    expect(result[0]).toEqual(cdn1);
+  });
+
+  it("re-downgrading a CDN resets its downgrade timer", () => {
+    mockGetCurrent.mockReturnValue({ DEFAULT_CDN_DOWNGRADE_TIME: 5000 });
+    const { signal } = makeCancellationSignal();
+    const prioritizer = new CdnPrioritizer(signal);
+    const cdn1 = { id: "cdn1", baseUrl: "https://cdn1.example.com" };
+    const cdn2 = { id: "cdn2", baseUrl: "https://cdn2.example.com" };
+
+    prioritizer.downgradeCdn(cdn1);
+    vi.advanceTimersByTime(3000);
+    prioritizer.downgradeCdn(cdn1); // reset
+    vi.advanceTimersByTime(3000); // only 3s since reset, should still be downgraded
+    const result = prioritizer.getCdnPreferenceForResource([cdn1, cdn2]);
+    expect(result[0]).toEqual(cdn2);
+  });
+
+  it("matches CDN by baseUrl when id is undefined", () => {
+    const { signal } = makeCancellationSignal();
+    const prioritizer = new CdnPrioritizer(signal);
+    const cdn1 = { baseUrl: "https://cdn1.example.com" } as any;
+    const cdn2 = { baseUrl: "https://cdn2.example.com" } as any;
+    prioritizer.downgradeCdn(cdn1);
+    const result = prioritizer.getCdnPreferenceForResource([cdn1, cdn2]);
+    expect(result).toEqual([cdn2, cdn1]);
+  });
+
+  it("clears timeouts and resets on destroy signal", () => {
+    const { signal, cancel } = makeCancellationSignal();
+    const prioritizer = new CdnPrioritizer(signal);
+    const cdn = { id: "cdn1", baseUrl: "https://cdn1.example.com" };
+    prioritizer.downgradeCdn(cdn);
+    cancel();
+    // After destroy, downgraded list should be empty
+    expect((prioritizer as any)._downgradedCdnList.metadata).toHaveLength(0);
+    expect((prioritizer as any)._downgradedCdnList.timeouts).toHaveLength(0);
+  });
+
+  it("returns empty array when given empty array", () => {
+    const { signal } = makeCancellationSignal();
+    const prioritizer = new CdnPrioritizer(signal);
+    expect(prioritizer.getCdnPreferenceForResource([])).toEqual([]);
+  });
+
+  it("handles multiple downgraded CDNs correctly", () => {
+    const { signal } = makeCancellationSignal();
+    const prioritizer = new CdnPrioritizer(signal);
+    const cdn1 = { id: "cdn1", baseUrl: "https://cdn1.example.com" };
+    const cdn2 = { id: "cdn2", baseUrl: "https://cdn2.example.com" };
+    const cdn3 = { id: "cdn3", baseUrl: "https://cdn3.example.com" };
+    prioritizer.downgradeCdn(cdn1);
+    prioritizer.downgradeCdn(cdn2);
+    const result = prioritizer.getCdnPreferenceForResource([cdn1, cdn2, cdn3]);
+    expect(result[0]).toEqual(cdn3);
+    expect(result).toContain(cdn1);
+    expect(result).toContain(cdn2);
+  });
+});