rx-player 4.5.0-dev.2026033100 → 4.5.0-dev.2026041501

package/src/main_thread/tracks_store/__tests__/media_element_tracks_store.test.ts

@@ -3,24 +3,27 @@ import type { IMediaElement } from "../../../compat/browser_compatibility_types"
 import assert from "../../../utils/assert";
 import MediaElementTracksStore from "../media_element_tracks_store";
 
-const fakeMediaElement = {
-  audioTracks: [
-    { language: "en", enabled: false },
-    { language: "fr", enabled: true },
-    { language: "el", enabled: false },
-    { language: "pt-BR", enabled: false },
-  ],
-  textTracks: [
-    { language: "en", mode: "hidden" },
-    { language: "fr", mode: "showing" },
-    { language: "el", mode: "hidden" },
-    { language: "pt-BR", mode: "hidden" },
-  ],
-  videoTracks: [{ language: "", selected: true }],
-} as unknown as IMediaElement;
+function createFakeMediaElement(): IMediaElement {
+  return {
+    audioTracks: [
+      { language: "en", enabled: false },
+      { language: "fr", enabled: true },
+      { language: "el", enabled: false },
+      { language: "pt-BR", enabled: false },
+    ],
+    textTracks: [
+      { language: "en", mode: "hidden" },
+      { language: "fr", mode: "showing" },
+      { language: "el", mode: "hidden" },
+      { language: "pt-BR", mode: "hidden" },
+    ],
+    videoTracks: [{ language: "", selected: true }],
+  } as unknown as IMediaElement;
+}
 
 describe("API - MediaElementTracksStore", () => {
   it("should returns correct results for getter", () => {
+    const fakeMediaElement = createFakeMediaElement();
     const trackManager = new MediaElementTracksStore(fakeMediaElement);
     const audioTracks = trackManager.getAvailableAudioTracks();
     const textTracks = trackManager.getAvailableTextTracks();
@@ -54,6 +57,7 @@ describe("API - MediaElementTracksStore", () => {
     });
   });
   it("should returns correct results for setters", () => {
+    const fakeMediaElement = createFakeMediaElement();
     const trackManager = new MediaElementTracksStore(fakeMediaElement);
 
     trackManager.setAudioTrackById("gen_audio_en_1");
@@ -80,6 +84,7 @@ describe("API - MediaElementTracksStore", () => {
     });
   });
   it("should emit available tracks change when changing text contents", () => {
+    const fakeMediaElement = createFakeMediaElement();
     const trackManager = new MediaElementTracksStore(fakeMediaElement);
 
     return new Promise<void>((res) => {
@@ -107,6 +112,7 @@ describe("API - MediaElementTracksStore", () => {
   });
 
   it("should emit available tracks change when changing video contents", () => {
+    const fakeMediaElement = createFakeMediaElement();
     const trackManager = new MediaElementTracksStore(fakeMediaElement);
     return new Promise<void>((res) => {
       trackManager.addEventListener("availableVideoTracksChange", (tracks) => {
@@ -129,6 +135,7 @@ describe("API - MediaElementTracksStore", () => {
   });
 
   it("should emit available tracks change when changing audio contents", () => {
+    const fakeMediaElement = createFakeMediaElement();
     const trackManager = new MediaElementTracksStore(fakeMediaElement);
     return new Promise<void>((res) => {
       trackManager.addEventListener("availableAudioTracksChange", (tracks) => {
@@ -154,18 +161,18 @@ describe("API - MediaElementTracksStore", () => {
   });
 
   it("should emit chosen track when changing text content", () => {
+    const fakeMediaElement = createFakeMediaElement();
     const trackManager = new MediaElementTracksStore(fakeMediaElement);
 
     return new Promise<void>((res) => {
       trackManager.addEventListener("textTrackChange", (chosenTrack) => {
-        expect(chosenTrack?.id).toBe("gen_text_fr_1");
+        expect(chosenTrack?.id).toBe("gen_text_en_1");
         res();
       });
 
-      trackManager.setTextTrackById("gen_text_fr_1");
+      trackManager.setTextTrackById("gen_text_en_1");
 
       // Fake browser behavior
-      fakeMediaElement.textTracks[0].mode = "hidden";
       (
         fakeMediaElement.textTracks as {
           onchange: ((arg: Event) => void) | undefined;

package/src/main_thread/tracks_store/media_element_tracks_store.ts

@@ -627,6 +627,7 @@ export default class MediaElementTracksStore extends EventEmitter<IMediaElementT
           const newAudioTracks = createAudioTracks(this._nativeAudioTracks);
           if (areTrackArraysDifferent(this._audioTracks, newAudioTracks)) {
             this._audioTracks = newAudioTracks;
+            this._setPreviouslyLockedAudioTrack();
             this.trigger("availableAudioTracksChange", this.getAvailableAudioTracks());
             const chosenAudioTrack = this._getCurrentAudioTrack();
             if (chosenAudioTrack?.nativeTrack !== this._lastEmittedNativeAudioTrack) {

package/src/main_thread/tracks_store/tracks_store.ts

@@ -1153,7 +1153,7 @@ export default class TracksStore extends EventEmitter<ITracksStoreEvents> {
    * Period.
    *
    * Returns `null` is the the current audio track is disabled or not
-   * set yet.a pas bcp de marge de manoeuvre j'ai l'impression
+   * set yet.
    *
    * Returns `undefined` if the given Period's id is not currently found in the
    * `TracksStore`. The cause being most probably that the corresponding

package/src/manifest/classes/__tests__/mocks.ts

@@ -0,0 +1,202 @@
+/**
+ * This file contains "dummy" versions of the exported classes imported from
+ * this location:
+ *
+ * - They respect the same API (e.g. a `DummyRepresentation` is a
+ *   `Representation`-compliant type).
+ *
+ * - They're doing no side-effect.
+ *
+ * - All of their methods throw an error immediately on call (you have to
+ *   implement the ones you want, generally through testing tools).
+ */
+import type { IRepresentationIndex, ISegment } from "../..";
+import { makeMockedClass } from "../../../utils/test-utils";
+import { ManifestMetadataFormat } from "../../types";
+import type Adaptation from "../adaptation";
+import type Manifest from "../manifest";
+import type Period from "../period";
+import type Representation from "../representation";
+
+export const DummyManifest = makeMockedClass<Manifest>(
+  {
+    addEventListener: notImplemented("addEventListener"),
+    removeEventListener: notImplemented("removeEventListener"),
+    updateCodecSupport: notImplemented("updateCodecSupport"),
+    getPeriod: notImplemented("getPeriod"),
+    getPeriodForTime: notImplemented("getPeriodForTime"),
+    getNextPeriod: notImplemented("getNextPeriod"),
+    getPeriodAfter: notImplemented("getPeriodAfter"),
+    getUrls: notImplemented("getUrls"),
+    replace: notImplemented("replace"),
+    update: notImplemented("update"),
+    getMinimumSafePosition: notImplemented("getMinimumSafePosition"),
+    getLivePosition: notImplemented("getLivePosition"),
+    getMaximumSafePosition: notImplemented("getMaximumSafePosition"),
+    updateCodecSupportList: notImplemented("updateCodecSupportList"),
+    updateRepresentationsDeciperability: notImplemented(
+      "updateRepresentationsDecipherability",
+    ),
+    addRepresentationsToAvoid: notImplemented("addRepresentationsToAvoid"),
+    getAdaptations: notImplemented("getAdaptations"),
+    getAdaptation: notImplemented("getAdaptation"),
+    getAdaptationsForType: notImplemented("getAdaptationsForType"),
+    getMetadataSnapshot: notImplemented("getMetadataSnapshot"),
+    getCodecsWithUnknownSupport: notImplemented("getCodecsWithUnknownSupport"),
+  },
+  {
+    id: "n/a",
+    manifestFormat: ManifestMetadataFormat.Class,
+    transport: "test",
+    periods: [],
+    expired: null,
+    adaptations: {},
+    isDynamic: false,
+    isLive: false,
+    isLastPeriodKnown: true,
+    uris: [],
+    updateUrl: undefined,
+    suggestedPresentationDelay: undefined,
+    lifetime: undefined,
+    availabilityStartTime: undefined,
+    publishTime: undefined,
+    clockOffset: undefined,
+    timeBounds: {
+      minimumSafePosition: undefined,
+      timeshiftDepth: null,
+      maximumTimeData: {
+        livePosition: undefined,
+        isLinear: false,
+        maximumSafePosition: Number.MAX_SAFE_INTEGER,
+        time: 0,
+      },
+    },
+  },
+);
+
+export const DummyPeriod = makeMockedClass<Period>(
+  {
+    getAdaptations: notImplemented("getAdaptations"),
+    getAdaptation: notImplemented("getAdaptation"),
+    getAdaptationsForType: notImplemented("getAdaptationsForType"),
+    getSupportedAdaptations: notImplemented("getSupportedAdaptations"),
+    getMetadataSnapshot: notImplemented("getMetadataSnapshot"),
+    containsTime: notImplemented("containsTime"),
+    refreshCodecSupport: notImplemented("refreshCodecSupport"),
+  },
+  {
+    id: "n/a",
+    start: 0,
+    adaptations: {},
+    streamEvents: [],
+    thumbnailTracks: [],
+    duration: undefined,
+    end: undefined,
+  },
+);
+
+export const DummyAdaptation = makeMockedClass<Adaptation>(
+  {
+    getRepresentation: notImplemented("getRepresentation"),
+    getMetadataSnapshot: notImplemented("getMetadataSnapshot"),
+    refreshCodecSupport: notImplemented("refreshCodecSupport"),
+  },
+  {
+    id: "n/a",
+    type: "video",
+    representations: [],
+    supportStatus: {
+      hasCodecWithUndefinedSupport: false,
+      hasSupportedCodec: true,
+      isDecipherable: undefined,
+    },
+    isDub: undefined,
+    label: undefined,
+    language: undefined,
+    manuallyAdded: undefined,
+    isClosedCaption: undefined,
+    trickModeTracks: undefined,
+    isTrickModeTrack: undefined,
+    isForcedSubtitles: undefined,
+    isSignInterpreted: undefined,
+    isAudioDescription: undefined,
+    normalizedLanguage: undefined,
+  },
+);
+
+export const DummyRepresentationIndex = makeMockedClass<IRepresentationIndex>(
+  {
+    getLastAvailablePosition: notImplemented("getLastAvailablePosition"),
+    addPredictedSegments: notImplemented("addPredictedSegments"),
+    getFirstAvailablePosition: notImplemented("getFirstAvailablePosition"),
+    getTargetSegmentDuration: notImplemented("getTargetSegmentDuration"),
+    getSegments: notImplemented("getSegments"),
+    getEnd: notImplemented("getEnd"),
+    getInitSegment: notImplemented("getInitSegment"),
+    shouldRefresh: notImplemented("shouldRefresh"),
+    isInitialized: notImplemented("isInitialized"),
+    isSegmentStillAvailable: notImplemented("isSegmentStillAvailable"),
+    initialize: notImplemented("initialize"),
+    isStillAwaitingFutureSegments: notImplemented("isStillAwaitingFutureSegments"),
+    canBeOutOfSyncError: notImplemented("canBeOutOfSyncError"),
+    checkDiscontinuity: notImplemented("checkDiscontinuity"),
+    awaitSegmentBetween: notImplemented("awaitSegmentBetween"),
+    _replace: notImplemented("_replace"),
+    _update: notImplemented("_update"),
+  },
+  {},
+);
+
+export const DummyRepresentation = makeMockedClass<Representation>(
+  {
+    isPlayable: notImplemented("isPlayable"),
+    addProtectionData: notImplemented("addProtectionData"),
+    getMimeTypeString: notImplemented("getMimeTypeString"),
+    getEncryptionData: notImplemented("getEncryptionData"),
+    getAllEncryptionData: notImplemented("getAllEncryptionData"),
+    getMetadataSnapshot: notImplemented("getMetadataSnapshot"),
+    refreshCodecSupport: notImplemented("refreshCodecSupport"),
+  },
+  {
+    id: "n/a",
+    isSupported: undefined,
+    index: new DummyRepresentationIndex(),
+    chosenCodec: undefined,
+    baseCodecs: [],
+    bitrate: 1000,
+    uniqueId: "n/a",
+    decipherable: undefined,
+    isSpatialAudio: undefined,
+    shouldBeAvoided: false,
+    isCodecSupportedInWebWorker: undefined,
+    trackType: "video",
+    cdnMetadata: null,
+    width: undefined,
+    height: undefined,
+    mimeType: undefined,
+    frameRate: undefined,
+    hdrInfo: undefined,
+    contentProtections: undefined,
+  },
+);
+
+export function createSegment(props: Partial<ISegment> = {}): ISegment {
+  return {
+    id: "n/a",
+    isInit: false,
+    time: 0,
+    end: 2,
+    duration: 2,
+    timescale: 1,
+    complete: true,
+    url: null,
+    privateInfos: {},
+    ...props,
+  };
+}
+
+function notImplemented(name: string): () => never {
+  return () => {
+    throw new Error(`${name} not implemented`);
+  };
+}

package/src/parsers/containers/isobmff/__tests__/extract_pssh.test.ts

@@ -0,0 +1,199 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { concat } from "../../../../utils/byte_parsing";
+import extractPssh, { getPsshSystemID } from "../extract_pssh";
+
+const { mockCanPatchOutPsshBox, mockLog } = vi.hoisted(() => {
+  return {
+    mockCanPatchOutPsshBox: vi.fn(() => false),
+    mockLog: {
+      warn: vi.fn(),
+      info: vi.fn(),
+      debug: vi.fn(),
+      log: vi.fn(),
+      error: vi.fn(),
+    },
+  };
+});
+
+vi.mock("../../../../compat/can_patch_out_pssh", () => ({
+  default: mockCanPatchOutPsshBox,
+}));
+
+vi.mock("../../../../log", () => ({
+  default: mockLog,
+}));
+
+/** Build a minimal moov box wrapping `innerBytes`. */
+function buildMoovBox(innerBytes: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer> {
+  const size = 8 + innerBytes.length;
+  const buf = new Uint8Array(size);
+  const view = new DataView(buf.buffer);
+  view.setUint32(0, size, false);
+  buf[4] = 0x6d;
+  buf[5] = 0x6f;
+  buf[6] = 0x6f;
+  buf[7] = 0x76; // "moov"
+  buf.set(innerBytes, 8);
+  return buf;
+}
+
+/**
+ * Build a pssh box.
+ *
+ * Layout (after size + name):
+ *   1 byte  version
+ *   3 bytes flags
+ *  16 bytes systemId
+ *   N bytes extra data
+ */
+function buildPsshBox(
+  systemId: Uint8Array<ArrayBuffer>,
+  version = 0,
+  extraData: Uint8Array<ArrayBuffer> = new Uint8Array(0),
+): Uint8Array<ArrayBuffer> {
+  // 8 (size+name) + 1 (version) + 3 (flags) + 16 (systemId) + extraData
+  const size = 8 + 1 + 3 + 16 + extraData.length;
+  const buf = new Uint8Array(size);
+  const view = new DataView(buf.buffer);
+  view.setUint32(0, size, false);
+  buf[4] = 0x70;
+  buf[5] = 0x73;
+  buf[6] = 0x73;
+  buf[7] = 0x68; // "pssh"
+  buf[8] = version; // version (bytes 0 of version+flags)
+  // flags stay 0x000000
+  buf.set(systemId, 12); // offset 8+4 = 12
+  buf.set(extraData, 28);
+  return buf;
+}
+
+const SYSTEM_ID_A = new Uint8Array([
+  0x10, 0x77, 0xef, 0xec, 0xc0, 0xb2, 0x4d, 0x02, 0xac, 0xe3, 0x3c, 0x1e, 0x52, 0xe2,
+  0xfb, 0x4b,
+]);
+const SYSTEM_ID_B = new Uint8Array([
+  0xed, 0xef, 0x8b, 0xa9, 0x79, 0xd6, 0x4a, 0xce, 0xa3, 0xc8, 0x27, 0xdc, 0xd5, 0x1d,
+  0x21, 0xed,
+]);
+
+const systemIdAHex = Array.from(SYSTEM_ID_A)
+  .map((b) => b.toString(16).padStart(2, "0"))
+  .join("");
+const systemIdBHex = Array.from(SYSTEM_ID_B)
+  .map((b) => b.toString(16).padStart(2, "0"))
+  .join("");
+
+describe("extractPssh", () => {
+  beforeEach(() => {
+    mockCanPatchOutPsshBox.mockReturnValue(true);
+  });
+  afterEach(() => {
+    vi.resetAllMocks();
+  });
+
+  it("returns [] when there is no moov box", () => {
+    const data = new Uint8Array(32); // no moov, only `0`
+    expect(extractPssh(data)).toEqual([]);
+  });
+
+  it("returns [] when moov contains no pssh box", () => {
+    // An empty moov (just the 8-byte header, no inner boxes)
+    const data = buildMoovBox(new Uint8Array(0));
+    expect(extractPssh(data)).toEqual([]);
+  });
+
+  it("extracts a single pssh box", () => {
+    const pssh = buildPsshBox(SYSTEM_ID_A);
+    const data = buildMoovBox(pssh);
+    const result = extractPssh(data);
+    expect(result).toHaveLength(1);
+    expect(result[0].systemId).toBe(systemIdAHex);
+  });
+
+  it("extracts multiple pssh boxes in order", () => {
+    const psshA = buildPsshBox(SYSTEM_ID_A);
+    const psshB = buildPsshBox(SYSTEM_ID_B);
+    const data = buildMoovBox(concat(psshA, psshB));
+    const result = extractPssh(data);
+    expect(result).toHaveLength(2);
+    expect(result[0].systemId).toBe(systemIdAHex);
+    expect(result[1].systemId).toBe(systemIdBHex);
+  });
+
+  it("skips a pssh whose systemId cannot be parsed and keeps going", () => {
+    // A pssh with version > 1 triggers the 'un-handled PSSH version' warn path,
+    // so getPsshSystemID returns undefined and the box is omitted.
+    const psshBad = buildPsshBox(SYSTEM_ID_A, 2 /* unsupported version */);
+    const psshGood = buildPsshBox(SYSTEM_ID_B);
+    const data = buildMoovBox(concat(psshBad, psshGood));
+    const result = extractPssh(data);
+    expect(result).toHaveLength(1);
+    expect(result[0].systemId).toBe(systemIdBHex);
+    expect(mockLog.warn).toHaveBeenCalledWith("isobmff", "un-handled PSSH version");
+  });
+
+  it("patches out pssh bytes when canPatchOutPsshBox returns true", () => {
+    mockCanPatchOutPsshBox.mockReturnValue(true);
+    const pssh = buildPsshBox(SYSTEM_ID_A);
+    const moov = buildMoovBox(pssh);
+    // The pssh box starts at offset 8 inside moov content (right after moov header).
+    // After patching, bytes 4–7 of the pssh box should be "free" (0x66 0x72 0x65 0x65).
+    extractPssh(moov);
+    // moov content starts at offset 8 of the full segment.
+    // pssh name is at moov_content[4..7] = segment[12..15]
+    expect(moov[12]).toBe(0x66); // 'f'
+    expect(moov[13]).toBe(0x72); // 'r'
+    expect(moov[14]).toBe(0x65); // 'e'
+    expect(moov[15]).toBe(0x65); // 'e'
+  });
+
+  it("does not patch bytes when canPatchOutPsshBox returns false", () => {
+    mockCanPatchOutPsshBox.mockReturnValue(false);
+    const pssh = buildPsshBox(SYSTEM_ID_A);
+    const originalNameByte1 = pssh[4]; // should be 0x70 ('p')
+    const originalNameByte2 = pssh[5]; // 's'
+    const originalNameByte3 = pssh[6]; // 's'
+    const originalNameByte4 = pssh[7]; // 'h'
+    const moov = buildMoovBox(pssh);
+    extractPssh(moov);
+    expect(moov[12]).toBe(originalNameByte1);
+    expect(moov[13]).toBe(originalNameByte2);
+    expect(moov[14]).toBe(originalNameByte3);
+    expect(moov[15]).toBe(originalNameByte4);
+  });
+});
+
+describe("getPsshSystemID", () => {
+  afterEach(() => {
+    vi.resetAllMocks();
+  });
+
+  it("parses a valid version-0 pssh and returns hex systemId", () => {
+    const pssh = buildPsshBox(SYSTEM_ID_A);
+    // initialDataOffset is the offset right after size (4) + name (4) = 8
+    const result = getPsshSystemID(pssh, 8);
+    expect(result).toBe(systemIdAHex);
+  });
+
+  it("parses a valid version-1 pssh", () => {
+    const pssh = buildPsshBox(SYSTEM_ID_B, 1);
+    const result = getPsshSystemID(pssh, 8);
+    expect(result).toBe(systemIdBHex);
+  });
+
+  it("returns undefined and warns for version > 1", () => {
+    const pssh = buildPsshBox(SYSTEM_ID_A, 2);
+    const result = getPsshSystemID(pssh, 8);
+    expect(result).toBeUndefined();
+    expect(mockLog.warn).toHaveBeenCalledWith("isobmff", "un-handled PSSH version");
+  });
+
+  it("returns undefined when buffer is too short to contain a full systemId", () => {
+    // Build a buffer that's big enough for the header (version + flags = 4 bytes)
+    // but lacks the 16-byte systemId.
+    const buf = new Uint8Array(8 + 4 + 10); // only 10 bytes where 16 are needed
+    const result = getPsshSystemID(buf, 8);
+    expect(result).toBeUndefined();
+    expect(mockLog.warn).not.toHaveBeenCalled();
+  });
+});

package/src/parsers/containers/isobmff/{take_pssh_out.ts → extract_pssh.ts}

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+import canPatchOutPsshBox from "../../../compat/can_patch_out_pssh";
 import log from "../../../log";
 import sliceUint8Array from "../../../utils/slice_uint8array";
 import { bytesToHex } from "../../../utils/string_parsing";
@@ -28,46 +29,49 @@ export interface IISOBMFFPSSHInfo {
 }
 
 /**
- * Replace every PSSH box from an ISOBMFF segment by FREE boxes and returns the
- * removed PSSH in an array.
+ * Return every `pssh` box from an ISOBMFF segment.
+ *
+ * If the current device has no issue with it, also replace them by `free` boxes.
  * Useful to manually manage encryption while avoiding the round-trip with the
  * browser's encrypted event.
+ *
  * @param {Uint8Array} data - the ISOBMFF segment
  * @returns {Array.<Uint8Array>} - The extracted PSSH boxes. In the order they
  * are encountered.
  */
-export default function takePSSHOut(data: Uint8Array<ArrayBuffer>): IISOBMFFPSSHInfo[] {
-  let i = 0;
-  const moov = getBoxContent(data, 0x6d6f6f76 /* moov */);
-  if (moov === null) {
+export default function extractPssh(data: Uint8Array<ArrayBuffer>): IISOBMFFPSSHInfo[] {
+  const moovContent = getBoxContent(data, 0x6d6f6f76 /* moov */);
+  if (moovContent === null) {
     return [];
   }
 
   const psshBoxes: IISOBMFFPSSHInfo[] = [];
-  while (i < moov.length) {
+  let remainingMoovContent = moovContent;
+  while (remainingMoovContent.length > 0) {
     let psshOffsets;
     try {
-      psshOffsets = getBoxOffsets(moov, 0x70737368 /* pssh */);
+      psshOffsets = getBoxOffsets(remainingMoovContent, 0x70737368 /* pssh */);
     } catch (e) {
-      const err = e instanceof Error ? e : "";
+      const err = e instanceof Error ? e : new Error("Unknown ISOBMFF box reading error");
       log.warn("isobmff", "Error while removing PSSH from ISOBMFF", err);
       return psshBoxes;
     }
     if (psshOffsets === null) {
       return psshBoxes;
     }
-    const pssh = sliceUint8Array(moov, psshOffsets[0], psshOffsets[2]);
+    const pssh = sliceUint8Array(remainingMoovContent, psshOffsets[0], psshOffsets[2]);
     const systemId = getPsshSystemID(pssh, psshOffsets[1] - psshOffsets[0]);
     if (systemId !== undefined) {
       psshBoxes.push({ systemId, data: pssh });
     }
-
-    // replace by `free` box.
-    moov[psshOffsets[0] + 4] = 0x66;
-    moov[psshOffsets[0] + 5] = 0x72;
-    moov[psshOffsets[0] + 6] = 0x65;
-    moov[psshOffsets[0] + 7] = 0x65;
-    i = psshOffsets[2];
+    if (canPatchOutPsshBox()) {
+      // replace by `free` box.
+      remainingMoovContent[psshOffsets[0] + 4] = 0x66;
+      remainingMoovContent[psshOffsets[0] + 5] = 0x72;
+      remainingMoovContent[psshOffsets[0] + 6] = 0x65;
+      remainingMoovContent[psshOffsets[0] + 7] = 0x65;
+    }
+    remainingMoovContent = remainingMoovContent.subarray(psshOffsets[2]);
   }
   return psshBoxes;
 }

package/src/parsers/containers/isobmff/index.ts

@@ -15,9 +15,9 @@
  */
 
 import extractCompleteChunks, { extractInitSegment } from "./extract_complete_chunks";
+import extractPssh, { getPsshSystemID } from "./extract_pssh";
 import findCompleteBox from "./find_complete_box";
 import removeDolbyVisionConfigData from "./remove_dolby_vision_config_data";
-import takePSSHOut, { getPsshSystemID } from "./take_pssh_out";
 
 export { extractInitSegment };
 export { createBox, createBoxWithChildren } from "./create_box";
@@ -44,5 +44,5 @@ export {
   findCompleteBox,
   getPsshSystemID,
   removeDolbyVisionConfigData,
-  takePSSHOut,
+  extractPssh,
 };

package/src/parsers/manifest/dash/wasm-parser/README.md

@@ -7,7 +7,7 @@ the default JS-based one, especially on very large (multiple megabytes) MPDs.
 
 ### How Manifest parsing works in the RxPlayer
 
-In the RxPlayer every Manifest parser output the same final Manifest format which follow
+In the RxPlayer every Manifest parser outputs the same final Manifest format which follows
 the same structure regardless of the transport protocol used (e.g. DASH, Smooth etc.).
 
 For the MPD (DASH's Manifest format), this transformation (from an XML to that final
@@ -30,7 +30,7 @@ XML format in JavaScript.
 Before the DASH-WASM parser, we only had the JavaScript parser, which relied on the
 browser's DOM APIs (e.g. `DOMParser`).
 
-This parser works fine but we found that its performance was really poor when encoutering
+This parser works fine but we found that its performance was really poor when encountering
 huge MPDs (several MBs), that we're dealing with at Canal+ on a regular basis. Usually
 those problematic MPDs have several gigantic `<SegmentTimeline>` elements that takes a lot
 of time to parse.
@@ -39,11 +39,11 @@ After multiple tests, profiling and improvements, it appeared that the issue had
 with XML parsing and the DOM APIs (regarding the speed of the parsing operation, but also
 some stability issues most likely related to garbage collection pressure).
 
-Moreover, on some embedded devices, this operation could take several seconds. This leaded
-us to try to implement a parser running in a WebWorker (to avoid blocking the main thread,
+Moreover, on some embedded devices, this operation could take several seconds. This led us
+to try to implement a parser running in a WebWorker (to avoid blocking the main thread,
 which is also handling the user interface).
 
-As no DOM API are available in a WebWorker, we had to re-define the XML parsing APIs. We
+As no DOM APIs are available in a WebWorker, we had to re-define the XML parsing APIs. We
 first opted for a JavaScript library, yet found performance in our initial tests to be
 subpar. We ended up trying with WebAssembly instead.
 
@@ -82,7 +82,7 @@ In the context of the RxPlayer, we only use it for optimization reasons, when we
 that switching the DASH MPD parser to WebAssembly has a high impact in terms of
 performance when compared to the equivalent JavaScript code.
 
-### Where does the DASH-WASM parser fits into this
+### Where does the DASH-WASM parser fit into this
 
 The DASH-WASM MPD parser only does the first step of transforming the initial XML format
 into the "intermediate representation", by using WebAssembly.
@@ -111,7 +111,7 @@ This logic was written as such because:
 
 ### Directories
 
-The DASH-WASM parser comes into part:
+The DASH-WASM parser comes in two parts:
 
 - the Rust part, written in the `rs` directory, that browses the XML and convert values to
   the right format.
@@ -142,7 +142,7 @@ Currently, the DASH-WASM parser parses in one go the XML.
    If the XML element encountered is recognized, it will call a JavaScript callback with
    the right number, to signal that this element has been encountered.
 
-4. This callback, registered by the TypeScript code, begin to create the object
+4. This callback, registered by the TypeScript code, begins to create the object
    corresponding to that element and update some callbacks called by Rust so that new
    elements and attributes are considered as part of this element.
 
@@ -181,7 +181,7 @@ preferable for any reason, don't hesitate to propose a change (through an issue
 
 ### Details on FFI
 
-Technically, some data and function calls needs to cross the language boundaries between
+Technically, some data and function calls need to cross the language boundaries between
 the compiled JavaScript and WebAssembly code.
 
 On the JavaScript/TypeScript-side, everything stays relatively simple, with few